diff options
author | Bruce Momjian | 2006-10-04 00:30:14 +0000 |
---|---|---|
committer | Bruce Momjian | 2006-10-04 00:30:14 +0000 |
commit | f99a569a2ee3763b4ae174e81250c95ca0fdcbb6 (patch) | |
tree | 76e6371fe8b347c73d7020c0bc54b9fba519dc10 | |
parent | 451e419e9852cdf9d7e7cefc09d5355abb3405e9 (diff) |
pgindent run for 8.2.
522 files changed, 21508 insertions, 17381 deletions
diff --git a/contrib/adminpack/adminpack.c b/contrib/adminpack/adminpack.c index 3213420ba1..dc756e4303 100644 --- a/contrib/adminpack/adminpack.c +++ b/contrib/adminpack/adminpack.c @@ -4,11 +4,11 @@ * * * Copyright (c) 2002 - 2006, PostgreSQL Global Development Group - * + * * Author: Andreas Pflug <[email protected]> * * IDENTIFICATION - * $PostgreSQL: pgsql/contrib/adminpack/adminpack.c,v 1.3 2006/07/11 16:35:30 momjian Exp $ + * $PostgreSQL: pgsql/contrib/adminpack/adminpack.c,v 1.4 2006/10/04 00:29:44 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -35,7 +35,6 @@ #ifdef unlink #undef unlink #endif - #endif extern DLLIMPORT char *DataDir; @@ -44,20 +43,20 @@ extern DLLIMPORT char *Log_filename; PG_MODULE_MAGIC; -Datum pg_file_write(PG_FUNCTION_ARGS); -Datum pg_file_rename(PG_FUNCTION_ARGS); -Datum pg_file_unlink(PG_FUNCTION_ARGS); -Datum pg_logdir_ls(PG_FUNCTION_ARGS); +Datum pg_file_write(PG_FUNCTION_ARGS); +Datum pg_file_rename(PG_FUNCTION_ARGS); +Datum pg_file_unlink(PG_FUNCTION_ARGS); +Datum pg_logdir_ls(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(pg_file_write); PG_FUNCTION_INFO_V1(pg_file_rename); PG_FUNCTION_INFO_V1(pg_file_unlink); PG_FUNCTION_INFO_V1(pg_logdir_ls); -typedef struct +typedef struct { - char *location; - DIR *dirdesc; + char *location; + DIR *dirdesc; } directory_fctx; /*----------------------- @@ -65,30 +64,31 @@ typedef struct */ /* - * Return an absolute path. Argument may be absolute or + * Return an absolute path. Argument may be absolute or * relative to the DataDir. */ -static char *absClusterPath(text *arg, bool logAllowed) +static char * +absClusterPath(text *arg, bool logAllowed) { - char *filename; - int len=VARSIZE(arg) - VARHDRSZ; - int dlen = strlen(DataDir); + char *filename; + int len = VARSIZE(arg) - VARHDRSZ; + int dlen = strlen(DataDir); - filename = palloc(len+1); + filename = palloc(len + 1); memcpy(filename, VARDATA(arg), len); filename[len] = 0; if (strstr(filename, "..") != NULL) - ereport(ERROR, - (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("No .. allowed in filenames")))); - + ereport(ERROR, + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + (errmsg("No .. allowed in filenames")))); + if (is_absolute_path(filename)) { - if (logAllowed && !strncmp(filename, Log_directory, strlen(Log_directory))) - return filename; + if (logAllowed && !strncmp(filename, Log_directory, strlen(Log_directory))) + return filename; if (strncmp(filename, DataDir, dlen)) - ereport(ERROR, + ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("Absolute path not allowed")))); @@ -96,7 +96,8 @@ static char *absClusterPath(text *arg, bool logAllowed) } else { - char *absname = palloc(dlen+len+2); + char *absname = palloc(dlen + len + 2); + sprintf(absname, "%s/%s", DataDir, filename); pfree(filename); return absname; @@ -111,9 +112,9 @@ static void requireSuperuser(void) { if (!superuser()) - ereport(ERROR, + ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), - (errmsg("only superuser may access generic file functions")))); + (errmsg("only superuser may access generic file functions")))); } @@ -122,12 +123,13 @@ requireSuperuser(void) * generic file handling functions */ -Datum pg_file_write(PG_FUNCTION_ARGS) +Datum +pg_file_write(PG_FUNCTION_ARGS) { - FILE *f; - char *filename; - text *data; - int64 count = 0; + FILE *f; + char *filename; + text *data; + int64 count = 0; requireSuperuser(); @@ -136,16 +138,17 @@ Datum pg_file_write(PG_FUNCTION_ARGS) if (PG_ARGISNULL(2) || !PG_GETARG_BOOL(2)) { - struct stat fst; + struct stat fst; + if (stat(filename, &fst) >= 0) - ereport(ERROR, + ereport(ERROR, (ERRCODE_DUPLICATE_FILE, errmsg("file %s exists", filename))); - f = fopen(filename, "wb"); + f = fopen(filename, "wb"); } else - f = fopen(filename, "ab"); + f = fopen(filename, "ab"); if (!f) { @@ -159,7 +162,7 @@ Datum pg_file_write(PG_FUNCTION_ARGS) count = fwrite(VARDATA(data), 1, VARSIZE(data) - VARHDRSZ, f); if (count != VARSIZE(data) - VARHDRSZ) - ereport(ERROR, + ereport(ERROR, (errcode_for_file_access(), errmsg("error writing file %s: %m", filename))); } @@ -169,22 +172,25 @@ Datum pg_file_write(PG_FUNCTION_ARGS) } -Datum pg_file_rename(PG_FUNCTION_ARGS) +Datum +pg_file_rename(PG_FUNCTION_ARGS) { - char *fn1, *fn2, *fn3; - int rc; + char *fn1, + *fn2, + *fn3; + int rc; requireSuperuser(); if (PG_ARGISNULL(0) || PG_ARGISNULL(1)) PG_RETURN_NULL(); - fn1=absClusterPath(PG_GETARG_TEXT_P(0), false); - fn2=absClusterPath(PG_GETARG_TEXT_P(1), false); + fn1 = absClusterPath(PG_GETARG_TEXT_P(0), false); + fn2 = absClusterPath(PG_GETARG_TEXT_P(1), false); if (PG_ARGISNULL(2)) - fn3=0; + fn3 = 0; else - fn3=absClusterPath(PG_GETARG_TEXT_P(2), false); + fn3 = absClusterPath(PG_GETARG_TEXT_P(2), false); if (access(fn1, W_OK) < 0) { @@ -192,7 +198,7 @@ Datum pg_file_rename(PG_FUNCTION_ARGS) (errcode_for_file_access(), errmsg("file %s not accessible: %m", fn1))); - PG_RETURN_BOOL(false); + PG_RETURN_BOOL(false); } if (fn3 && access(fn2, W_OK) < 0) @@ -201,7 +207,7 @@ Datum pg_file_rename(PG_FUNCTION_ARGS) (errcode_for_file_access(), errmsg("file %s not accessible: %m", fn2))); - PG_RETURN_BOOL(false); + PG_RETURN_BOOL(false); } @@ -212,10 +218,10 @@ Datum pg_file_rename(PG_FUNCTION_ARGS) (ERRCODE_DUPLICATE_FILE, errmsg("cannot rename to target file %s", fn3 ? fn3 : fn2))); } - + if (fn3) { - if (rename(fn2, fn3) != 0) + if (rename(fn2, fn3) != 0) { ereport(ERROR, (errcode_for_file_access(), @@ -231,7 +237,7 @@ Datum pg_file_rename(PG_FUNCTION_ARGS) { ereport(ERROR, (errcode_for_file_access(), - errmsg("could not rename %s back to %s: %m", fn3, fn2))); + errmsg("could not rename %s back to %s: %m", fn3, fn2))); } else { @@ -244,9 +250,9 @@ Datum pg_file_rename(PG_FUNCTION_ARGS) } else if (rename(fn1, fn2) != 0) { - ereport(WARNING, - (errcode_for_file_access(), - errmsg("renaming %s to %s %m", fn1, fn2))); + ereport(WARNING, + (errcode_for_file_access(), + errmsg("renaming %s to %s %m", fn1, fn2))); ereport(ERROR, (errcode_for_file_access(), errmsg("could not rename %s to %s: %m", fn1, fn2))); @@ -256,20 +262,21 @@ Datum pg_file_rename(PG_FUNCTION_ARGS) } -Datum pg_file_unlink(PG_FUNCTION_ARGS) +Datum +pg_file_unlink(PG_FUNCTION_ARGS) { - char *filename; + char *filename; requireSuperuser(); - filename = absClusterPath(PG_GETARG_TEXT_P(0), false); + filename = absClusterPath(PG_GETARG_TEXT_P(0), false); if (access(filename, W_OK) < 0) { - if (errno == ENOENT) - PG_RETURN_BOOL(false); + if (errno == ENOENT) + PG_RETURN_BOOL(false); else - ereport(ERROR, + ereport(ERROR, (errcode_for_file_access(), errmsg("file %s not accessible: %m", filename))); @@ -287,17 +294,18 @@ Datum pg_file_unlink(PG_FUNCTION_ARGS) } -Datum pg_logdir_ls(PG_FUNCTION_ARGS) +Datum +pg_logdir_ls(PG_FUNCTION_ARGS) { FuncCallContext *funcctx; struct dirent *de; directory_fctx *fctx; - if (!superuser()) + if (!superuser()) ereport(ERROR, (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("only superuser can list the log directory")))); - + if (memcmp(Log_filename, "postgresql-%Y-%m-%d_%H%M%S.log", 30) != 0) ereport(ERROR, (errcode(ERRCODE_INVALID_PARAMETER_VALUE), @@ -306,17 +314,17 @@ Datum pg_logdir_ls(PG_FUNCTION_ARGS) if (SRF_IS_FIRSTCALL()) { MemoryContext oldcontext; - TupleDesc tupdesc; + TupleDesc tupdesc; - funcctx=SRF_FIRSTCALL_INIT(); + funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); fctx = palloc(sizeof(directory_fctx)); if (is_absolute_path(Log_directory)) - fctx->location = Log_directory; + fctx->location = Log_directory; else { - fctx->location = palloc(strlen(DataDir) + strlen(Log_directory) +2); + fctx->location = palloc(strlen(DataDir) + strlen(Log_directory) + 2); sprintf(fctx->location, "%s/%s", DataDir, Log_directory); } tupdesc = CreateTemplateTupleDesc(2, false); @@ -326,11 +334,11 @@ Datum pg_logdir_ls(PG_FUNCTION_ARGS) TEXTOID, -1, 0); funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc); - + fctx->dirdesc = AllocateDir(fctx->location); if (!fctx->dirdesc) - ereport(ERROR, + ereport(ERROR, (errcode_for_file_access(), errmsg("%s is not browsable: %m", fctx->location))); @@ -338,47 +346,47 @@ Datum pg_logdir_ls(PG_FUNCTION_ARGS) MemoryContextSwitchTo(oldcontext); } - funcctx=SRF_PERCALL_SETUP(); - fctx = (directory_fctx*) funcctx->user_fctx; + funcctx = SRF_PERCALL_SETUP(); + fctx = (directory_fctx *) funcctx->user_fctx; - if (!fctx->dirdesc) /* not a readable directory */ + if (!fctx->dirdesc) /* not a readable directory */ SRF_RETURN_DONE(funcctx); while ((de = readdir(fctx->dirdesc)) != NULL) { - char *values[2]; - HeapTuple tuple; - - char *field[MAXDATEFIELDS]; + char *values[2]; + HeapTuple tuple; + + char *field[MAXDATEFIELDS]; char lowstr[MAXDATELEN + 1]; - int dtype; - int nf, ftype[MAXDATEFIELDS]; + int dtype; + int nf, + ftype[MAXDATEFIELDS]; fsec_t fsec; - int tz = 0; - struct pg_tm date; + int tz = 0; + struct pg_tm date; /* - * Default format: - * postgresql-YYYY-MM-DD_HHMMSS.log + * Default format: postgresql-YYYY-MM-DD_HHMMSS.log */ if (strlen(de->d_name) != 32 - || memcmp(de->d_name, "postgresql-", 11) + || memcmp(de->d_name, "postgresql-", 11) || de->d_name[21] != '_' || strcmp(de->d_name + 28, ".log")) - continue; + continue; values[1] = palloc(strlen(fctx->location) + strlen(de->d_name) + 2); sprintf(values[1], "%s/%s", fctx->location, de->d_name); - values[0] = de->d_name + 11; /* timestamp */ + values[0] = de->d_name + 11; /* timestamp */ values[0][17] = 0; - /* parse and decode expected timestamp */ + /* parse and decode expected timestamp */ if (ParseDateTime(values[0], lowstr, MAXDATELEN, field, ftype, MAXDATEFIELDS, &nf)) - continue; + continue; if (DecodeDateTime(field, ftype, nf, &dtype, &date, &fsec, &tz)) - continue; + continue; /* Seems the format fits the expected format; feed it into the tuple */ diff --git a/contrib/cube/cube.c b/contrib/cube/cube.c index 16ba5340fb..9d3b46648e 100644 --- a/contrib/cube/cube.c +++ b/contrib/cube/cube.c @@ -1,5 +1,5 @@ /****************************************************************************** - $PostgreSQL: pgsql/contrib/cube/cube.c,v 1.29 2006/09/10 17:36:50 tgl Exp $ + $PostgreSQL: pgsql/contrib/cube/cube.c,v 1.30 2006/10/04 00:29:44 momjian Exp $ This file contains routines that can be bound to a Postgres backend and called by the backend in the process of processing queries. The calling @@ -159,7 +159,7 @@ Datum cube_in(PG_FUNCTION_ARGS) { void *result; - char *str; + char *str; str = PG_GETARG_CSTRING(0); @@ -170,7 +170,7 @@ cube_in(PG_FUNCTION_ARGS) cube_scanner_finish(); - PG_RETURN_POINTER (result); + PG_RETURN_POINTER(result); } /* Allow conversion from text to cube to allow input of computed strings */ @@ -178,11 +178,11 @@ cube_in(PG_FUNCTION_ARGS) Datum cube(PG_FUNCTION_ARGS) { - char *cstring; + char *cstring; cstring = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(PG_GETARG_TEXT_P(0)))); - PG_RETURN_DATUM (DirectFunctionCall1 (cube_in, PointerGetDatum(cstring))); + PG_RETURN_DATUM(DirectFunctionCall1(cube_in, PointerGetDatum(cstring))); } @@ -192,12 +192,14 @@ cube(PG_FUNCTION_ARGS) Datum cube_a_f8_f8(PG_FUNCTION_ARGS) { - int i; - int dim; - int size; - NDBOX *result; - ArrayType *ur, *ll; - double *dur, *dll; + int i; + int dim; + int size; + NDBOX *result; + ArrayType *ur, + *ll; + double *dur, + *dll; ur = (ArrayType *) PG_GETARG_VARLENA_P(0); ll = (ArrayType *) PG_GETARG_VARLENA_P(1); @@ -205,31 +207,31 @@ cube_a_f8_f8(PG_FUNCTION_ARGS) if (ARR_HASNULL(ur) || ARR_HASNULL(ll)) { ereport(ERROR, - (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), - errmsg("Cannot work with NULL arrays"))); + (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), + errmsg("Cannot work with NULL arrays"))); } dim = ARRNELEMS(ur); if (ARRNELEMS(ll) != dim) { ereport(ERROR, - (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), - errmsg("UR and LL arrays must be of same length"))); + (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), + errmsg("UR and LL arrays must be of same length"))); } dur = ARRPTR(ur); dll = ARRPTR(ll); size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim; - result = (NDBOX *) palloc (size); - memset (result, 0, size); + result = (NDBOX *) palloc(size); + memset(result, 0, size); result->size = size; result->dim = dim; - for (i=0; i<dim; i++) + for (i = 0; i < dim; i++) { result->x[i] = dur[i]; - result->x[i+dim] = dll[i]; + result->x[i + dim] = dll[i]; } PG_RETURN_POINTER(result); @@ -241,20 +243,20 @@ cube_a_f8_f8(PG_FUNCTION_ARGS) Datum cube_a_f8(PG_FUNCTION_ARGS) { - int i; - int dim; - int size; - NDBOX *result; - ArrayType *ur; - double *dur; + int i; + int dim; + int size; + NDBOX *result; + ArrayType *ur; + double *dur; ur = (ArrayType *) PG_GETARG_VARLENA_P(0); if (ARR_HASNULL(ur)) { ereport(ERROR, - (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), - errmsg("Cannot work with NULL arrays"))); + (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), + errmsg("Cannot work with NULL arrays"))); } dim = ARRNELEMS(ur); @@ -262,15 +264,15 @@ cube_a_f8(PG_FUNCTION_ARGS) dur = ARRPTR(ur); size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim; - result = (NDBOX *) palloc (size); - memset (result, 0, size); + result = (NDBOX *) palloc(size); + memset(result, 0, size); result->size = size; result->dim = dim; - for (i=0; i<dim; i++) + for (i = 0; i < dim; i++) { result->x[i] = dur[i]; - result->x[i+dim] = dur[i]; + result->x[i + dim] = dur[i]; } PG_RETURN_POINTER(result); @@ -279,10 +281,13 @@ cube_a_f8(PG_FUNCTION_ARGS) Datum cube_subset(PG_FUNCTION_ARGS) { - NDBOX *c, *result; - ArrayType *idx; - int size, dim, i; - int *dx; + NDBOX *c, + *result; + ArrayType *idx; + int size, + dim, + i; + int *dx; c = (NDBOX *) PG_GETARG_POINTER(0); idx = (ArrayType *) PG_GETARG_VARLENA_P(1); @@ -290,30 +295,30 @@ cube_subset(PG_FUNCTION_ARGS) if (ARR_HASNULL(idx)) { ereport(ERROR, - (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), - errmsg("Cannot work with NULL arrays"))); + (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), + errmsg("Cannot work with NULL arrays"))); } - dx = (int4 *) ARR_DATA_PTR (idx); + dx = (int4 *) ARR_DATA_PTR(idx); dim = ARRNELEMS(idx); size = offsetof(NDBOX, x[0]) + sizeof(double) * 2 * dim; - result = (NDBOX *) palloc (size); - memset (result, 0, size); + result = (NDBOX *) palloc(size); + memset(result, 0, size); result->size = size; result->dim = dim; - for (i=0; i<dim; i++) + for (i = 0; i < dim; i++) { if ((dx[i] <= 0) || (dx[i] > c->dim)) { - pfree (result); + pfree(result); ereport(ERROR, - (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), - errmsg("Index out of bounds"))); + (errcode(ERRCODE_ARRAY_ELEMENT_ERROR), + errmsg("Index out of bounds"))); } - result->x[i] = c->x[dx[i]-1]; - result->x[i+dim] = c->x[dx[i]+c->dim-1]; + result->x[i] = c->x[dx[i] - 1]; + result->x[i + dim] = c->x[dx[i] + c->dim - 1]; } PG_RETURN_POINTER(result); @@ -327,11 +332,11 @@ cube_out(PG_FUNCTION_ARGS) int dim; int i; int ndig; - NDBOX *cube; + NDBOX *cube; initStringInfo(&buf); - cube = (NDBOX *) PG_GETARG_POINTER (0); + cube = (NDBOX *) PG_GETARG_POINTER(0); dim = cube->dim; @@ -369,7 +374,7 @@ cube_out(PG_FUNCTION_ARGS) appendStringInfoChar(&buf, ')'); } - PG_RETURN_CSTRING (buf.data); + PG_RETURN_CSTRING(buf.data); } @@ -383,11 +388,11 @@ cube_out(PG_FUNCTION_ARGS) ** the predicate x op query == FALSE, where op is the oper ** corresponding to strategy in the pg_amop table. */ -Datum +Datum g_cube_consistent(PG_FUNCTION_ARGS) { - GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); - NDBOX *query = (NDBOX *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); + GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); + NDBOX *query = (NDBOX *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(1))); StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); /* @@ -414,7 +419,7 @@ g_cube_union(PG_FUNCTION_ARGS) NDBOX *out = (NDBOX *) NULL; NDBOX *tmp; int *sizep; - GistEntryVector *entryvec; + GistEntryVector *entryvec; entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); sizep = (int *) PG_GETARG_POINTER(1); @@ -446,15 +451,15 @@ g_cube_union(PG_FUNCTION_ARGS) */ Datum -g_cube_compress (PG_FUNCTION_ARGS) +g_cube_compress(PG_FUNCTION_ARGS) { - PG_RETURN_DATUM(PG_GETARG_DATUM(0)); + PG_RETURN_DATUM(PG_GETARG_DATUM(0)); } Datum -g_cube_decompress (PG_FUNCTION_ARGS) +g_cube_decompress(PG_FUNCTION_ARGS) { - PG_RETURN_DATUM(PG_GETARG_DATUM(0)); + PG_RETURN_DATUM(PG_GETARG_DATUM(0)); } @@ -463,17 +468,17 @@ g_cube_decompress (PG_FUNCTION_ARGS) ** As in the R-tree paper, we use change in area as our penalty metric */ Datum -g_cube_penalty (PG_FUNCTION_ARGS) +g_cube_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); + GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); + GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); + float *result = (float *) PG_GETARG_POINTER(2); NDBOX *ud; double tmp1, tmp2; ud = cube_union_v0((NDBOX *) DatumGetPointer(origentry->key), - (NDBOX *) DatumGetPointer(newentry->key)); + (NDBOX *) DatumGetPointer(newentry->key)); rt_cube_size(ud, &tmp1); rt_cube_size((NDBOX *) DatumGetPointer(origentry->key), &tmp2); *result = (float) (tmp1 - tmp2); @@ -481,7 +486,7 @@ g_cube_penalty (PG_FUNCTION_ARGS) /* * fprintf(stderr, "penalty\n"); fprintf(stderr, "\t%g\n", *result); */ - PG_RETURN_FLOAT8 (*result); + PG_RETURN_FLOAT8(*result); } @@ -493,8 +498,8 @@ g_cube_penalty (PG_FUNCTION_ARGS) Datum g_cube_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec; - GIST_SPLITVEC *v; + GistEntryVector *entryvec; + GIST_SPLITVEC *v; OffsetNumber i, j; NDBOX *datum_alpha, @@ -546,9 +551,9 @@ g_cube_picksplit(PG_FUNCTION_ARGS) /* size_waste = size_union - size_inter; */ union_d = cube_union_v0(datum_alpha, datum_beta); rt_cube_size(union_d, &size_union); - inter_d = (NDBOX *) DatumGetPointer (DirectFunctionCall2 - (cube_inter, - entryvec->vector[i].key, entryvec->vector[j].key)); + inter_d = (NDBOX *) DatumGetPointer(DirectFunctionCall2 + (cube_inter, + entryvec->vector[i].key, entryvec->vector[j].key)); rt_cube_size(inter_d, &size_inter); size_waste = size_union - size_inter; @@ -649,12 +654,13 @@ g_cube_picksplit(PG_FUNCTION_ARGS) Datum g_cube_same(PG_FUNCTION_ARGS) { - NDBOX *b1, *b2; - bool *result; - - b1 = (NDBOX *) PG_GETARG_POINTER (0); - b2 = (NDBOX *) PG_GETARG_POINTER (1); - result = (bool *) PG_GETARG_POINTER (2); + NDBOX *b1, + *b2; + bool *result; + + b1 = (NDBOX *) PG_GETARG_POINTER(0); + b2 = (NDBOX *) PG_GETARG_POINTER(1); + result = (bool *) PG_GETARG_POINTER(2); if (cube_cmp_v0(b1, b2) == 0) *result = TRUE; @@ -664,7 +670,7 @@ g_cube_same(PG_FUNCTION_ARGS) /* * fprintf(stderr, "same: %s\n", (*result ? "TRUE" : "FALSE" )); */ - PG_RETURN_POINTER (result); + PG_RETURN_POINTER(result); } /* @@ -803,14 +809,15 @@ cube_union_v0(NDBOX * a, NDBOX * b) } Datum -cube_union (PG_FUNCTION_ARGS) +cube_union(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); - PG_RETURN_POINTER(cube_union_v0(a,b)); + PG_RETURN_POINTER(cube_union_v0(a, b)); } /* cube_inter */ @@ -818,7 +825,9 @@ Datum cube_inter(PG_FUNCTION_ARGS) { int i; - NDBOX *result, *a, *b; + NDBOX *result, + *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -874,17 +883,17 @@ cube_inter(PG_FUNCTION_ARGS) /* * Is it OK to return a non-null intersection for non-overlapping boxes? */ - PG_RETURN_POINTER (result); + PG_RETURN_POINTER(result); } /* cube_size */ Datum cube_size(PG_FUNCTION_ARGS) { - NDBOX *a; + NDBOX *a; int i, j; - double result; + double result; a = (NDBOX *) PG_GETARG_POINTER(0); @@ -892,7 +901,7 @@ cube_size(PG_FUNCTION_ARGS) for (i = 0, j = a->dim; i < a->dim; i++, j++) result = result * Abs((a->x[j] - a->x[i])); - PG_RETURN_FLOAT8 (result); + PG_RETURN_FLOAT8(result); } void @@ -994,10 +1003,11 @@ cube_cmp_v0(NDBOX * a, NDBOX * b) return 0; } -Datum +Datum cube_cmp(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1009,7 +1019,8 @@ cube_cmp(PG_FUNCTION_ARGS) Datum cube_eq(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1021,7 +1032,8 @@ cube_eq(PG_FUNCTION_ARGS) Datum cube_ne(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1033,7 +1045,8 @@ cube_ne(PG_FUNCTION_ARGS) Datum cube_lt(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1045,7 +1058,8 @@ cube_lt(PG_FUNCTION_ARGS) Datum cube_gt(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1057,7 +1071,8 @@ cube_gt(PG_FUNCTION_ARGS) Datum cube_le(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1069,7 +1084,8 @@ cube_le(PG_FUNCTION_ARGS) Datum cube_ge(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1122,7 +1138,8 @@ cube_contains_v0(NDBOX * a, NDBOX * b) Datum cube_contains(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1135,12 +1152,13 @@ cube_contains(PG_FUNCTION_ARGS) Datum cube_contained(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); - PG_RETURN_BOOL (cube_contains_v0(b, a)); + PG_RETURN_BOOL(cube_contains_v0(b, a)); } /* Overlap */ @@ -1193,12 +1211,13 @@ cube_overlap_v0(NDBOX * a, NDBOX * b) Datum cube_overlap(PG_FUNCTION_ARGS) { - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); - PG_RETURN_BOOL (cube_overlap_v0(a, b)); + PG_RETURN_BOOL(cube_overlap_v0(a, b)); } @@ -1213,7 +1232,8 @@ cube_distance(PG_FUNCTION_ARGS) int i; double d, distance; - NDBOX *a, *b; + NDBOX *a, + *b; a = (NDBOX *) PG_GETARG_POINTER(0); b = (NDBOX *) PG_GETARG_POINTER(1); @@ -1266,7 +1286,7 @@ cube_is_point(PG_FUNCTION_ARGS) { int i, j; - NDBOX *a; + NDBOX *a; a = (NDBOX *) PG_GETARG_POINTER(0); @@ -1283,7 +1303,7 @@ cube_is_point(PG_FUNCTION_ARGS) Datum cube_dim(PG_FUNCTION_ARGS) { - NDBOX *c; + NDBOX *c; c = (NDBOX *) PG_GETARG_POINTER(0); @@ -1397,8 +1417,8 @@ cube_f8(PG_FUNCTION_ARGS) result->dim = 1; result->x[0] = PG_GETARG_FLOAT8(0); result->x[1] = result->x[0]; - - PG_RETURN_POINTER (result); + + PG_RETURN_POINTER(result); } /* Create a one dimensional box */ @@ -1416,7 +1436,7 @@ cube_f8_f8(PG_FUNCTION_ARGS) result->x[0] = PG_GETARG_FLOAT8(0); result->x[1] = PG_GETARG_FLOAT8(1); - PG_RETURN_POINTER (result); + PG_RETURN_POINTER(result); } /* Add a dimension to an existing cube with the same values for the new @@ -1431,7 +1451,7 @@ cube_c_f8(PG_FUNCTION_ARGS) int i; c = (NDBOX *) PG_GETARG_POINTER(0); - x = PG_GETARG_FLOAT8 (1); + x = PG_GETARG_FLOAT8(1); size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2; result = (NDBOX *) palloc(size); @@ -1446,7 +1466,7 @@ cube_c_f8(PG_FUNCTION_ARGS) result->x[result->dim - 1] = x; result->x[2 * result->dim - 1] = x; - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } /* Add a dimension to an existing cube */ @@ -1455,13 +1475,14 @@ cube_c_f8_f8(PG_FUNCTION_ARGS) { NDBOX *c; NDBOX *result; - double x1, x2; + double x1, + x2; int size; int i; c = (NDBOX *) PG_GETARG_POINTER(0); - x1 = PG_GETARG_FLOAT8 (1); - x2 = PG_GETARG_FLOAT8 (2); + x1 = PG_GETARG_FLOAT8(1); + x2 = PG_GETARG_FLOAT8(2); size = offsetof(NDBOX, x[0]) + sizeof(double) * (c->dim + 1) *2; result = (NDBOX *) palloc(size); @@ -1476,7 +1497,5 @@ cube_c_f8_f8(PG_FUNCTION_ARGS) result->x[result->dim - 1] = x1; result->x[2 * result->dim - 1] = x2; - PG_RETURN_POINTER(result); + PG_RETURN_POINTER(result); } - - diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c index 7a46673b6b..08fb6328fb 100644 --- a/contrib/dblink/dblink.c +++ b/contrib/dblink/dblink.c @@ -8,7 +8,7 @@ * Darko Prenosil <[email protected]> * Shridhar Daithankar <[email protected]> * - * $PostgreSQL: pgsql/contrib/dblink/dblink.c,v 1.58 2006/09/02 21:11:15 joe Exp $ + * $PostgreSQL: pgsql/contrib/dblink/dblink.c,v 1.59 2006/10/04 00:29:44 momjian Exp $ * Copyright (c) 2001-2006, PostgreSQL Global Development Group * ALL RIGHTS RESERVED; * @@ -362,11 +362,11 @@ dblink_open(PG_FUNCTION_ARGS) DBLINK_RES_INTERNALERROR("begin error"); PQclear(res); rconn->newXactForCursor = TRUE; + /* * Since transaction state was IDLE, we force cursor count to - * initially be 0. This is needed as a previous ABORT might - * have wiped out our transaction without maintaining the - * cursor count for us. + * initially be 0. This is needed as a previous ABORT might have wiped + * out our transaction without maintaining the cursor count for us. */ rconn->openCursorCount = 0; } @@ -621,8 +621,8 @@ dblink_fetch(PG_FUNCTION_ARGS) if (PQnfields(res) != tupdesc->natts) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), - errmsg("remote query result rowtype does not match " - "the specified FROM clause rowtype"))); + errmsg("remote query result rowtype does not match " + "the specified FROM clause rowtype"))); /* fast track when no results */ if (funcctx->max_calls < 1) @@ -827,7 +827,7 @@ dblink_record_internal(FunctionCallInfo fcinfo, bool is_async, bool do_get) if (!res || (PQresultStatus(res) != PGRES_COMMAND_OK && - PQresultStatus(res) != PGRES_TUPLES_OK)) + PQresultStatus(res) != PGRES_TUPLES_OK)) { if (fail) DBLINK_RES_ERROR("sql error"); @@ -839,33 +839,33 @@ dblink_record_internal(FunctionCallInfo fcinfo, bool is_async, bool do_get) SRF_RETURN_DONE(funcctx); } } - + if (PQresultStatus(res) == PGRES_COMMAND_OK) { is_sql_cmd = true; - + /* need a tuple descriptor representing one TEXT column */ tupdesc = CreateTemplateTupleDesc(1, false); TupleDescInitEntry(tupdesc, (AttrNumber) 1, "status", - TEXTOID, -1, 0); - + TEXTOID, -1, 0); + /* - * and save a copy of the command status string to return as our - * result tuple - */ + * and save a copy of the command status string to return as + * our result tuple + */ sql_cmd_status = PQcmdStatus(res); funcctx->max_calls = 1; } else funcctx->max_calls = PQntuples(res); - + /* got results, keep track of them */ funcctx->user_fctx = res; - + /* if needed, close the connection to the database and cleanup */ if (freeconn) PQfinish(conn); - + if (!is_sql_cmd) { /* get a tuple descriptor for our result type */ @@ -878,26 +878,29 @@ dblink_record_internal(FunctionCallInfo fcinfo, bool is_async, bool do_get) /* failed to determine actual type of RECORD */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("function returning record called in context " - "that cannot accept type record"))); + errmsg("function returning record called in context " + "that cannot accept type record"))); break; default: /* result type isn't composite */ elog(ERROR, "return type must be a row type"); break; } - + /* make sure we have a persistent copy of the tupdesc */ tupdesc = CreateTupleDescCopy(tupdesc); } - - /* check result and tuple descriptor have the same number of columns */ + + /* + * check result and tuple descriptor have the same number of + * columns + */ if (PQnfields(res) != tupdesc->natts) ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), - errmsg("remote query result rowtype does not match " - "the specified FROM clause rowtype"))); - + errmsg("remote query result rowtype does not match " + "the specified FROM clause rowtype"))); + /* fast track when no results */ if (funcctx->max_calls < 1) { @@ -905,11 +908,11 @@ dblink_record_internal(FunctionCallInfo fcinfo, bool is_async, bool do_get) PQclear(res); SRF_RETURN_DONE(funcctx); } - + /* store needed metadata for subsequent calls */ attinmeta = TupleDescGetAttInMetadata(tupdesc); funcctx->attinmeta = attinmeta; - + MemoryContextSwitchTo(oldcontext); } else @@ -991,9 +994,9 @@ PG_FUNCTION_INFO_V1(dblink_get_connections); Datum dblink_get_connections(PG_FUNCTION_ARGS) { - HASH_SEQ_STATUS status; - remoteConnHashEnt *hentry; - ArrayBuildState *astate = NULL; + HASH_SEQ_STATUS status; + remoteConnHashEnt *hentry; + ArrayBuildState *astate = NULL; if (remoteConnHash) { @@ -1019,19 +1022,19 @@ dblink_get_connections(PG_FUNCTION_ARGS) * * Returns 1 if the connection is busy, 0 otherwise * Params: - * text connection_name - name of the connection to check - * + * text connection_name - name of the connection to check + * */ PG_FUNCTION_INFO_V1(dblink_is_busy); Datum dblink_is_busy(PG_FUNCTION_ARGS) { - char *msg; - PGconn *conn = NULL; - char *conname = NULL; - char *connstr = NULL; - remoteConn *rconn = NULL; - bool freeconn = false; + char *msg; + PGconn *conn = NULL; + char *conname = NULL; + char *connstr = NULL; + remoteConn *rconn = NULL; + bool freeconn = false; DBLINK_INIT; DBLINK_GET_CONN; @@ -1045,27 +1048,27 @@ dblink_is_busy(PG_FUNCTION_ARGS) /* * Cancels a running request on a connection * - * Returns text: + * Returns text: * "OK" if the cancel request has been sent correctly, - * an error message otherwise - * + * an error message otherwise + * * Params: - * text connection_name - name of the connection to check - * + * text connection_name - name of the connection to check + * */ PG_FUNCTION_INFO_V1(dblink_cancel_query); Datum dblink_cancel_query(PG_FUNCTION_ARGS) { - char *msg; - int res = 0; - PGconn *conn = NULL; - char *conname = NULL; - char *connstr = NULL; - remoteConn *rconn = NULL; - bool freeconn = false; - PGcancel *cancel; - char errbuf[256]; + char *msg; + int res = 0; + PGconn *conn = NULL; + char *conname = NULL; + char *connstr = NULL; + remoteConn *rconn = NULL; + bool freeconn = false; + PGcancel *cancel; + char errbuf[256]; DBLINK_INIT; DBLINK_GET_CONN; @@ -1077,7 +1080,7 @@ dblink_cancel_query(PG_FUNCTION_ARGS) PQfreeCancel(cancel); if (res == 0) - PG_RETURN_TEXT_P(GET_TEXT("OK")); + PG_RETURN_TEXT_P(GET_TEXT("OK")); else PG_RETURN_TEXT_P(GET_TEXT(errbuf)); } @@ -1086,23 +1089,23 @@ dblink_cancel_query(PG_FUNCTION_ARGS) /* * Get error message from a connection * - * Returns text: + * Returns text: * "OK" if no error, an error message otherwise - * + * * Params: - * text connection_name - name of the connection to check - * + * text connection_name - name of the connection to check + * */ PG_FUNCTION_INFO_V1(dblink_error_message); Datum dblink_error_message(PG_FUNCTION_ARGS) { - char *msg; - PGconn *conn = NULL; - char *conname = NULL; - char *connstr = NULL; - remoteConn *rconn = NULL; - bool freeconn = false; + char *msg; + PGconn *conn = NULL; + char *conname = NULL; + char *connstr = NULL; + remoteConn *rconn = NULL; + bool freeconn = false; DBLINK_INIT; DBLINK_GET_CONN; @@ -1859,7 +1862,7 @@ get_sql_delete(Oid relid, int2vector *pkattnums, int16 pknumatts, char **tgt_pka char *relname; TupleDesc tupdesc; int natts; - StringInfoData buf; + StringInfoData buf; int i; initStringInfo(&buf); diff --git a/contrib/hstore/hstore.h b/contrib/hstore/hstore.h index 5fb5999610..20ae203416 100644 --- a/contrib/hstore/hstore.h +++ b/contrib/hstore/hstore.h @@ -11,39 +11,42 @@ #include "storage/bufpage.h" -typedef struct { - uint16 keylen; - uint16 vallen; - uint32 - valisnull:1, - pos:31; -} HEntry; - - -typedef struct { - int4 len; - int4 size; - char data[1]; -} HStore; +typedef struct +{ + uint16 keylen; + uint16 vallen; + uint32 + valisnull:1, + pos:31; +} HEntry; + + +typedef struct +{ + int4 len; + int4 size; + char data[1]; +} HStore; #define HSHRDSIZE (2*sizeof(int4)) #define CALCDATASIZE(x, lenstr) ( (x) * sizeof(HEntry) + HSHRDSIZE + (lenstr) ) -#define ARRPTR(x) ( (HEntry*) ( (char*)(x) + HSHRDSIZE ) ) -#define STRPTR(x) ( (char*)(x) + HSHRDSIZE + ( sizeof(HEntry) * ((HStore*)x)->size ) ) +#define ARRPTR(x) ( (HEntry*) ( (char*)(x) + HSHRDSIZE ) ) +#define STRPTR(x) ( (char*)(x) + HSHRDSIZE + ( sizeof(HEntry) * ((HStore*)x)->size ) ) -#define PG_GETARG_HS(x) ((HStore*)PG_DETOAST_DATUM(PG_GETARG_DATUM(x))) +#define PG_GETARG_HS(x) ((HStore*)PG_DETOAST_DATUM(PG_GETARG_DATUM(x))) -typedef struct { - char *key; - char *val; - uint16 keylen; - uint16 vallen; - bool isnull; - bool needfree; -} Pairs; +typedef struct +{ + char *key; + char *val; + uint16 keylen; + uint16 vallen; + bool isnull; + bool needfree; +} Pairs; -int comparePairs(const void *a, const void *b); -int uniquePairs(Pairs * a, int4 l, int4 *buflen); +int comparePairs(const void *a, const void *b); +int uniquePairs(Pairs * a, int4 l, int4 *buflen); #endif diff --git a/contrib/hstore/hstore_gist.c b/contrib/hstore/hstore_gist.c index f1c8738266..4220a5541d 100644 --- a/contrib/hstore/hstore_gist.c +++ b/contrib/hstore/hstore_gist.c @@ -7,8 +7,8 @@ /* bigint defines */ #define BITBYTE 8 -#define SIGLENINT 4 /* >122 => key will toast, so very slow!!! */ -#define SIGLEN ( sizeof(int)*SIGLENINT ) +#define SIGLENINT 4 /* >122 => key will toast, so very slow!!! */ +#define SIGLEN ( sizeof(int)*SIGLENINT ) #define SIGLENBIT (SIGLEN*BITBYTE) typedef char BITVEC[SIGLEN]; @@ -36,22 +36,23 @@ typedef char *BITVECP; #define HASHVAL(val) (((unsigned int)(val)) % SIGLENBIT) #define HASH(sign, val) SETBIT((sign), HASHVAL(val)) -typedef struct { - int4 len; - int4 flag; - char data[1]; -} GISTTYPE; +typedef struct +{ + int4 len; + int4 flag; + char data[1]; +} GISTTYPE; -#define ALLISTRUE 0x04 +#define ALLISTRUE 0x04 -#define ISALLTRUE(x) ( ((GISTTYPE*)x)->flag & ALLISTRUE ) +#define ISALLTRUE(x) ( ((GISTTYPE*)x)->flag & ALLISTRUE ) -#define GTHDRSIZE ( sizeof(int4)*2 ) +#define GTHDRSIZE ( sizeof(int4)*2 ) #define CALCGTSIZE(flag) ( GTHDRSIZE+(((flag) & ALLISTRUE) ? 0 : SIGLEN) ) - -#define GETSIGN(x) ( (BITVECP)( (char*)x+GTHDRSIZE ) ) -#define SUMBIT(val) ( \ +#define GETSIGN(x) ( (BITVECP)( (char*)x+GTHDRSIZE ) ) + +#define SUMBIT(val) ( \ GETBITBYTE((val),0) + \ GETBITBYTE((val),1) + \ GETBITBYTE((val),2) + \ @@ -67,20 +68,22 @@ typedef struct { #define WISH_F(a,b,c) (double)( -(double)(((a)-(b))*((a)-(b))*((a)-(b)))*(c) ) PG_FUNCTION_INFO_V1(ghstore_in); -Datum ghstore_in(PG_FUNCTION_ARGS); +Datum ghstore_in(PG_FUNCTION_ARGS); PG_FUNCTION_INFO_V1(ghstore_out); -Datum ghstore_out(PG_FUNCTION_ARGS); - +Datum ghstore_out(PG_FUNCTION_ARGS); + Datum -ghstore_in(PG_FUNCTION_ARGS) { +ghstore_in(PG_FUNCTION_ARGS) +{ elog(ERROR, "Not implemented"); PG_RETURN_DATUM(0); } Datum -ghstore_out(PG_FUNCTION_ARGS) { +ghstore_out(PG_FUNCTION_ARGS) +{ elog(ERROR, "Not implemented"); PG_RETURN_DATUM(0); } @@ -93,36 +96,41 @@ PG_FUNCTION_INFO_V1(ghstore_picksplit); PG_FUNCTION_INFO_V1(ghstore_union); PG_FUNCTION_INFO_V1(ghstore_same); -Datum ghstore_consistent(PG_FUNCTION_ARGS); -Datum ghstore_compress(PG_FUNCTION_ARGS); -Datum ghstore_decompress(PG_FUNCTION_ARGS); -Datum ghstore_penalty(PG_FUNCTION_ARGS); -Datum ghstore_picksplit(PG_FUNCTION_ARGS); -Datum ghstore_union(PG_FUNCTION_ARGS); -Datum ghstore_same(PG_FUNCTION_ARGS); +Datum ghstore_consistent(PG_FUNCTION_ARGS); +Datum ghstore_compress(PG_FUNCTION_ARGS); +Datum ghstore_decompress(PG_FUNCTION_ARGS); +Datum ghstore_penalty(PG_FUNCTION_ARGS); +Datum ghstore_picksplit(PG_FUNCTION_ARGS); +Datum ghstore_union(PG_FUNCTION_ARGS); +Datum ghstore_same(PG_FUNCTION_ARGS); Datum -ghstore_compress(PG_FUNCTION_ARGS) { +ghstore_compress(PG_FUNCTION_ARGS) +{ GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); GISTENTRY *retval = entry; - - if (entry->leafkey) { - GISTTYPE *res = (GISTTYPE*)palloc(CALCGTSIZE(0)); - HStore *toastedval = (HStore *) DatumGetPointer(entry->key); - HStore *val = (HStore *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); - HEntry *ptr = ARRPTR(val); - char *words = STRPTR(val); - - memset(res,0,CALCGTSIZE(0)); - res->len=CALCGTSIZE(0); - - while(ptr-ARRPTR(val) < val->size) { - int h; - h = crc32_sz((char*)(words+ptr->pos), ptr->keylen); - HASH( GETSIGN(res), h); - if ( !ptr->valisnull ) { - h = crc32_sz((char *)(words+ptr->pos+ptr->keylen), ptr->vallen); - HASH( GETSIGN(res), h); + + if (entry->leafkey) + { + GISTTYPE *res = (GISTTYPE *) palloc(CALCGTSIZE(0)); + HStore *toastedval = (HStore *) DatumGetPointer(entry->key); + HStore *val = (HStore *) DatumGetPointer(PG_DETOAST_DATUM(entry->key)); + HEntry *ptr = ARRPTR(val); + char *words = STRPTR(val); + + memset(res, 0, CALCGTSIZE(0)); + res->len = CALCGTSIZE(0); + + while (ptr - ARRPTR(val) < val->size) + { + int h; + + h = crc32_sz((char *) (words + ptr->pos), ptr->keylen); + HASH(GETSIGN(res), h); + if (!ptr->valisnull) + { + h = crc32_sz((char *) (words + ptr->pos + ptr->keylen), ptr->vallen); + HASH(GETSIGN(res), h); } ptr++; } @@ -135,14 +143,16 @@ ghstore_compress(PG_FUNCTION_ARGS) { entry->rel, entry->page, entry->offset, FALSE); - } else if ( !ISALLTRUE(DatumGetPointer(entry->key)) ) { - int4 i; + } + else if (!ISALLTRUE(DatumGetPointer(entry->key))) + { + int4 i; GISTTYPE *res; - BITVECP sign = GETSIGN(DatumGetPointer(entry->key)); - + BITVECP sign = GETSIGN(DatumGetPointer(entry->key)); + LOOPBYTE( - if ((sign[i] & 0xff) != 0xff) - PG_RETURN_POINTER(retval); + if ((sign[i] & 0xff) != 0xff) + PG_RETURN_POINTER(retval); ); res = (GISTTYPE *) palloc(CALCGTSIZE(ALLISTRUE)); @@ -152,7 +162,7 @@ ghstore_compress(PG_FUNCTION_ARGS) { retval = (GISTENTRY *) palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(res), entry->rel, entry->page, - entry->offset, + entry->offset, FALSE); } @@ -160,15 +170,17 @@ ghstore_compress(PG_FUNCTION_ARGS) { } Datum -ghstore_decompress(PG_FUNCTION_ARGS) { +ghstore_decompress(PG_FUNCTION_ARGS) +{ PG_RETURN_DATUM(PG_GETARG_DATUM(0)); } Datum -ghstore_same(PG_FUNCTION_ARGS) { +ghstore_same(PG_FUNCTION_ARGS) +{ GISTTYPE *a = (GISTTYPE *) PG_GETARG_POINTER(0); GISTTYPE *b = (GISTTYPE *) PG_GETARG_POINTER(1); - bool *result = (bool *) PG_GETARG_POINTER(2); + bool *result = (bool *) PG_GETARG_POINTER(2); if (ISALLTRUE(a) && ISALLTRUE(b)) *result = true; @@ -176,83 +188,97 @@ ghstore_same(PG_FUNCTION_ARGS) { *result = false; else if (ISALLTRUE(b)) *result = false; - else { - int4 i; - BITVECP sa = GETSIGN(a), - sb = GETSIGN(b); + else + { + int4 i; + BITVECP sa = GETSIGN(a), + sb = GETSIGN(b); + *result = true; LOOPBYTE( - if (sa[i] != sb[i]) { - *result = false; - break; - } + if (sa[i] != sb[i]) + { + *result = false; + break; + } ); } PG_RETURN_POINTER(result); } static int4 -sizebitvec(BITVECP sign) { - int4 size = 0, i; +sizebitvec(BITVECP sign) +{ + int4 size = 0, + i; + LOOPBYTE( - size += SUMBIT(sign); - sign = (BITVECP) (((char *) sign) + 1); + size += SUMBIT(sign); + sign = (BITVECP) (((char *) sign) + 1); ); return size; } - + static int -hemdistsign(BITVECP a, BITVECP b) { - int i,dist=0; +hemdistsign(BITVECP a, BITVECP b) +{ + int i, + dist = 0; LOOPBIT( - if ( GETBIT(a,i) != GETBIT(b,i) ) + if (GETBIT(a, i) != GETBIT(b, i)) dist++; ); return dist; } static int -hemdist(GISTTYPE *a, GISTTYPE *b) { - if ( ISALLTRUE(a) ) { +hemdist(GISTTYPE * a, GISTTYPE * b) +{ + if (ISALLTRUE(a)) + { if (ISALLTRUE(b)) return 0; else - return SIGLENBIT-sizebitvec(GETSIGN(b)); - } else if (ISALLTRUE(b)) - return SIGLENBIT-sizebitvec(GETSIGN(a)); + return SIGLENBIT - sizebitvec(GETSIGN(b)); + } + else if (ISALLTRUE(b)) + return SIGLENBIT - sizebitvec(GETSIGN(a)); - return hemdistsign( GETSIGN(a), GETSIGN(b) ); + return hemdistsign(GETSIGN(a), GETSIGN(b)); } static int4 unionkey(BITVECP sbase, GISTTYPE * add) { - int4 i; - BITVECP sadd = GETSIGN(add); + int4 i; + BITVECP sadd = GETSIGN(add); if (ISALLTRUE(add)) return 1; LOOPBYTE( - sbase[i] |= sadd[i]; + sbase[i] |= sadd[i]; ); return 0; } Datum -ghstore_union(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); - int4 len = entryvec->n; - - int *size = (int *) PG_GETARG_POINTER(1); - BITVEC base; - int4 i; - int4 flag = 0; +ghstore_union(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); + int4 len = entryvec->n; + + int *size = (int *) PG_GETARG_POINTER(1); + BITVEC base; + int4 i; + int4 flag = 0; GISTTYPE *result; MemSet((void *) base, 0, sizeof(BITVEC)); - for (i = 0; i < len; i++) { - if (unionkey(base, GETENTRY(entryvec, i))) { + for (i = 0; i < len; i++) + { + if (unionkey(base, GETENTRY(entryvec, i))) + { flag = ALLISTRUE; break; } @@ -269,64 +295,72 @@ ghstore_union(PG_FUNCTION_ARGS) { } Datum -ghstore_penalty(PG_FUNCTION_ARGS) { +ghstore_penalty(PG_FUNCTION_ARGS) +{ GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); /* always ISSIGNKEY */ GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); - float *penalty = (float *) PG_GETARG_POINTER(2); + float *penalty = (float *) PG_GETARG_POINTER(2); GISTTYPE *origval = (GISTTYPE *) DatumGetPointer(origentry->key); GISTTYPE *newval = (GISTTYPE *) DatumGetPointer(newentry->key); - *penalty=hemdist(origval,newval); + *penalty = hemdist(origval, newval); PG_RETURN_POINTER(penalty); } -typedef struct { +typedef struct +{ OffsetNumber pos; - int4 cost; -} SPLITCOST; + int4 cost; +} SPLITCOST; static int -comparecost(const void *a, const void *b) { +comparecost(const void *a, const void *b) +{ return ((SPLITCOST *) a)->cost - ((SPLITCOST *) b)->cost; } Datum -ghstore_picksplit(PG_FUNCTION_ARGS) { - GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); +ghstore_picksplit(PG_FUNCTION_ARGS) +{ + GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); OffsetNumber maxoff = entryvec->n - 2; GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); OffsetNumber k, j; - GISTTYPE *datum_l, + GISTTYPE *datum_l, *datum_r; - BITVECP union_l, + BITVECP union_l, union_r; - int4 size_alpha, size_beta; - int4 size_waste, + int4 size_alpha, + size_beta; + int4 size_waste, waste = -1; - int4 nbytes; + int4 nbytes; OffsetNumber seed_1 = 0, seed_2 = 0; OffsetNumber *left, *right; - BITVECP ptr; - int i; + BITVECP ptr; + int i; SPLITCOST *costvector; - GISTTYPE *_k, + GISTTYPE *_k, *_j; nbytes = (maxoff + 2) * sizeof(OffsetNumber); v->spl_left = (OffsetNumber *) palloc(nbytes); v->spl_right = (OffsetNumber *) palloc(nbytes); - for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) { + for (k = FirstOffsetNumber; k < maxoff; k = OffsetNumberNext(k)) + { _k = GETENTRY(entryvec, k); - for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) { - size_waste=hemdist(_k, GETENTRY(entryvec, j)); - if (size_waste > waste ) { + for (j = OffsetNumberNext(k); j <= maxoff; j = OffsetNumberNext(j)) + { + size_waste = hemdist(_k, GETENTRY(entryvec, j)); + if (size_waste > waste) + { waste = size_waste; seed_1 = k; seed_2 = j; @@ -346,26 +380,32 @@ ghstore_picksplit(PG_FUNCTION_ARGS) { } /* form initial .. */ - if (ISALLTRUE(GETENTRY(entryvec, seed_1))) { + if (ISALLTRUE(GETENTRY(entryvec, seed_1))) + { datum_l = (GISTTYPE *) palloc(GTHDRSIZE); datum_l->len = GTHDRSIZE; datum_l->flag = ALLISTRUE; - } else { + } + else + { datum_l = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); datum_l->len = GTHDRSIZE + SIGLEN; datum_l->flag = 0; memcpy((void *) GETSIGN(datum_l), (void *) GETSIGN(GETENTRY(entryvec, seed_1)), sizeof(BITVEC)) -; + ; } - if (ISALLTRUE(GETENTRY(entryvec, seed_2))) { + if (ISALLTRUE(GETENTRY(entryvec, seed_2))) + { datum_r = (GISTTYPE *) palloc(GTHDRSIZE); datum_r->len = GTHDRSIZE; datum_r->flag = ALLISTRUE; - } else { + } + else + { datum_r = (GISTTYPE *) palloc(GTHDRSIZE + SIGLEN); datum_r->len = GTHDRSIZE + SIGLEN; datum_r->flag = 0; - memcpy((void *) GETSIGN(datum_r), (void *) GETSIGN(GETENTRY(entryvec, seed_2)), sizeof(BITVEC)) ; + memcpy((void *) GETSIGN(datum_r), (void *) GETSIGN(GETENTRY(entryvec, seed_2)), sizeof(BITVEC)); } maxoff = OffsetNumberNext(maxoff); @@ -375,50 +415,63 @@ ghstore_picksplit(PG_FUNCTION_ARGS) { { costvector[j - 1].pos = j; _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l,_j); - size_beta = hemdist(datum_r,_j); + size_alpha = hemdist(datum_l, _j); + size_beta = hemdist(datum_r, _j); costvector[j - 1].cost = abs(size_alpha - size_beta); } qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost); - union_l=GETSIGN(datum_l); - union_r=GETSIGN(datum_r); + union_l = GETSIGN(datum_l); + union_r = GETSIGN(datum_r); - for (k = 0; k < maxoff; k++) { + for (k = 0; k < maxoff; k++) + { j = costvector[k].pos; - if (j == seed_1) { + if (j == seed_1) + { *left++ = j; v->spl_nleft++; continue; - } else if (j == seed_2) { + } + else if (j == seed_2) + { *right++ = j; v->spl_nright++; continue; } _j = GETENTRY(entryvec, j); - size_alpha = hemdist(datum_l,_j); - size_beta = hemdist(datum_r,_j); + size_alpha = hemdist(datum_l, _j); + size_beta = hemdist(datum_r, _j); - if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.0001)) { - if (ISALLTRUE(datum_l) || ISALLTRUE(_j) ) { + if (size_alpha < size_beta + WISH_F(v->spl_nleft, v->spl_nright, 0.0001)) + { + if (ISALLTRUE(datum_l) || ISALLTRUE(_j)) + { if (!ISALLTRUE(datum_l)) MemSet((void *) union_l, 0xff, sizeof(BITVEC)); - } else { - ptr=GETSIGN(_j); + } + else + { + ptr = GETSIGN(_j); LOOPBYTE( - union_l[i] |= ptr[i]; + union_l[i] |= ptr[i]; ); } *left++ = j; v->spl_nleft++; - } else { - if (ISALLTRUE(datum_r) || ISALLTRUE(_j) ) { + } + else + { + if (ISALLTRUE(datum_r) || ISALLTRUE(_j)) + { if (!ISALLTRUE(datum_r)) MemSet((void *) union_r, 0xff, sizeof(BITVEC)); - } else { - ptr=GETSIGN(_j); + } + else + { + ptr = GETSIGN(_j); LOOPBYTE( - union_r[i] |= ptr[i]; + union_r[i] |= ptr[i]; ); } *right++ = j; @@ -436,36 +489,41 @@ ghstore_picksplit(PG_FUNCTION_ARGS) { } -Datum -ghstore_consistent(PG_FUNCTION_ARGS) { - GISTTYPE *entry = (GISTTYPE*) DatumGetPointer( ((GISTENTRY *) PG_GETARG_POINTER(0))->key ); - HStore *query=PG_GETARG_HS(1); - bool res=true; - HEntry *qe = ARRPTR(query); - char *qv = STRPTR(query); - BITVECP sign; - - if ( ISALLTRUE(entry) ) { - PG_FREE_IF_COPY(query,1); +Datum +ghstore_consistent(PG_FUNCTION_ARGS) +{ + GISTTYPE *entry = (GISTTYPE *) DatumGetPointer(((GISTENTRY *) PG_GETARG_POINTER(0))->key); + HStore *query = PG_GETARG_HS(1); + bool res = true; + HEntry *qe = ARRPTR(query); + char *qv = STRPTR(query); + BITVECP sign; + + if (ISALLTRUE(entry)) + { + PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(true); } - sign=GETSIGN(entry); - while(res && qe-ARRPTR(query) < query->size) { - int crc = crc32_sz((char *)(qv + qe->pos), qe->keylen); - if (GETBIT(sign,HASHVAL(crc))) { - if ( !qe->valisnull ) { - crc = crc32_sz((char *)(qv + qe->pos + qe->keylen), qe->vallen); - if ( !GETBIT(sign,HASHVAL(crc)) ) - res=false; + sign = GETSIGN(entry); + while (res && qe - ARRPTR(query) < query->size) + { + int crc = crc32_sz((char *) (qv + qe->pos), qe->keylen); + + if (GETBIT(sign, HASHVAL(crc))) + { + if (!qe->valisnull) + { + crc = crc32_sz((char *) (qv + qe->pos + qe->keylen), qe->vallen); + if (!GETBIT(sign, HASHVAL(crc))) + res = false; } - } else - res=false; + } + else + res = false; qe++; } - PG_FREE_IF_COPY(query,1); + PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(res); } - - diff --git a/contrib/hstore/hstore_io.c b/contrib/hstore/hstore_io.c index 051a411a99..e01cb4e759 100644 --- a/contrib/hstore/hstore_io.c +++ b/contrib/hstore/hstore_io.c @@ -3,304 +3,396 @@ PG_MODULE_MAGIC; -typedef struct { - char *begin; - char *ptr; - char *cur; - char *word; - int wordlen; - - Pairs *pairs; - int pcur; - int plen; -} HSParser; +typedef struct +{ + char *begin; + char *ptr; + char *cur; + char *word; + int wordlen; + + Pairs *pairs; + int pcur; + int plen; +} HSParser; #define RESIZEPRSBUF \ do { \ - if ( state->cur - state->word + 1 >= state->wordlen ) \ - { \ - int4 clen = state->cur - state->word; \ - state->wordlen *= 2; \ - state->word = (char*)repalloc( (void*)state->word, state->wordlen ); \ - state->cur = state->word + clen; \ - } \ + if ( state->cur - state->word + 1 >= state->wordlen ) \ + { \ + int4 clen = state->cur - state->word; \ + state->wordlen *= 2; \ + state->word = (char*)repalloc( (void*)state->word, state->wordlen ); \ + state->cur = state->word + clen; \ + } \ } while (0) -#define GV_WAITVAL 0 -#define GV_INVAL 1 -#define GV_INESCVAL 2 -#define GV_WAITESCIN 3 -#define GV_WAITESCESCIN 4 +#define GV_WAITVAL 0 +#define GV_INVAL 1 +#define GV_INESCVAL 2 +#define GV_WAITESCIN 3 +#define GV_WAITESCESCIN 4 static bool -get_val( HSParser *state, bool ignoreeq, bool *escaped ) { - int st = GV_WAITVAL; - state->wordlen=32; - state->cur = state->word = palloc( state->wordlen ); - *escaped=false; - - while(1) { - if ( st == GV_WAITVAL ) { - if ( *(state->ptr) == '"' ) { - *escaped=true; +get_val(HSParser * state, bool ignoreeq, bool *escaped) +{ + int st = GV_WAITVAL; + + state->wordlen = 32; + state->cur = state->word = palloc(state->wordlen); + *escaped = false; + + while (1) + { + if (st == GV_WAITVAL) + { + if (*(state->ptr) == '"') + { + *escaped = true; st = GV_INESCVAL; - } else if ( *(state->ptr) == '\0' ) { + } + else if (*(state->ptr) == '\0') + { return false; - } else if ( *(state->ptr) == '=' && !ignoreeq ) { - elog(ERROR,"Syntax error near '%c' at postion %d", *(state->ptr), (int4)(state->ptr-state->begin)); - } else if ( *(state->ptr) == '\\' ) { + } + else if (*(state->ptr) == '=' && !ignoreeq) + { + elog(ERROR, "Syntax error near '%c' at postion %d", *(state->ptr), (int4) (state->ptr - state->begin)); + } + else if (*(state->ptr) == '\\') + { st = GV_WAITESCIN; - } else if ( !isspace((unsigned char) *(state->ptr)) ) { + } + else if (!isspace((unsigned char) *(state->ptr))) + { *(state->cur) = *(state->ptr); state->cur++; st = GV_INVAL; } - } else if ( st == GV_INVAL ) { - if ( *(state->ptr) == '\\' ) { + } + else if (st == GV_INVAL) + { + if (*(state->ptr) == '\\') + { st = GV_WAITESCIN; - } else if ( *(state->ptr) == '=' && !ignoreeq ) { + } + else if (*(state->ptr) == '=' && !ignoreeq) + { state->ptr--; return true; - } else if ( *(state->ptr) == ',' && ignoreeq ) { + } + else if (*(state->ptr) == ',' && ignoreeq) + { state->ptr--; return true; - } else if ( isspace((unsigned char) *(state->ptr)) ) { + } + else if (isspace((unsigned char) *(state->ptr))) + { return true; - } else if ( *(state->ptr) == '\0' ) { + } + else if (*(state->ptr) == '\0') + { state->ptr--; return true; - } else { + } + else + { RESIZEPRSBUF; *(state->cur) = *(state->ptr); state->cur++; } - } else if ( st == GV_INESCVAL ) { - if ( *(state->ptr) == '\\' ) { + } + else if (st == GV_INESCVAL) + { + if (*(state->ptr) == '\\') + { st = GV_WAITESCESCIN; - } else if ( *(state->ptr) == '"' ) { + } + else if (*(state->ptr) == '"') + { return true; - } else if ( *(state->ptr) == '\0' ) { - elog(ERROR,"Unexpected end of string"); - } else { + } + else if (*(state->ptr) == '\0') + { + elog(ERROR, "Unexpected end of string"); + } + else + { RESIZEPRSBUF; *(state->cur) = *(state->ptr); state->cur++; } - } else if ( st == GV_WAITESCIN ) { - if ( *(state->ptr) == '\0' ) - elog(ERROR,"Unexpected end of string"); + } + else if (st == GV_WAITESCIN) + { + if (*(state->ptr) == '\0') + elog(ERROR, "Unexpected end of string"); RESIZEPRSBUF; *(state->cur) = *(state->ptr); state->cur++; - st = GV_INVAL; - } else if ( st == GV_WAITESCESCIN ) { - if ( *(state->ptr) == '\0' ) - elog(ERROR,"Unexpected end of string"); + st = GV_INVAL; + } + else if (st == GV_WAITESCESCIN) + { + if (*(state->ptr) == '\0') + elog(ERROR, "Unexpected end of string"); RESIZEPRSBUF; *(state->cur) = *(state->ptr); state->cur++; st = GV_INESCVAL; - } else - elog(ERROR,"Unknown state %d at postion line %d in file '%s'", st, __LINE__, __FILE__); + } + else + elog(ERROR, "Unknown state %d at postion line %d in file '%s'", st, __LINE__, __FILE__); state->ptr++; - } + } return false; } #define WKEY 0 #define WVAL 1 -#define WEQ 2 -#define WGT 3 +#define WEQ 2 +#define WGT 3 #define WDEL 4 static void -parse_hstore( HSParser *state ) { - int st = WKEY; - bool escaped=false; - - state->plen=16; - state->pairs = (Pairs*)palloc( sizeof(Pairs) * state->plen ); - state->pcur=0; +parse_hstore(HSParser * state) +{ + int st = WKEY; + bool escaped = false; + + state->plen = 16; + state->pairs = (Pairs *) palloc(sizeof(Pairs) * state->plen); + state->pcur = 0; state->ptr = state->begin; - state->word=NULL; + state->word = NULL; - while(1) { - if (st == WKEY) { - if ( !get_val(state, false, &escaped) ) + while (1) + { + if (st == WKEY) + { + if (!get_val(state, false, &escaped)) return; - if ( state->pcur >= state->plen ) { + if (state->pcur >= state->plen) + { state->plen *= 2; - state->pairs = (Pairs*)repalloc( state->pairs, sizeof(Pairs) * state->plen ); + state->pairs = (Pairs *) repalloc(state->pairs, sizeof(Pairs) * state->plen); } - state->pairs[ state->pcur ].key = state->word; - state->pairs[ state->pcur ].keylen = state->cur - state->word; - state->pairs[ state->pcur ].val=NULL; - state->word=NULL; + state->pairs[state->pcur].key = state->word; + state->pairs[state->pcur].keylen = state->cur - state->word; + state->pairs[state->pcur].val = NULL; + state->word = NULL; st = WEQ; - } else if ( st == WEQ ) { - if ( *(state->ptr) == '=' ) { + } + else if (st == WEQ) + { + if (*(state->ptr) == '=') + { st = WGT; - } else if ( *(state->ptr) == '\0' ) { - elog(ERROR,"Unexpectd end of string"); - } else if (!isspace((unsigned char) *(state->ptr))) { - elog(ERROR,"Syntax error near '%c' at postion %d", *(state->ptr), (int4)(state->ptr-state->begin)); } - } else if ( st == WGT ) { - if ( *(state->ptr) == '>' ) { + else if (*(state->ptr) == '\0') + { + elog(ERROR, "Unexpectd end of string"); + } + else if (!isspace((unsigned char) *(state->ptr))) + { + elog(ERROR, "Syntax error near '%c' at postion %d", *(state->ptr), (int4) (state->ptr - state->begin)); + } + } + else if (st == WGT) + { + if (*(state->ptr) == '>') + { st = WVAL; - } else if ( *(state->ptr) == '\0' ) { - elog(ERROR,"Unexpectd end of string"); - } else { - elog(ERROR,"Syntax error near '%c' at postion %d", *(state->ptr), (int4)(state->ptr-state->begin)); } - } else if ( st == WVAL ) { - if ( !get_val(state, true, &escaped) ) - elog(ERROR,"Unexpected end of string"); - state->pairs[ state->pcur ].val = state->word; - state->pairs[ state->pcur ].vallen = state->cur - state->word; - state->pairs[ state->pcur ].isnull = false; - state->pairs[ state->pcur ].needfree = true; - if ( state->cur - state->word == 4 && !escaped) { + else if (*(state->ptr) == '\0') + { + elog(ERROR, "Unexpectd end of string"); + } + else + { + elog(ERROR, "Syntax error near '%c' at postion %d", *(state->ptr), (int4) (state->ptr - state->begin)); + } + } + else if (st == WVAL) + { + if (!get_val(state, true, &escaped)) + elog(ERROR, "Unexpected end of string"); + state->pairs[state->pcur].val = state->word; + state->pairs[state->pcur].vallen = state->cur - state->word; + state->pairs[state->pcur].isnull = false; + state->pairs[state->pcur].needfree = true; + if (state->cur - state->word == 4 && !escaped) + { state->word[4] = '\0'; - if ( 0==pg_strcasecmp(state->word, "null") ) - state->pairs[ state->pcur ].isnull=true; - } - state->word=NULL; + if (0 == pg_strcasecmp(state->word, "null")) + state->pairs[state->pcur].isnull = true; + } + state->word = NULL; state->pcur++; st = WDEL; - } else if ( st == WDEL ) { - if ( *(state->ptr) == ',' ) { + } + else if (st == WDEL) + { + if (*(state->ptr) == ',') + { st = WKEY; - } else if ( *(state->ptr) == '\0' ) { + } + else if (*(state->ptr) == '\0') + { return; - } else if (!isspace((unsigned char) *(state->ptr))) { - elog(ERROR,"Syntax error near '%c' at postion %d", *(state->ptr), (int4)(state->ptr-state->begin)); } - } else - elog(ERROR,"Unknown state %d at line %d in file '%s'", st, __LINE__, __FILE__); + else if (!isspace((unsigned char) *(state->ptr))) + { + elog(ERROR, "Syntax error near '%c' at postion %d", *(state->ptr), (int4) (state->ptr - state->begin)); + } + } + else + elog(ERROR, "Unknown state %d at line %d in file '%s'", st, __LINE__, __FILE__); state->ptr++; } -} +} int -comparePairs(const void *a, const void *b) { - if ( ((Pairs*)a)->keylen == ((Pairs*)b)->keylen ) { - int res = strncmp( - ((Pairs*)a)->key, - ((Pairs*)b)->key, - ((Pairs*)a)->keylen - ); - if ( res ) +comparePairs(const void *a, const void *b) +{ + if (((Pairs *) a)->keylen == ((Pairs *) b)->keylen) + { + int res = strncmp( + ((Pairs *) a)->key, + ((Pairs *) b)->key, + ((Pairs *) a)->keylen + ); + + if (res) return res; /* guarantee that neddfree willl be later */ - if ( ((Pairs*)b)->needfree == ((Pairs*)a)->needfree ) + if (((Pairs *) b)->needfree == ((Pairs *) a)->needfree) return 0; - else if ( ((Pairs*)a)->needfree ) + else if (((Pairs *) a)->needfree) return 1; else - return -1; + return -1; } - return ( ((Pairs*)a)->keylen > ((Pairs*)b)->keylen ) ? 1 : -1; + return (((Pairs *) a)->keylen > ((Pairs *) b)->keylen) ? 1 : -1; } int -uniquePairs(Pairs * a, int4 l, int4 *buflen) { - Pairs *ptr, *res; - - *buflen=0; - if ( l < 2 ) { - if ( l==1 ) - *buflen = a->keylen + ((a->isnull) ? 0 : a->vallen) ; +uniquePairs(Pairs * a, int4 l, int4 *buflen) +{ + Pairs *ptr, + *res; + + *buflen = 0; + if (l < 2) + { + if (l == 1) + *buflen = a->keylen + ((a->isnull) ? 0 : a->vallen); return l; } qsort((void *) a, l, sizeof(Pairs), comparePairs); - ptr=a+1; - res=a; - while( ptr - a < l ) { - if ( ptr->keylen == res->keylen && strncmp( ptr->key, res->key, res->keylen )==0 ) { - if ( ptr->needfree ) { + ptr = a + 1; + res = a; + while (ptr - a < l) + { + if (ptr->keylen == res->keylen && strncmp(ptr->key, res->key, res->keylen) == 0) + { + if (ptr->needfree) + { pfree(ptr->key); pfree(ptr->val); } - } else { - *buflen += res->keylen + (( res->isnull ) ? 0 : res->vallen); + } + else + { + *buflen += res->keylen + ((res->isnull) ? 0 : res->vallen); res++; - memcpy(res,ptr,sizeof(Pairs)); + memcpy(res, ptr, sizeof(Pairs)); } ptr++; } - *buflen += res->keylen + (( res->isnull ) ? 0 : res->vallen); + *buflen += res->keylen + ((res->isnull) ? 0 : res->vallen); return res + 1 - a; } static void -freeHSParse(HSParser *state) { - int i; - - if ( state->word ) pfree( state->word ); - for (i=0;i<state->pcur;i++) - if ( state->pairs[i].needfree ) { - if (state->pairs[i].key) pfree(state->pairs[i].key); - if (state->pairs[i].val) pfree(state->pairs[i].val); +freeHSParse(HSParser * state) +{ + int i; + + if (state->word) + pfree(state->word); + for (i = 0; i < state->pcur; i++) + if (state->pairs[i].needfree) + { + if (state->pairs[i].key) + pfree(state->pairs[i].key); + if (state->pairs[i].val) + pfree(state->pairs[i].val); } - pfree( state->pairs ); + pfree(state->pairs); } PG_FUNCTION_INFO_V1(hstore_in); -Datum hstore_in(PG_FUNCTION_ARGS); +Datum hstore_in(PG_FUNCTION_ARGS); Datum -hstore_in(PG_FUNCTION_ARGS) { - HSParser state; - int4 len,buflen,i; - HStore *out; - HEntry *entries; - char *ptr; - - state.begin = PG_GETARG_CSTRING(0); +hstore_in(PG_FUNCTION_ARGS) +{ + HSParser state; + int4 len, + buflen, + i; + HStore *out; + HEntry *entries; + char *ptr; + + state.begin = PG_GETARG_CSTRING(0); parse_hstore(&state); - if ( state.pcur == 0 ) { + if (state.pcur == 0) + { freeHSParse(&state); - len = CALCDATASIZE(0,0); + len = CALCDATASIZE(0, 0); out = palloc(len); - out->len=len; - out->size=0; + out->len = len; + out->size = 0; PG_RETURN_POINTER(out); } state.pcur = uniquePairs(state.pairs, state.pcur, &buflen); - len=CALCDATASIZE(state.pcur, buflen); + len = CALCDATASIZE(state.pcur, buflen); out = palloc(len); - out->len=len; - out->size=state.pcur; + out->len = len; + out->size = state.pcur; - entries=ARRPTR(out); + entries = ARRPTR(out); ptr = STRPTR(out); - for(i=0;i<out->size;i++) { + for (i = 0; i < out->size; i++) + { entries[i].keylen = state.pairs[i].keylen; entries[i].pos = ptr - STRPTR(out); memcpy(ptr, state.pairs[i].key, state.pairs[i].keylen); - ptr+=entries[i].keylen; + ptr += entries[i].keylen; entries[i].valisnull = state.pairs[i].isnull; - if ( entries[i].valisnull ) - entries[i].vallen=4; /* null */ - else { + if (entries[i].valisnull) + entries[i].vallen = 4; /* null */ + else + { entries[i].vallen = state.pairs[i].vallen; - memcpy(ptr, state.pairs[i].val,state.pairs[i].vallen); - ptr+=entries[i].vallen; + memcpy(ptr, state.pairs[i].val, state.pairs[i].vallen); + ptr += entries[i].vallen; } } @@ -308,63 +400,74 @@ hstore_in(PG_FUNCTION_ARGS) { PG_RETURN_POINTER(out); } -static char* -cpw(char *dst, char *src, int len) { - char *ptr = src; +static char * +cpw(char *dst, char *src, int len) +{ + char *ptr = src; - while(ptr-src<len) { - if ( *ptr == '"' || *ptr == '\\' ) - *dst++='\\'; + while (ptr - src < len) + { + if (*ptr == '"' || *ptr == '\\') + *dst++ = '\\'; *dst++ = *ptr++; } return dst; } PG_FUNCTION_INFO_V1(hstore_out); -Datum hstore_out(PG_FUNCTION_ARGS); +Datum hstore_out(PG_FUNCTION_ARGS); Datum -hstore_out(PG_FUNCTION_ARGS) { - HStore *in = PG_GETARG_HS(0); - int buflen,i; - char *out,*ptr; - char *base = STRPTR(in); - HEntry *entries = ARRPTR(in); - - if ( in->size==0 ) { - out=palloc(1); - *out='\0'; - PG_FREE_IF_COPY(in,0); +hstore_out(PG_FUNCTION_ARGS) +{ + HStore *in = PG_GETARG_HS(0); + int buflen, + i; + char *out, + *ptr; + char *base = STRPTR(in); + HEntry *entries = ARRPTR(in); + + if (in->size == 0) + { + out = palloc(1); + *out = '\0'; + PG_FREE_IF_COPY(in, 0); PG_RETURN_CSTRING(out); } - buflen = ( 4 /* " */ + 2 /* => */ + 2 /*, */ )*in->size + - 2 /* esc */ * ( in->len - CALCDATASIZE(in->size,0) ); - - out=ptr=palloc(buflen); - for(i=0;i<in->size;i++) { - *ptr++='"'; - ptr = cpw( ptr, base + entries[i].pos, entries[i].keylen ); - *ptr++='"'; - *ptr++='='; - *ptr++='>'; - if ( entries[i].valisnull ) { - *ptr++='N'; - *ptr++='U'; - *ptr++='L'; - *ptr++='L'; - } else { - *ptr++='"'; - ptr = cpw( ptr, base + entries[i].pos + entries[i].keylen, entries[i].vallen ); - *ptr++='"'; + buflen = (4 /* " */ + 2 /* => */ + 2 /* , */ ) * in->size + + 2 /* esc */ * (in->len - CALCDATASIZE(in->size, 0)); + + out = ptr = palloc(buflen); + for (i = 0; i < in->size; i++) + { + *ptr++ = '"'; + ptr = cpw(ptr, base + entries[i].pos, entries[i].keylen); + *ptr++ = '"'; + *ptr++ = '='; + *ptr++ = '>'; + if (entries[i].valisnull) + { + *ptr++ = 'N'; + *ptr++ = 'U'; + *ptr++ = 'L'; + *ptr++ = 'L'; + } + else + { + *ptr++ = '"'; + ptr = cpw(ptr, base + entries[i].pos + entries[i].keylen, entries[i].vallen); + *ptr++ = '"'; } - if ( i+1 != in->size ) { - *ptr++=','; - *ptr++=' '; + if (i + 1 != in->size) + { + *ptr++ = ','; + *ptr++ = ' '; } } - *ptr='\0'; + *ptr = '\0'; - PG_FREE_IF_COPY(in,0); + PG_FREE_IF_COPY(in, 0); PG_RETURN_CSTRING(out); } diff --git a/contrib/hstore/hstore_op.c b/contrib/hstore/hstore_op.c index 12f783cb25..971e93cf31 100644 --- a/contrib/hstore/hstore_op.c +++ b/contrib/hstore/hstore_op.c @@ -7,20 +7,22 @@ static HEntry * -findkey(HStore *hs, char *key, int keylen) { - HEntry *StopLow = ARRPTR(hs); - HEntry *StopHigh = StopLow + hs->size; - HEntry *StopMiddle; - int difference; - char *base = STRPTR(hs); - - while (StopLow < StopHigh) { +findkey(HStore * hs, char *key, int keylen) +{ + HEntry *StopLow = ARRPTR(hs); + HEntry *StopHigh = StopLow + hs->size; + HEntry *StopMiddle; + int difference; + char *base = STRPTR(hs); + + while (StopLow < StopHigh) + { StopMiddle = StopLow + (StopHigh - StopLow) / 2; - if ( StopMiddle->keylen == keylen ) - difference=strncmp(base+StopMiddle->pos, key, StopMiddle->keylen); + if (StopMiddle->keylen == keylen) + difference = strncmp(base + StopMiddle->pos, key, StopMiddle->keylen); else - difference=(StopMiddle->keylen > keylen) ? 1 : -1; + difference = (StopMiddle->keylen > keylen) ? 1 : -1; if (difference == 0) return StopMiddle; @@ -29,520 +31,583 @@ findkey(HStore *hs, char *key, int keylen) { else StopHigh = StopMiddle; } - + return NULL; } PG_FUNCTION_INFO_V1(fetchval); -Datum fetchval(PG_FUNCTION_ARGS); +Datum fetchval(PG_FUNCTION_ARGS); Datum -fetchval(PG_FUNCTION_ARGS) { - HStore *hs = PG_GETARG_HS(0); - text *key = PG_GETARG_TEXT_P(1); - HEntry *entry; - text *out; - - if ((entry=findkey(hs,VARDATA(key), VARSIZE(key)-VARHDRSZ))==NULL || entry->valisnull) { - PG_FREE_IF_COPY(hs,0); - PG_FREE_IF_COPY(key,1); +fetchval(PG_FUNCTION_ARGS) +{ + HStore *hs = PG_GETARG_HS(0); + text *key = PG_GETARG_TEXT_P(1); + HEntry *entry; + text *out; + + if ((entry = findkey(hs, VARDATA(key), VARSIZE(key) - VARHDRSZ)) == NULL || entry->valisnull) + { + PG_FREE_IF_COPY(hs, 0); + PG_FREE_IF_COPY(key, 1); PG_RETURN_NULL(); } - out=palloc(VARHDRSZ+entry->vallen); - memcpy(VARDATA(out),STRPTR(hs) + entry->pos + entry->keylen, entry->vallen); - VARATT_SIZEP(out) = VARHDRSZ+entry->vallen; + out = palloc(VARHDRSZ + entry->vallen); + memcpy(VARDATA(out), STRPTR(hs) + entry->pos + entry->keylen, entry->vallen); + VARATT_SIZEP(out) = VARHDRSZ + entry->vallen; - PG_FREE_IF_COPY(hs,0); - PG_FREE_IF_COPY(key,1); + PG_FREE_IF_COPY(hs, 0); + PG_FREE_IF_COPY(key, 1); PG_RETURN_POINTER(out); } PG_FUNCTION_INFO_V1(exists); -Datum exists(PG_FUNCTION_ARGS); +Datum exists(PG_FUNCTION_ARGS); Datum -exists(PG_FUNCTION_ARGS) { - HStore *hs = PG_GETARG_HS(0); - text *key = PG_GETARG_TEXT_P(1); - HEntry *entry; +exists(PG_FUNCTION_ARGS) +{ + HStore *hs = PG_GETARG_HS(0); + text *key = PG_GETARG_TEXT_P(1); + HEntry *entry; - entry=findkey(hs,VARDATA(key), VARSIZE(key)-VARHDRSZ); + entry = findkey(hs, VARDATA(key), VARSIZE(key) - VARHDRSZ); - PG_FREE_IF_COPY(hs,0); - PG_FREE_IF_COPY(key,1); + PG_FREE_IF_COPY(hs, 0); + PG_FREE_IF_COPY(key, 1); PG_RETURN_BOOL(entry); } PG_FUNCTION_INFO_V1(defined); -Datum defined(PG_FUNCTION_ARGS); +Datum defined(PG_FUNCTION_ARGS); Datum -defined(PG_FUNCTION_ARGS) { - HStore *hs = PG_GETARG_HS(0); - text *key = PG_GETARG_TEXT_P(1); - HEntry *entry; - bool res; +defined(PG_FUNCTION_ARGS) +{ + HStore *hs = PG_GETARG_HS(0); + text *key = PG_GETARG_TEXT_P(1); + HEntry *entry; + bool res; - entry=findkey(hs,VARDATA(key), VARSIZE(key)-VARHDRSZ); + entry = findkey(hs, VARDATA(key), VARSIZE(key) - VARHDRSZ); - res = ( entry && !entry->valisnull ) ? true : false; + res = (entry && !entry->valisnull) ? true : false; - PG_FREE_IF_COPY(hs,0); - PG_FREE_IF_COPY(key,1); + PG_FREE_IF_COPY(hs, 0); + PG_FREE_IF_COPY(key, 1); PG_RETURN_BOOL(res); } PG_FUNCTION_INFO_V1(delete); -Datum delete(PG_FUNCTION_ARGS); +Datum delete(PG_FUNCTION_ARGS); Datum -delete(PG_FUNCTION_ARGS) { - HStore *hs = PG_GETARG_HS(0); - text *key = PG_GETARG_TEXT_P(1); - HStore *out = palloc(hs->len); - char *ptrs, *ptrd; - HEntry *es, *ed; - - out->len=hs->len; - out->size=hs->size; /* temprorary! */ - - ptrs=STRPTR(hs); - es =ARRPTR(hs); - ptrd=STRPTR(out); - ed =ARRPTR(out); - - while( es - ARRPTR(hs) < hs->size ) { - if ( !(es->keylen == VARSIZE(key) - VARHDRSZ && strncmp(ptrs, VARDATA(key), es->keylen)==0) ) { - memcpy( ed, es, sizeof(HEntry) ); - memcpy( ptrd, ptrs, es->keylen + ( (es->valisnull) ? 0 : es->vallen ) ); +delete(PG_FUNCTION_ARGS) +{ + HStore *hs = PG_GETARG_HS(0); + text *key = PG_GETARG_TEXT_P(1); + HStore *out = palloc(hs->len); + char *ptrs, + *ptrd; + HEntry *es, + *ed; + + out->len = hs->len; + out->size = hs->size; /* temprorary! */ + + ptrs = STRPTR(hs); + es = ARRPTR(hs); + ptrd = STRPTR(out); + ed = ARRPTR(out); + + while (es - ARRPTR(hs) < hs->size) + { + if (!(es->keylen == VARSIZE(key) - VARHDRSZ && strncmp(ptrs, VARDATA(key), es->keylen) == 0)) + { + memcpy(ed, es, sizeof(HEntry)); + memcpy(ptrd, ptrs, es->keylen + ((es->valisnull) ? 0 : es->vallen)); ed->pos = ptrd - STRPTR(out); - ptrd += es->keylen + ( (es->valisnull) ? 0 : es->vallen ); + ptrd += es->keylen + ((es->valisnull) ? 0 : es->vallen); ed++; } - ptrs += es->keylen + ( (es->valisnull) ? 0 : es->vallen ); + ptrs += es->keylen + ((es->valisnull) ? 0 : es->vallen); es++; } - if ( ed - ARRPTR(out) != out->size ) { - int buflen=ptrd-STRPTR(out); + if (ed - ARRPTR(out) != out->size) + { + int buflen = ptrd - STRPTR(out); + ptrd = STRPTR(out); out->size = ed - ARRPTR(out); - memmove( STRPTR(out), ptrd, buflen); + memmove(STRPTR(out), ptrd, buflen); out->len = CALCDATASIZE(out->size, buflen); } - - PG_FREE_IF_COPY(hs,0); - PG_FREE_IF_COPY(key,1); + + PG_FREE_IF_COPY(hs, 0); + PG_FREE_IF_COPY(key, 1); PG_RETURN_POINTER(out); } PG_FUNCTION_INFO_V1(hs_concat); -Datum hs_concat(PG_FUNCTION_ARGS); +Datum hs_concat(PG_FUNCTION_ARGS); Datum -hs_concat(PG_FUNCTION_ARGS) { - HStore *s1 = PG_GETARG_HS(0); - HStore *s2 = PG_GETARG_HS(1); - HStore *out = palloc( s1->len + s2->len ); - char *ps1, *ps2, *pd; - HEntry *es1, *es2, *ed; +hs_concat(PG_FUNCTION_ARGS) +{ + HStore *s1 = PG_GETARG_HS(0); + HStore *s2 = PG_GETARG_HS(1); + HStore *out = palloc(s1->len + s2->len); + char *ps1, + *ps2, + *pd; + HEntry *es1, + *es2, + *ed; out->len = s1->len + s2->len; out->size = s1->size + s2->size; - ps1=STRPTR(s1); - ps2=STRPTR(s2); - pd=STRPTR(out); - es1=ARRPTR(s1); - es2=ARRPTR(s2); - ed=ARRPTR(out); - - while( es1 - ARRPTR(s1) < s1->size && es2 - ARRPTR(s2) < s2->size ) { - int difference; - if ( es1->keylen == es2->keylen ) - difference=strncmp(ps1, ps2, es1->keylen); + ps1 = STRPTR(s1); + ps2 = STRPTR(s2); + pd = STRPTR(out); + es1 = ARRPTR(s1); + es2 = ARRPTR(s2); + ed = ARRPTR(out); + + while (es1 - ARRPTR(s1) < s1->size && es2 - ARRPTR(s2) < s2->size) + { + int difference; + + if (es1->keylen == es2->keylen) + difference = strncmp(ps1, ps2, es1->keylen); else - difference=(es1->keylen > es2->keylen) ? 1 : -1; + difference = (es1->keylen > es2->keylen) ? 1 : -1; - if ( difference == 0 ) { - memcpy( ed, es2, sizeof(HEntry) ); - memcpy( pd, ps2, es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ) ); + if (difference == 0) + { + memcpy(ed, es2, sizeof(HEntry)); + memcpy(pd, ps2, es2->keylen + ((es2->valisnull) ? 0 : es2->vallen)); ed->pos = pd - STRPTR(out); - pd += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ); + pd += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen); ed++; - - ps1 += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ); + + ps1 += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen); es1++; - ps2 += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ); + ps2 += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen); es2++; - } else if ( difference > 0 ) { - memcpy( ed, es2, sizeof(HEntry) ); - memcpy( pd, ps2, es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ) ); + } + else if (difference > 0) + { + memcpy(ed, es2, sizeof(HEntry)); + memcpy(pd, ps2, es2->keylen + ((es2->valisnull) ? 0 : es2->vallen)); ed->pos = pd - STRPTR(out); - pd += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ); + pd += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen); ed++; - - ps2 += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ); + + ps2 += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen); es2++; - } else { - memcpy( ed, es1, sizeof(HEntry) ); - memcpy( pd, ps1, es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ) ); + } + else + { + memcpy(ed, es1, sizeof(HEntry)); + memcpy(pd, ps1, es1->keylen + ((es1->valisnull) ? 0 : es1->vallen)); ed->pos = pd - STRPTR(out); - pd += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ); + pd += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen); ed++; - - ps1 += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ); + + ps1 += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen); es1++; } } - while( es1 - ARRPTR(s1) < s1->size ) { - memcpy( ed, es1, sizeof(HEntry) ); - memcpy( pd, ps1, es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ) ); + while (es1 - ARRPTR(s1) < s1->size) + { + memcpy(ed, es1, sizeof(HEntry)); + memcpy(pd, ps1, es1->keylen + ((es1->valisnull) ? 0 : es1->vallen)); ed->pos = pd - STRPTR(out); - pd += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ); + pd += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen); ed++; - - ps1 += es1->keylen + ( (es1->valisnull) ? 0 : es1->vallen ); + + ps1 += es1->keylen + ((es1->valisnull) ? 0 : es1->vallen); es1++; } - while( es2 - ARRPTR(s2) < s2->size ) { - memcpy( ed, es2, sizeof(HEntry) ); - memcpy( pd, ps2, es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ) ); + while (es2 - ARRPTR(s2) < s2->size) + { + memcpy(ed, es2, sizeof(HEntry)); + memcpy(pd, ps2, es2->keylen + ((es2->valisnull) ? 0 : es2->vallen)); ed->pos = pd - STRPTR(out); - pd += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ); + pd += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen); ed++; - - ps2 += es2->keylen + ( (es2->valisnull) ? 0 : es2->vallen ); + + ps2 += es2->keylen + ((es2->valisnull) ? 0 : es2->vallen); es2++; } - if ( ed - ARRPTR(out) != out->size ) { - int buflen=pd-STRPTR(out); + if (ed - ARRPTR(out) != out->size) + { + int buflen = pd - STRPTR(out); + pd = STRPTR(out); out->size = ed - ARRPTR(out); - memmove( STRPTR(out), pd, buflen); + memmove(STRPTR(out), pd, buflen); out->len = CALCDATASIZE(out->size, buflen); } - - PG_FREE_IF_COPY(s1,0); - PG_FREE_IF_COPY(s2,1); + + PG_FREE_IF_COPY(s1, 0); + PG_FREE_IF_COPY(s2, 1); PG_RETURN_POINTER(out); } PG_FUNCTION_INFO_V1(tconvert); -Datum tconvert(PG_FUNCTION_ARGS); +Datum tconvert(PG_FUNCTION_ARGS); Datum -tconvert(PG_FUNCTION_ARGS) { - text *key = PG_GETARG_TEXT_P(0); - text *val = PG_GETARG_TEXT_P(1); - int len; - HStore *out; - - len=CALCDATASIZE(1, VARSIZE(key) + VARSIZE(val) - 2*VARHDRSZ); +tconvert(PG_FUNCTION_ARGS) +{ + text *key = PG_GETARG_TEXT_P(0); + text *val = PG_GETARG_TEXT_P(1); + int len; + HStore *out; + + len = CALCDATASIZE(1, VARSIZE(key) + VARSIZE(val) - 2 * VARHDRSZ); out = palloc(len); - out->len=len; - out->size=1; + out->len = len; + out->size = 1; ARRPTR(out)->keylen = VARSIZE(key) - VARHDRSZ; ARRPTR(out)->vallen = VARSIZE(val) - VARHDRSZ; ARRPTR(out)->valisnull = false; - ARRPTR(out)->pos=0; + ARRPTR(out)->pos = 0; - memcpy( STRPTR(out), VARDATA(key), ARRPTR(out)->keylen ); - memcpy( STRPTR(out) + ARRPTR(out)->keylen, VARDATA(val), ARRPTR(out)->vallen ); - - PG_FREE_IF_COPY(key,0); - PG_FREE_IF_COPY(val,1); + memcpy(STRPTR(out), VARDATA(key), ARRPTR(out)->keylen); + memcpy(STRPTR(out) + ARRPTR(out)->keylen, VARDATA(val), ARRPTR(out)->vallen); + + PG_FREE_IF_COPY(key, 0); + PG_FREE_IF_COPY(val, 1); PG_RETURN_POINTER(out); } PG_FUNCTION_INFO_V1(akeys); -Datum akeys(PG_FUNCTION_ARGS); +Datum akeys(PG_FUNCTION_ARGS); Datum -akeys(PG_FUNCTION_ARGS) { - HStore *hs = PG_GETARG_HS(0); - Datum *d; - ArrayType *a; - HEntry *ptr=ARRPTR(hs); - char *base=STRPTR(hs); - - d=(Datum*)palloc(sizeof(Datum)*(hs->size+1)); - while( ptr-ARRPTR(hs) < hs->size ) { - text *item=(text*)palloc(VARHDRSZ + ptr->keylen); - VARATT_SIZEP(item) = VARHDRSZ+ptr->keylen; +akeys(PG_FUNCTION_ARGS) +{ + HStore *hs = PG_GETARG_HS(0); + Datum *d; + ArrayType *a; + HEntry *ptr = ARRPTR(hs); + char *base = STRPTR(hs); + + d = (Datum *) palloc(sizeof(Datum) * (hs->size + 1)); + while (ptr - ARRPTR(hs) < hs->size) + { + text *item = (text *) palloc(VARHDRSZ + ptr->keylen); + + VARATT_SIZEP(item) = VARHDRSZ + ptr->keylen; memcpy(VARDATA(item), base + ptr->pos, ptr->keylen); - d[ ptr-ARRPTR(hs) ] = PointerGetDatum(item); + d[ptr - ARRPTR(hs)] = PointerGetDatum(item); ptr++; } - + a = construct_array( - d, - hs->size, - TEXTOID, - -1, - false, - 'i' - ); - - ptr=ARRPTR(hs); - while( ptr-ARRPTR(hs) < hs->size ) { - pfree(DatumGetPointer(d[ ptr-ARRPTR(hs) ])); + d, + hs->size, + TEXTOID, + -1, + false, + 'i' + ); + + ptr = ARRPTR(hs); + while (ptr - ARRPTR(hs) < hs->size) + { + pfree(DatumGetPointer(d[ptr - ARRPTR(hs)])); ptr++; } pfree(d); - PG_FREE_IF_COPY(hs,0); + PG_FREE_IF_COPY(hs, 0); PG_RETURN_POINTER(a); } PG_FUNCTION_INFO_V1(avals); -Datum avals(PG_FUNCTION_ARGS); +Datum avals(PG_FUNCTION_ARGS); Datum -avals(PG_FUNCTION_ARGS) { - HStore *hs = PG_GETARG_HS(0); - Datum *d; - ArrayType *a; - HEntry *ptr=ARRPTR(hs); - char *base=STRPTR(hs); - - d=(Datum*)palloc(sizeof(Datum)*(hs->size+1)); - while( ptr-ARRPTR(hs) < hs->size ) { - int vallen = (ptr->valisnull) ? 0 : ptr->vallen; - text *item=(text*)palloc(VARHDRSZ + vallen); - VARATT_SIZEP(item) = VARHDRSZ+vallen; +avals(PG_FUNCTION_ARGS) +{ + HStore *hs = PG_GETARG_HS(0); + Datum *d; + ArrayType *a; + HEntry *ptr = ARRPTR(hs); + char *base = STRPTR(hs); + + d = (Datum *) palloc(sizeof(Datum) * (hs->size + 1)); + while (ptr - ARRPTR(hs) < hs->size) + { + int vallen = (ptr->valisnull) ? 0 : ptr->vallen; + text *item = (text *) palloc(VARHDRSZ + vallen); + + VARATT_SIZEP(item) = VARHDRSZ + vallen; memcpy(VARDATA(item), base + ptr->pos + ptr->keylen, vallen); - d[ ptr-ARRPTR(hs) ] = PointerGetDatum(item); + d[ptr - ARRPTR(hs)] = PointerGetDatum(item); ptr++; } - + a = construct_array( - d, - hs->size, - TEXTOID, - -1, - false, - 'i' - ); - - ptr=ARRPTR(hs); - while( ptr-ARRPTR(hs) < hs->size ) { - pfree(DatumGetPointer(d[ ptr-ARRPTR(hs) ])); + d, + hs->size, + TEXTOID, + -1, + false, + 'i' + ); + + ptr = ARRPTR(hs); + while (ptr - ARRPTR(hs) < hs->size) + { + pfree(DatumGetPointer(d[ptr - ARRPTR(hs)])); ptr++; } pfree(d); - PG_FREE_IF_COPY(hs,0); + PG_FREE_IF_COPY(hs, 0); PG_RETURN_POINTER(a); } -typedef struct { - HStore *hs; - int i; -} AKStore; +typedef struct +{ + HStore *hs; + int i; +} AKStore; static void -setup_firstcall(FuncCallContext *funcctx, HStore *hs) { - MemoryContext oldcontext; - AKStore *st; +setup_firstcall(FuncCallContext *funcctx, HStore * hs) +{ + MemoryContext oldcontext; + AKStore *st; oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); - st=(AKStore*)palloc( sizeof(AKStore) ); - st->i=0; - st->hs = (HStore*)palloc(hs->len); - memcpy( st->hs, hs, hs->len ); + st = (AKStore *) palloc(sizeof(AKStore)); + st->i = 0; + st->hs = (HStore *) palloc(hs->len); + memcpy(st->hs, hs, hs->len); - funcctx->user_fctx = (void*)st; + funcctx->user_fctx = (void *) st; MemoryContextSwitchTo(oldcontext); } PG_FUNCTION_INFO_V1(skeys); -Datum skeys(PG_FUNCTION_ARGS); +Datum skeys(PG_FUNCTION_ARGS); Datum -skeys(PG_FUNCTION_ARGS) { - FuncCallContext *funcctx; - AKStore *st; +skeys(PG_FUNCTION_ARGS) +{ + FuncCallContext *funcctx; + AKStore *st; + + if (SRF_IS_FIRSTCALL()) + { + HStore *hs = PG_GETARG_HS(0); - if (SRF_IS_FIRSTCALL()) { - HStore *hs = PG_GETARG_HS(0); funcctx = SRF_FIRSTCALL_INIT(); setup_firstcall(funcctx, hs); - PG_FREE_IF_COPY(hs,0); + PG_FREE_IF_COPY(hs, 0); } funcctx = SRF_PERCALL_SETUP(); - st = (AKStore*)funcctx->user_fctx; - - if ( st->i < st->hs->size ) { - HEntry *ptr = &(ARRPTR(st->hs)[st->i]); - text *item=(text*)palloc(VARHDRSZ + ptr->keylen); + st = (AKStore *) funcctx->user_fctx; + + if (st->i < st->hs->size) + { + HEntry *ptr = &(ARRPTR(st->hs)[st->i]); + text *item = (text *) palloc(VARHDRSZ + ptr->keylen); - VARATT_SIZEP(item) = VARHDRSZ+ptr->keylen; + VARATT_SIZEP(item) = VARHDRSZ + ptr->keylen; memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos, ptr->keylen); st->i++; SRF_RETURN_NEXT(funcctx, PointerGetDatum(item)); } - - pfree( st->hs ); - pfree( st ); - SRF_RETURN_DONE(funcctx); + pfree(st->hs); + pfree(st); + + SRF_RETURN_DONE(funcctx); } PG_FUNCTION_INFO_V1(svals); -Datum svals(PG_FUNCTION_ARGS); +Datum svals(PG_FUNCTION_ARGS); Datum -svals(PG_FUNCTION_ARGS) { - FuncCallContext *funcctx; - AKStore *st; +svals(PG_FUNCTION_ARGS) +{ + FuncCallContext *funcctx; + AKStore *st; + + if (SRF_IS_FIRSTCALL()) + { + HStore *hs = PG_GETARG_HS(0); - if (SRF_IS_FIRSTCALL()) { - HStore *hs = PG_GETARG_HS(0); funcctx = SRF_FIRSTCALL_INIT(); setup_firstcall(funcctx, hs); - PG_FREE_IF_COPY(hs,0); + PG_FREE_IF_COPY(hs, 0); } funcctx = SRF_PERCALL_SETUP(); - st = (AKStore*)funcctx->user_fctx; - - if ( st->i < st->hs->size ) { - HEntry *ptr = &(ARRPTR(st->hs)[st->i]); + st = (AKStore *) funcctx->user_fctx; - if ( ptr->valisnull ) { - ReturnSetInfo *rsi; + if (st->i < st->hs->size) + { + HEntry *ptr = &(ARRPTR(st->hs)[st->i]); + + if (ptr->valisnull) + { + ReturnSetInfo *rsi; st->i++; (funcctx)->call_cntr++; rsi = (ReturnSetInfo *) fcinfo->resultinfo; rsi->isDone = ExprMultipleResult; PG_RETURN_NULL(); - } else { - int vallen = ptr->vallen; - text *item=(text*)palloc(VARHDRSZ + vallen); + } + else + { + int vallen = ptr->vallen; + text *item = (text *) palloc(VARHDRSZ + vallen); - VARATT_SIZEP(item) = VARHDRSZ+vallen; + VARATT_SIZEP(item) = VARHDRSZ + vallen; memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos + ptr->keylen, vallen); st->i++; SRF_RETURN_NEXT(funcctx, PointerGetDatum(item)); } } - - pfree( st->hs ); - pfree( st ); - SRF_RETURN_DONE(funcctx); + pfree(st->hs); + pfree(st); + + SRF_RETURN_DONE(funcctx); } PG_FUNCTION_INFO_V1(hs_contains); -Datum hs_contains(PG_FUNCTION_ARGS); +Datum hs_contains(PG_FUNCTION_ARGS); Datum -hs_contains(PG_FUNCTION_ARGS) { - HStore *val = PG_GETARG_HS(0); - HStore *tmpl = PG_GETARG_HS(1); - bool res = true; - HEntry *te = ARRPTR(tmpl); - char *vv = STRPTR(val); - char *tv = STRPTR(tmpl); - - while(res && te-ARRPTR(tmpl) < tmpl->size) { - HEntry *entry = findkey(val, tv + te->pos, te->keylen); - if ( entry ) { - if ( ! te->valisnull ) { - if ( entry->valisnull || !( - te->vallen==entry->vallen && - strncmp( - vv + entry->pos + entry->keylen, - tv + te->pos + te->keylen, - te->vallen ) == 0 - ) ) - res=false; +hs_contains(PG_FUNCTION_ARGS) +{ + HStore *val = PG_GETARG_HS(0); + HStore *tmpl = PG_GETARG_HS(1); + bool res = true; + HEntry *te = ARRPTR(tmpl); + char *vv = STRPTR(val); + char *tv = STRPTR(tmpl); + + while (res && te - ARRPTR(tmpl) < tmpl->size) + { + HEntry *entry = findkey(val, tv + te->pos, te->keylen); + + if (entry) + { + if (!te->valisnull) + { + if (entry->valisnull || !( + te->vallen == entry->vallen && + strncmp( + vv + entry->pos + entry->keylen, + tv + te->pos + te->keylen, + te->vallen) == 0 + )) + res = false; } - } else + } + else res = false; te++; } - PG_FREE_IF_COPY(val,0); - PG_FREE_IF_COPY(tmpl,1); + PG_FREE_IF_COPY(val, 0); + PG_FREE_IF_COPY(tmpl, 1); PG_RETURN_BOOL(res); } - + PG_FUNCTION_INFO_V1(hs_contained); -Datum hs_contained(PG_FUNCTION_ARGS); +Datum hs_contained(PG_FUNCTION_ARGS); Datum -hs_contained(PG_FUNCTION_ARGS) { - PG_RETURN_DATUM( DirectFunctionCall2( - hs_contains, - PG_GETARG_DATUM(1), - PG_GETARG_DATUM(0) - )); +hs_contained(PG_FUNCTION_ARGS) +{ + PG_RETURN_DATUM(DirectFunctionCall2( + hs_contains, + PG_GETARG_DATUM(1), + PG_GETARG_DATUM(0) + )); } PG_FUNCTION_INFO_V1(each); -Datum each(PG_FUNCTION_ARGS); +Datum each(PG_FUNCTION_ARGS); Datum -each(PG_FUNCTION_ARGS) { - FuncCallContext *funcctx; - AKStore *st; +each(PG_FUNCTION_ARGS) +{ + FuncCallContext *funcctx; + AKStore *st; - if (SRF_IS_FIRSTCALL()) { - TupleDesc tupdesc; - MemoryContext oldcontext; - HStore *hs = PG_GETARG_HS(0); + if (SRF_IS_FIRSTCALL()) + { + TupleDesc tupdesc; + MemoryContext oldcontext; + HStore *hs = PG_GETARG_HS(0); funcctx = SRF_FIRSTCALL_INIT(); oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); - st=(AKStore*)palloc( sizeof(AKStore) ); - st->i=0; - st->hs = (HStore*)palloc(hs->len); - memcpy( st->hs, hs, hs->len ); - funcctx->user_fctx = (void*)st; - + st = (AKStore *) palloc(sizeof(AKStore)); + st->i = 0; + st->hs = (HStore *) palloc(hs->len); + memcpy(st->hs, hs, hs->len); + funcctx->user_fctx = (void *) st; + tupdesc = RelationNameGetTupleDesc("hs_each"); funcctx->slot = TupleDescGetSlot(tupdesc); funcctx->attinmeta = TupleDescGetAttInMetadata(tupdesc); MemoryContextSwitchTo(oldcontext); - PG_FREE_IF_COPY(hs,0); + PG_FREE_IF_COPY(hs, 0); } funcctx = SRF_PERCALL_SETUP(); - st = (AKStore*)funcctx->user_fctx; - - if ( st->i < st->hs->size ) { - HEntry *ptr = &(ARRPTR(st->hs)[st->i]); - Datum res, dvalues[2]; - char nulls[] = {' ', ' '}; - text *item; - HeapTuple tuple; - - item=(text*)palloc(VARHDRSZ + ptr->keylen); - VARATT_SIZEP(item) = VARHDRSZ+ptr->keylen; + st = (AKStore *) funcctx->user_fctx; + + if (st->i < st->hs->size) + { + HEntry *ptr = &(ARRPTR(st->hs)[st->i]); + Datum res, + dvalues[2]; + char nulls[] = {' ', ' '}; + text *item; + HeapTuple tuple; + + item = (text *) palloc(VARHDRSZ + ptr->keylen); + VARATT_SIZEP(item) = VARHDRSZ + ptr->keylen; memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos, ptr->keylen); dvalues[0] = PointerGetDatum(item); - if ( ptr->valisnull ) { - dvalues[1]=(Datum)0; - nulls[1]='n'; - } else { - int vallen = ptr->vallen; + if (ptr->valisnull) + { + dvalues[1] = (Datum) 0; + nulls[1] = 'n'; + } + else + { + int vallen = ptr->vallen; - item=(text*)palloc(VARHDRSZ + vallen); - VARATT_SIZEP(item) = VARHDRSZ+vallen; + item = (text *) palloc(VARHDRSZ + vallen); + VARATT_SIZEP(item) = VARHDRSZ + vallen; memcpy(VARDATA(item), STRPTR(st->hs) + ptr->pos + ptr->keylen, vallen); dvalues[1] = PointerGetDatum(item); } @@ -551,17 +616,15 @@ each(PG_FUNCTION_ARGS) { tuple = heap_formtuple(funcctx->attinmeta->tupdesc, dvalues, nulls); res = TupleGetDatum(funcctx->slot, tuple); - pfree( DatumGetPointer(dvalues[0]) ); - if ( nulls[1] != 'n' ) - pfree( DatumGetPointer(dvalues[1]) ); + pfree(DatumGetPointer(dvalues[0])); + if (nulls[1] != 'n') + pfree(DatumGetPointer(dvalues[1])); SRF_RETURN_NEXT(funcctx, PointerGetDatum(res)); } - - pfree( st->hs ); - pfree( st ); - - SRF_RETURN_DONE(funcctx); -} + pfree(st->hs); + pfree(st); + SRF_RETURN_DONE(funcctx); +} diff --git a/contrib/intarray/_int.h b/contrib/intarray/_int.h index f40dc06a92..bf10f10922 100644 --- a/contrib/intarray/_int.h +++ b/contrib/intarray/_int.h @@ -154,17 +154,17 @@ typedef struct #define COMPUTESIZE(size) ( HDRSIZEQT + size * sizeof(ITEM) ) #define GETQUERY(x) (ITEM*)( (char*)(x)+HDRSIZEQT ) -#define END 0 -#define ERR 1 -#define VAL 2 -#define OPR 3 -#define OPEN 4 -#define CLOSE 5 +#define END 0 +#define ERR 1 +#define VAL 2 +#define OPR 3 +#define OPEN 4 +#define CLOSE 5 bool signconsistent(QUERYTYPE * query, BITVEC sign, bool calcnot); bool execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot); -bool ginconsistent(QUERYTYPE * query, bool *check); -int4 shorterquery(ITEM * q, int4 len); +bool ginconsistent(QUERYTYPE * query, bool *check); +int4 shorterquery(ITEM * q, int4 len); int compASC(const void *a, const void *b); diff --git a/contrib/intarray/_int_bool.c b/contrib/intarray/_int_bool.c index 230c412a04..8517010e5e 100644 --- a/contrib/intarray/_int_bool.c +++ b/contrib/intarray/_int_bool.c @@ -232,7 +232,7 @@ typedef struct * is there value 'val' in array or not ? */ static bool -checkcondition_arr(void *checkval, ITEM *item) +checkcondition_arr(void *checkval, ITEM * item) { int4 *StopLow = ((CHKVAL *) checkval)->arrb; int4 *StopHigh = ((CHKVAL *) checkval)->arre; @@ -254,7 +254,7 @@ checkcondition_arr(void *checkval, ITEM *item) } static bool -checkcondition_bit(void *checkval, ITEM *item) +checkcondition_bit(void *checkval, ITEM * item) { return GETBIT(checkval, HASHVAL(item->val)); } @@ -263,7 +263,7 @@ checkcondition_bit(void *checkval, ITEM *item) * check for boolean condition */ static bool -execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM *item)) +execute(ITEM * curitem, void *checkval, bool calcnot, bool (*chkcond) (void *checkval, ITEM * item)) { if (curitem->type == VAL) @@ -319,38 +319,42 @@ execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot) ); } -typedef struct { - ITEM *first; - bool *mapped_check; -} GinChkVal; +typedef struct +{ + ITEM *first; + bool *mapped_check; +} GinChkVal; static bool -checkcondition_gin(void *checkval, ITEM *item) { - GinChkVal *gcv = (GinChkVal*)checkval; +checkcondition_gin(void *checkval, ITEM * item) +{ + GinChkVal *gcv = (GinChkVal *) checkval; - return gcv->mapped_check[ item - gcv->first ]; + return gcv->mapped_check[item - gcv->first]; } bool -ginconsistent(QUERYTYPE * query, bool *check) { - GinChkVal gcv; - ITEM *items = GETQUERY(query); - int i, j=0; +ginconsistent(QUERYTYPE * query, bool *check) +{ + GinChkVal gcv; + ITEM *items = GETQUERY(query); + int i, + j = 0; - if ( query->size < 0 ) + if (query->size < 0) return FALSE; gcv.first = items; - gcv.mapped_check = (bool*)palloc( sizeof(bool)*query->size ); - for(i=0; i<query->size; i++) - if ( items[i].type == VAL ) - gcv.mapped_check[ i ] = check[ j++ ]; - - return execute( - GETQUERY(query) + query->size - 1, - (void *) &gcv, true, - checkcondition_gin - ); + gcv.mapped_check = (bool *) palloc(sizeof(bool) * query->size); + for (i = 0; i < query->size; i++) + if (items[i].type == VAL) + gcv.mapped_check[i] = check[j++]; + + return execute( + GETQUERY(query) + query->size - 1, + (void *) &gcv, true, + checkcondition_gin + ); } /* diff --git a/contrib/intarray/_int_gin.c b/contrib/intarray/_int_gin.c index 2a2830e578..7bb9599b33 100644 --- a/contrib/intarray/_int_gin.c +++ b/contrib/intarray/_int_gin.c @@ -1,102 +1,118 @@ #include "_int.h" PG_FUNCTION_INFO_V1(ginint4_queryextract); -Datum ginint4_queryextract(PG_FUNCTION_ARGS); +Datum ginint4_queryextract(PG_FUNCTION_ARGS); Datum -ginint4_queryextract(PG_FUNCTION_ARGS) { - uint32 *nentries = (uint32*)PG_GETARG_POINTER(1); - StrategyNumber strategy = PG_GETARG_UINT16(2); - Datum *res = NULL; - +ginint4_queryextract(PG_FUNCTION_ARGS) +{ + uint32 *nentries = (uint32 *) PG_GETARG_POINTER(1); + StrategyNumber strategy = PG_GETARG_UINT16(2); + Datum *res = NULL; + *nentries = 0; - if ( strategy == BooleanSearchStrategy ) { - QUERYTYPE *query = (QUERYTYPE*)PG_DETOAST_DATUM_COPY(PG_GETARG_POINTER(0)); - ITEM *items = GETQUERY(query); - int i; + if (strategy == BooleanSearchStrategy) + { + QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM_COPY(PG_GETARG_POINTER(0)); + ITEM *items = GETQUERY(query); + int i; if (query->size == 0) PG_RETURN_POINTER(NULL); - if ( shorterquery(items, query->size) == 0 ) - elog(ERROR,"Query requires full scan, GIN doesn't support it"); + if (shorterquery(items, query->size) == 0) + elog(ERROR, "Query requires full scan, GIN doesn't support it"); - pfree( query ); + pfree(query); - query = (QUERYTYPE*)PG_DETOAST_DATUM(PG_GETARG_POINTER(0)); + query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_POINTER(0)); items = GETQUERY(query); - res = (Datum*)palloc(sizeof(Datum) * query->size); + res = (Datum *) palloc(sizeof(Datum) * query->size); *nentries = 0; - for(i=0;i<query->size;i++) - if ( items[i].type == VAL ) { - res[*nentries] = Int32GetDatum( items[i].val ); + for (i = 0; i < query->size; i++) + if (items[i].type == VAL) + { + res[*nentries] = Int32GetDatum(items[i].val); (*nentries)++; } - } else { - ArrayType *query = PG_GETARG_ARRAYTYPE_P(0); - int4 *arr; - uint32 i; + } + else + { + ArrayType *query = PG_GETARG_ARRAYTYPE_P(0); + int4 *arr; + uint32 i; CHECKARRVALID(query); - *nentries=ARRNELEMS(query); - if ( *nentries > 0 ) { - res = (Datum*)palloc(sizeof(Datum) * (*nentries)); - - arr=ARRPTR(query); - for(i=0;i<*nentries;i++) - res[i] = Int32GetDatum( arr[i] ); + *nentries = ARRNELEMS(query); + if (*nentries > 0) + { + res = (Datum *) palloc(sizeof(Datum) * (*nentries)); + + arr = ARRPTR(query); + for (i = 0; i < *nentries; i++) + res[i] = Int32GetDatum(arr[i]); } } - PG_RETURN_POINTER( res ); + PG_RETURN_POINTER(res); } PG_FUNCTION_INFO_V1(ginint4_consistent); -Datum ginint4_consistent(PG_FUNCTION_ARGS); +Datum ginint4_consistent(PG_FUNCTION_ARGS); Datum -ginint4_consistent(PG_FUNCTION_ARGS) { - bool *check = (bool*)PG_GETARG_POINTER(0); - StrategyNumber strategy = PG_GETARG_UINT16(1); - int res=FALSE; - - /* we can do not check array carefully, it's done by previous ginarrayextract call */ - - switch( strategy ) { - case RTOverlapStrategyNumber: - case RTContainedByStrategyNumber: - case RTOldContainedByStrategyNumber: - /* at least one element in check[] is true, so result = true */ - - res = TRUE; - break; - case RTSameStrategyNumber: - case RTContainsStrategyNumber: - case RTOldContainsStrategyNumber: - res = TRUE; - do { - ArrayType *query = PG_GETARG_ARRAYTYPE_P(2); - int i, nentries=ARRNELEMS(query); - - for(i=0;i<nentries;i++) - if ( !check[i] ) { - res = FALSE; - break; - } - } while(0); - break; - case BooleanSearchStrategy: - do { - QUERYTYPE *query = (QUERYTYPE*)PG_DETOAST_DATUM(PG_GETARG_POINTER(2)); - res = ginconsistent( query, check ); - } while(0); +ginint4_consistent(PG_FUNCTION_ARGS) +{ + bool *check = (bool *) PG_GETARG_POINTER(0); + StrategyNumber strategy = PG_GETARG_UINT16(1); + int res = FALSE; + + /* + * we can do not check array carefully, it's done by previous + * ginarrayextract call + */ + + switch (strategy) + { + case RTOverlapStrategyNumber: + case RTContainedByStrategyNumber: + case RTOldContainedByStrategyNumber: + /* at least one element in check[] is true, so result = true */ + + res = TRUE; + break; + case RTSameStrategyNumber: + case RTContainsStrategyNumber: + case RTOldContainsStrategyNumber: + res = TRUE; + do + { + ArrayType *query = PG_GETARG_ARRAYTYPE_P(2); + int i, + nentries = ARRNELEMS(query); + + for (i = 0; i < nentries; i++) + if (!check[i]) + { + res = FALSE; + break; + } + } while (0); break; - default: - elog(ERROR, "ginint4_consistent: unknown strategy number: %d", strategy); - } + case BooleanSearchStrategy: + do + { + QUERYTYPE *query = (QUERYTYPE *) PG_DETOAST_DATUM(PG_GETARG_POINTER(2)); + + res = ginconsistent(query, check); + } while (0); + break; + default: + elog(ERROR, "ginint4_consistent: unknown strategy number: %d", strategy); + } - PG_RETURN_BOOL(res); + PG_RETURN_BOOL(res); } diff --git a/contrib/intarray/_int_gist.c b/contrib/intarray/_int_gist.c index 71c9ad0cec..56eb0c08c2 100644 --- a/contrib/intarray/_int_gist.c +++ b/contrib/intarray/_int_gist.c @@ -36,19 +36,21 @@ g_int_consistent(PG_FUNCTION_ARGS) StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); bool retval; - if (strategy == BooleanSearchStrategy) { + if (strategy == BooleanSearchStrategy) + { retval = execconsistent((QUERYTYPE *) query, - (ArrayType *) DatumGetPointer(entry->key), - GIST_LEAF(entry)); + (ArrayType *) DatumGetPointer(entry->key), + GIST_LEAF(entry)); - pfree( query ); + pfree(query); PG_RETURN_BOOL(retval); } /* sort query for fast search, key is already sorted */ CHECKARRVALID(query); - if (ARRISVOID(query)) { - pfree( query ); + if (ARRISVOID(query)) + { + pfree(query); PG_RETURN_BOOL(false); } PREPAREARR(query); @@ -88,7 +90,7 @@ g_int_consistent(PG_FUNCTION_ARGS) default: retval = FALSE; } - pfree( query ); + pfree(query); PG_RETURN_BOOL(retval); } @@ -156,7 +158,7 @@ g_int_compress(PG_FUNCTION_ARGS) retval = palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, entry->offset, FALSE); + entry->rel, entry->page, entry->offset, FALSE); PG_RETURN_POINTER(retval); } @@ -203,7 +205,7 @@ g_int_compress(PG_FUNCTION_ARGS) r = resize_intArrayType(r, len); retval = palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(r), - entry->rel, entry->page, entry->offset, FALSE); + entry->rel, entry->page, entry->offset, FALSE); PG_RETURN_POINTER(retval); } else @@ -240,7 +242,7 @@ g_int_decompress(PG_FUNCTION_ARGS) { retval = palloc(sizeof(GISTENTRY)); gistentryinit(*retval, PointerGetDatum(in), - entry->rel, entry->page, entry->offset, FALSE); + entry->rel, entry->page, entry->offset, FALSE); PG_RETURN_POINTER(retval); } @@ -331,7 +333,7 @@ typedef struct { OffsetNumber pos; float cost; -} SPLITCOST; +} SPLITCOST; static int comparecost(const void *a, const void *b) diff --git a/contrib/intarray/_int_tool.c b/contrib/intarray/_int_tool.c index 82ce4b7ac5..2ad0ef0cc0 100644 --- a/contrib/intarray/_int_tool.c +++ b/contrib/intarray/_int_tool.c @@ -89,22 +89,27 @@ inner_int_union(ArrayType *a, ArrayType *b) if (!r) { - int na = ARRNELEMS(a), - nb = ARRNELEMS(b); - int *da = ARRPTR(a), - *db = ARRPTR(b); - int i,j, *dr; + int na = ARRNELEMS(a), + nb = ARRNELEMS(b); + int *da = ARRPTR(a), + *db = ARRPTR(b); + int i, + j, + *dr; r = new_intArrayType(na + nb); dr = ARRPTR(r); /* union */ i = j = 0; - while (i < na && j < nb) { - if (da[i] == db[j]) { + while (i < na && j < nb) + { + if (da[i] == db[j]) + { *dr++ = da[i++]; j++; - } else if (da[i] < db[j]) + } + else if (da[i] < db[j]) *dr++ = da[i++]; else *dr++ = db[j++]; @@ -115,7 +120,7 @@ inner_int_union(ArrayType *a, ArrayType *b) while (j < nb) *dr++ = db[j++]; - r = resize_intArrayType(r, dr-ARRPTR(r)); + r = resize_intArrayType(r, dr - ARRPTR(r)); } if (ARRNELEMS(r) > 1) diff --git a/contrib/intarray/_intbig_gist.c b/contrib/intarray/_intbig_gist.c index b25814c7ce..cb80d8f6f2 100644 --- a/contrib/intarray/_intbig_gist.c +++ b/contrib/intarray/_intbig_gist.c @@ -214,7 +214,7 @@ sizebitvec(BITVECP sign) i; LOOPBYTE( - size += number_of_ones[(unsigned char) sign[i]]; + size += number_of_ones[(unsigned char) sign[i]]; ); return size; } @@ -227,8 +227,8 @@ hemdistsign(BITVECP a, BITVECP b) dist = 0; LOOPBYTE( - diff = (unsigned char) (a[i] ^ b[i]); - dist += number_of_ones[diff]; + diff = (unsigned char) (a[i] ^ b[i]); + dist += number_of_ones[diff]; ); return dist; } @@ -318,7 +318,7 @@ typedef struct { OffsetNumber pos; int4 cost; -} SPLITCOST; +} SPLITCOST; static int comparecost(const void *a, const void *b) @@ -506,16 +506,17 @@ g_intbig_consistent(PG_FUNCTION_ARGS) if (strategy == BooleanSearchStrategy) { - retval =signconsistent((QUERYTYPE *) query, - GETSIGN(DatumGetPointer(entry->key)), - false); - PG_FREE_IF_COPY( query, 1 ); + retval = signconsistent((QUERYTYPE *) query, + GETSIGN(DatumGetPointer(entry->key)), + false); + PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(retval); } CHECKARRVALID(query); - if (ARRISVOID(query)) { - PG_FREE_IF_COPY( query, 1 ); + if (ARRISVOID(query)) + { + PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(FALSE); } @@ -602,6 +603,6 @@ g_intbig_consistent(PG_FUNCTION_ARGS) default: retval = FALSE; } - PG_FREE_IF_COPY( query, 1 ); + PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(retval); } diff --git a/contrib/isn/EAN13.h b/contrib/isn/EAN13.h index 43886c2d68..87b611a542 100644 --- a/contrib/isn/EAN13.h +++ b/contrib/isn/EAN13.h @@ -1,4 +1,4 @@ -/* +/* * EAN13.h * PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC) * @@ -6,142 +6,143 @@ * http://www.gs1.org/productssolutions/idkeys/support/prefix_list.html * * IDENTIFICATION - * $PostgreSQL: pgsql/contrib/isn/EAN13.h,v 1.1 2006/09/09 04:07:52 tgl Exp $ + * $PostgreSQL: pgsql/contrib/isn/EAN13.h,v 1.2 2006/10/04 00:29:45 momjian Exp $ * */ /* where the digit set begins, and how many of them are in the table */ const unsigned EAN13_index[10][2] = { - {0, 6}, - {6, 1}, - {7, 1}, - {8, 5}, - {13, 20}, - {33, 15}, - {48, 19}, - {67, 23}, - {90, 17}, - {107, 12}, + {0, 6}, + {6, 1}, + {7, 1}, + {8, 5}, + {13, 20}, + {33, 15}, + {48, 19}, + {67, 23}, + {90, 17}, + {107, 12}, }; const char *EAN13_range[][2] = { - {"000", "019"}, /* GS1 US */ - {"020", "029"}, /* Restricted distribution (MO defined) */ - {"030", "039"}, /* GS1 US */ - {"040", "049"}, /* Restricted distribution (MO defined) */ - {"050", "059"}, /* Coupons */ - {"060", "099"}, /* GS1 US */ - {"100", "139"}, /* GS1 US */ - {"200", "299"}, /* Restricted distribution (MO defined) */ - {"300", "379"}, /* GS1 France */ - {"380", "380"}, /* GS1 Bulgaria */ - {"383", "383"}, /* GS1 Slovenija */ - {"385", "385"}, /* GS1 Croatia */ - {"387", "387"}, /* GS1 BIH (Bosnia-Herzegovina) */ - {"400", "440"}, /* GS1 Germany */ - {"450", "459"}, /* GS1 Japan */ - {"460", "469"}, /* GS1 Russia */ - {"470", "470"}, /* GS1 Kyrgyzstan */ - {"471", "471"}, /* GS1 Taiwan */ - {"474", "474"}, /* GS1 Estonia */ - {"475", "475"}, /* GS1 Latvia */ - {"476", "476"}, /* GS1 Azerbaijan */ - {"477", "477"}, /* GS1 Lithuania */ - {"478", "478"}, /* GS1 Uzbekistan */ - {"479", "479"}, /* GS1 Sri Lanka */ - {"480", "480"}, /* GS1 Philippines */ - {"481", "481"}, /* GS1 Belarus */ - {"482", "482"}, /* GS1 Ukraine */ - {"484", "484"}, /* GS1 Moldova */ - {"485", "485"}, /* GS1 Armenia */ - {"486", "486"}, /* GS1 Georgia */ - {"487", "487"}, /* GS1 Kazakstan */ - {"489", "489"}, /* GS1 Hong Kong */ - {"490", "499"}, /* GS1 Japan */ - {"500", "509"}, /* GS1 UK */ - {"520", "520"}, /* GS1 Greece */ - {"528", "528"}, /* GS1 Lebanon */ - {"529", "529"}, /* GS1 Cyprus */ - {"530", "530"}, /* GS1 Albania */ - {"531", "531"}, /* GS1 MAC (FYR Macedonia) */ - {"535", "535"}, /* GS1 Malta */ - {"539", "539"}, /* GS1 Ireland */ - {"540", "549"}, /* GS1 Belgium & Luxembourg */ - {"560", "560"}, /* GS1 Portugal */ - {"569", "569"}, /* GS1 Iceland */ - {"570", "579"}, /* GS1 Denmark */ - {"590", "590"}, /* GS1 Poland */ - {"594", "594"}, /* GS1 Romania */ - {"599", "599"}, /* GS1 Hungary */ - {"600", "601"}, /* GS1 South Africa */ - {"603", "603"}, /* GS1 Ghana */ - {"608", "608"}, /* GS1 Bahrain */ - {"609", "609"}, /* GS1 Mauritius */ - {"611", "611"}, /* GS1 Morocco */ - {"613", "613"}, /* GS1 Algeria */ - {"616", "616"}, /* GS1 Kenya */ - {"618", "618"}, /* GS1 Ivory Coast */ - {"619", "619"}, /* GS1 Tunisia */ - {"621", "621"}, /* GS1 Syria */ - {"622", "622"}, /* GS1 Egypt */ - {"624", "624"}, /* GS1 Libya */ - {"625", "625"}, /* GS1 Jordan */ - {"626", "626"}, /* GS1 Iran */ - {"627", "627"}, /* GS1 Kuwait */ - {"628", "628"}, /* GS1 Saudi Arabia */ - {"629", "629"}, /* GS1 Emirates */ - {"640", "649"}, /* GS1 Finland */ - {"690", "695"}, /* GS1 China */ - {"700", "709"}, /* GS1 Norway */ - {"729", "729"}, /* GS1 Israel */ - {"730", "739"}, /* GS1 Sweden */ - {"740", "740"}, /* GS1 Guatemala */ - {"741", "741"}, /* GS1 El Salvador */ - {"742", "742"}, /* GS1 Honduras */ - {"743", "743"}, /* GS1 Nicaragua */ - {"744", "744"}, /* GS1 Costa Rica */ - {"745", "745"}, /* GS1 Panama */ - {"746", "746"}, /* GS1 Republica Dominicana */ - {"750", "750"}, /* GS1 Mexico */ - {"754", "755"}, /* GS1 Canada */ - {"759", "759"}, /* GS1 Venezuela */ - {"760", "769"}, /* GS1 Schweiz, Suisse, Svizzera */ - {"770", "770"}, /* GS1 Colombia */ - {"773", "773"}, /* GS1 Uruguay */ - {"775", "775"}, /* GS1 Peru */ - {"777", "777"}, /* GS1 Bolivia */ - {"779", "779"}, /* GS1 Argentina */ - {"780", "780"}, /* GS1 Chile */ - {"784", "784"}, /* GS1 Paraguay */ - {"786", "786"}, /* GS1 Ecuador */ - {"789", "790"}, /* GS1 Brasil */ - {"800", "839"}, /* GS1 Italy */ - {"840", "849"}, /* GS1 Spain */ - {"850", "850"}, /* GS1 Cuba */ - {"858", "858"}, /* GS1 Slovakia */ - {"859", "859"}, /* GS1 Czech */ - {"860", "860"}, /* GS1 YU (Serbia & Montenegro) */ - {"865", "865"}, /* GS1 Mongolia */ - {"867", "867"}, /* GS1 North Korea */ - {"869", "869"}, /* GS1 Turkey */ - {"870", "879"}, /* GS1 Netherlands */ - {"880", "880"}, /* GS1 South Korea */ - {"884", "884"}, /* GS1 Cambodia */ - {"885", "885"}, /* GS1 Thailand */ - {"888", "888"}, /* GS1 Singapore */ - {"890", "890"}, /* GS1 India */ - {"893", "893"}, /* GS1 Vietnam */ - {"899", "899"}, /* GS1 Indonesia */ - {"900", "919"}, /* GS1 Austria */ - {"930", "939"}, /* GS1 Australia */ - {"940", "949"}, /* GS1 New Zealand */ - {"950", "950"}, /* GS1 Head Office */ - {"955", "955"}, /* GS1 Malaysia */ - {"958", "958"}, /* GS1 Macau */ - {"977", "977"}, /* Serial publications (ISSN) */ - {"978", "978"}, /* Bookland (ISBN) */ - {"979", "979"}, /* International Standard Music Number (ISMN) and ISBN contingent */ - {"980", "980"}, /* Refund receipts */ - {"981", "982"}, /* Common Currency Coupons */ - {"990", "999"}, /* Coupons */ + {"000", "019"}, /* GS1 US */ + {"020", "029"}, /* Restricted distribution (MO defined) */ + {"030", "039"}, /* GS1 US */ + {"040", "049"}, /* Restricted distribution (MO defined) */ + {"050", "059"}, /* Coupons */ + {"060", "099"}, /* GS1 US */ + {"100", "139"}, /* GS1 US */ + {"200", "299"}, /* Restricted distribution (MO defined) */ + {"300", "379"}, /* GS1 France */ + {"380", "380"}, /* GS1 Bulgaria */ + {"383", "383"}, /* GS1 Slovenija */ + {"385", "385"}, /* GS1 Croatia */ + {"387", "387"}, /* GS1 BIH (Bosnia-Herzegovina) */ + {"400", "440"}, /* GS1 Germany */ + {"450", "459"}, /* GS1 Japan */ + {"460", "469"}, /* GS1 Russia */ + {"470", "470"}, /* GS1 Kyrgyzstan */ + {"471", "471"}, /* GS1 Taiwan */ + {"474", "474"}, /* GS1 Estonia */ + {"475", "475"}, /* GS1 Latvia */ + {"476", "476"}, /* GS1 Azerbaijan */ + {"477", "477"}, /* GS1 Lithuania */ + {"478", "478"}, /* GS1 Uzbekistan */ + {"479", "479"}, /* GS1 Sri Lanka */ + {"480", "480"}, /* GS1 Philippines */ + {"481", "481"}, /* GS1 Belarus */ + {"482", "482"}, /* GS1 Ukraine */ + {"484", "484"}, /* GS1 Moldova */ + {"485", "485"}, /* GS1 Armenia */ + {"486", "486"}, /* GS1 Georgia */ + {"487", "487"}, /* GS1 Kazakstan */ + {"489", "489"}, /* GS1 Hong Kong */ + {"490", "499"}, /* GS1 Japan */ + {"500", "509"}, /* GS1 UK */ + {"520", "520"}, /* GS1 Greece */ + {"528", "528"}, /* GS1 Lebanon */ + {"529", "529"}, /* GS1 Cyprus */ + {"530", "530"}, /* GS1 Albania */ + {"531", "531"}, /* GS1 MAC (FYR Macedonia) */ + {"535", "535"}, /* GS1 Malta */ + {"539", "539"}, /* GS1 Ireland */ + {"540", "549"}, /* GS1 Belgium & Luxembourg */ + {"560", "560"}, /* GS1 Portugal */ + {"569", "569"}, /* GS1 Iceland */ + {"570", "579"}, /* GS1 Denmark */ + {"590", "590"}, /* GS1 Poland */ + {"594", "594"}, /* GS1 Romania */ + {"599", "599"}, /* GS1 Hungary */ + {"600", "601"}, /* GS1 South Africa */ + {"603", "603"}, /* GS1 Ghana */ + {"608", "608"}, /* GS1 Bahrain */ + {"609", "609"}, /* GS1 Mauritius */ + {"611", "611"}, /* GS1 Morocco */ + {"613", "613"}, /* GS1 Algeria */ + {"616", "616"}, /* GS1 Kenya */ + {"618", "618"}, /* GS1 Ivory Coast */ + {"619", "619"}, /* GS1 Tunisia */ + {"621", "621"}, /* GS1 Syria */ + {"622", "622"}, /* GS1 Egypt */ + {"624", "624"}, /* GS1 Libya */ + {"625", "625"}, /* GS1 Jordan */ + {"626", "626"}, /* GS1 Iran */ + {"627", "627"}, /* GS1 Kuwait */ + {"628", "628"}, /* GS1 Saudi Arabia */ + {"629", "629"}, /* GS1 Emirates */ + {"640", "649"}, /* GS1 Finland */ + {"690", "695"}, /* GS1 China */ + {"700", "709"}, /* GS1 Norway */ + {"729", "729"}, /* GS1 Israel */ + {"730", "739"}, /* GS1 Sweden */ + {"740", "740"}, /* GS1 Guatemala */ + {"741", "741"}, /* GS1 El Salvador */ + {"742", "742"}, /* GS1 Honduras */ + {"743", "743"}, /* GS1 Nicaragua */ + {"744", "744"}, /* GS1 Costa Rica */ + {"745", "745"}, /* GS1 Panama */ + {"746", "746"}, /* GS1 Republica Dominicana */ + {"750", "750"}, /* GS1 Mexico */ + {"754", "755"}, /* GS1 Canada */ + {"759", "759"}, /* GS1 Venezuela */ + {"760", "769"}, /* GS1 Schweiz, Suisse, Svizzera */ + {"770", "770"}, /* GS1 Colombia */ + {"773", "773"}, /* GS1 Uruguay */ + {"775", "775"}, /* GS1 Peru */ + {"777", "777"}, /* GS1 Bolivia */ + {"779", "779"}, /* GS1 Argentina */ + {"780", "780"}, /* GS1 Chile */ + {"784", "784"}, /* GS1 Paraguay */ + {"786", "786"}, /* GS1 Ecuador */ + {"789", "790"}, /* GS1 Brasil */ + {"800", "839"}, /* GS1 Italy */ + {"840", "849"}, /* GS1 Spain */ + {"850", "850"}, /* GS1 Cuba */ + {"858", "858"}, /* GS1 Slovakia */ + {"859", "859"}, /* GS1 Czech */ + {"860", "860"}, /* GS1 YU (Serbia & Montenegro) */ + {"865", "865"}, /* GS1 Mongolia */ + {"867", "867"}, /* GS1 North Korea */ + {"869", "869"}, /* GS1 Turkey */ + {"870", "879"}, /* GS1 Netherlands */ + {"880", "880"}, /* GS1 South Korea */ + {"884", "884"}, /* GS1 Cambodia */ + {"885", "885"}, /* GS1 Thailand */ + {"888", "888"}, /* GS1 Singapore */ + {"890", "890"}, /* GS1 India */ + {"893", "893"}, /* GS1 Vietnam */ + {"899", "899"}, /* GS1 Indonesia */ + {"900", "919"}, /* GS1 Austria */ + {"930", "939"}, /* GS1 Australia */ + {"940", "949"}, /* GS1 New Zealand */ + {"950", "950"}, /* GS1 Head Office */ + {"955", "955"}, /* GS1 Malaysia */ + {"958", "958"}, /* GS1 Macau */ + {"977", "977"}, /* Serial publications (ISSN) */ + {"978", "978"}, /* Bookland (ISBN) */ + {"979", "979"}, /* International Standard Music Number (ISMN) + * and ISBN contingent */ + {"980", "980"}, /* Refund receipts */ + {"981", "982"}, /* Common Currency Coupons */ + {"990", "999"}, /* Coupons */ {NULL, NULL} }; diff --git a/contrib/isn/ISBN.h b/contrib/isn/ISBN.h index 0b23a95ccf..26c84afe80 100644 --- a/contrib/isn/ISBN.h +++ b/contrib/isn/ISBN.h @@ -1,4 +1,4 @@ -/* +/* * ISBN.h * PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC) * @@ -7,39 +7,39 @@ * http://www.isbn.org/ * * IDENTIFICATION - * $PostgreSQL: pgsql/contrib/isn/ISBN.h,v 1.1 2006/09/09 04:07:52 tgl Exp $ + * $PostgreSQL: pgsql/contrib/isn/ISBN.h,v 1.2 2006/10/04 00:29:45 momjian Exp $ * * 0-393-04002-X => 039304002(X) <=> 039304002 <=> (978)039304002 <=> 978039304002(9) <=> 978-0-393-04002-9 * * - * ISBN 0 3 9 3 0 4 0 0 2 - * Weight 10 9 8 7 6 5 4 3 2 - * Product 0 + 27 + 72 + 21 + 0 + 20 + 0 + 0 + 4 = 144 - * 144 / 11 = 13 remainder 1 - * Check digit 11 - 1 = 10 = X + * ISBN 0 3 9 3 0 4 0 0 2 + * Weight 10 9 8 7 6 5 4 3 2 + * Product 0 + 27 + 72 + 21 + 0 + 20 + 0 + 0 + 4 = 144 + * 144 / 11 = 13 remainder 1 + * Check digit 11 - 1 = 10 = X * => 0-393-04002-X * - * ISBN 9 7 8 0 3 9 3 0 4 0 0 2 - * Weight 1 3 1 3 1 3 1 3 1 3 1 3 - * Product 9 + 21 + 8 + 0 + 3 + 27 + 3 + 0 + 4 + 0 + 0 + 6 = 81 - * 81 / 10 = 8 remainder 1 - * Check digit 10 - 1 = 9 + * ISBN 9 7 8 0 3 9 3 0 4 0 0 2 + * Weight 1 3 1 3 1 3 1 3 1 3 1 3 + * Product 9 + 21 + 8 + 0 + 3 + 27 + 3 + 0 + 4 + 0 + 0 + 6 = 81 + * 81 / 10 = 8 remainder 1 + * Check digit 10 - 1 = 9 * => 978-0-393-04002-9 * */ /* where the digit set begins, and how many of them are in the table */ const unsigned ISBN_index[10][2] = { - {0, 6}, - {6, 6}, - {12, 8}, - {20, 10}, - {30, 6}, - {36, 12}, - {48, 0}, - {48, 5}, - {53, 59}, - {112, 573}, + {0, 6}, + {6, 6}, + {12, 8}, + {20, 10}, + {30, 6}, + {36, 12}, + {48, 0}, + {48, 5}, + {53, 59}, + {112, 573}, }; const char *ISBN_range[][2] = { diff --git a/contrib/isn/ISMN.h b/contrib/isn/ISMN.h index 0451d1942c..1d7b2af8fd 100644 --- a/contrib/isn/ISMN.h +++ b/contrib/isn/ISMN.h @@ -1,4 +1,4 @@ -/* +/* * ISMN.h * PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC) * @@ -6,23 +6,23 @@ * http://www.ismn-international.org * * IDENTIFICATION - * $PostgreSQL: pgsql/contrib/isn/ISMN.h,v 1.1 2006/09/09 04:07:52 tgl Exp $ + * $PostgreSQL: pgsql/contrib/isn/ISMN.h,v 1.2 2006/10/04 00:29:45 momjian Exp $ * * M-3452-4680-5 <=> (0)-3452-4680-5 <=> 0345246805 <=> 9790345246805 <=> 979-0-3452-4680-5 * - * (M counts as 3) - * ISMN M 3 4 5 2 4 6 8 0 - * Weight 3 1 3 1 3 1 3 1 3 - * Product 9 + 3 + 12 + 5 + 6 + 4 + 18 + 8 + 0 = 65 - * 65 / 10 = 6 remainder 5 - * Check digit 10 - 5 = 5 + * (M counts as 3) + * ISMN M 3 4 5 2 4 6 8 0 + * Weight 3 1 3 1 3 1 3 1 3 + * Product 9 + 3 + 12 + 5 + 6 + 4 + 18 + 8 + 0 = 65 + * 65 / 10 = 6 remainder 5 + * Check digit 10 - 5 = 5 * => M-3452-4680-5 * - * ISMN 9 7 9 0 3 4 5 2 4 6 8 0 - * Weight 1 3 1 3 1 3 1 3 1 3 1 3 - * Product 9 + 21 + 9 + 0 + 3 + 12 + 5 + 6 + 4 + 18 + 8 + 0 = 95 - * 95 / 10 = 9 remainder 5 - * Check digit 10 - 5 = 5 + * ISMN 9 7 9 0 3 4 5 2 4 6 8 0 + * Weight 1 3 1 3 1 3 1 3 1 3 1 3 + * Product 9 + 21 + 9 + 0 + 3 + 12 + 5 + 6 + 4 + 18 + 8 + 0 = 95 + * 95 / 10 = 9 remainder 5 + * Check digit 10 - 5 = 5 * => 979-0-3452-4680-5 * * Since mod10(9*1 + 7*3 + 9*1 + 0*3) = mod10(M*3) = mod10(3*3) = 9; the check digit remains the same. @@ -31,16 +31,16 @@ /* where the digit set begins, and how many of them are in the table */ const unsigned ISMN_index[10][2] = { - {0, 5}, - {5, 0}, - {5, 0}, - {5, 0}, - {5, 0}, - {5, 0}, - {5, 0}, - {5, 0}, - {5, 0}, - {5, 0}, + {0, 5}, + {5, 0}, + {5, 0}, + {5, 0}, + {5, 0}, + {5, 0}, + {5, 0}, + {5, 0}, + {5, 0}, + {5, 0}, }; const char *ISMN_range[][2] = { {"0-000", "0-099"}, diff --git a/contrib/isn/ISSN.h b/contrib/isn/ISSN.h index aeafb0c3c7..063a5d97f1 100644 --- a/contrib/isn/ISSN.h +++ b/contrib/isn/ISSN.h @@ -1,4 +1,4 @@ -/* +/* * ISSN.h * PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC) * @@ -6,25 +6,25 @@ * http://www.issn.org/ * * IDENTIFICATION - * $PostgreSQL: pgsql/contrib/isn/ISSN.h,v 1.1 2006/09/09 04:07:52 tgl Exp $ + * $PostgreSQL: pgsql/contrib/isn/ISSN.h,v 1.2 2006/10/04 00:29:45 momjian Exp $ * * 1144-875X <=> 1144875(X) <=> 1144875 <=> (977)1144875 <=> 9771144875(00) <=> 977114487500(7) <=> 977-1144-875-00-7 * - * - * ISSN 1 1 4 4 8 7 5 - * Weight 8 7 6 5 4 3 2 - * Product 8 + 7 + 24 + 20 + 32 + 21 + 10 = 122 - * 122 / 11 = 11 remainder 1 - * Check digit 11 - 1 = 10 = X + * + * ISSN 1 1 4 4 8 7 5 + * Weight 8 7 6 5 4 3 2 + * Product 8 + 7 + 24 + 20 + 32 + 21 + 10 = 122 + * 122 / 11 = 11 remainder 1 + * Check digit 11 - 1 = 10 = X * => 1144-875X - * - * ISSN 9 7 7 1 1 4 4 8 7 5 0 0 - * Weight 1 3 1 3 1 3 1 3 1 3 1 3 - * Product 9 + 21 + 7 + 3 + 1 + 12 + 4 + 24 + 7 + 15 + 0 + 0 = 103 - * 103 / 10 = 10 remainder 3 - * Check digit 10 - 3 = 7 + * + * ISSN 9 7 7 1 1 4 4 8 7 5 0 0 + * Weight 1 3 1 3 1 3 1 3 1 3 1 3 + * Product 9 + 21 + 7 + 3 + 1 + 12 + 4 + 24 + 7 + 15 + 0 + 0 = 103 + * 103 / 10 = 10 remainder 3 + * Check digit 10 - 3 = 7 * => 977-1144875-00-7 ?? <- suplemental number (number of the week, month, etc.) - * ^^ 00 for non-daily publications (01=Monday, 02=Tuesday, ...) + * ^^ 00 for non-daily publications (01=Monday, 02=Tuesday, ...) * * The hyphenation is always in after the four digits of the ISSN code. * @@ -32,16 +32,16 @@ /* where the digit set begins, and how many of them are in the table */ const unsigned ISSN_index[10][2] = { - {0, 1}, - {0, 1}, - {0, 1}, - {0, 1}, - {0, 1}, - {0, 1}, - {0, 1}, - {0, 1}, - {0, 1}, - {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, + {0, 1}, }; const char *ISSN_range[][2] = { {"0000-000", "9999-999"}, diff --git a/contrib/isn/UPC.h b/contrib/isn/UPC.h index 2491fa3ee2..2b58a6b566 100644 --- a/contrib/isn/UPC.h +++ b/contrib/isn/UPC.h @@ -1,27 +1,27 @@ -/* +/* * ISSN.h * PostgreSQL type definitions for ISNs (ISBN, ISMN, ISSN, EAN13, UPC) * * No information available for UPC prefixes - * + * * * IDENTIFICATION - * $PostgreSQL: pgsql/contrib/isn/UPC.h,v 1.1 2006/09/09 04:07:52 tgl Exp $ + * $PostgreSQL: pgsql/contrib/isn/UPC.h,v 1.2 2006/10/04 00:29:45 momjian Exp $ * */ /* where the digit set begins, and how many of them are in the table */ const unsigned UPC_index[10][2] = { - {0, 0}, - {0, 0}, - {0, 0}, - {0, 0}, - {0, 0}, - {0, 0}, - {0, 0}, - {0, 0}, - {0, 0}, - {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, + {0, 0}, }; const char *UPC_range[][2] = { {NULL, NULL} diff --git a/contrib/isn/isn.c b/contrib/isn/isn.c index 53e23228c9..cd4fd6c84a 100644 --- a/contrib/isn/isn.c +++ b/contrib/isn/isn.c @@ -7,7 +7,7 @@ * Portions Copyright (c) 1996-2004, PostgreSQL Global Development Group * * IDENTIFICATION - * $PostgreSQL: pgsql/contrib/isn/isn.c,v 1.3 2006/09/22 21:39:57 tgl Exp $ + * $PostgreSQL: pgsql/contrib/isn/isn.c,v 1.4 2006/10/04 00:29:45 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -29,9 +29,12 @@ PG_MODULE_MAGIC; #define MAXEAN13LEN 18 -enum isn_type { INVALID, ANY, EAN13, ISBN, ISMN, ISSN, UPC }; +enum isn_type +{ + INVALID, ANY, EAN13, ISBN, ISMN, ISSN, UPC +}; -static const char *isn_names[] = { "EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC" }; +static const char *isn_names[] = {"EAN13/UPC/ISxN", "EAN13/UPC/ISxN", "EAN13", "ISBN", "ISMN", "ISSN", "UPC"}; static bool g_weak = false; static bool g_initialized = false; @@ -46,8 +49,8 @@ static bool g_initialized = false; ** Routines for EAN13/UPC/ISxNs. ** ** Note: - ** In this code, a normalized string is one that is known to be a valid - ** ISxN number containing only digits and hyphens and with enough space + ** In this code, a normalized string is one that is known to be a valid + ** ISxN number containing only digits and hyphens and with enough space ** to hold the full 13 digits plus the maximum of four hyphens. ***********************************************************************/ @@ -60,14 +63,25 @@ static bool g_initialized = false; */ #ifdef ISN_DEBUG static -bool check_table(const char *(*TABLE)[2], const unsigned TABLE_index[10][2]) +bool +check_table(const char *(*TABLE)[2], const unsigned TABLE_index[10][2]) { - const char *aux1, *aux2; - int a, b, x=0, y=-1, i=0, j, cnt=0, init=0; - - if(TABLE == NULL || TABLE_index == NULL) return true; - - while(TABLE[i][0] && TABLE[i][1]) { + const char *aux1, + *aux2; + int a, + b, + x = 0, + y = -1, + i = 0, + j, + cnt = 0, + init = 0; + + if (TABLE == NULL || TABLE_index == NULL) + return true; + + while (TABLE[i][0] && TABLE[i][1]) + { aux1 = TABLE[i][0]; aux2 = TABLE[i][1]; @@ -78,30 +92,37 @@ bool check_table(const char *(*TABLE)[2], const unsigned TABLE_index[10][2]) b = *aux2 - '0'; /* must always have the same format and length: */ - while(*aux1 && *aux2) { + while (*aux1 && *aux2) + { if (!(isdigit((unsigned char) *aux1) && isdigit((unsigned char) *aux2)) && - (*aux1 != *aux2 || *aux1 != '-')) + (*aux1 != *aux2 || *aux1 != '-')) goto invalidtable; aux1++; aux2++; } - if(*aux1!=*aux2) goto invalidtable; + if (*aux1 != *aux2) + goto invalidtable; /* found a new range */ - if(a>y) { + if (a > y) + { /* check current range in the index: */ - for(j=x;j<=y;j++) { - if(TABLE_index[j][0] != init) goto invalidindex; - if(TABLE_index[j][1] != i-init) goto invalidindex; + for (j = x; j <= y; j++) + { + if (TABLE_index[j][0] != init) + goto invalidindex; + if (TABLE_index[j][1] != i - init) + goto invalidindex; } init = i; x = a; - } + } /* Always get the new limit */ y = b; - if(y<x) goto invalidtable; + if (y < x) + goto invalidtable; i++; } @@ -116,18 +137,22 @@ invalidindex: elog(DEBUG1, "index %d is invalid", j); return false; } -#endif /* ISN_DEBUG */ +#endif /* ISN_DEBUG */ /*---------------------------------------------------------- * Formatting and conversion routines. *---------------------------------------------------------*/ static -unsigned dehyphenate(char *bufO, char *bufI) +unsigned +dehyphenate(char *bufO, char *bufI) { - unsigned ret = 0; - while(*bufI) { - if(isdigit((unsigned char) *bufI)) { + unsigned ret = 0; + + while (*bufI) + { + if (isdigit((unsigned char) *bufI)) + { *bufO++ = *bufI; ret++; } @@ -138,29 +163,40 @@ unsigned dehyphenate(char *bufO, char *bufI) } /* - * hyphenate --- Try to hyphenate, in-place, the string starting at bufI - * into bufO using the given hyphenation range TABLE. - * Assumes the input string to be used is of only digits. + * hyphenate --- Try to hyphenate, in-place, the string starting at bufI + * into bufO using the given hyphenation range TABLE. + * Assumes the input string to be used is of only digits. * * Returns the number of characters acctually hyphenated. */ static -unsigned hyphenate(char *bufO, char *bufI, const char *(*TABLE)[2], const unsigned TABLE_index[10][2]) +unsigned +hyphenate(char *bufO, char *bufI, const char *(*TABLE)[2], const unsigned TABLE_index[10][2]) { - unsigned ret = 0; - const char *ean_aux1, *ean_aux2, *ean_p; - char *firstdig, *aux1, *aux2; - unsigned search, upper, lower, step; - bool ean_in1, ean_in2; + unsigned ret = 0; + const char *ean_aux1, + *ean_aux2, + *ean_p; + char *firstdig, + *aux1, + *aux2; + unsigned search, + upper, + lower, + step; + bool ean_in1, + ean_in2; /* just compress the string if no further hyphenation is required */ - if(TABLE == NULL || TABLE_index == NULL) { - while(*bufI) { + if (TABLE == NULL || TABLE_index == NULL) + { + while (*bufI) + { *bufO++ = *bufI++; ret++; } *bufO = '\0'; - return (ret+1); + return (ret + 1); } /* add remaining hyphenations */ @@ -171,26 +207,41 @@ unsigned hyphenate(char *bufO, char *bufI, const char *(*TABLE)[2], const unsign lower--; step = (upper - lower) / 2; - if(step == 0) return 0; + if (step == 0) + return 0; search = lower + step; firstdig = bufI; ean_in1 = ean_in2 = false; ean_aux1 = TABLE[search][0]; ean_aux2 = TABLE[search][1]; - do { - if((ean_in1 || *firstdig>=*ean_aux1) && (ean_in2 || *firstdig<=*ean_aux2)) { - if(*firstdig > *ean_aux1) ean_in1 = true; - if(*firstdig < *ean_aux2) ean_in2 = true; - if(ean_in1 && ean_in2) break; + do + { + if ((ean_in1 || *firstdig >= *ean_aux1) && (ean_in2 || *firstdig <= *ean_aux2)) + { + if (*firstdig > *ean_aux1) + ean_in1 = true; + if (*firstdig < *ean_aux2) + ean_in2 = true; + if (ean_in1 && ean_in2) + break; firstdig++, ean_aux1++, ean_aux2++; - if(!(*ean_aux1 && *ean_aux2 && *firstdig)) break; - if(!isdigit((unsigned char) *ean_aux1)) ean_aux1++, ean_aux2++; - } else { - /* check in what direction we should go and move the pointer accordingly */ - if(*firstdig < *ean_aux1 && !ean_in1) upper = search; - else lower = search; + if (!(*ean_aux1 && *ean_aux2 && *firstdig)) + break; + if (!isdigit((unsigned char) *ean_aux1)) + ean_aux1++, ean_aux2++; + } + else + { + /* + * check in what direction we should go and move the pointer + * accordingly + */ + if (*firstdig < *ean_aux1 && !ean_in1) + upper = search; + else + lower = search; step = (upper - lower) / 2; search = lower + step; @@ -201,150 +252,189 @@ unsigned hyphenate(char *bufO, char *bufI, const char *(*TABLE)[2], const unsign ean_aux1 = TABLE[search][0]; ean_aux2 = TABLE[search][1]; } - } while(step); - - if(step) { + } while (step); + + if (step) + { aux1 = bufO; aux2 = bufI; ean_p = TABLE[search][0]; - while(*ean_p && *aux2) { - if(*ean_p++!='-') *aux1++ = *aux2++; - else *aux1++ = '-'; + while (*ean_p && *aux2) + { + if (*ean_p++ != '-') + *aux1++ = *aux2++; + else + *aux1++ = '-'; ret++; } - *aux1++='-'; - *aux1 = *aux2; /* add a lookahead char */ - return (ret+1); + *aux1++ = '-'; + *aux1 = *aux2; /* add a lookahead char */ + return (ret + 1); } return ret; } /* - * weight_checkdig -- Receives a buffer with a normalized ISxN string number, - * and the length to weight. + * weight_checkdig -- Receives a buffer with a normalized ISxN string number, + * and the length to weight. * * Returns the weight of the number (the check digit value, 0-10) */ static -unsigned weight_checkdig(char *isn, unsigned size) +unsigned +weight_checkdig(char *isn, unsigned size) { - unsigned weight = 0; - while(*isn && size>1) { - if(isdigit((unsigned char) *isn)) { + unsigned weight = 0; + + while (*isn && size > 1) + { + if (isdigit((unsigned char) *isn)) + { weight += size-- * (*isn - '0'); } isn++; } weight = weight % 11; - if(weight != 0) weight = 11 - weight; + if (weight != 0) + weight = 11 - weight; return weight; } /* - * checkdig --- Receives a buffer with a normalized ISxN string number, - * and the length to check. + * checkdig --- Receives a buffer with a normalized ISxN string number, + * and the length to check. * * Returns the check digit value (0-9) */ static -unsigned checkdig(char *num, unsigned size) +unsigned +checkdig(char *num, unsigned size) { - unsigned check=0, check3=0; - unsigned pos = 0; - if(*num == 'M') { /* ISMN start with 'M' */ + unsigned check = 0, + check3 = 0; + unsigned pos = 0; + + if (*num == 'M') + { /* ISMN start with 'M' */ check3 = 3; pos = 1; } - while(*num && size>1) { - if(isdigit((unsigned char) *num)) { - if(pos++%2) check3 += *num - '0'; - else check += *num - '0'; + while (*num && size > 1) + { + if (isdigit((unsigned char) *num)) + { + if (pos++ % 2) + check3 += *num - '0'; + else + check += *num - '0'; size--; } num++; } - check = (check + 3*check3) % 10; - if(check != 0) check = 10 - check; + check = (check + 3 * check3) % 10; + if (check != 0) + check = 10 - check; return check; } /* * ean2isn --- Try to convert an ean13 number to a UPC/ISxN number. - * This doesn't verify for a valid check digit. + * This doesn't verify for a valid check digit. * * If errorOK is false, ereport a useful error message if the ean13 is bad. * If errorOK is true, just return "false" for bad input. */ static -bool ean2isn(ean13 ean, bool errorOK, ean13 *result, enum isn_type accept) +bool +ean2isn(ean13 ean, bool errorOK, ean13 * result, enum isn_type accept) { enum isn_type type = INVALID; - char buf[MAXEAN13LEN + 1]; - char *firstdig, *aux; - unsigned digval; - unsigned search; - ean13 ret = ean; - + char buf[MAXEAN13LEN + 1]; + char *firstdig, + *aux; + unsigned digval; + unsigned search; + ean13 ret = ean; + ean >>= 1; /* verify it's in the EAN13 range */ - if(ean > UINT64CONST(9999999999999)) + if (ean > UINT64CONST(9999999999999)) goto eantoobig; /* convert the number */ search = 0; firstdig = aux = buf + 13; - *aux = '\0'; /* terminate string; aux points to last digit */ - do { - digval = (unsigned)(ean % 10); /* get the decimal value */ - ean /= 10; /* get next digit */ - *--aux = (char)(digval + '0'); /* convert to ascii and store */ - } while(ean && search++<12); - while(search++<12) *--aux = '0'; /* fill the remaining EAN13 with '0' */ - + *aux = '\0'; /* terminate string; aux points to last digit */ + do + { + digval = (unsigned) (ean % 10); /* get the decimal value */ + ean /= 10; /* get next digit */ + *--aux = (char) (digval + '0'); /* convert to ascii and store */ + } while (ean && search++ < 12); + while (search++ < 12) + *--aux = '0'; /* fill the remaining EAN13 with '0' */ + /* find out the data type: */ - if(!strncmp("978", buf, 3)) { /* ISBN */ + if (!strncmp("978", buf, 3)) + { /* ISBN */ type = ISBN; - } else if(!strncmp("977", buf, 3)) { /* ISSN */ + } + else if (!strncmp("977", buf, 3)) + { /* ISSN */ type = ISSN; - } else if(!strncmp("9790", buf, 4)) { /* ISMN */ + } + else if (!strncmp("9790", buf, 4)) + { /* ISMN */ type = ISMN; - } else if(!strncmp("979", buf, 3)) { /* ISBN-13 */ + } + else if (!strncmp("979", buf, 3)) + { /* ISBN-13 */ type = ISBN; - } else if(*buf == '0') { /* UPC */ + } + else if (*buf == '0') + { /* UPC */ type = UPC; - } else { + } + else + { type = EAN13; } - if(accept != ANY && accept != EAN13 && accept != type) goto eanwrongtype; + if (accept != ANY && accept != EAN13 && accept != type) + goto eanwrongtype; *result = ret; return true; - + eanwrongtype: - if(!errorOK) { - if(type!=EAN13) { + if (!errorOK) + { + if (type != EAN13) + { ereport(ERROR, - (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), - errmsg("cannot cast EAN13(%s) to %s for number: \"%s\"", - isn_names[type], isn_names[accept], buf))); - } else { + (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), + errmsg("cannot cast EAN13(%s) to %s for number: \"%s\"", + isn_names[type], isn_names[accept], buf))); + } + else + { ereport(ERROR, - (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), - errmsg("cannot cast %s to %s for number: \"%s\"", - isn_names[type], isn_names[accept], buf))); + (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), + errmsg("cannot cast %s to %s for number: \"%s\"", + isn_names[type], isn_names[accept], buf))); } } return false; eantoobig: - if(!errorOK) { - char eanbuf[64]; + if (!errorOK) + { + char eanbuf[64]; /* - * Format the number separately to keep the machine-dependent - * format code out of the translatable message text + * Format the number separately to keep the machine-dependent format + * code out of the translatable message text */ snprintf(eanbuf, sizeof(eanbuf), EAN13_FORMAT, ean); ereport(ERROR, @@ -356,144 +446,176 @@ eantoobig: } /* - * ean2UPC/ISxN --- Convert in-place a normalized EAN13 string to the corresponding - * UPC/ISxN string number. Assumes the input string is normalized. + * ean2UPC/ISxN --- Convert in-place a normalized EAN13 string to the corresponding + * UPC/ISxN string number. Assumes the input string is normalized. */ static inline -void ean2ISBN(char *isn) +void +ean2ISBN(char *isn) { - char *aux; - unsigned check; + char *aux; + unsigned check; + /* the number should come in this format: 978-0-000-00000-0 */ /* Strip the first part and calculate the new check digit */ - hyphenate(isn, isn+4, NULL, NULL); + hyphenate(isn, isn + 4, NULL, NULL); check = weight_checkdig(isn, 10); aux = strchr(isn, '\0'); - while(!isdigit((unsigned char) *--aux)); - if(check == 10) *aux = 'X'; - else *aux = check + '0'; + while (!isdigit((unsigned char) *--aux)); + if (check == 10) + *aux = 'X'; + else + *aux = check + '0'; } static inline -void ean2ISMN(char *isn) +void +ean2ISMN(char *isn) { /* the number should come in this format: 979-0-000-00000-0 */ /* Just strip the first part and change the first digit ('0') to 'M' */ - hyphenate(isn, isn+4, NULL, NULL); + hyphenate(isn, isn + 4, NULL, NULL); isn[0] = 'M'; } static inline -void ean2ISSN(char *isn) +void +ean2ISSN(char *isn) { - unsigned check; + unsigned check; + /* the number should come in this format: 977-0000-000-00-0 */ /* Strip the first part, crop, and calculate the new check digit */ - hyphenate(isn, isn+4, NULL, NULL); + hyphenate(isn, isn + 4, NULL, NULL); check = weight_checkdig(isn, 8); - if(check == 10) isn[8] = 'X'; - else isn[8] = check + '0'; + if (check == 10) + isn[8] = 'X'; + else + isn[8] = check + '0'; isn[9] = '\0'; } static inline -void ean2UPC(char *isn) +void +ean2UPC(char *isn) { /* the number should come in this format: 000-000000000-0 */ /* Strip the first part, crop, and dehyphenate */ - dehyphenate(isn, isn+1); + dehyphenate(isn, isn + 1); isn[12] = '\0'; } /* * ean2* --- Converts a string of digits into an ean13 number. - * Assumes the input string is a string with only digits - * on it, and that it's within the range of ean13. + * Assumes the input string is a string with only digits + * on it, and that it's within the range of ean13. * * Returns the ean13 value of the string. */ static -ean13 str2ean(const char *num) +ean13 +str2ean(const char *num) { - ean13 ean = 0; /* current ean */ - while(*num) { - if(isdigit((unsigned char) *num)) ean = 10 * ean + (*num - '0'); + ean13 ean = 0; /* current ean */ + + while (*num) + { + if (isdigit((unsigned char) *num)) + ean = 10 * ean + (*num - '0'); num++; } - return (ean<<1); /* also give room to a flag */ + return (ean << 1); /* also give room to a flag */ } /* * ean2string --- Try to convert an ean13 number to an hyphenated string. - * Assumes there's enough space in result to hold - * the string (maximum MAXEAN13LEN+1 bytes) - * This doesn't verify for a valid check digit. + * Assumes there's enough space in result to hold + * the string (maximum MAXEAN13LEN+1 bytes) + * This doesn't verify for a valid check digit. * * If shortType is true, the returned string is in the old ISxN short format. * If errorOK is false, ereport a useful error message if the string is bad. * If errorOK is true, just return "false" for bad input. */ static -bool ean2string(ean13 ean, bool errorOK, char *result, bool shortType) +bool +ean2string(ean13 ean, bool errorOK, char *result, bool shortType) { const char *(*TABLE)[2]; const unsigned (*TABLE_index)[2]; enum isn_type type = INVALID; - char *firstdig, *aux; - unsigned digval; - unsigned search; - char valid = '\0'; /* was the number initially written with a valid check digit? */ + char *firstdig, + *aux; + unsigned digval; + unsigned search; + char valid = '\0'; /* was the number initially written with a + * valid check digit? */ TABLE_index = ISBN_index; - if((ean & 1)!=0) valid = '!'; + if ((ean & 1) != 0) + valid = '!'; ean >>= 1; /* verify it's in the EAN13 range */ - if(ean > UINT64CONST(9999999999999)) + if (ean > UINT64CONST(9999999999999)) goto eantoobig; /* convert the number */ search = 0; firstdig = aux = result + MAXEAN13LEN; - *aux = '\0'; /* terminate string; aux points to last digit */ - *--aux = valid; /* append '!' for numbers with invalid but corrected check digit */ - do { - digval = (unsigned)(ean % 10); /* get the decimal value */ - ean /= 10; /* get next digit */ - *--aux = (char)(digval + '0'); /* convert to ascii and store */ - if(search == 0) *--aux = '-'; /* the check digit is always there */ - } while(ean && search++<13); - while(search++<13) *--aux = '0'; /* fill the remaining EAN13 with '0' */ + *aux = '\0'; /* terminate string; aux points to last digit */ + *--aux = valid; /* append '!' for numbers with invalid but + * corrected check digit */ + do + { + digval = (unsigned) (ean % 10); /* get the decimal value */ + ean /= 10; /* get next digit */ + *--aux = (char) (digval + '0'); /* convert to ascii and store */ + if (search == 0) + *--aux = '-'; /* the check digit is always there */ + } while (ean && search++ < 13); + while (search++ < 13) + *--aux = '0'; /* fill the remaining EAN13 with '0' */ /* The string should be in this form: ???DDDDDDDDDDDD-D" */ - search = hyphenate(result, result+3, EAN13_range, EAN13_index); - + search = hyphenate(result, result + 3, EAN13_range, EAN13_index); + /* verify it's a logically valid EAN13 */ - if(search == 0) { - search = hyphenate(result, result+3, NULL, NULL); + if (search == 0) + { + search = hyphenate(result, result + 3, NULL, NULL); goto okay; } /* find out what type of hyphenation is needed: */ - if(!strncmp("978-", result, search)) { /* ISBN */ + if (!strncmp("978-", result, search)) + { /* ISBN */ /* The string should be in this form: 978-??000000000-0" */ type = ISBN; TABLE = ISBN_range; TABLE_index = ISBN_index; - } else if(!strncmp("977-", result, search)) { /* ISSN */ + } + else if (!strncmp("977-", result, search)) + { /* ISSN */ /* The string should be in this form: 977-??000000000-0" */ type = ISSN; TABLE = ISSN_range; TABLE_index = ISSN_index; - } else if(!strncmp("979-0", result, search+1)) { /* ISMN */ + } + else if (!strncmp("979-0", result, search + 1)) + { /* ISMN */ /* The string should be in this form: 979-0?000000000-0" */ type = ISMN; TABLE = ISMN_range; TABLE_index = ISMN_index; - } else if(*result == '0') { /* UPC */ + } + else if (*result == '0') + { /* UPC */ /* The string should be in this form: 000-00000000000-0" */ type = UPC; TABLE = UPC_range; TABLE_index = UPC_index; - } else { + } + else + { type = EAN13; TABLE = NULL; TABLE_index = NULL; @@ -501,18 +623,20 @@ bool ean2string(ean13 ean, bool errorOK, char *result, bool shortType) /* verify it's a logically valid EAN13/UPC/ISxN */ digval = search; - search = hyphenate(result+digval, result+digval+2, TABLE, TABLE_index); + search = hyphenate(result + digval, result + digval + 2, TABLE, TABLE_index); /* verify it's a valid EAN13 */ - if(search == 0) { - search = hyphenate(result+digval, result+digval+2, NULL, NULL); + if (search == 0) + { + search = hyphenate(result + digval, result + digval + 2, NULL, NULL); goto okay; } okay: /* convert to the old short type: */ - if(shortType) - switch(type) { + if (shortType) + switch (type) + { case ISBN: ean2ISBN(result); break; @@ -531,13 +655,13 @@ okay: return true; eantoobig: - if(!errorOK) + if (!errorOK) { - char eanbuf[64]; + char eanbuf[64]; /* - * Format the number separately to keep the machine-dependent - * format code out of the translatable message text + * Format the number separately to keep the machine-dependent format + * code out of the translatable message text */ snprintf(eanbuf, sizeof(eanbuf), EAN13_FORMAT, ean); ereport(ERROR, @@ -558,157 +682,222 @@ eantoobig: * (even if the check digit is valid) */ static -bool string2ean(const char *str, bool errorOK, ean13 *result, - enum isn_type accept) +bool +string2ean(const char *str, bool errorOK, ean13 * result, + enum isn_type accept) { - bool digit, last; - char buf[17] = " "; - char *aux1 = buf + 3; /* leave space for the first part, in case it's needed */ + bool digit, + last; + char buf[17] = " "; + char *aux1 = buf + 3; /* leave space for the first part, in case + * it's needed */ const char *aux2 = str; enum isn_type type = INVALID; - unsigned check = 0, rcheck = (unsigned)-1; - unsigned length = 0; - bool magic = false, valid = true; + unsigned check = 0, + rcheck = (unsigned) -1; + unsigned length = 0; + bool magic = false, + valid = true; /* recognize and validate the number: */ - while(*aux2 && length <= 13) { - last = (*(aux2+1) == '!' || *(aux2+1) == '\0'); /* is the last character */ - digit = (isdigit((unsigned char) *aux2)!=0); /* is current character a digit? */ - if(*aux2=='?' && last) /* automagically calculate check digit if it's '?' */ + while (*aux2 && length <= 13) + { + last = (*(aux2 + 1) == '!' || *(aux2 + 1) == '\0'); /* is the last character */ + digit = (isdigit((unsigned char) *aux2) != 0); /* is current character + * a digit? */ + if (*aux2 == '?' && last) /* automagically calculate check digit + * if it's '?' */ magic = digit = true; - if(length == 0 && (*aux2=='M' || *aux2=='m')) { + if (length == 0 && (*aux2 == 'M' || *aux2 == 'm')) + { /* only ISMN can be here */ - if(type != INVALID) goto eaninvalid; + if (type != INVALID) + goto eaninvalid; type = ISMN; *aux1++ = 'M'; length++; - } else if(length == 7 && (digit || *aux2=='X' || *aux2=='x') && last) { + } + else if (length == 7 && (digit || *aux2 == 'X' || *aux2 == 'x') && last) + { /* only ISSN can be here */ - if(type != INVALID) goto eaninvalid; + if (type != INVALID) + goto eaninvalid; type = ISSN; *aux1++ = toupper((unsigned char) *aux2); length++; - } else if(length == 9 && (digit || *aux2=='X' || *aux2=='x') && last) { + } + else if (length == 9 && (digit || *aux2 == 'X' || *aux2 == 'x') && last) + { /* only ISBN and ISMN can be here */ - if(type != INVALID && type != ISMN) goto eaninvalid; - if(type == INVALID) type = ISBN; /* ISMN must start with 'M' */ + if (type != INVALID && type != ISMN) + goto eaninvalid; + if (type == INVALID) + type = ISBN; /* ISMN must start with 'M' */ *aux1++ = toupper((unsigned char) *aux2); length++; - } else if(length == 11 && digit && last) { + } + else if (length == 11 && digit && last) + { /* only UPC can be here */ - if(type != INVALID) goto eaninvalid; + if (type != INVALID) + goto eaninvalid; type = UPC; *aux1++ = *aux2; length++; - } else if(*aux2 == '-' || *aux2 == ' ') { + } + else if (*aux2 == '-' || *aux2 == ' ') + { /* skip, we could validate but I think it's worthless */ - } else if(*aux2 == '!' && *(aux2+1) == '\0') { + } + else if (*aux2 == '!' && *(aux2 + 1) == '\0') + { /* the invalid check digit sufix was found, set it */ - if(!magic) valid = false; + if (!magic) + valid = false; magic = true; - } else if(!digit) { + } + else if (!digit) + { goto eaninvalid; - } else { + } + else + { *aux1++ = *aux2; - if(++length > 13) goto eantoobig; + if (++length > 13) + goto eantoobig; } aux2++; } - *aux1 = '\0'; /* terminate the string */ + *aux1 = '\0'; /* terminate the string */ /* find the current check digit value */ - if(length == 13) { + if (length == 13) + { /* only EAN13 can be here */ - if(type != INVALID) goto eaninvalid; + if (type != INVALID) + goto eaninvalid; type = EAN13; - check = buf[15]-'0'; - } else if(length == 12) { + check = buf[15] - '0'; + } + else if (length == 12) + { /* only UPC can be here */ - if(type != UPC) goto eaninvalid; - check = buf[14]-'0'; - } else if(length == 10) { - if(type != ISBN && type != ISMN) goto eaninvalid; - if(buf[12] == 'X') check = 10; - else check = buf[12]-'0'; - } else if(length == 8) { - if(type != INVALID && type != ISSN) goto eaninvalid; + if (type != UPC) + goto eaninvalid; + check = buf[14] - '0'; + } + else if (length == 10) + { + if (type != ISBN && type != ISMN) + goto eaninvalid; + if (buf[12] == 'X') + check = 10; + else + check = buf[12] - '0'; + } + else if (length == 8) + { + if (type != INVALID && type != ISSN) + goto eaninvalid; type = ISSN; - if(buf[10] == 'X') check = 10; - else check = buf[10]-'0'; - } else goto eaninvalid; - - if(type == INVALID) goto eaninvalid; - - /* obtain the real check digit value, validate, and convert to ean13: */ - if(accept == EAN13 && type != accept) goto eanwrongtype; - if(accept != ANY && type != EAN13 && type != accept) goto eanwrongtype; - switch(type) { + if (buf[10] == 'X') + check = 10; + else + check = buf[10] - '0'; + } + else + goto eaninvalid; + + if (type == INVALID) + goto eaninvalid; + + /* obtain the real check digit value, validate, and convert to ean13: */ + if (accept == EAN13 && type != accept) + goto eanwrongtype; + if (accept != ANY && type != EAN13 && type != accept) + goto eanwrongtype; + switch (type) + { case EAN13: - valid = (valid && ((rcheck=checkdig(buf+3, 13)) == check || magic)); + valid = (valid && ((rcheck = checkdig(buf + 3, 13)) == check || magic)); /* now get the subtype of EAN13: */ - if(buf[3] == '0') type = UPC; - else if(!strncmp("977", buf+3, 3)) type = ISSN; - else if(!strncmp("978", buf+3, 3)) type = ISBN; - else if(!strncmp("9790", buf+3, 4)) type = ISMN; - else if(!strncmp("979", buf+3, 3)) type = ISBN; - if(accept != EAN13 && accept != ANY && type != accept) goto eanwrongtype; + if (buf[3] == '0') + type = UPC; + else if (!strncmp("977", buf + 3, 3)) + type = ISSN; + else if (!strncmp("978", buf + 3, 3)) + type = ISBN; + else if (!strncmp("9790", buf + 3, 4)) + type = ISMN; + else if (!strncmp("979", buf + 3, 3)) + type = ISBN; + if (accept != EAN13 && accept != ANY && type != accept) + goto eanwrongtype; break; case ISMN: - strncpy(buf, "9790", 4); /* this isn't for sure yet, for now ISMN it's only 9790 */ - valid = (valid && ((rcheck=checkdig(buf+3, 10)) == check || magic)); + strncpy(buf, "9790", 4); /* this isn't for sure yet, for now + * ISMN it's only 9790 */ + valid = (valid && ((rcheck = checkdig(buf + 3, 10)) == check || magic)); break; case ISBN: strncpy(buf, "978", 3); - valid = (valid && ((rcheck=weight_checkdig(buf+3, 10)) == check || magic)); + valid = (valid && ((rcheck = weight_checkdig(buf + 3, 10)) == check || magic)); break; case ISSN: - strncpy(buf+10, "00", 2); /* append 00 as the normal issue publication code */ + strncpy(buf + 10, "00", 2); /* append 00 as the normal issue + * publication code */ strncpy(buf, "977", 3); - valid = (valid && ((rcheck=weight_checkdig(buf+3, 8)) == check || magic)); + valid = (valid && ((rcheck = weight_checkdig(buf + 3, 8)) == check || magic)); break; case UPC: buf[2] = '0'; - valid = (valid && ((rcheck=checkdig(buf+2, 13)) == check || magic)); + valid = (valid && ((rcheck = checkdig(buf + 2, 13)) == check || magic)); default: break; } - /* fix the check digit: */ - for(aux1 = buf; *aux1 && *aux1 <= ' '; aux1++); + /* fix the check digit: */ + for (aux1 = buf; *aux1 && *aux1 <= ' '; aux1++); aux1[12] = checkdig(aux1, 13) + '0'; aux1[13] = '\0'; - - if(!valid && !magic) goto eanbadcheck; + + if (!valid && !magic) + goto eanbadcheck; *result = str2ean(aux1); - *result |= valid?0:1; + *result |= valid ? 0 : 1; return true; -eanbadcheck: - if(g_weak) { /* weak input mode is activated: */ - /* set the "invalid-check-digit-on-input" flag */ +eanbadcheck: + if (g_weak) + { /* weak input mode is activated: */ + /* set the "invalid-check-digit-on-input" flag */ *result = str2ean(aux1); *result |= 1; - return true; + return true; } - if(!errorOK) { - if(rcheck == (unsigned)-1) { - ereport(ERROR, + if (!errorOK) + { + if (rcheck == (unsigned) -1) + { + ereport(ERROR, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), - errmsg("invalid %s number: \"%s\"", + errmsg("invalid %s number: \"%s\"", isn_names[accept], str))); - } else { - ereport(ERROR, + } + else + { + ereport(ERROR, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), - errmsg("invalid check digit for %s number: \"%s\", should be %c", - isn_names[accept], str, (rcheck==10)?('X'):(rcheck+'0')))); - } + errmsg("invalid check digit for %s number: \"%s\", should be %c", + isn_names[accept], str, (rcheck == 10) ? ('X') : (rcheck + '0')))); } - return false; + } + return false; eaninvalid: - if(!errorOK) + if (!errorOK) ereport(ERROR, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("invalid input syntax for %s number: \"%s\"", @@ -716,7 +905,7 @@ eaninvalid: return false; eanwrongtype: - if(!errorOK) + if (!errorOK) ereport(ERROR, (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION), errmsg("cannot cast %s to %s for number: \"%s\"", @@ -724,11 +913,11 @@ eanwrongtype: return false; eantoobig: - if(!errorOK) + if (!errorOK) ereport(ERROR, - (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), - errmsg("value \"%s\" is out of range for %s type", - str, isn_names[accept]))); + (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE), + errmsg("value \"%s\" is out of range for %s type", + str, isn_names[accept]))); return false; } @@ -736,18 +925,19 @@ eantoobig: * Exported routines. *---------------------------------------------------------*/ -void initialize(void) +void +initialize(void) { #ifdef ISN_DEBUG - if(!check_table(EAN13, EAN13_index)) + if (!check_table(EAN13, EAN13_index)) elog(LOG, "EAN13 failed check"); - if(!check_table(ISBN, ISBN_index)) + if (!check_table(ISBN, ISBN_index)) elog(LOG, "ISBN failed check"); - if(!check_table(ISMN, ISMN_index)) + if (!check_table(ISMN, ISMN_index)) elog(LOG, "ISMN failed check"); - if(!check_table(ISSN, ISSN_index)) + if (!check_table(ISSN, ISSN_index)) elog(LOG, "ISSN failed check"); - if(!check_table(UPC, UPC_index)) + if (!check_table(UPC, UPC_index)) elog(LOG, "UPC failed check"); #endif g_initialized = true; @@ -791,7 +981,7 @@ PG_FUNCTION_INFO_V1(ean13_in); Datum ean13_in(PG_FUNCTION_ARGS) { - const char *str = PG_GETARG_CSTRING(0); + const char *str = PG_GETARG_CSTRING(0); ean13 result; (void) string2ean(str, false, &result, EAN13); @@ -804,7 +994,7 @@ PG_FUNCTION_INFO_V1(isbn_in); Datum isbn_in(PG_FUNCTION_ARGS) { - const char *str = PG_GETARG_CSTRING(0); + const char *str = PG_GETARG_CSTRING(0); ean13 result; (void) string2ean(str, false, &result, ISBN); @@ -817,7 +1007,7 @@ PG_FUNCTION_INFO_V1(ismn_in); Datum ismn_in(PG_FUNCTION_ARGS) { - const char *str = PG_GETARG_CSTRING(0); + const char *str = PG_GETARG_CSTRING(0); ean13 result; (void) string2ean(str, false, &result, ISMN); @@ -830,7 +1020,7 @@ PG_FUNCTION_INFO_V1(issn_in); Datum issn_in(PG_FUNCTION_ARGS) { - const char *str = PG_GETARG_CSTRING(0); + const char *str = PG_GETARG_CSTRING(0); ean13 result; (void) string2ean(str, false, &result, ISSN); @@ -843,7 +1033,7 @@ PG_FUNCTION_INFO_V1(upc_in); Datum upc_in(PG_FUNCTION_ARGS) { - const char *str = PG_GETARG_CSTRING(0); + const char *str = PG_GETARG_CSTRING(0); ean13 result; (void) string2ean(str, false, &result, UPC); @@ -861,7 +1051,7 @@ ean13_cast_to_text(PG_FUNCTION_ARGS) (void) ean2string(val, false, buf, false); - PG_RETURN_TEXT_P(GET_TEXT(buf)); + PG_RETURN_TEXT_P(GET_TEXT(buf)); } PG_FUNCTION_INFO_V1(isn_cast_to_text); @@ -873,7 +1063,7 @@ isn_cast_to_text(PG_FUNCTION_ARGS) (void) ean2string(val, false, buf, true); - PG_RETURN_TEXT_P(GET_TEXT(buf)); + PG_RETURN_TEXT_P(GET_TEXT(buf)); } PG_FUNCTION_INFO_V1(isbn_cast_from_ean13); @@ -929,7 +1119,7 @@ PG_FUNCTION_INFO_V1(ean13_cast_from_text); Datum ean13_cast_from_text(PG_FUNCTION_ARGS) { - const char *str = GET_STR(PG_GETARG_TEXT_P(0)); + const char *str = GET_STR(PG_GETARG_TEXT_P(0)); ean13 result; (void) string2ean(str, false, &result, EAN13); @@ -940,7 +1130,7 @@ PG_FUNCTION_INFO_V1(isbn_cast_from_text); Datum isbn_cast_from_text(PG_FUNCTION_ARGS) { - const char *str = GET_STR(PG_GETARG_TEXT_P(0)); + const char *str = GET_STR(PG_GETARG_TEXT_P(0)); ean13 result; (void) string2ean(str, false, &result, ISBN); @@ -951,7 +1141,7 @@ PG_FUNCTION_INFO_V1(ismn_cast_from_text); Datum ismn_cast_from_text(PG_FUNCTION_ARGS) { - const char *str = GET_STR(PG_GETARG_TEXT_P(0)); + const char *str = GET_STR(PG_GETARG_TEXT_P(0)); ean13 result; (void) string2ean(str, false, &result, ISMN); @@ -962,7 +1152,7 @@ PG_FUNCTION_INFO_V1(issn_cast_from_text); Datum issn_cast_from_text(PG_FUNCTION_ARGS) { - const char *str = GET_STR(PG_GETARG_TEXT_P(0)); + const char *str = GET_STR(PG_GETARG_TEXT_P(0)); ean13 result; (void) string2ean(str, false, &result, ISSN); @@ -973,7 +1163,7 @@ PG_FUNCTION_INFO_V1(upc_cast_from_text); Datum upc_cast_from_text(PG_FUNCTION_ARGS) { - const char *str = GET_STR(PG_GETARG_TEXT_P(0)); + const char *str = GET_STR(PG_GETARG_TEXT_P(0)); ean13 result; (void) string2ean(str, false, &result, UPC); @@ -986,7 +1176,8 @@ PG_FUNCTION_INFO_V1(is_valid); Datum is_valid(PG_FUNCTION_ARGS) { - ean13 val = PG_GETARG_EAN13(0); + ean13 val = PG_GETARG_EAN13(0); + PG_RETURN_BOOL((val & 1) == 0); } @@ -996,13 +1187,14 @@ PG_FUNCTION_INFO_V1(make_valid); Datum make_valid(PG_FUNCTION_ARGS) { - ean13 val = PG_GETARG_EAN13(0); + ean13 val = PG_GETARG_EAN13(0); + val &= ~((ean13) 1); PG_RETURN_EAN13(val); } #ifdef ISN_WEAK_MODE -/* this function temporarily sets weak input flag +/* this function temporarily sets weak input flag * (to lose the strictness of check digit acceptance) * It's a helper function, not intended to be used!! */ @@ -1021,7 +1213,7 @@ accept_weak_input(PG_FUNCTION_ARGS) /* function has no effect */ PG_RETURN_BOOL(false); } -#endif /* ISN_WEAK_MODE */ +#endif /* ISN_WEAK_MODE */ PG_FUNCTION_INFO_V1(weak_input_status); Datum diff --git a/contrib/ltree/_ltree_gist.c b/contrib/ltree/_ltree_gist.c index 30bf2e0296..0bac647547 100644 --- a/contrib/ltree/_ltree_gist.c +++ b/contrib/ltree/_ltree_gist.c @@ -219,7 +219,7 @@ sizebitvec(BITVECP sign) i; ALOOPBYTE( - size += number_of_ones[(unsigned char) sign[i]]; + size += number_of_ones[(unsigned char) sign[i]]; ); return size; } @@ -232,8 +232,8 @@ hemdistsign(BITVECP a, BITVECP b) dist = 0; ALOOPBYTE( - diff = (unsigned char) (a[i] ^ b[i]); - dist += number_of_ones[diff]; + diff = (unsigned char) (a[i] ^ b[i]); + dist += number_of_ones[diff]; ); return dist; } @@ -270,7 +270,7 @@ typedef struct { OffsetNumber pos; int4 cost; -} SPLITCOST; +} SPLITCOST; static int comparecost(const void *a, const void *b) @@ -580,6 +580,6 @@ _ltree_consistent(PG_FUNCTION_ARGS) /* internal error */ elog(ERROR, "unrecognized StrategyNumber: %d", strategy); } - PG_FREE_IF_COPY(query,1); + PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(res); } diff --git a/contrib/ltree/lquery_op.c b/contrib/ltree/lquery_op.c index 07269ceaee..8522c5e053 100644 --- a/contrib/ltree/lquery_op.c +++ b/contrib/ltree/lquery_op.c @@ -1,7 +1,7 @@ /* * op function for ltree and lquery * Teodor Sigaev <[email protected]> - * $PostgreSQL: pgsql/contrib/ltree/lquery_op.c,v 1.10 2006/03/11 04:38:29 momjian Exp $ + * $PostgreSQL: pgsql/contrib/ltree/lquery_op.c,v 1.11 2006/10/04 00:29:45 momjian Exp $ */ #include "ltree.h" @@ -46,7 +46,7 @@ getlexeme(char *start, char *end, int *len) } bool -compare_subnode(ltree_level * t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend) + compare_subnode(ltree_level * t, char *qn, int len, int (*cmpptr) (const char *, const char *, size_t), bool anyend) { char *endt = t->name + t->len; char *endq = qn + len; diff --git a/contrib/ltree/ltree.h b/contrib/ltree/ltree.h index b9058d5edf..1ff5707fb1 100644 --- a/contrib/ltree/ltree.h +++ b/contrib/ltree/ltree.h @@ -1,4 +1,4 @@ -/* $PostgreSQL: pgsql/contrib/ltree/ltree.h,v 1.16 2006/07/11 16:00:44 teodor Exp $ */ +/* $PostgreSQL: pgsql/contrib/ltree/ltree.h,v 1.17 2006/10/04 00:29:45 momjian Exp $ */ #ifndef __LTREE_H__ #define __LTREE_H__ @@ -163,7 +163,7 @@ bool compare_subnode(ltree_level * t, char *q, int len, ltree *lca_inner(ltree ** a, int len); #define PG_GETARG_LTREE(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x)))) -#define PG_GETARG_LTREE_COPY(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x)))) +#define PG_GETARG_LTREE_COPY(x) ((ltree*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x)))) #define PG_GETARG_LQUERY(x) ((lquery*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x)))) #define PG_GETARG_LQUERY_COPY(x) ((lquery*)DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(x)))) #define PG_GETARG_LTXTQUERY(x) ((ltxtquery*)DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(x)))) diff --git a/contrib/ltree/ltree_gist.c b/contrib/ltree/ltree_gist.c index 5cfddd7634..0239c5fe99 100644 --- a/contrib/ltree/ltree_gist.c +++ b/contrib/ltree/ltree_gist.c @@ -1,7 +1,7 @@ /* * GiST support for ltree * Teodor Sigaev <[email protected]> - * $PostgreSQL: pgsql/contrib/ltree/ltree_gist.c,v 1.18 2006/08/08 15:45:18 teodor Exp $ + * $PostgreSQL: pgsql/contrib/ltree/ltree_gist.c,v 1.19 2006/10/04 00:29:45 momjian Exp $ */ #include "ltree.h" @@ -457,8 +457,10 @@ gist_isparent(ltree_gist * key, ltree * query) } static ltree * -copy_ltree( ltree *src ) { - ltree *dst = (ltree*)palloc(src->len); +copy_ltree(ltree * src) +{ + ltree *dst = (ltree *) palloc(src->len); + memcpy(dst, src, src->len); return dst; } @@ -466,9 +468,9 @@ copy_ltree( ltree *src ) { static bool gist_ischild(ltree_gist * key, ltree * query) { - ltree *left = copy_ltree(LTG_GETLNODE(key)); - ltree *right = copy_ltree(LTG_GETRNODE(key)); - bool res = true; + ltree *left = copy_ltree(LTG_GETLNODE(key)); + ltree *right = copy_ltree(LTG_GETRNODE(key)); + bool res = true; if (left->numlevel > query->numlevel) left->numlevel = query->numlevel; @@ -711,6 +713,6 @@ ltree_consistent(PG_FUNCTION_ARGS) elog(ERROR, "unrecognized StrategyNumber: %d", strategy); } - PG_FREE_IF_COPY(query,1); + PG_FREE_IF_COPY(query, 1); PG_RETURN_BOOL(res); } diff --git a/contrib/ltree/ltree_op.c b/contrib/ltree/ltree_op.c index f4348e0161..9b8a360ca8 100644 --- a/contrib/ltree/ltree_op.c +++ b/contrib/ltree/ltree_op.c @@ -1,7 +1,7 @@ /* * op function for ltree * Teodor Sigaev <[email protected]> - * $PostgreSQL: pgsql/contrib/ltree/ltree_op.c,v 1.13 2006/09/20 19:50:21 tgl Exp $ + * $PostgreSQL: pgsql/contrib/ltree/ltree_op.c,v 1.14 2006/10/04 00:29:45 momjian Exp $ */ #include "ltree.h" @@ -620,8 +620,8 @@ ltreeparentsel(PG_FUNCTION_ARGS) /* * If the histogram is large enough, see what fraction of it the * constant is "<@" to, and assume that's representative of the - * non-MCV population. Otherwise use the default selectivity for - * the non-MCV population. + * non-MCV population. Otherwise use the default selectivity for the + * non-MCV population. */ selec = histogram_selectivity(&vardata, &contproc, constval, varonleft, diff --git a/contrib/pg_buffercache/pg_buffercache_pages.c b/contrib/pg_buffercache/pg_buffercache_pages.c index 2d7392884e..3c8af235d1 100644 --- a/contrib/pg_buffercache/pg_buffercache_pages.c +++ b/contrib/pg_buffercache/pg_buffercache_pages.c @@ -3,7 +3,7 @@ * pg_buffercache_pages.c * display some contents of the buffer cache * - * $PostgreSQL: pgsql/contrib/pg_buffercache/pg_buffercache_pages.c,v 1.8 2006/07/23 03:07:57 tgl Exp $ + * $PostgreSQL: pgsql/contrib/pg_buffercache/pg_buffercache_pages.c,v 1.9 2006/10/04 00:29:45 momjian Exp $ *------------------------------------------------------------------------- */ #include "postgres.h" @@ -74,7 +74,7 @@ pg_buffercache_pages(PG_FUNCTION_ARGS) if (SRF_IS_FIRSTCALL()) { - int i; + int i; volatile BufferDesc *bufHdr; funcctx = SRF_FIRSTCALL_INIT(); @@ -123,9 +123,9 @@ pg_buffercache_pages(PG_FUNCTION_ARGS) MemoryContextSwitchTo(oldcontext); /* - * To get a consistent picture of the buffer state, we must lock - * all partitions of the buffer map. Needless to say, this is - * horrible for concurrency... + * To get a consistent picture of the buffer state, we must lock all + * partitions of the buffer map. Needless to say, this is horrible + * for concurrency... */ for (i = 0; i < NUM_BUFFER_PARTITIONS; i++) LWLockAcquire(FirstBufMappingLock + i, LW_SHARED); diff --git a/contrib/pg_freespacemap/pg_freespacemap.c b/contrib/pg_freespacemap/pg_freespacemap.c index 9ce8422157..5486a98d48 100644 --- a/contrib/pg_freespacemap/pg_freespacemap.c +++ b/contrib/pg_freespacemap/pg_freespacemap.c @@ -3,7 +3,7 @@ * pg_freespacemap.c * display some contents of the free space relation and page maps. * - * $PostgreSQL: pgsql/contrib/pg_freespacemap/pg_freespacemap.c,v 1.7 2006/09/21 20:31:21 tgl Exp $ + * $PostgreSQL: pgsql/contrib/pg_freespacemap/pg_freespacemap.c,v 1.8 2006/10/04 00:29:45 momjian Exp $ *------------------------------------------------------------------------- */ #include "postgres.h" @@ -14,13 +14,13 @@ #include "storage/freespace.h" -#define NUM_FREESPACE_PAGES_ELEM 5 -#define NUM_FREESPACE_RELATIONS_ELEM 7 +#define NUM_FREESPACE_PAGES_ELEM 5 +#define NUM_FREESPACE_RELATIONS_ELEM 7 #if defined(WIN32) || defined(__CYGWIN__) /* Need DLLIMPORT for some things that are not so marked in main headers */ -extern DLLIMPORT int MaxFSMPages; -extern DLLIMPORT int MaxFSMRelations; +extern DLLIMPORT int MaxFSMPages; +extern DLLIMPORT int MaxFSMRelations; extern DLLIMPORT volatile uint32 InterruptHoldoffCount; #endif @@ -35,12 +35,12 @@ Datum pg_freespacemap_relations(PG_FUNCTION_ARGS); */ typedef struct { - Oid reltablespace; - Oid reldatabase; - Oid relfilenode; - BlockNumber relblocknumber; - Size bytes; - bool isindex; + Oid reltablespace; + Oid reldatabase; + Oid relfilenode; + BlockNumber relblocknumber; + Size bytes; + bool isindex; } FreeSpacePagesRec; @@ -49,14 +49,14 @@ typedef struct */ typedef struct { - Oid reltablespace; - Oid reldatabase; - Oid relfilenode; - Size avgrequest; - BlockNumber interestingpages; - int storedpages; - int nextpage; - bool isindex; + Oid reltablespace; + Oid reldatabase; + Oid relfilenode; + Size avgrequest; + BlockNumber interestingpages; + int storedpages; + int nextpage; + bool isindex; } FreeSpaceRelationsRec; @@ -66,8 +66,8 @@ typedef struct */ typedef struct { - TupleDesc tupdesc; - FreeSpacePagesRec *record; + TupleDesc tupdesc; + FreeSpacePagesRec *record; } FreeSpacePagesContext; @@ -76,8 +76,8 @@ typedef struct */ typedef struct { - TupleDesc tupdesc; - FreeSpaceRelationsRec *record; + TupleDesc tupdesc; + FreeSpaceRelationsRec *record; } FreeSpaceRelationsContext; @@ -89,21 +89,21 @@ PG_FUNCTION_INFO_V1(pg_freespacemap_pages); Datum pg_freespacemap_pages(PG_FUNCTION_ARGS) { - FuncCallContext *funcctx; - Datum result; - MemoryContext oldcontext; - FreeSpacePagesContext *fctx; /* User function context. */ - TupleDesc tupledesc; - HeapTuple tuple; - FSMHeader *FreeSpaceMap; /* FSM main structure. */ - FSMRelation *fsmrel; /* Individual relation. */ + FuncCallContext *funcctx; + Datum result; + MemoryContext oldcontext; + FreeSpacePagesContext *fctx; /* User function context. */ + TupleDesc tupledesc; + HeapTuple tuple; + FSMHeader *FreeSpaceMap; /* FSM main structure. */ + FSMRelation *fsmrel; /* Individual relation. */ if (SRF_IS_FIRSTCALL()) { - int i; - int numPages; /* Max possible no. of pages in map. */ - int nPages; /* Mapped pages for a relation. */ - + int i; + int numPages; /* Max possible no. of pages in map. */ + int nPages; /* Mapped pages for a relation. */ + /* * Get the free space map data structure. */ @@ -138,8 +138,8 @@ pg_freespacemap_pages(PG_FUNCTION_ARGS) fctx->tupdesc = BlessTupleDesc(tupledesc); /* - * Allocate numPages worth of FreeSpacePagesRec records, this is - * an upper bound. + * Allocate numPages worth of FreeSpacePagesRec records, this is an + * upper bound. */ fctx->record = (FreeSpacePagesRec *) palloc(sizeof(FreeSpacePagesRec) * numPages); @@ -147,16 +147,16 @@ pg_freespacemap_pages(PG_FUNCTION_ARGS) MemoryContextSwitchTo(oldcontext); /* - * Lock free space map and scan though all the relations. - * For each relation, gets all its mapped pages. + * Lock free space map and scan though all the relations. For each + * relation, gets all its mapped pages. */ LWLockAcquire(FreeSpaceLock, LW_EXCLUSIVE); i = 0; - for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) + for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) { - if (fsmrel->isIndex) + if (fsmrel->isIndex) { /* Index relation. */ IndexFSMPageData *page; @@ -169,9 +169,9 @@ pg_freespacemap_pages(PG_FUNCTION_ARGS) fctx->record[i].reltablespace = fsmrel->key.spcNode; fctx->record[i].reldatabase = fsmrel->key.dbNode; fctx->record[i].relfilenode = fsmrel->key.relNode; - fctx->record[i].relblocknumber = IndexFSMPageGetPageNum(page); - fctx->record[i].bytes = 0; - fctx->record[i].isindex = true; + fctx->record[i].relblocknumber = IndexFSMPageGetPageNum(page); + fctx->record[i].bytes = 0; + fctx->record[i].isindex = true; page++; i++; @@ -191,9 +191,9 @@ pg_freespacemap_pages(PG_FUNCTION_ARGS) fctx->record[i].reldatabase = fsmrel->key.dbNode; fctx->record[i].relfilenode = fsmrel->key.relNode; fctx->record[i].relblocknumber = FSMPageGetPageNum(page); - fctx->record[i].bytes = FSMPageGetSpace(page); - fctx->record[i].isindex = false; - + fctx->record[i].bytes = FSMPageGetSpace(page); + fctx->record[i].isindex = false; + page++; i++; } @@ -216,7 +216,7 @@ pg_freespacemap_pages(PG_FUNCTION_ARGS) if (funcctx->call_cntr < funcctx->max_calls) { int i = funcctx->call_cntr; - FreeSpacePagesRec *record = &fctx->record[i]; + FreeSpacePagesRec *record = &fctx->record[i]; Datum values[NUM_FREESPACE_PAGES_ELEM]; bool nulls[NUM_FREESPACE_PAGES_ELEM]; @@ -261,20 +261,20 @@ PG_FUNCTION_INFO_V1(pg_freespacemap_relations); Datum pg_freespacemap_relations(PG_FUNCTION_ARGS) { - FuncCallContext *funcctx; - Datum result; - MemoryContext oldcontext; - FreeSpaceRelationsContext *fctx; /* User function context. */ - TupleDesc tupledesc; - HeapTuple tuple; - FSMHeader *FreeSpaceMap; /* FSM main structure. */ - FSMRelation *fsmrel; /* Individual relation. */ + FuncCallContext *funcctx; + Datum result; + MemoryContext oldcontext; + FreeSpaceRelationsContext *fctx; /* User function context. */ + TupleDesc tupledesc; + HeapTuple tuple; + FSMHeader *FreeSpaceMap; /* FSM main structure. */ + FSMRelation *fsmrel; /* Individual relation. */ if (SRF_IS_FIRSTCALL()) { - int i; - int numRelations; /* Max no. of Relations in map. */ - + int i; + int numRelations; /* Max no. of Relations in map. */ + /* * Get the free space map data structure. */ @@ -313,8 +313,8 @@ pg_freespacemap_relations(PG_FUNCTION_ARGS) fctx->tupdesc = BlessTupleDesc(tupledesc); /* - * Allocate numRelations worth of FreeSpaceRelationsRec records, - * this is also an upper bound. + * Allocate numRelations worth of FreeSpaceRelationsRec records, this + * is also an upper bound. */ fctx->record = (FreeSpaceRelationsRec *) palloc(sizeof(FreeSpaceRelationsRec) * numRelations); @@ -328,12 +328,12 @@ pg_freespacemap_relations(PG_FUNCTION_ARGS) i = 0; - for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) + for (fsmrel = FreeSpaceMap->usageList; fsmrel; fsmrel = fsmrel->nextUsage) { fctx->record[i].reltablespace = fsmrel->key.spcNode; fctx->record[i].reldatabase = fsmrel->key.dbNode; fctx->record[i].relfilenode = fsmrel->key.relNode; - fctx->record[i].avgrequest = (int64)fsmrel->avgRequest; + fctx->record[i].avgrequest = (int64) fsmrel->avgRequest; fctx->record[i].interestingpages = fsmrel->interestingPages; fctx->record[i].storedpages = fsmrel->storedPages; fctx->record[i].nextpage = fsmrel->nextPage; @@ -358,7 +358,7 @@ pg_freespacemap_relations(PG_FUNCTION_ARGS) if (funcctx->call_cntr < funcctx->max_calls) { int i = funcctx->call_cntr; - FreeSpaceRelationsRec *record = &fctx->record[i]; + FreeSpaceRelationsRec *record = &fctx->record[i]; Datum values[NUM_FREESPACE_RELATIONS_ELEM]; bool nulls[NUM_FREESPACE_RELATIONS_ELEM]; @@ -368,6 +368,7 @@ pg_freespacemap_relations(PG_FUNCTION_ARGS) nulls[1] = false; values[2] = ObjectIdGetDatum(record->relfilenode); nulls[2] = false; + /* * avgrequest isn't meaningful for an index */ diff --git a/contrib/pg_trgm/trgm_gist.c b/contrib/pg_trgm/trgm_gist.c index bfb92336d7..41a827ae0c 100644 --- a/contrib/pg_trgm/trgm_gist.c +++ b/contrib/pg_trgm/trgm_gist.c @@ -307,7 +307,7 @@ sizebitvec(BITVECP sign) i; LOOPBYTE( - size += number_of_ones[(unsigned char) sign[i]]; + size += number_of_ones[(unsigned char) sign[i]]; ); return size; } @@ -320,8 +320,8 @@ hemdistsign(BITVECP a, BITVECP b) dist = 0; LOOPBYTE( - diff = (unsigned char) (a[i] ^ b[i]); - dist += number_of_ones[diff]; + diff = (unsigned char) (a[i] ^ b[i]); + dist += number_of_ones[diff]; ); return dist; } @@ -393,7 +393,7 @@ typedef struct { OffsetNumber pos; int4 cost; -} SPLITCOST; +} SPLITCOST; static int comparecost(const void *a, const void *b) diff --git a/contrib/pgbench/pgbench.c b/contrib/pgbench/pgbench.c index 702bee80ba..447e8487b0 100644 --- a/contrib/pgbench/pgbench.c +++ b/contrib/pgbench/pgbench.c @@ -1,5 +1,5 @@ /* - * $PostgreSQL: pgsql/contrib/pgbench/pgbench.c,v 1.55 2006/09/16 13:31:40 tgl Exp $ + * $PostgreSQL: pgsql/contrib/pgbench/pgbench.c,v 1.56 2006/10/04 00:29:45 momjian Exp $ * * pgbench: a simple benchmark program for PostgreSQL * written by Tatsuo Ishii @@ -136,7 +136,7 @@ int num_files; /* its number */ static char *tpc_b = { "\\set nbranches :scale\n" "\\set ntellers 10 * :scale\n" - "\\set naccounts 100000 * :scale\n" + "\\set naccounts 100000 * :scale\n" "\\setrandom aid 1 :naccounts\n" "\\setrandom bid 1 :nbranches\n" "\\setrandom tid 1 :ntellers\n" @@ -154,7 +154,7 @@ static char *tpc_b = { static char *simple_update = { "\\set nbranches :scale\n" "\\set ntellers 10 * :scale\n" - "\\set naccounts 100000 * :scale\n" + "\\set naccounts 100000 * :scale\n" "\\setrandom aid 1 :naccounts\n" "\\setrandom bid 1 :nbranches\n" "\\setrandom tid 1 :ntellers\n" @@ -168,7 +168,7 @@ static char *simple_update = { /* -S case */ static char *select_only = { - "\\set naccounts 100000 * :scale\n" + "\\set naccounts 100000 * :scale\n" "\\setrandom aid 1 :naccounts\n" "SELECT abalance FROM accounts WHERE aid = :aid;\n" }; @@ -338,7 +338,7 @@ putVariable(CState * st, char *name, char *value) } else { - char *val; + char *val; if ((val = strdup(value)) == NULL) return false; @@ -1009,14 +1009,16 @@ process_file(char *filename) while (isspace((unsigned char) buf[i])) i++; - if (buf[i] != '\0' && strncmp(&buf[i], "--", 2) != 0) { + if (buf[i] != '\0' && strncmp(&buf[i], "--", 2) != 0) + { commands = process_commands(&buf[i]); if (commands == NULL) { fclose(fd); return false; } - } else + } + else continue; my_commands[lineno] = commands; @@ -1530,7 +1532,7 @@ main(int argc, char **argv) if (state[i].ecnt > prev_ecnt && commands[state[i].state]->type == META_COMMAND) { fprintf(stderr, "Client %d aborted in state %d. Execution meta-command failed.\n", i, state[i].state); - remains--; /* I've aborted */ + remains--; /* I've aborted */ PQfinish(state[i].con); state[i].con = NULL; } @@ -1610,7 +1612,7 @@ main(int argc, char **argv) if (state[i].ecnt > prev_ecnt && commands[state[i].state]->type == META_COMMAND) { fprintf(stderr, "Client %d aborted in state %d. Execution meta-command failed.\n", i, state[i].state); - remains--; /* I've aborted */ + remains--; /* I've aborted */ PQfinish(state[i].con); state[i].con = NULL; } diff --git a/contrib/pgcrypto/crypt-gensalt.c b/contrib/pgcrypto/crypt-gensalt.c index 30a35b1796..c3ec01b900 100644 --- a/contrib/pgcrypto/crypt-gensalt.c +++ b/contrib/pgcrypto/crypt-gensalt.c @@ -2,7 +2,7 @@ * Written by Solar Designer and placed in the public domain. * See crypt_blowfish.c for more information. * - * $PostgreSQL: pgsql/contrib/pgcrypto/crypt-gensalt.c,v 1.9 2006/07/13 04:15:24 neilc Exp $ + * $PostgreSQL: pgsql/contrib/pgcrypto/crypt-gensalt.c,v 1.10 2006/10/04 00:29:46 momjian Exp $ * * This file contains salt generation functions for the traditional and * other common crypt(3) algorithms, except for bcrypt which is defined @@ -64,9 +64,9 @@ _crypt_gensalt_extended_rn(unsigned long count, output[2] = _crypt_itoa64[(count >> 6) & 0x3f]; output[3] = _crypt_itoa64[(count >> 12) & 0x3f]; output[4] = _crypt_itoa64[(count >> 18) & 0x3f]; - value = (unsigned long)(unsigned char) input[0] | - ((unsigned long)(unsigned char) input[1] << 8) | - ((unsigned long)(unsigned char) input[2] << 16); + value = (unsigned long) (unsigned char) input[0] | + ((unsigned long) (unsigned char) input[1] << 8) | + ((unsigned long) (unsigned char) input[2] << 16); output[5] = _crypt_itoa64[value & 0x3f]; output[6] = _crypt_itoa64[(value >> 6) & 0x3f]; output[7] = _crypt_itoa64[(value >> 12) & 0x3f]; @@ -92,9 +92,9 @@ _crypt_gensalt_md5_rn(unsigned long count, output[0] = '$'; output[1] = '1'; output[2] = '$'; - value = (unsigned long)(unsigned char) input[0] | - ((unsigned long)(unsigned char) input[1] << 8) | - ((unsigned long)(unsigned char) input[2] << 16); + value = (unsigned long) (unsigned char) input[0] | + ((unsigned long) (unsigned char) input[1] << 8) | + ((unsigned long) (unsigned char) input[2] << 16); output[3] = _crypt_itoa64[value & 0x3f]; output[4] = _crypt_itoa64[(value >> 6) & 0x3f]; output[5] = _crypt_itoa64[(value >> 12) & 0x3f]; @@ -103,9 +103,9 @@ _crypt_gensalt_md5_rn(unsigned long count, if (size >= 6 && output_size >= 3 + 4 + 4 + 1) { - value = (unsigned long)(unsigned char) input[3] | - ((unsigned long)(unsigned char) input[4] << 8) | - ((unsigned long)(unsigned char) input[5] << 16); + value = (unsigned long) (unsigned char) input[3] | + ((unsigned long) (unsigned char) input[4] << 8) | + ((unsigned long) (unsigned char) input[5] << 16); output[7] = _crypt_itoa64[value & 0x3f]; output[8] = _crypt_itoa64[(value >> 6) & 0x3f]; output[9] = _crypt_itoa64[(value >> 12) & 0x3f]; diff --git a/contrib/pgcrypto/crypt-md5.c b/contrib/pgcrypto/crypt-md5.c index 556a0e9e8e..c05e334a99 100644 --- a/contrib/pgcrypto/crypt-md5.c +++ b/contrib/pgcrypto/crypt-md5.c @@ -8,7 +8,7 @@ * * $FreeBSD: src/lib/libcrypt/crypt-md5.c,v 1.5 1999/12/17 20:21:45 peter Exp $ * - * $PostgreSQL: pgsql/contrib/pgcrypto/crypt-md5.c,v 1.7 2006/07/13 04:15:24 neilc Exp $ + * $PostgreSQL: pgsql/contrib/pgcrypto/crypt-md5.c,v 1.8 2006/10/04 00:29:46 momjian Exp $ */ #include "postgres.h" @@ -24,7 +24,7 @@ static const char _crypt_a64[] = static void _crypt_to64(char *s, unsigned long v, int n) { - while (--n >= 0) + while (--n >= 0) { *s++ = _crypt_a64[v & 0x3f]; v >>= 6; diff --git a/contrib/pgcrypto/fortuna.c b/contrib/pgcrypto/fortuna.c index cd08fd2bc6..5a2596fe78 100644 --- a/contrib/pgcrypto/fortuna.c +++ b/contrib/pgcrypto/fortuna.c @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $PostgreSQL: pgsql/contrib/pgcrypto/fortuna.c,v 1.7 2006/07/13 04:15:24 neilc Exp $ + * $PostgreSQL: pgsql/contrib/pgcrypto/fortuna.c,v 1.8 2006/10/04 00:29:46 momjian Exp $ */ #include "postgres.h" @@ -365,8 +365,8 @@ rekey(FState * st) static void startup_tricks(FState * st) { - int i; - uint8 buf[BLOCK]; + int i; + uint8 buf[BLOCK]; /* Use next block as counter. */ encrypt_counter(st, st->counter); diff --git a/contrib/pgcrypto/imath.c b/contrib/pgcrypto/imath.c index 6375fd7a88..197e24f74b 100644 --- a/contrib/pgcrypto/imath.c +++ b/contrib/pgcrypto/imath.c @@ -1,9 +1,9 @@ /* imath version 1.3 */ /* - Name: imath.c - Purpose: Arbitrary precision integer arithmetic routines. - Author: M. J. Fromberger <http://www.dartmouth.edu/~sting/> - Info: Id: imath.c 21 2006-04-02 18:58:36Z sting + Name: imath.c + Purpose: Arbitrary precision integer arithmetic routines. + Author: M. J. Fromberger <http://www.dartmouth.edu/~sting/> + Info: Id: imath.c 21 2006-04-02 18:58:36Z sting Copyright (C) 2002 Michael J. Fromberger, All Rights Reserved. @@ -21,13 +21,13 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/* $PostgreSQL: pgsql/contrib/pgcrypto/imath.c,v 1.5 2006/09/22 21:39:57 tgl Exp $ */ +/* $PostgreSQL: pgsql/contrib/pgcrypto/imath.c,v 1.6 2006/10/04 00:29:46 momjian Exp $ */ #include "postgres.h" #include "px.h" @@ -40,36 +40,36 @@ /* {{{ Constants */ -const mp_result MP_OK = 0; /* no error, all is well */ -const mp_result MP_FALSE = 0; /* boolean false */ -const mp_result MP_TRUE = -1; /* boolean true */ -const mp_result MP_MEMORY = -2; /* out of memory */ -const mp_result MP_RANGE = -3; /* argument out of range */ -const mp_result MP_UNDEF = -4; /* result undefined */ -const mp_result MP_TRUNC = -5; /* output truncated */ +const mp_result MP_OK = 0; /* no error, all is well */ +const mp_result MP_FALSE = 0; /* boolean false */ +const mp_result MP_TRUE = -1; /* boolean true */ +const mp_result MP_MEMORY = -2; /* out of memory */ +const mp_result MP_RANGE = -3; /* argument out of range */ +const mp_result MP_UNDEF = -4; /* result undefined */ +const mp_result MP_TRUNC = -5; /* output truncated */ const mp_result MP_BADARG = -6; /* invalid null argument */ -const mp_sign MP_NEG = 1; /* value is strictly negative */ -const mp_sign MP_ZPOS = 0; /* value is non-negative */ +const mp_sign MP_NEG = 1; /* value is strictly negative */ +const mp_sign MP_ZPOS = 0; /* value is non-negative */ static const char *s_unknown_err = "unknown result code"; static const char *s_error_msg[] = { - "error code 0", - "boolean true", - "out of memory", - "argument out of range", - "result undefined", - "output truncated", - "invalid null argument", - NULL + "error code 0", + "boolean true", + "out of memory", + "argument out of range", + "result undefined", + "output truncated", + "invalid null argument", + NULL }; /* }}} */ /* Optional library flags */ -#define MP_CAP_DIGITS 1 /* flag bit to capitalize letter digits */ +#define MP_CAP_DIGITS 1 /* flag bit to capitalize letter digits */ -/* Argument checking macros +/* Argument checking macros Use CHECK() where a return value is required; NRCHECK() elsewhere */ #define CHECK(TEST) assert(TEST) #define NRCHECK(TEST) assert(TEST) @@ -83,23 +83,23 @@ static const char *s_error_msg[] = { can compute log_i(n) = lg(n) * log_i(2). */ static const double s_log2[] = { - 0.000000000, 0.000000000, 1.000000000, 0.630929754, /* 0 1 2 3 */ - 0.500000000, 0.430676558, 0.386852807, 0.356207187, /* 4 5 6 7 */ - 0.333333333, 0.315464877, 0.301029996, 0.289064826, /* 8 9 10 11 */ - 0.278942946, 0.270238154, 0.262649535, 0.255958025, /* 12 13 14 15 */ - 0.250000000, 0.244650542, 0.239812467, 0.235408913, /* 16 17 18 19 */ - 0.231378213, 0.227670249, 0.224243824, 0.221064729, /* 20 21 22 23 */ - 0.218104292, 0.215338279, 0.212746054, 0.210309918, /* 24 25 26 27 */ - 0.208014598, 0.205846832, 0.203795047, 0.201849087, /* 28 29 30 31 */ - 0.200000000, 0.198239863, 0.196561632, 0.194959022, /* 32 33 34 35 */ - 0.193426404, 0.191958720, 0.190551412, 0.189200360, /* 36 37 38 39 */ - 0.187901825, 0.186652411, 0.185449023, 0.184288833, /* 40 41 42 43 */ - 0.183169251, 0.182087900, 0.181042597, 0.180031327, /* 44 45 46 47 */ - 0.179052232, 0.178103594, 0.177183820, 0.176291434, /* 48 49 50 51 */ - 0.175425064, 0.174583430, 0.173765343, 0.172969690, /* 52 53 54 55 */ - 0.172195434, 0.171441601, 0.170707280, 0.169991616, /* 56 57 58 59 */ - 0.169293808, 0.168613099, 0.167948779, 0.167300179, /* 60 61 62 63 */ - 0.166666667 + 0.000000000, 0.000000000, 1.000000000, 0.630929754, /* 0 1 2 3 */ + 0.500000000, 0.430676558, 0.386852807, 0.356207187, /* 4 5 6 7 */ + 0.333333333, 0.315464877, 0.301029996, 0.289064826, /* 8 9 10 11 */ + 0.278942946, 0.270238154, 0.262649535, 0.255958025, /* 12 13 14 15 */ + 0.250000000, 0.244650542, 0.239812467, 0.235408913, /* 16 17 18 19 */ + 0.231378213, 0.227670249, 0.224243824, 0.221064729, /* 20 21 22 23 */ + 0.218104292, 0.215338279, 0.212746054, 0.210309918, /* 24 25 26 27 */ + 0.208014598, 0.205846832, 0.203795047, 0.201849087, /* 28 29 30 31 */ + 0.200000000, 0.198239863, 0.196561632, 0.194959022, /* 32 33 34 35 */ + 0.193426404, 0.191958720, 0.190551412, 0.189200360, /* 36 37 38 39 */ + 0.187901825, 0.186652411, 0.185449023, 0.184288833, /* 40 41 42 43 */ + 0.183169251, 0.182087900, 0.181042597, 0.180031327, /* 44 45 46 47 */ + 0.179052232, 0.178103594, 0.177183820, 0.176291434, /* 48 49 50 51 */ + 0.175425064, 0.174583430, 0.173765343, 0.172969690, /* 52 53 54 55 */ + 0.172195434, 0.171441601, 0.170707280, 0.169991616, /* 56 57 58 59 */ + 0.169293808, 0.168613099, 0.167948779, 0.167300179, /* 60 61 62 63 */ + 0.166666667 }; /* }}} */ @@ -156,9 +156,9 @@ MP_USED(Z)=o_;CLAMP(Z);}while(0) do{mp_size ua_=MP_USED(X),o_=ua_+ua_;ZERO(MP_DIGITS(Z),o_);\ (void) s_ksqr(MP_DIGITS(X),MP_DIGITS(Z),ua_);MP_USED(Z)=o_;CLAMP(Z);}while(0) -#define UPPER_HALF(W) ((mp_word)((W) >> MP_DIGIT_BIT)) -#define LOWER_HALF(W) ((mp_digit)(W)) -#define HIGH_BIT_SET(W) ((W) >> (MP_WORD_BIT - 1)) +#define UPPER_HALF(W) ((mp_word)((W) >> MP_DIGIT_BIT)) +#define LOWER_HALF(W) ((mp_digit)(W)) +#define HIGH_BIT_SET(W) ((W) >> (MP_WORD_BIT - 1)) #define ADD_WILL_OVERFLOW(W, V) ((MP_WORD_MAX - (V)) < (W)) /* }}} */ @@ -175,6 +175,7 @@ static mp_word mp_flags = MP_CAP_DIGITS; /* Allocate a buffer of (at least) num digits, or return NULL if that couldn't be done. */ static mp_digit *s_alloc(mp_size num); + #if TRACEABLE_FREE static void s_free(void *ptr); #else @@ -183,97 +184,97 @@ static void s_free(void *ptr); /* Insure that z has at least min digits allocated, resizing if necessary. Returns true if successful, false if out of memory. */ -static int s_pad(mp_int z, mp_size min); +static int s_pad(mp_int z, mp_size min); /* Normalize by removing leading zeroes (except when z = 0) */ #if TRACEABLE_CLAMP -static void s_clamp(mp_int z); +static void s_clamp(mp_int z); #endif /* Fill in a "fake" mp_int on the stack with a given value */ -static void s_fake(mp_int z, int value, mp_digit vbuf[]); +static void s_fake(mp_int z, int value, mp_digit vbuf[]); /* Compare two runs of digits of given length, returns <0, 0, >0 */ -static int s_cdig(mp_digit *da, mp_digit *db, mp_size len); +static int s_cdig(mp_digit * da, mp_digit * db, mp_size len); /* Pack the unsigned digits of v into array t */ -static int s_vpack(int v, mp_digit t[]); +static int s_vpack(int v, mp_digit t[]); /* Compare magnitudes of a and b, returns <0, 0, >0 */ -static int s_ucmp(mp_int a, mp_int b); +static int s_ucmp(mp_int a, mp_int b); /* Compare magnitudes of a and v, returns <0, 0, >0 */ -static int s_vcmp(mp_int a, int v); +static int s_vcmp(mp_int a, int v); /* Unsigned magnitude addition; assumes dc is big enough. Carry out is returned (no memory allocated). */ -static mp_digit s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b); +static mp_digit s_uadd(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b); -/* Unsigned magnitude subtraction. Assumes dc is big enough. */ -static void s_usub(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b); +/* Unsigned magnitude subtraction. Assumes dc is big enough. */ +static void s_usub(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b); /* Unsigned recursive multiplication. Assumes dc is big enough. */ -static int s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b); +static int s_kmul(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b); /* Unsigned magnitude multiplication. Assumes dc is big enough. */ -static void s_umul(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b); +static void s_umul(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b); /* Unsigned recursive squaring. Assumes dc is big enough. */ -static int s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a); +static int s_ksqr(mp_digit * da, mp_digit * dc, mp_size size_a); /* Unsigned magnitude squaring. Assumes dc is big enough. */ -static void s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a); +static void s_usqr(mp_digit * da, mp_digit * dc, mp_size size_a); /* Single digit addition. Assumes a is big enough. */ -static void s_dadd(mp_int a, mp_digit b); +static void s_dadd(mp_int a, mp_digit b); /* Single digit multiplication. Assumes a is big enough. */ -static void s_dmul(mp_int a, mp_digit b); +static void s_dmul(mp_int a, mp_digit b); /* Single digit multiplication on buffers; assumes dc is big enough. */ -static void s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc, - mp_size size_a); +static void s_dbmul(mp_digit * da, mp_digit b, mp_digit * dc, + mp_size size_a); -/* Single digit division. Replaces a with the quotient, +/* Single digit division. Replaces a with the quotient, returns the remainder. */ -static mp_digit s_ddiv(mp_int a, mp_digit b); +static mp_digit s_ddiv(mp_int a, mp_digit b); /* Quick division by a power of 2, replaces z (no allocation) */ -static void s_qdiv(mp_int z, mp_size p2); +static void s_qdiv(mp_int z, mp_size p2); /* Quick remainder by a power of 2, replaces z (no allocation) */ -static void s_qmod(mp_int z, mp_size p2); +static void s_qmod(mp_int z, mp_size p2); -/* Quick multiplication by a power of 2, replaces z. +/* Quick multiplication by a power of 2, replaces z. Allocates if necessary; returns false in case this fails. */ -static int s_qmul(mp_int z, mp_size p2); +static int s_qmul(mp_int z, mp_size p2); /* Quick subtraction from a power of 2, replaces z. Allocates if necessary; returns false in case this fails. */ -static int s_qsub(mp_int z, mp_size p2); +static int s_qsub(mp_int z, mp_size p2); /* Return maximum k such that 2^k divides z. */ -static int s_dp2k(mp_int z); +static int s_dp2k(mp_int z); /* Return k >= 0 such that z = 2^k, or -1 if there is no such k. */ -static int s_isp2(mp_int z); +static int s_isp2(mp_int z); /* Set z to 2^k. May allocate; returns false in case this fails. */ -static int s_2expt(mp_int z, int k); +static int s_2expt(mp_int z, int k); /* Normalize a and b for division, returns normalization constant */ -static int s_norm(mp_int a, mp_int b); +static int s_norm(mp_int a, mp_int b); /* Compute constant mu for Barrett reduction, given modulus m, result replaces z, m is untouched. */ static mp_result s_brmu(mp_int z, mp_int m); /* Reduce a modulo m, using Barrett's algorithm. */ -static int s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2); +static int s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2); /* Modular exponentiation, using Barrett reduction */ static mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c); @@ -284,22 +285,22 @@ static mp_result s_udiv(mp_int a, mp_int b); /* Compute the number of digits in radix r required to represent the given value. Does not account for sign flags, terminators, etc. */ -static int s_outlen(mp_int z, mp_size r); +static int s_outlen(mp_int z, mp_size r); /* Guess how many digits of precision will be needed to represent a radix r value of the specified number of digits. Returns a value guaranteed to be no smaller than the actual number required. */ -static mp_size s_inlen(int len, mp_size r); +static mp_size s_inlen(int len, mp_size r); -/* Convert a character to a digit value in radix r, or +/* Convert a character to a digit value in radix r, or -1 if out of range */ -static int s_ch2val(char c, int r); +static int s_ch2val(char c, int r); /* Convert a digit value to a character */ -static char s_val2ch(int v, int caps); +static char s_val2ch(int v, int caps); /* Take 2's complement of a buffer in place */ -static void s_2comp(unsigned char *buf, int len); +static void s_2comp(unsigned char *buf, int len); /* Convert a value to binary, ignoring sign. On input, *limpos is the bound on how many bytes should be written to buf; on output, *limpos @@ -308,698 +309,804 @@ static mp_result s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad); #if 0 /* Dump a representation of the mp_int to standard output */ -void s_print(char *tag, mp_int z); -void s_print_buf(char *tag, mp_digit *buf, mp_size num); +void s_print(char *tag, mp_int z); +void s_print_buf(char *tag, mp_digit * buf, mp_size num); #endif /* {{{ get_default_precision() */ -mp_size mp_get_default_precision(void) -{ - return default_precision; +mp_size +mp_get_default_precision(void) +{ + return default_precision; } /* }}} */ /* {{{ mp_set_default_precision(s) */ -void mp_set_default_precision(mp_size s) -{ - NRCHECK(s > 0); +void +mp_set_default_precision(mp_size s) +{ + NRCHECK(s > 0); - default_precision = (mp_size) ROUND_PREC(s); + default_precision = (mp_size) ROUND_PREC(s); } /* }}} */ /* {{{ mp_get_multiply_threshold() */ -mp_size mp_get_multiply_threshold(void) +mp_size +mp_get_multiply_threshold(void) { - return multiply_threshold; + return multiply_threshold; } /* }}} */ /* {{{ mp_set_multiply_threshold(s) */ -void mp_set_multiply_threshold(mp_size s) +void +mp_set_multiply_threshold(mp_size s) { - multiply_threshold = s; + multiply_threshold = s; } /* }}} */ /* {{{ mp_int_init(z) */ -mp_result mp_int_init(mp_int z) +mp_result +mp_int_init(mp_int z) { - return mp_int_init_size(z, default_precision); + return mp_int_init_size(z, default_precision); } /* }}} */ /* {{{ mp_int_alloc() */ -mp_int mp_int_alloc(void) +mp_int +mp_int_alloc(void) { - mp_int out = px_alloc(sizeof(mpz_t)); + mp_int out = px_alloc(sizeof(mpz_t)); - assert(out != NULL); - out->digits = NULL; - out->used = 0; - out->alloc = 0; - out->sign = 0; + assert(out != NULL); + out->digits = NULL; + out->used = 0; + out->alloc = 0; + out->sign = 0; - return out; + return out; } /* }}} */ /* {{{ mp_int_init_size(z, prec) */ -mp_result mp_int_init_size(mp_int z, mp_size prec) +mp_result +mp_int_init_size(mp_int z, mp_size prec) { - CHECK(z != NULL); + CHECK(z != NULL); + + prec = (mp_size) ROUND_PREC(prec); + prec = MAX(prec, default_precision); - prec = (mp_size) ROUND_PREC(prec); - prec = MAX(prec, default_precision); + if ((MP_DIGITS(z) = s_alloc(prec)) == NULL) + return MP_MEMORY; - if((MP_DIGITS(z) = s_alloc(prec)) == NULL) - return MP_MEMORY; + z->digits[0] = 0; + MP_USED(z) = 1; + MP_ALLOC(z) = prec; + MP_SIGN(z) = MP_ZPOS; - z->digits[0] = 0; - MP_USED(z) = 1; - MP_ALLOC(z) = prec; - MP_SIGN(z) = MP_ZPOS; - - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_init_copy(z, old) */ -mp_result mp_int_init_copy(mp_int z, mp_int old) +mp_result +mp_int_init_copy(mp_int z, mp_int old) { - mp_result res; - mp_size uold, target; + mp_result res; + mp_size uold, + target; - CHECK(z != NULL && old != NULL); + CHECK(z != NULL && old != NULL); - uold = MP_USED(old); - target = MAX(uold, default_precision); + uold = MP_USED(old); + target = MAX(uold, default_precision); - if((res = mp_int_init_size(z, target)) != MP_OK) - return res; + if ((res = mp_int_init_size(z, target)) != MP_OK) + return res; - MP_USED(z) = uold; - MP_SIGN(z) = MP_SIGN(old); - COPY(MP_DIGITS(old), MP_DIGITS(z), uold); + MP_USED(z) = uold; + MP_SIGN(z) = MP_SIGN(old); + COPY(MP_DIGITS(old), MP_DIGITS(z), uold); - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_init_value(z, value) */ -mp_result mp_int_init_value(mp_int z, int value) +mp_result +mp_int_init_value(mp_int z, int value) { - mp_result res; + mp_result res; - CHECK(z != NULL); + CHECK(z != NULL); - if((res = mp_int_init(z)) != MP_OK) - return res; + if ((res = mp_int_init(z)) != MP_OK) + return res; - return mp_int_set_value(z, value); + return mp_int_set_value(z, value); } /* }}} */ /* {{{ mp_int_set_value(z, value) */ -mp_result mp_int_set_value(mp_int z, int value) +mp_result +mp_int_set_value(mp_int z, int value) { - mp_size ndig; + mp_size ndig; - CHECK(z != NULL); + CHECK(z != NULL); - /* How many digits to copy */ - ndig = (mp_size) MP_VALUE_DIGITS(value); + /* How many digits to copy */ + ndig = (mp_size) MP_VALUE_DIGITS(value); - if(!s_pad(z, ndig)) - return MP_MEMORY; + if (!s_pad(z, ndig)) + return MP_MEMORY; - MP_USED(z) = (mp_size)s_vpack(value, MP_DIGITS(z)); - MP_SIGN(z) = (value < 0) ? MP_NEG : MP_ZPOS; + MP_USED(z) = (mp_size) s_vpack(value, MP_DIGITS(z)); + MP_SIGN(z) = (value < 0) ? MP_NEG : MP_ZPOS; - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_clear(z) */ -void mp_int_clear(mp_int z) +void +mp_int_clear(mp_int z) { - if(z == NULL) - return; + if (z == NULL) + return; - if(MP_DIGITS(z) != NULL) { - s_free(MP_DIGITS(z)); - MP_DIGITS(z) = NULL; - } + if (MP_DIGITS(z) != NULL) + { + s_free(MP_DIGITS(z)); + MP_DIGITS(z) = NULL; + } } /* }}} */ /* {{{ mp_int_free(z) */ -void mp_int_free(mp_int z) +void +mp_int_free(mp_int z) { - NRCHECK(z != NULL); + NRCHECK(z != NULL); - if(z->digits != NULL) - mp_int_clear(z); + if (z->digits != NULL) + mp_int_clear(z); - px_free(z); + px_free(z); } /* }}} */ /* {{{ mp_int_copy(a, c) */ -mp_result mp_int_copy(mp_int a, mp_int c) +mp_result +mp_int_copy(mp_int a, mp_int c) { - CHECK(a != NULL && c != NULL); + CHECK(a != NULL && c != NULL); - if(a != c) { - mp_size ua = MP_USED(a); - mp_digit *da, *dc; + if (a != c) + { + mp_size ua = MP_USED(a); + mp_digit *da, + *dc; - if(!s_pad(c, ua)) - return MP_MEMORY; + if (!s_pad(c, ua)) + return MP_MEMORY; - da = MP_DIGITS(a); dc = MP_DIGITS(c); - COPY(da, dc, ua); + da = MP_DIGITS(a); + dc = MP_DIGITS(c); + COPY(da, dc, ua); - MP_USED(c) = ua; - MP_SIGN(c) = MP_SIGN(a); - } + MP_USED(c) = ua; + MP_SIGN(c) = MP_SIGN(a); + } - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_swap(a, c) */ -void mp_int_swap(mp_int a, mp_int c) +void +mp_int_swap(mp_int a, mp_int c) { - if(a != c) { - mpz_t tmp = *a; + if (a != c) + { + mpz_t tmp = *a; - *a = *c; - *c = tmp; - } + *a = *c; + *c = tmp; + } } /* }}} */ /* {{{ mp_int_zero(z) */ -void mp_int_zero(mp_int z) +void +mp_int_zero(mp_int z) { - NRCHECK(z != NULL); + NRCHECK(z != NULL); - z->digits[0] = 0; - MP_USED(z) = 1; - MP_SIGN(z) = MP_ZPOS; + z->digits[0] = 0; + MP_USED(z) = 1; + MP_SIGN(z) = MP_ZPOS; } /* }}} */ /* {{{ mp_int_abs(a, c) */ -mp_result mp_int_abs(mp_int a, mp_int c) +mp_result +mp_int_abs(mp_int a, mp_int c) { - mp_result res; + mp_result res; - CHECK(a != NULL && c != NULL); + CHECK(a != NULL && c != NULL); - if((res = mp_int_copy(a, c)) != MP_OK) - return res; + if ((res = mp_int_copy(a, c)) != MP_OK) + return res; - MP_SIGN(c) = MP_ZPOS; - return MP_OK; + MP_SIGN(c) = MP_ZPOS; + return MP_OK; } /* }}} */ /* {{{ mp_int_neg(a, c) */ -mp_result mp_int_neg(mp_int a, mp_int c) +mp_result +mp_int_neg(mp_int a, mp_int c) { - mp_result res; + mp_result res; - CHECK(a != NULL && c != NULL); + CHECK(a != NULL && c != NULL); - if((res = mp_int_copy(a, c)) != MP_OK) - return res; + if ((res = mp_int_copy(a, c)) != MP_OK) + return res; - if(CMPZ(c) != 0) - MP_SIGN(c) = 1 - MP_SIGN(a); + if (CMPZ(c) != 0) + MP_SIGN(c) = 1 - MP_SIGN(a); - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_add(a, b, c) */ -mp_result mp_int_add(mp_int a, mp_int b, mp_int c) -{ - mp_size ua, ub, uc, max; - - CHECK(a != NULL && b != NULL && c != NULL); - - ua = MP_USED(a); ub = MP_USED(b); uc = MP_USED(c); - max = MAX(ua, ub); - - if(MP_SIGN(a) == MP_SIGN(b)) { - /* Same sign -- add magnitudes, preserve sign of addends */ - mp_digit carry; +mp_result +mp_int_add(mp_int a, mp_int b, mp_int c) +{ + mp_size ua, + ub, + uc, + max; - if(!s_pad(c, max)) - return MP_MEMORY; + CHECK(a != NULL && b != NULL && c != NULL); - carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub); - uc = max; + ua = MP_USED(a); + ub = MP_USED(b); + uc = MP_USED(c); + max = MAX(ua, ub); - if(carry) { - if(!s_pad(c, max + 1)) - return MP_MEMORY; + if (MP_SIGN(a) == MP_SIGN(b)) + { + /* Same sign -- add magnitudes, preserve sign of addends */ + mp_digit carry; - c->digits[max] = carry; - ++uc; - } + if (!s_pad(c, max)) + return MP_MEMORY; - MP_USED(c) = uc; - MP_SIGN(c) = MP_SIGN(a); + carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub); + uc = max; - } - else { - /* Different signs -- subtract magnitudes, preserve sign of greater */ - mp_int x, y; - int cmp = s_ucmp(a, b); /* magnitude comparision, sign ignored */ + if (carry) + { + if (!s_pad(c, max + 1)) + return MP_MEMORY; - /* Set x to max(a, b), y to min(a, b) to simplify later code */ - if(cmp >= 0) { - x = a; y = b; - } - else { - x = b; y = a; - } + c->digits[max] = carry; + ++uc; + } - if(!s_pad(c, MP_USED(x))) - return MP_MEMORY; + MP_USED(c) = uc; + MP_SIGN(c) = MP_SIGN(a); - /* Subtract smaller from larger */ - s_usub(MP_DIGITS(x), MP_DIGITS(y), MP_DIGITS(c), MP_USED(x), MP_USED(y)); - MP_USED(c) = MP_USED(x); - CLAMP(c); - - /* Give result the sign of the larger */ - MP_SIGN(c) = MP_SIGN(x); - } + } + else + { + /* Different signs -- subtract magnitudes, preserve sign of greater */ + mp_int x, + y; + int cmp = s_ucmp(a, b); /* magnitude comparision, sign ignored */ + + /* Set x to max(a, b), y to min(a, b) to simplify later code */ + if (cmp >= 0) + { + x = a; + y = b; + } + else + { + x = b; + y = a; + } + + if (!s_pad(c, MP_USED(x))) + return MP_MEMORY; + + /* Subtract smaller from larger */ + s_usub(MP_DIGITS(x), MP_DIGITS(y), MP_DIGITS(c), MP_USED(x), MP_USED(y)); + MP_USED(c) = MP_USED(x); + CLAMP(c); + + /* Give result the sign of the larger */ + MP_SIGN(c) = MP_SIGN(x); + } - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_add_value(a, value, c) */ -mp_result mp_int_add_value(mp_int a, int value, mp_int c) +mp_result +mp_int_add_value(mp_int a, int value, mp_int c) { - mpz_t vtmp; - mp_digit vbuf[MP_VALUE_DIGITS(value)]; + mpz_t vtmp; + mp_digit vbuf[MP_VALUE_DIGITS(value)]; - s_fake(&vtmp, value, vbuf); + s_fake(&vtmp, value, vbuf); - return mp_int_add(a, &vtmp, c); + return mp_int_add(a, &vtmp, c); } /* }}} */ /* {{{ mp_int_sub(a, b, c) */ -mp_result mp_int_sub(mp_int a, mp_int b, mp_int c) +mp_result +mp_int_sub(mp_int a, mp_int b, mp_int c) { - mp_size ua, ub, uc, max; + mp_size ua, + ub, + uc, + max; - CHECK(a != NULL && b != NULL && c != NULL); + CHECK(a != NULL && b != NULL && c != NULL); - ua = MP_USED(a); ub = MP_USED(b); uc = MP_USED(c); - max = MAX(ua, ub); + ua = MP_USED(a); + ub = MP_USED(b); + uc = MP_USED(c); + max = MAX(ua, ub); - if(MP_SIGN(a) != MP_SIGN(b)) { - /* Different signs -- add magnitudes and keep sign of a */ - mp_digit carry; + if (MP_SIGN(a) != MP_SIGN(b)) + { + /* Different signs -- add magnitudes and keep sign of a */ + mp_digit carry; - if(!s_pad(c, max)) - return MP_MEMORY; + if (!s_pad(c, max)) + return MP_MEMORY; - carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub); - uc = max; + carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub); + uc = max; - if(carry) { - if(!s_pad(c, max + 1)) - return MP_MEMORY; + if (carry) + { + if (!s_pad(c, max + 1)) + return MP_MEMORY; - c->digits[max] = carry; - ++uc; - } + c->digits[max] = carry; + ++uc; + } - MP_USED(c) = uc; - MP_SIGN(c) = MP_SIGN(a); + MP_USED(c) = uc; + MP_SIGN(c) = MP_SIGN(a); - } - else { - /* Same signs -- subtract magnitudes */ - mp_int x, y; - mp_sign osign; - int cmp = s_ucmp(a, b); + } + else + { + /* Same signs -- subtract magnitudes */ + mp_int x, + y; + mp_sign osign; + int cmp = s_ucmp(a, b); + + if (!s_pad(c, max)) + return MP_MEMORY; + + if (cmp >= 0) + { + x = a; + y = b; + osign = MP_ZPOS; + } + else + { + x = b; + y = a; + osign = MP_NEG; + } + + if (MP_SIGN(a) == MP_NEG && cmp != 0) + osign = 1 - osign; + + s_usub(MP_DIGITS(x), MP_DIGITS(y), MP_DIGITS(c), MP_USED(x), MP_USED(y)); + MP_USED(c) = MP_USED(x); + CLAMP(c); + + MP_SIGN(c) = osign; + } - if(!s_pad(c, max)) - return MP_MEMORY; + return MP_OK; +} - if(cmp >= 0) { - x = a; y = b; osign = MP_ZPOS; - } - else { - x = b; y = a; osign = MP_NEG; - } +/* }}} */ - if(MP_SIGN(a) == MP_NEG && cmp != 0) - osign = 1 - osign; +/* {{{ mp_int_sub_value(a, value, c) */ - s_usub(MP_DIGITS(x), MP_DIGITS(y), MP_DIGITS(c), MP_USED(x), MP_USED(y)); - MP_USED(c) = MP_USED(x); - CLAMP(c); +mp_result +mp_int_sub_value(mp_int a, int value, mp_int c) +{ + mpz_t vtmp; + mp_digit vbuf[MP_VALUE_DIGITS(value)]; - MP_SIGN(c) = osign; - } + s_fake(&vtmp, value, vbuf); - return MP_OK; + return mp_int_sub(a, &vtmp, c); } /* }}} */ -/* {{{ mp_int_sub_value(a, value, c) */ +/* {{{ mp_int_mul(a, b, c) */ -mp_result mp_int_sub_value(mp_int a, int value, mp_int c) +mp_result +mp_int_mul(mp_int a, mp_int b, mp_int c) { - mpz_t vtmp; - mp_digit vbuf[MP_VALUE_DIGITS(value)]; + mp_digit *out; + mp_size osize, + ua, + ub, + p = 0; + mp_sign osign; - s_fake(&vtmp, value, vbuf); + CHECK(a != NULL && b != NULL && c != NULL); - return mp_int_sub(a, &vtmp, c); -} + /* If either input is zero, we can shortcut multiplication */ + if (mp_int_compare_zero(a) == 0 || mp_int_compare_zero(b) == 0) + { + mp_int_zero(c); + return MP_OK; + } -/* }}} */ + /* Output is positive if inputs have same sign, otherwise negative */ + osign = (MP_SIGN(a) == MP_SIGN(b)) ? MP_ZPOS : MP_NEG; -/* {{{ mp_int_mul(a, b, c) */ + /* + * If the output is not equal to any of the inputs, we'll write the + * results there directly; otherwise, allocate a temporary space. + */ + ua = MP_USED(a); + ub = MP_USED(b); + osize = ua + ub; + + if (c == a || c == b) + { + p = ROUND_PREC(osize); + p = MAX(p, default_precision); + + if ((out = s_alloc(p)) == NULL) + return MP_MEMORY; + } + else + { + if (!s_pad(c, osize)) + return MP_MEMORY; -mp_result mp_int_mul(mp_int a, mp_int b, mp_int c) -{ - mp_digit *out; - mp_size osize, ua, ub, p = 0; - mp_sign osign; - - CHECK(a != NULL && b != NULL && c != NULL); - - /* If either input is zero, we can shortcut multiplication */ - if(mp_int_compare_zero(a) == 0 || mp_int_compare_zero(b) == 0) { - mp_int_zero(c); - return MP_OK; - } - - /* Output is positive if inputs have same sign, otherwise negative */ - osign = (MP_SIGN(a) == MP_SIGN(b)) ? MP_ZPOS : MP_NEG; - - /* If the output is not equal to any of the inputs, we'll write the - results there directly; otherwise, allocate a temporary space. */ - ua = MP_USED(a); ub = MP_USED(b); - osize = ua + ub; - - if(c == a || c == b) { - p = ROUND_PREC(osize); - p = MAX(p, default_precision); - - if((out = s_alloc(p)) == NULL) - return MP_MEMORY; - } - else { - if(!s_pad(c, osize)) - return MP_MEMORY; - - out = MP_DIGITS(c); - } - ZERO(out, osize); - - if(!s_kmul(MP_DIGITS(a), MP_DIGITS(b), out, ua, ub)) - return MP_MEMORY; - - /* If we allocated a new buffer, get rid of whatever memory c was - already using, and fix up its fields to reflect that. - */ - if(out != MP_DIGITS(c)) { - s_free(MP_DIGITS(c)); - MP_DIGITS(c) = out; - MP_ALLOC(c) = p; - } - - MP_USED(c) = osize; /* might not be true, but we'll fix it ... */ - CLAMP(c); /* ... right here */ - MP_SIGN(c) = osign; - - return MP_OK; + out = MP_DIGITS(c); + } + ZERO(out, osize); + + if (!s_kmul(MP_DIGITS(a), MP_DIGITS(b), out, ua, ub)) + return MP_MEMORY; + + /* + * If we allocated a new buffer, get rid of whatever memory c was already + * using, and fix up its fields to reflect that. + */ + if (out != MP_DIGITS(c)) + { + s_free(MP_DIGITS(c)); + MP_DIGITS(c) = out; + MP_ALLOC(c) = p; + } + + MP_USED(c) = osize; /* might not be true, but we'll fix it ... */ + CLAMP(c); /* ... right here */ + MP_SIGN(c) = osign; + + return MP_OK; } /* }}} */ /* {{{ mp_int_mul_value(a, value, c) */ -mp_result mp_int_mul_value(mp_int a, int value, mp_int c) +mp_result +mp_int_mul_value(mp_int a, int value, mp_int c) { - mpz_t vtmp; - mp_digit vbuf[MP_VALUE_DIGITS(value)]; + mpz_t vtmp; + mp_digit vbuf[MP_VALUE_DIGITS(value)]; - s_fake(&vtmp, value, vbuf); + s_fake(&vtmp, value, vbuf); - return mp_int_mul(a, &vtmp, c); + return mp_int_mul(a, &vtmp, c); } /* }}} */ /* {{{ mp_int_mul_pow2(a, p2, c) */ -mp_result mp_int_mul_pow2(mp_int a, int p2, mp_int c) +mp_result +mp_int_mul_pow2(mp_int a, int p2, mp_int c) { - mp_result res; - CHECK(a != NULL && c != NULL && p2 >= 0); + mp_result res; - if((res = mp_int_copy(a, c)) != MP_OK) - return res; + CHECK(a != NULL && c != NULL && p2 >= 0); - if(s_qmul(c, (mp_size) p2)) - return MP_OK; - else - return MP_MEMORY; + if ((res = mp_int_copy(a, c)) != MP_OK) + return res; + + if (s_qmul(c, (mp_size) p2)) + return MP_OK; + else + return MP_MEMORY; } /* }}} */ /* {{{ mp_int_sqr(a, c) */ -mp_result mp_int_sqr(mp_int a, mp_int c) -{ - mp_digit *out; - mp_size osize, p = 0; +mp_result +mp_int_sqr(mp_int a, mp_int c) +{ + mp_digit *out; + mp_size osize, + p = 0; - CHECK(a != NULL && c != NULL); + CHECK(a != NULL && c != NULL); - /* Get a temporary buffer big enough to hold the result */ - osize = (mp_size) 2 * MP_USED(a); - if(a == c) { - p = ROUND_PREC(osize); - p = MAX(p, default_precision); + /* Get a temporary buffer big enough to hold the result */ + osize = (mp_size) 2 *MP_USED(a); - if((out = s_alloc(p)) == NULL) - return MP_MEMORY; - } - else { - if(!s_pad(c, osize)) - return MP_MEMORY; + if (a == c) + { + p = ROUND_PREC(osize); + p = MAX(p, default_precision); - out = MP_DIGITS(c); - } - ZERO(out, osize); + if ((out = s_alloc(p)) == NULL) + return MP_MEMORY; + } + else + { + if (!s_pad(c, osize)) + return MP_MEMORY; - s_ksqr(MP_DIGITS(a), out, MP_USED(a)); + out = MP_DIGITS(c); + } + ZERO(out, osize); + + s_ksqr(MP_DIGITS(a), out, MP_USED(a)); + + /* + * Get rid of whatever memory c was already using, and fix up its fields + * to reflect the new digit array it's using + */ + if (out != MP_DIGITS(c)) + { + s_free(MP_DIGITS(c)); + MP_DIGITS(c) = out; + MP_ALLOC(c) = p; + } - /* Get rid of whatever memory c was already using, and fix up its - fields to reflect the new digit array it's using - */ - if(out != MP_DIGITS(c)) { - s_free(MP_DIGITS(c)); - MP_DIGITS(c) = out; - MP_ALLOC(c) = p; - } + MP_USED(c) = osize; /* might not be true, but we'll fix it ... */ + CLAMP(c); /* ... right here */ + MP_SIGN(c) = MP_ZPOS; - MP_USED(c) = osize; /* might not be true, but we'll fix it ... */ - CLAMP(c); /* ... right here */ - MP_SIGN(c) = MP_ZPOS; - - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_div(a, b, q, r) */ -mp_result mp_int_div(mp_int a, mp_int b, mp_int q, mp_int r) -{ - int cmp, last = 0, lg; - mp_result res = MP_OK; - mpz_t temp[2]; - mp_int qout, rout; - mp_sign sa = MP_SIGN(a), sb = MP_SIGN(b); - - CHECK(a != NULL && b != NULL && q != r); - - if(CMPZ(b) == 0) - return MP_UNDEF; - else if((cmp = s_ucmp(a, b)) < 0) { - /* If |a| < |b|, no division is required: - q = 0, r = a - */ - if(r && (res = mp_int_copy(a, r)) != MP_OK) - return res; - - if(q) - mp_int_zero(q); - - return MP_OK; - } - else if(cmp == 0) { - /* If |a| = |b|, no division is required: - q = 1 or -1, r = 0 - */ - if(r) - mp_int_zero(r); - - if(q) { - mp_int_zero(q); - q->digits[0] = 1; - - if(sa != sb) - MP_SIGN(q) = MP_NEG; - } - - return MP_OK; - } - - /* When |a| > |b|, real division is required. We need someplace to - store quotient and remainder, but q and r are allowed to be NULL - or to overlap with the inputs. - */ - if((lg = s_isp2(b)) < 0) { - if(q && b != q && (res = mp_int_copy(a, q)) == MP_OK) { - qout = q; - } - else { - qout = TEMP(last); - SETUP(mp_int_init_copy(TEMP(last), a), last); - } - - if(r && a != r && (res = mp_int_copy(b, r)) == MP_OK) { - rout = r; - } - else { - rout = TEMP(last); - SETUP(mp_int_init_copy(TEMP(last), b), last); - } - - if((res = s_udiv(qout, rout)) != MP_OK) goto CLEANUP; - } - else { - if(q && (res = mp_int_copy(a, q)) != MP_OK) goto CLEANUP; - if(r && (res = mp_int_copy(a, r)) != MP_OK) goto CLEANUP; - - if(q) s_qdiv(q, (mp_size) lg); qout = q; - if(r) s_qmod(r, (mp_size) lg); rout = r; - } - - /* Recompute signs for output */ - if(rout) { - MP_SIGN(rout) = sa; - if(CMPZ(rout) == 0) - MP_SIGN(rout) = MP_ZPOS; - } - if(qout) { - MP_SIGN(qout) = (sa == sb) ? MP_ZPOS : MP_NEG; - if(CMPZ(qout) == 0) - MP_SIGN(qout) = MP_ZPOS; - } - - if(q && (res = mp_int_copy(qout, q)) != MP_OK) goto CLEANUP; - if(r && (res = mp_int_copy(rout, r)) != MP_OK) goto CLEANUP; - - CLEANUP: - while(--last >= 0) - mp_int_clear(TEMP(last)); - - return res; +mp_result +mp_int_div(mp_int a, mp_int b, mp_int q, mp_int r) +{ + int cmp, + last = 0, + lg; + mp_result res = MP_OK; + mpz_t temp[2]; + mp_int qout, + rout; + mp_sign sa = MP_SIGN(a), + sb = MP_SIGN(b); + + CHECK(a != NULL && b != NULL && q != r); + + if (CMPZ(b) == 0) + return MP_UNDEF; + else if ((cmp = s_ucmp(a, b)) < 0) + { + /* + * If |a| < |b|, no division is required: q = 0, r = a + */ + if (r && (res = mp_int_copy(a, r)) != MP_OK) + return res; + + if (q) + mp_int_zero(q); + + return MP_OK; + } + else if (cmp == 0) + { + /* + * If |a| = |b|, no division is required: q = 1 or -1, r = 0 + */ + if (r) + mp_int_zero(r); + + if (q) + { + mp_int_zero(q); + q->digits[0] = 1; + + if (sa != sb) + MP_SIGN(q) = MP_NEG; + } + + return MP_OK; + } + + /* + * When |a| > |b|, real division is required. We need someplace to store + * quotient and remainder, but q and r are allowed to be NULL or to + * overlap with the inputs. + */ + if ((lg = s_isp2(b)) < 0) + { + if (q && b != q && (res = mp_int_copy(a, q)) == MP_OK) + { + qout = q; + } + else + { + qout = TEMP(last); + SETUP(mp_int_init_copy(TEMP(last), a), last); + } + + if (r && a != r && (res = mp_int_copy(b, r)) == MP_OK) + { + rout = r; + } + else + { + rout = TEMP(last); + SETUP(mp_int_init_copy(TEMP(last), b), last); + } + + if ((res = s_udiv(qout, rout)) != MP_OK) + goto CLEANUP; + } + else + { + if (q && (res = mp_int_copy(a, q)) != MP_OK) + goto CLEANUP; + if (r && (res = mp_int_copy(a, r)) != MP_OK) + goto CLEANUP; + + if (q) + s_qdiv(q, (mp_size) lg); + qout = q; + if (r) + s_qmod(r, (mp_size) lg); + rout = r; + } + + /* Recompute signs for output */ + if (rout) + { + MP_SIGN(rout) = sa; + if (CMPZ(rout) == 0) + MP_SIGN(rout) = MP_ZPOS; + } + if (qout) + { + MP_SIGN(qout) = (sa == sb) ? MP_ZPOS : MP_NEG; + if (CMPZ(qout) == 0) + MP_SIGN(qout) = MP_ZPOS; + } + + if (q && (res = mp_int_copy(qout, q)) != MP_OK) + goto CLEANUP; + if (r && (res = mp_int_copy(rout, r)) != MP_OK) + goto CLEANUP; + +CLEANUP: + while (--last >= 0) + mp_int_clear(TEMP(last)); + + return res; } /* }}} */ /* {{{ mp_int_mod(a, m, c) */ -mp_result mp_int_mod(mp_int a, mp_int m, mp_int c) +mp_result +mp_int_mod(mp_int a, mp_int m, mp_int c) { - mp_result res; - mpz_t tmp; - mp_int out; + mp_result res; + mpz_t tmp; + mp_int out; - if(m == c) { - if((res = mp_int_init(&tmp)) != MP_OK) - return res; + if (m == c) + { + if ((res = mp_int_init(&tmp)) != MP_OK) + return res; - out = &tmp; - } - else { - out = c; - } + out = &tmp; + } + else + { + out = c; + } - if((res = mp_int_div(a, m, NULL, out)) != MP_OK) - goto CLEANUP; + if ((res = mp_int_div(a, m, NULL, out)) != MP_OK) + goto CLEANUP; - if(CMPZ(out) < 0) - res = mp_int_add(out, m, c); - else - res = mp_int_copy(out, c); + if (CMPZ(out) < 0) + res = mp_int_add(out, m, c); + else + res = mp_int_copy(out, c); - CLEANUP: - if(out != c) - mp_int_clear(&tmp); +CLEANUP: + if (out != c) + mp_int_clear(&tmp); - return res; + return res; } /* }}} */ @@ -1007,379 +1114,416 @@ mp_result mp_int_mod(mp_int a, mp_int m, mp_int c) /* {{{ mp_int_div_value(a, value, q, r) */ -mp_result mp_int_div_value(mp_int a, int value, mp_int q, int *r) +mp_result +mp_int_div_value(mp_int a, int value, mp_int q, int *r) { - mpz_t vtmp, rtmp; - mp_digit vbuf[MP_VALUE_DIGITS(value)]; - mp_result res; + mpz_t vtmp, + rtmp; + mp_digit vbuf[MP_VALUE_DIGITS(value)]; + mp_result res; - if((res = mp_int_init(&rtmp)) != MP_OK) return res; - s_fake(&vtmp, value, vbuf); + if ((res = mp_int_init(&rtmp)) != MP_OK) + return res; + s_fake(&vtmp, value, vbuf); - if((res = mp_int_div(a, &vtmp, q, &rtmp)) != MP_OK) - goto CLEANUP; + if ((res = mp_int_div(a, &vtmp, q, &rtmp)) != MP_OK) + goto CLEANUP; - if(r) - (void) mp_int_to_int(&rtmp, r); /* can't fail */ + if (r) + (void) mp_int_to_int(&rtmp, r); /* can't fail */ - CLEANUP: - mp_int_clear(&rtmp); - return res; +CLEANUP: + mp_int_clear(&rtmp); + return res; } /* }}} */ /* {{{ mp_int_div_pow2(a, p2, q, r) */ -mp_result mp_int_div_pow2(mp_int a, int p2, mp_int q, mp_int r) +mp_result +mp_int_div_pow2(mp_int a, int p2, mp_int q, mp_int r) { - mp_result res = MP_OK; + mp_result res = MP_OK; + + CHECK(a != NULL && p2 >= 0 && q != r); - CHECK(a != NULL && p2 >= 0 && q != r); + if (q != NULL && (res = mp_int_copy(a, q)) == MP_OK) + s_qdiv(q, (mp_size) p2); - if(q != NULL && (res = mp_int_copy(a, q)) == MP_OK) - s_qdiv(q, (mp_size) p2); - - if(res == MP_OK && r != NULL && (res = mp_int_copy(a, r)) == MP_OK) - s_qmod(r, (mp_size) p2); + if (res == MP_OK && r != NULL && (res = mp_int_copy(a, r)) == MP_OK) + s_qmod(r, (mp_size) p2); - return res; + return res; } /* }}} */ /* {{{ mp_int_expt(a, b, c) */ -mp_result mp_int_expt(mp_int a, int b, mp_int c) +mp_result +mp_int_expt(mp_int a, int b, mp_int c) { - mpz_t t; - mp_result res; - unsigned int v = abs(b); - - CHECK(b >= 0 && c != NULL); + mpz_t t; + mp_result res; + unsigned int v = abs(b); - if((res = mp_int_init_copy(&t, a)) != MP_OK) - return res; + CHECK(b >= 0 && c != NULL); - (void) mp_int_set_value(c, 1); - while(v != 0) { - if(v & 1) { - if((res = mp_int_mul(c, &t, c)) != MP_OK) - goto CLEANUP; - } + if ((res = mp_int_init_copy(&t, a)) != MP_OK) + return res; - v >>= 1; - if(v == 0) break; + (void) mp_int_set_value(c, 1); + while (v != 0) + { + if (v & 1) + { + if ((res = mp_int_mul(c, &t, c)) != MP_OK) + goto CLEANUP; + } - if((res = mp_int_sqr(&t, &t)) != MP_OK) - goto CLEANUP; - } - - CLEANUP: - mp_int_clear(&t); - return res; + v >>= 1; + if (v == 0) + break; + + if ((res = mp_int_sqr(&t, &t)) != MP_OK) + goto CLEANUP; + } + +CLEANUP: + mp_int_clear(&t); + return res; } /* }}} */ /* {{{ mp_int_expt_value(a, b, c) */ -mp_result mp_int_expt_value(int a, int b, mp_int c) +mp_result +mp_int_expt_value(int a, int b, mp_int c) { - mpz_t t; - mp_result res; - unsigned int v = abs(b); - - CHECK(b >= 0 && c != NULL); + mpz_t t; + mp_result res; + unsigned int v = abs(b); + + CHECK(b >= 0 && c != NULL); - if((res = mp_int_init_value(&t, a)) != MP_OK) - return res; + if ((res = mp_int_init_value(&t, a)) != MP_OK) + return res; - (void) mp_int_set_value(c, 1); - while(v != 0) { - if(v & 1) { - if((res = mp_int_mul(c, &t, c)) != MP_OK) - goto CLEANUP; - } + (void) mp_int_set_value(c, 1); + while (v != 0) + { + if (v & 1) + { + if ((res = mp_int_mul(c, &t, c)) != MP_OK) + goto CLEANUP; + } - v >>= 1; - if(v == 0) break; + v >>= 1; + if (v == 0) + break; - if((res = mp_int_sqr(&t, &t)) != MP_OK) - goto CLEANUP; - } - - CLEANUP: - mp_int_clear(&t); - return res; + if ((res = mp_int_sqr(&t, &t)) != MP_OK) + goto CLEANUP; + } + +CLEANUP: + mp_int_clear(&t); + return res; } /* }}} */ /* {{{ mp_int_compare(a, b) */ -int mp_int_compare(mp_int a, mp_int b) -{ - mp_sign sa; +int +mp_int_compare(mp_int a, mp_int b) +{ + mp_sign sa; - CHECK(a != NULL && b != NULL); + CHECK(a != NULL && b != NULL); - sa = MP_SIGN(a); - if(sa == MP_SIGN(b)) { - int cmp = s_ucmp(a, b); + sa = MP_SIGN(a); + if (sa == MP_SIGN(b)) + { + int cmp = s_ucmp(a, b); - /* If they're both zero or positive, the normal comparison - applies; if both negative, the sense is reversed. */ - if(sa == MP_ZPOS) - return cmp; - else - return -cmp; + /* + * If they're both zero or positive, the normal comparison applies; if + * both negative, the sense is reversed. + */ + if (sa == MP_ZPOS) + return cmp; + else + return -cmp; - } - else { - if(sa == MP_ZPOS) - return 1; - else - return -1; - } + } + else + { + if (sa == MP_ZPOS) + return 1; + else + return -1; + } } /* }}} */ /* {{{ mp_int_compare_unsigned(a, b) */ -int mp_int_compare_unsigned(mp_int a, mp_int b) -{ - NRCHECK(a != NULL && b != NULL); +int +mp_int_compare_unsigned(mp_int a, mp_int b) +{ + NRCHECK(a != NULL && b != NULL); - return s_ucmp(a, b); + return s_ucmp(a, b); } /* }}} */ /* {{{ mp_int_compare_zero(z) */ -int mp_int_compare_zero(mp_int z) -{ - NRCHECK(z != NULL); +int +mp_int_compare_zero(mp_int z) +{ + NRCHECK(z != NULL); - if(MP_USED(z) == 1 && z->digits[0] == 0) - return 0; - else if(MP_SIGN(z) == MP_ZPOS) - return 1; - else - return -1; + if (MP_USED(z) == 1 && z->digits[0] == 0) + return 0; + else if (MP_SIGN(z) == MP_ZPOS) + return 1; + else + return -1; } /* }}} */ /* {{{ mp_int_compare_value(z, value) */ -int mp_int_compare_value(mp_int z, int value) +int +mp_int_compare_value(mp_int z, int value) { - mp_sign vsign = (value < 0) ? MP_NEG : MP_ZPOS; - int cmp; + mp_sign vsign = (value < 0) ? MP_NEG : MP_ZPOS; + int cmp; - CHECK(z != NULL); + CHECK(z != NULL); - if(vsign == MP_SIGN(z)) { - cmp = s_vcmp(z, value); + if (vsign == MP_SIGN(z)) + { + cmp = s_vcmp(z, value); - if(vsign == MP_ZPOS) - return cmp; - else - return -cmp; - } - else { - if(value < 0) - return 1; - else - return -1; - } + if (vsign == MP_ZPOS) + return cmp; + else + return -cmp; + } + else + { + if (value < 0) + return 1; + else + return -1; + } } /* }}} */ /* {{{ mp_int_exptmod(a, b, m, c) */ -mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m, mp_int c) -{ - mp_result res; - mp_size um; - mpz_t temp[3]; - mp_int s; - int last = 0; +mp_result +mp_int_exptmod(mp_int a, mp_int b, mp_int m, mp_int c) +{ + mp_result res; + mp_size um; + mpz_t temp[3]; + mp_int s; + int last = 0; - CHECK(a != NULL && b != NULL && c != NULL && m != NULL); + CHECK(a != NULL && b != NULL && c != NULL && m != NULL); - /* Zero moduli and negative exponents are not considered. */ - if(CMPZ(m) == 0) - return MP_UNDEF; - if(CMPZ(b) < 0) - return MP_RANGE; + /* Zero moduli and negative exponents are not considered. */ + if (CMPZ(m) == 0) + return MP_UNDEF; + if (CMPZ(b) < 0) + return MP_RANGE; - um = MP_USED(m); - SETUP(mp_int_init_size(TEMP(0), 2 * um), last); - SETUP(mp_int_init_size(TEMP(1), 2 * um), last); + um = MP_USED(m); + SETUP(mp_int_init_size(TEMP(0), 2 * um), last); + SETUP(mp_int_init_size(TEMP(1), 2 * um), last); - if(c == b || c == m) { - SETUP(mp_int_init_size(TEMP(2), 2 * um), last); - s = TEMP(2); - } - else { - s = c; - } - - if((res = mp_int_mod(a, m, TEMP(0))) != MP_OK) goto CLEANUP; + if (c == b || c == m) + { + SETUP(mp_int_init_size(TEMP(2), 2 * um), last); + s = TEMP(2); + } + else + { + s = c; + } - if((res = s_brmu(TEMP(1), m)) != MP_OK) goto CLEANUP; + if ((res = mp_int_mod(a, m, TEMP(0))) != MP_OK) + goto CLEANUP; - if((res = s_embar(TEMP(0), b, m, TEMP(1), s)) != MP_OK) - goto CLEANUP; + if ((res = s_brmu(TEMP(1), m)) != MP_OK) + goto CLEANUP; - res = mp_int_copy(s, c); + if ((res = s_embar(TEMP(0), b, m, TEMP(1), s)) != MP_OK) + goto CLEANUP; - CLEANUP: - while(--last >= 0) - mp_int_clear(TEMP(last)); + res = mp_int_copy(s, c); - return res; +CLEANUP: + while (--last >= 0) + mp_int_clear(TEMP(last)); + + return res; } /* }}} */ /* {{{ mp_int_exptmod_evalue(a, value, m, c) */ -mp_result mp_int_exptmod_evalue(mp_int a, int value, mp_int m, mp_int c) +mp_result +mp_int_exptmod_evalue(mp_int a, int value, mp_int m, mp_int c) { - mpz_t vtmp; - mp_digit vbuf[MP_VALUE_DIGITS(value)]; + mpz_t vtmp; + mp_digit vbuf[MP_VALUE_DIGITS(value)]; - s_fake(&vtmp, value, vbuf); + s_fake(&vtmp, value, vbuf); - return mp_int_exptmod(a, &vtmp, m, c); + return mp_int_exptmod(a, &vtmp, m, c); } /* }}} */ /* {{{ mp_int_exptmod_bvalue(v, b, m, c) */ -mp_result mp_int_exptmod_bvalue(int value, mp_int b, - mp_int m, mp_int c) +mp_result +mp_int_exptmod_bvalue(int value, mp_int b, + mp_int m, mp_int c) { - mpz_t vtmp; - mp_digit vbuf[MP_VALUE_DIGITS(value)]; + mpz_t vtmp; + mp_digit vbuf[MP_VALUE_DIGITS(value)]; - s_fake(&vtmp, value, vbuf); + s_fake(&vtmp, value, vbuf); - return mp_int_exptmod(&vtmp, b, m, c); + return mp_int_exptmod(&vtmp, b, m, c); } /* }}} */ /* {{{ mp_int_exptmod_known(a, b, m, mu, c) */ -mp_result mp_int_exptmod_known(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c) +mp_result +mp_int_exptmod_known(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c) { - mp_result res; - mp_size um; - mpz_t temp[2]; - mp_int s; - int last = 0; + mp_result res; + mp_size um; + mpz_t temp[2]; + mp_int s; + int last = 0; + + CHECK(a && b && m && c); - CHECK(a && b && m && c); + /* Zero moduli and negative exponents are not considered. */ + if (CMPZ(m) == 0) + return MP_UNDEF; + if (CMPZ(b) < 0) + return MP_RANGE; - /* Zero moduli and negative exponents are not considered. */ - if(CMPZ(m) == 0) - return MP_UNDEF; - if(CMPZ(b) < 0) - return MP_RANGE; + um = MP_USED(m); + SETUP(mp_int_init_size(TEMP(0), 2 * um), last); - um = MP_USED(m); - SETUP(mp_int_init_size(TEMP(0), 2 * um), last); + if (c == b || c == m) + { + SETUP(mp_int_init_size(TEMP(1), 2 * um), last); + s = TEMP(1); + } + else + { + s = c; + } - if(c == b || c == m) { - SETUP(mp_int_init_size(TEMP(1), 2 * um), last); - s = TEMP(1); - } - else { - s = c; - } - - if((res = mp_int_mod(a, m, TEMP(0))) != MP_OK) goto CLEANUP; + if ((res = mp_int_mod(a, m, TEMP(0))) != MP_OK) + goto CLEANUP; - if((res = s_embar(TEMP(0), b, m, mu, s)) != MP_OK) - goto CLEANUP; + if ((res = s_embar(TEMP(0), b, m, mu, s)) != MP_OK) + goto CLEANUP; - res = mp_int_copy(s, c); + res = mp_int_copy(s, c); - CLEANUP: - while(--last >= 0) - mp_int_clear(TEMP(last)); +CLEANUP: + while (--last >= 0) + mp_int_clear(TEMP(last)); - return res; + return res; } /* }}} */ /* {{{ mp_int_redux_const(m, c) */ -mp_result mp_int_redux_const(mp_int m, mp_int c) +mp_result +mp_int_redux_const(mp_int m, mp_int c) { - CHECK(m != NULL && c != NULL && m != c); + CHECK(m != NULL && c != NULL && m != c); - return s_brmu(c, m); + return s_brmu(c, m); } /* }}} */ /* {{{ mp_int_invmod(a, m, c) */ -mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c) +mp_result +mp_int_invmod(mp_int a, mp_int m, mp_int c) { - mp_result res; - mp_sign sa; - int last = 0; - mpz_t temp[2]; + mp_result res; + mp_sign sa; + int last = 0; + mpz_t temp[2]; - CHECK(a != NULL && m != NULL && c != NULL); + CHECK(a != NULL && m != NULL && c != NULL); - if(CMPZ(a) == 0 || CMPZ(m) <= 0) - return MP_RANGE; + if (CMPZ(a) == 0 || CMPZ(m) <= 0) + return MP_RANGE; - sa = MP_SIGN(a); /* need this for the result later */ + sa = MP_SIGN(a); /* need this for the result later */ - for(last = 0; last < 2; ++last) - if((res = mp_int_init(TEMP(last))) != MP_OK) - goto CLEANUP; + for (last = 0; last < 2; ++last) + if ((res = mp_int_init(TEMP(last))) != MP_OK) + goto CLEANUP; - if((res = mp_int_egcd(a, m, TEMP(0), TEMP(1), NULL)) != MP_OK) - goto CLEANUP; + if ((res = mp_int_egcd(a, m, TEMP(0), TEMP(1), NULL)) != MP_OK) + goto CLEANUP; - if(mp_int_compare_value(TEMP(0), 1) != 0) { - res = MP_UNDEF; - goto CLEANUP; - } + if (mp_int_compare_value(TEMP(0), 1) != 0) + { + res = MP_UNDEF; + goto CLEANUP; + } - /* It is first necessary to constrain the value to the proper range */ - if((res = mp_int_mod(TEMP(1), m, TEMP(1))) != MP_OK) - goto CLEANUP; + /* It is first necessary to constrain the value to the proper range */ + if ((res = mp_int_mod(TEMP(1), m, TEMP(1))) != MP_OK) + goto CLEANUP; - /* Now, if 'a' was originally negative, the value we have is - actually the magnitude of the negative representative; to get the - positive value we have to subtract from the modulus. Otherwise, - the value is okay as it stands. - */ - if(sa == MP_NEG) - res = mp_int_sub(m, TEMP(1), c); - else - res = mp_int_copy(TEMP(1), c); + /* + * Now, if 'a' was originally negative, the value we have is actually the + * magnitude of the negative representative; to get the positive value we + * have to subtract from the modulus. Otherwise, the value is okay as it + * stands. + */ + if (sa == MP_NEG) + res = mp_int_sub(m, TEMP(1), c); + else + res = mp_int_copy(TEMP(1), c); - CLEANUP: - while(--last >= 0) - mp_int_clear(TEMP(last)); +CLEANUP: + while (--last >= 0) + mp_int_clear(TEMP(last)); - return res; + return res; } /* }}} */ @@ -1387,79 +1531,91 @@ mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c) /* {{{ mp_int_gcd(a, b, c) */ /* Binary GCD algorithm due to Josef Stein, 1961 */ -mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c) -{ - int ca, cb, k = 0; - mpz_t u, v, t; - mp_result res; - - CHECK(a != NULL && b != NULL && c != NULL); - - ca = CMPZ(a); - cb = CMPZ(b); - if(ca == 0 && cb == 0) - return MP_UNDEF; - else if(ca == 0) - return mp_int_abs(b, c); - else if(cb == 0) - return mp_int_abs(a, c); - - if((res = mp_int_init(&t)) != MP_OK) - return res; - if((res = mp_int_init_copy(&u, a)) != MP_OK) - goto U; - if((res = mp_int_init_copy(&v, b)) != MP_OK) - goto V; - - MP_SIGN(&u) = MP_ZPOS; MP_SIGN(&v) = MP_ZPOS; - - { /* Divide out common factors of 2 from u and v */ - int div2_u = s_dp2k(&u), div2_v = s_dp2k(&v); - - k = MIN(div2_u, div2_v); - s_qdiv(&u, (mp_size) k); - s_qdiv(&v, (mp_size) k); - } - - if(mp_int_is_odd(&u)) { - if((res = mp_int_neg(&v, &t)) != MP_OK) - goto CLEANUP; - } - else { - if((res = mp_int_copy(&u, &t)) != MP_OK) - goto CLEANUP; - } - - for(;;) { - s_qdiv(&t, s_dp2k(&t)); - - if(CMPZ(&t) > 0) { - if((res = mp_int_copy(&t, &u)) != MP_OK) - goto CLEANUP; - } - else { - if((res = mp_int_neg(&t, &v)) != MP_OK) - goto CLEANUP; - } - - if((res = mp_int_sub(&u, &v, &t)) != MP_OK) - goto CLEANUP; - - if(CMPZ(&t) == 0) - break; - } - - if((res = mp_int_abs(&u, c)) != MP_OK) - goto CLEANUP; - if(!s_qmul(c, (mp_size) k)) - res = MP_MEMORY; - - CLEANUP: - mp_int_clear(&v); - V: mp_int_clear(&u); - U: mp_int_clear(&t); - - return res; +mp_result +mp_int_gcd(mp_int a, mp_int b, mp_int c) +{ + int ca, + cb, + k = 0; + mpz_t u, + v, + t; + mp_result res; + + CHECK(a != NULL && b != NULL && c != NULL); + + ca = CMPZ(a); + cb = CMPZ(b); + if (ca == 0 && cb == 0) + return MP_UNDEF; + else if (ca == 0) + return mp_int_abs(b, c); + else if (cb == 0) + return mp_int_abs(a, c); + + if ((res = mp_int_init(&t)) != MP_OK) + return res; + if ((res = mp_int_init_copy(&u, a)) != MP_OK) + goto U; + if ((res = mp_int_init_copy(&v, b)) != MP_OK) + goto V; + + MP_SIGN(&u) = MP_ZPOS; + MP_SIGN(&v) = MP_ZPOS; + + { /* Divide out common factors of 2 from u and v */ + int div2_u = s_dp2k(&u), + div2_v = s_dp2k(&v); + + k = MIN(div2_u, div2_v); + s_qdiv(&u, (mp_size) k); + s_qdiv(&v, (mp_size) k); + } + + if (mp_int_is_odd(&u)) + { + if ((res = mp_int_neg(&v, &t)) != MP_OK) + goto CLEANUP; + } + else + { + if ((res = mp_int_copy(&u, &t)) != MP_OK) + goto CLEANUP; + } + + for (;;) + { + s_qdiv(&t, s_dp2k(&t)); + + if (CMPZ(&t) > 0) + { + if ((res = mp_int_copy(&t, &u)) != MP_OK) + goto CLEANUP; + } + else + { + if ((res = mp_int_neg(&t, &v)) != MP_OK) + goto CLEANUP; + } + + if ((res = mp_int_sub(&u, &v, &t)) != MP_OK) + goto CLEANUP; + + if (CMPZ(&t) == 0) + break; + } + + if ((res = mp_int_abs(&u, c)) != MP_OK) + goto CLEANUP; + if (!s_qmul(c, (mp_size) k)) + res = MP_MEMORY; + +CLEANUP: + mp_int_clear(&v); +V: mp_int_clear(&u); +U: mp_int_clear(&t); + + return res; } /* }}} */ @@ -1470,308 +1626,361 @@ mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c) of the elementary matrix operations as we go, so we can get values x and y satisfying c = ax + by. */ -mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c, - mp_int x, mp_int y) -{ - int k, last = 0, ca, cb; - mpz_t temp[8]; - mp_result res; - - CHECK(a != NULL && b != NULL && c != NULL && - (x != NULL || y != NULL)); - - ca = CMPZ(a); - cb = CMPZ(b); - if(ca == 0 && cb == 0) - return MP_UNDEF; - else if(ca == 0) { - if((res = mp_int_abs(b, c)) != MP_OK) return res; - mp_int_zero(x); (void) mp_int_set_value(y, 1); return MP_OK; - } - else if(cb == 0) { - if((res = mp_int_abs(a, c)) != MP_OK) return res; - (void) mp_int_set_value(x, 1); mp_int_zero(y); return MP_OK; - } - - /* Initialize temporaries: - A:0, B:1, C:2, D:3, u:4, v:5, ou:6, ov:7 */ - for(last = 0; last < 4; ++last) { - if((res = mp_int_init(TEMP(last))) != MP_OK) - goto CLEANUP; - } - TEMP(0)->digits[0] = 1; - TEMP(3)->digits[0] = 1; - - SETUP(mp_int_init_copy(TEMP(4), a), last); - SETUP(mp_int_init_copy(TEMP(5), b), last); - - /* We will work with absolute values here */ - MP_SIGN(TEMP(4)) = MP_ZPOS; - MP_SIGN(TEMP(5)) = MP_ZPOS; - - { /* Divide out common factors of 2 from u and v */ - int div2_u = s_dp2k(TEMP(4)), div2_v = s_dp2k(TEMP(5)); - - k = MIN(div2_u, div2_v); - s_qdiv(TEMP(4), k); - s_qdiv(TEMP(5), k); - } - - SETUP(mp_int_init_copy(TEMP(6), TEMP(4)), last); - SETUP(mp_int_init_copy(TEMP(7), TEMP(5)), last); - - for(;;) { - while(mp_int_is_even(TEMP(4))) { - s_qdiv(TEMP(4), 1); - - if(mp_int_is_odd(TEMP(0)) || mp_int_is_odd(TEMP(1))) { - if((res = mp_int_add(TEMP(0), TEMP(7), TEMP(0))) != MP_OK) - goto CLEANUP; - if((res = mp_int_sub(TEMP(1), TEMP(6), TEMP(1))) != MP_OK) - goto CLEANUP; - } - - s_qdiv(TEMP(0), 1); - s_qdiv(TEMP(1), 1); - } - - while(mp_int_is_even(TEMP(5))) { - s_qdiv(TEMP(5), 1); - - if(mp_int_is_odd(TEMP(2)) || mp_int_is_odd(TEMP(3))) { - if((res = mp_int_add(TEMP(2), TEMP(7), TEMP(2))) != MP_OK) - goto CLEANUP; - if((res = mp_int_sub(TEMP(3), TEMP(6), TEMP(3))) != MP_OK) - goto CLEANUP; - } - - s_qdiv(TEMP(2), 1); - s_qdiv(TEMP(3), 1); - } - - if(mp_int_compare(TEMP(4), TEMP(5)) >= 0) { - if((res = mp_int_sub(TEMP(4), TEMP(5), TEMP(4))) != MP_OK) goto CLEANUP; - if((res = mp_int_sub(TEMP(0), TEMP(2), TEMP(0))) != MP_OK) goto CLEANUP; - if((res = mp_int_sub(TEMP(1), TEMP(3), TEMP(1))) != MP_OK) goto CLEANUP; - } - else { - if((res = mp_int_sub(TEMP(5), TEMP(4), TEMP(5))) != MP_OK) goto CLEANUP; - if((res = mp_int_sub(TEMP(2), TEMP(0), TEMP(2))) != MP_OK) goto CLEANUP; - if((res = mp_int_sub(TEMP(3), TEMP(1), TEMP(3))) != MP_OK) goto CLEANUP; - } - - if(CMPZ(TEMP(4)) == 0) { - if(x && (res = mp_int_copy(TEMP(2), x)) != MP_OK) goto CLEANUP; - if(y && (res = mp_int_copy(TEMP(3), y)) != MP_OK) goto CLEANUP; - if(c) { - if(!s_qmul(TEMP(5), k)) { - res = MP_MEMORY; - goto CLEANUP; - } - - res = mp_int_copy(TEMP(5), c); - } - - break; - } - } - - CLEANUP: - while(--last >= 0) - mp_int_clear(TEMP(last)); - - return res; +mp_result +mp_int_egcd(mp_int a, mp_int b, mp_int c, + mp_int x, mp_int y) +{ + int k, + last = 0, + ca, + cb; + mpz_t temp[8]; + mp_result res; + + CHECK(a != NULL && b != NULL && c != NULL && + (x != NULL || y != NULL)); + + ca = CMPZ(a); + cb = CMPZ(b); + if (ca == 0 && cb == 0) + return MP_UNDEF; + else if (ca == 0) + { + if ((res = mp_int_abs(b, c)) != MP_OK) + return res; + mp_int_zero(x); + (void) mp_int_set_value(y, 1); + return MP_OK; + } + else if (cb == 0) + { + if ((res = mp_int_abs(a, c)) != MP_OK) + return res; + (void) mp_int_set_value(x, 1); + mp_int_zero(y); + return MP_OK; + } + + /* + * Initialize temporaries: A:0, B:1, C:2, D:3, u:4, v:5, ou:6, ov:7 + */ + for (last = 0; last < 4; ++last) + { + if ((res = mp_int_init(TEMP(last))) != MP_OK) + goto CLEANUP; + } + TEMP(0)->digits[0] = 1; + TEMP(3)->digits[0] = 1; + + SETUP(mp_int_init_copy(TEMP(4), a), last); + SETUP(mp_int_init_copy(TEMP(5), b), last); + + /* We will work with absolute values here */ + MP_SIGN(TEMP(4)) = MP_ZPOS; + MP_SIGN(TEMP(5)) = MP_ZPOS; + + { /* Divide out common factors of 2 from u and v */ + int div2_u = s_dp2k(TEMP(4)), + div2_v = s_dp2k(TEMP(5)); + + k = MIN(div2_u, div2_v); + s_qdiv(TEMP(4), k); + s_qdiv(TEMP(5), k); + } + + SETUP(mp_int_init_copy(TEMP(6), TEMP(4)), last); + SETUP(mp_int_init_copy(TEMP(7), TEMP(5)), last); + + for (;;) + { + while (mp_int_is_even(TEMP(4))) + { + s_qdiv(TEMP(4), 1); + + if (mp_int_is_odd(TEMP(0)) || mp_int_is_odd(TEMP(1))) + { + if ((res = mp_int_add(TEMP(0), TEMP(7), TEMP(0))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_sub(TEMP(1), TEMP(6), TEMP(1))) != MP_OK) + goto CLEANUP; + } + + s_qdiv(TEMP(0), 1); + s_qdiv(TEMP(1), 1); + } + + while (mp_int_is_even(TEMP(5))) + { + s_qdiv(TEMP(5), 1); + + if (mp_int_is_odd(TEMP(2)) || mp_int_is_odd(TEMP(3))) + { + if ((res = mp_int_add(TEMP(2), TEMP(7), TEMP(2))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_sub(TEMP(3), TEMP(6), TEMP(3))) != MP_OK) + goto CLEANUP; + } + + s_qdiv(TEMP(2), 1); + s_qdiv(TEMP(3), 1); + } + + if (mp_int_compare(TEMP(4), TEMP(5)) >= 0) + { + if ((res = mp_int_sub(TEMP(4), TEMP(5), TEMP(4))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_sub(TEMP(0), TEMP(2), TEMP(0))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_sub(TEMP(1), TEMP(3), TEMP(1))) != MP_OK) + goto CLEANUP; + } + else + { + if ((res = mp_int_sub(TEMP(5), TEMP(4), TEMP(5))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_sub(TEMP(2), TEMP(0), TEMP(2))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_sub(TEMP(3), TEMP(1), TEMP(3))) != MP_OK) + goto CLEANUP; + } + + if (CMPZ(TEMP(4)) == 0) + { + if (x && (res = mp_int_copy(TEMP(2), x)) != MP_OK) + goto CLEANUP; + if (y && (res = mp_int_copy(TEMP(3), y)) != MP_OK) + goto CLEANUP; + if (c) + { + if (!s_qmul(TEMP(5), k)) + { + res = MP_MEMORY; + goto CLEANUP; + } + + res = mp_int_copy(TEMP(5), c); + } + + break; + } + } + +CLEANUP: + while (--last >= 0) + mp_int_clear(TEMP(last)); + + return res; } /* }}} */ /* {{{ mp_int_divisible_value(a, v) */ -int mp_int_divisible_value(mp_int a, int v) +int +mp_int_divisible_value(mp_int a, int v) { - int rem = 0; + int rem = 0; - if(mp_int_div_value(a, v, NULL, &rem) != MP_OK) - return 0; + if (mp_int_div_value(a, v, NULL, &rem) != MP_OK) + return 0; - return rem == 0; + return rem == 0; } /* }}} */ /* {{{ mp_int_is_pow2(z) */ -int mp_int_is_pow2(mp_int z) +int +mp_int_is_pow2(mp_int z) { - CHECK(z != NULL); + CHECK(z != NULL); - return s_isp2(z); + return s_isp2(z); } /* }}} */ /* {{{ mp_int_sqrt(a, c) */ -mp_result mp_int_sqrt(mp_int a, mp_int c) +mp_result +mp_int_sqrt(mp_int a, mp_int c) { - mp_result res = MP_OK; - mpz_t temp[2]; - int last = 0; + mp_result res = MP_OK; + mpz_t temp[2]; + int last = 0; - CHECK(a != NULL && c != NULL); + CHECK(a != NULL && c != NULL); - /* The square root of a negative value does not exist in the integers. */ - if(MP_SIGN(a) == MP_NEG) - return MP_UNDEF; + /* The square root of a negative value does not exist in the integers. */ + if (MP_SIGN(a) == MP_NEG) + return MP_UNDEF; - SETUP(mp_int_init_copy(TEMP(last), a), last); - SETUP(mp_int_init(TEMP(last)), last); + SETUP(mp_int_init_copy(TEMP(last), a), last); + SETUP(mp_int_init(TEMP(last)), last); - for(;;) { - if((res = mp_int_sqr(TEMP(0), TEMP(1))) != MP_OK) - goto CLEANUP; + for (;;) + { + if ((res = mp_int_sqr(TEMP(0), TEMP(1))) != MP_OK) + goto CLEANUP; - if(mp_int_compare_unsigned(a, TEMP(1)) == 0) break; + if (mp_int_compare_unsigned(a, TEMP(1)) == 0) + break; - if((res = mp_int_copy(a, TEMP(1))) != MP_OK) - goto CLEANUP; - if((res = mp_int_div(TEMP(1), TEMP(0), TEMP(1), NULL)) != MP_OK) - goto CLEANUP; - if((res = mp_int_add(TEMP(0), TEMP(1), TEMP(1))) != MP_OK) - goto CLEANUP; - if((res = mp_int_div_pow2(TEMP(1), 1, TEMP(1), NULL)) != MP_OK) - goto CLEANUP; + if ((res = mp_int_copy(a, TEMP(1))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_div(TEMP(1), TEMP(0), TEMP(1), NULL)) != MP_OK) + goto CLEANUP; + if ((res = mp_int_add(TEMP(0), TEMP(1), TEMP(1))) != MP_OK) + goto CLEANUP; + if ((res = mp_int_div_pow2(TEMP(1), 1, TEMP(1), NULL)) != MP_OK) + goto CLEANUP; - if(mp_int_compare_unsigned(TEMP(0), TEMP(1)) == 0) break; - if((res = mp_int_sub_value(TEMP(0), 1, TEMP(0))) != MP_OK) goto CLEANUP; - if(mp_int_compare_unsigned(TEMP(0), TEMP(1)) == 0) break; + if (mp_int_compare_unsigned(TEMP(0), TEMP(1)) == 0) + break; + if ((res = mp_int_sub_value(TEMP(0), 1, TEMP(0))) != MP_OK) + goto CLEANUP; + if (mp_int_compare_unsigned(TEMP(0), TEMP(1)) == 0) + break; - if((res = mp_int_copy(TEMP(1), TEMP(0))) != MP_OK) goto CLEANUP; - } - - res = mp_int_copy(TEMP(0), c); + if ((res = mp_int_copy(TEMP(1), TEMP(0))) != MP_OK) + goto CLEANUP; + } - CLEANUP: - while(--last >= 0) - mp_int_clear(TEMP(last)); - - return res; + res = mp_int_copy(TEMP(0), c); + +CLEANUP: + while (--last >= 0) + mp_int_clear(TEMP(last)); + + return res; } /* }}} */ /* {{{ mp_int_to_int(z, out) */ -mp_result mp_int_to_int(mp_int z, int *out) +mp_result +mp_int_to_int(mp_int z, int *out) { - unsigned int uv = 0; - mp_size uz; - mp_digit *dz; - mp_sign sz; + unsigned int uv = 0; + mp_size uz; + mp_digit *dz; + mp_sign sz; - CHECK(z != NULL); + CHECK(z != NULL); - /* Make sure the value is representable as an int */ - sz = MP_SIGN(z); - if((sz == MP_ZPOS && mp_int_compare_value(z, INT_MAX) > 0) || - mp_int_compare_value(z, INT_MIN) < 0) - return MP_RANGE; - - uz = MP_USED(z); - dz = MP_DIGITS(z) + uz - 1; - - while(uz > 0) { - uv <<= MP_DIGIT_BIT/2; - uv = (uv << (MP_DIGIT_BIT/2)) | *dz--; - --uz; - } + /* Make sure the value is representable as an int */ + sz = MP_SIGN(z); + if ((sz == MP_ZPOS && mp_int_compare_value(z, INT_MAX) > 0) || + mp_int_compare_value(z, INT_MIN) < 0) + return MP_RANGE; - if(out) - *out = (sz == MP_NEG) ? -(int)uv : (int)uv; + uz = MP_USED(z); + dz = MP_DIGITS(z) + uz - 1; - return MP_OK; + while (uz > 0) + { + uv <<= MP_DIGIT_BIT / 2; + uv = (uv << (MP_DIGIT_BIT / 2)) | *dz--; + --uz; + } + + if (out) + *out = (sz == MP_NEG) ? -(int) uv : (int) uv; + + return MP_OK; } /* }}} */ /* {{{ mp_int_to_string(z, radix, str, limit) */ -mp_result mp_int_to_string(mp_int z, mp_size radix, - char *str, int limit) +mp_result +mp_int_to_string(mp_int z, mp_size radix, + char *str, int limit) { - mp_result res; - int cmp = 0; - - CHECK(z != NULL && str != NULL && limit >= 2); - - if(radix < MP_MIN_RADIX || radix > MP_MAX_RADIX) - return MP_RANGE; - - if(CMPZ(z) == 0) { - *str++ = s_val2ch(0, mp_flags & MP_CAP_DIGITS); - } - else { - mpz_t tmp; - char *h, *t; - - if((res = mp_int_init_copy(&tmp, z)) != MP_OK) - return res; - - if(MP_SIGN(z) == MP_NEG) { - *str++ = '-'; - --limit; - } - h = str; + mp_result res; + int cmp = 0; - /* Generate digits in reverse order until finished or limit reached */ - for(/* */; limit > 0; --limit) { - mp_digit d; + CHECK(z != NULL && str != NULL && limit >= 2); - if((cmp = CMPZ(&tmp)) == 0) - break; + if (radix < MP_MIN_RADIX || radix > MP_MAX_RADIX) + return MP_RANGE; - d = s_ddiv(&tmp, (mp_digit)radix); - *str++ = s_val2ch(d, mp_flags & MP_CAP_DIGITS); - } - t = str - 1; - - /* Put digits back in correct output order */ - while(h < t) { - char tc = *h; - *h++ = *t; - *t-- = tc; - } - - mp_int_clear(&tmp); - } + if (CMPZ(z) == 0) + { + *str++ = s_val2ch(0, mp_flags & MP_CAP_DIGITS); + } + else + { + mpz_t tmp; + char *h, + *t; + + if ((res = mp_int_init_copy(&tmp, z)) != MP_OK) + return res; + + if (MP_SIGN(z) == MP_NEG) + { + *str++ = '-'; + --limit; + } + h = str; + + /* Generate digits in reverse order until finished or limit reached */ + for ( /* */ ; limit > 0; --limit) + { + mp_digit d; + + if ((cmp = CMPZ(&tmp)) == 0) + break; + + d = s_ddiv(&tmp, (mp_digit) radix); + *str++ = s_val2ch(d, mp_flags & MP_CAP_DIGITS); + } + t = str - 1; + + /* Put digits back in correct output order */ + while (h < t) + { + char tc = *h; + + *h++ = *t; + *t-- = tc; + } + + mp_int_clear(&tmp); + } - *str = '\0'; - if(cmp == 0) - return MP_OK; - else - return MP_TRUNC; + *str = '\0'; + if (cmp == 0) + return MP_OK; + else + return MP_TRUNC; } /* }}} */ /* {{{ mp_int_string_len(z, radix) */ -mp_result mp_int_string_len(mp_int z, mp_size radix) -{ - int len; +mp_result +mp_int_string_len(mp_int z, mp_size radix) +{ + int len; - CHECK(z != NULL); + CHECK(z != NULL); - if(radix < MP_MIN_RADIX || radix > MP_MAX_RADIX) - return MP_RANGE; + if (radix < MP_MIN_RADIX || radix > MP_MAX_RADIX) + return MP_RANGE; - len = s_outlen(z, radix) + 1; /* for terminator */ + len = s_outlen(z, radix) + 1; /* for terminator */ - /* Allow for sign marker on negatives */ - if(MP_SIGN(z) == MP_NEG) - len += 1; + /* Allow for sign marker on negatives */ + if (MP_SIGN(z) == MP_NEG) + len += 1; - return len; + return len; } /* }}} */ @@ -1779,9 +1988,10 @@ mp_result mp_int_string_len(mp_int z, mp_size radix) /* {{{ mp_int_read_string(z, radix, *str) */ /* Read zero-terminated string into z */ -mp_result mp_int_read_string(mp_int z, mp_size radix, const char *str) +mp_result +mp_int_read_string(mp_int z, mp_size radix, const char *str) { - return mp_int_read_cstring(z, radix, str, NULL); + return mp_int_read_cstring(z, radix, str, NULL); } @@ -1789,281 +1999,308 @@ mp_result mp_int_read_string(mp_int z, mp_size radix, const char *str) /* {{{ mp_int_read_cstring(z, radix, *str, **end) */ -mp_result mp_int_read_cstring(mp_int z, mp_size radix, const char *str, char **end) -{ - int ch; +mp_result +mp_int_read_cstring(mp_int z, mp_size radix, const char *str, char **end) +{ + int ch; - CHECK(z != NULL && str != NULL); + CHECK(z != NULL && str != NULL); - if(radix < MP_MIN_RADIX || radix > MP_MAX_RADIX) - return MP_RANGE; + if (radix < MP_MIN_RADIX || radix > MP_MAX_RADIX) + return MP_RANGE; - /* Skip leading whitespace */ - while(isspace((unsigned char) *str)) - ++str; + /* Skip leading whitespace */ + while (isspace((unsigned char) *str)) + ++str; - /* Handle leading sign tag (+/-, positive default) */ - switch(*str) { - case '-': - MP_SIGN(z) = MP_NEG; - ++str; - break; - case '+': - ++str; /* fallthrough */ - default: - MP_SIGN(z) = MP_ZPOS; - break; - } + /* Handle leading sign tag (+/-, positive default) */ + switch (*str) + { + case '-': + MP_SIGN(z) = MP_NEG; + ++str; + break; + case '+': + ++str; /* fallthrough */ + default: + MP_SIGN(z) = MP_ZPOS; + break; + } + + /* Skip leading zeroes */ + while ((ch = s_ch2val(*str, radix)) == 0) + ++str; - /* Skip leading zeroes */ - while((ch = s_ch2val(*str, radix)) == 0) - ++str; + /* Make sure there is enough space for the value */ + if (!s_pad(z, s_inlen(strlen(str), radix))) + return MP_MEMORY; - /* Make sure there is enough space for the value */ - if(!s_pad(z, s_inlen(strlen(str), radix))) - return MP_MEMORY; + MP_USED(z) = 1; + z->digits[0] = 0; + + while (*str != '\0' && ((ch = s_ch2val(*str, radix)) >= 0)) + { + s_dmul(z, (mp_digit) radix); + s_dadd(z, (mp_digit) ch); + ++str; + } - MP_USED(z) = 1; z->digits[0] = 0; + CLAMP(z); - while(*str != '\0' && ((ch = s_ch2val(*str, radix)) >= 0)) { - s_dmul(z, (mp_digit)radix); - s_dadd(z, (mp_digit)ch); - ++str; - } - - CLAMP(z); + /* Override sign for zero, even if negative specified. */ + if (CMPZ(z) == 0) + MP_SIGN(z) = MP_ZPOS; - /* Override sign for zero, even if negative specified. */ - if(CMPZ(z) == 0) - MP_SIGN(z) = MP_ZPOS; - - if(end != NULL) - *end = (char *)str; + if (end != NULL) + *end = (char *) str; - /* Return a truncation error if the string has unprocessed - characters remaining, so the caller can tell if the whole string - was done */ - if(*str != '\0') - return MP_TRUNC; - else - return MP_OK; + /* + * Return a truncation error if the string has unprocessed characters + * remaining, so the caller can tell if the whole string was done + */ + if (*str != '\0') + return MP_TRUNC; + else + return MP_OK; } /* }}} */ /* {{{ mp_int_count_bits(z) */ -mp_result mp_int_count_bits(mp_int z) +mp_result +mp_int_count_bits(mp_int z) { - mp_size nbits = 0, uz; - mp_digit d; + mp_size nbits = 0, + uz; + mp_digit d; - CHECK(z != NULL); + CHECK(z != NULL); - uz = MP_USED(z); - if(uz == 1 && z->digits[0] == 0) - return 1; + uz = MP_USED(z); + if (uz == 1 && z->digits[0] == 0) + return 1; - --uz; - nbits = uz * MP_DIGIT_BIT; - d = z->digits[uz]; + --uz; + nbits = uz * MP_DIGIT_BIT; + d = z->digits[uz]; - while(d != 0) { - d >>= 1; - ++nbits; - } + while (d != 0) + { + d >>= 1; + ++nbits; + } - return nbits; + return nbits; } /* }}} */ /* {{{ mp_int_to_binary(z, buf, limit) */ -mp_result mp_int_to_binary(mp_int z, unsigned char *buf, int limit) +mp_result +mp_int_to_binary(mp_int z, unsigned char *buf, int limit) { - static const int PAD_FOR_2C = 1; + static const int PAD_FOR_2C = 1; + + mp_result res; + int limpos = limit; - mp_result res; - int limpos = limit; + CHECK(z != NULL && buf != NULL); - CHECK(z != NULL && buf != NULL); - - res = s_tobin(z, buf, &limpos, PAD_FOR_2C); + res = s_tobin(z, buf, &limpos, PAD_FOR_2C); - if(MP_SIGN(z) == MP_NEG) - s_2comp(buf, limpos); + if (MP_SIGN(z) == MP_NEG) + s_2comp(buf, limpos); - return res; + return res; } /* }}} */ /* {{{ mp_int_read_binary(z, buf, len) */ -mp_result mp_int_read_binary(mp_int z, unsigned char *buf, int len) +mp_result +mp_int_read_binary(mp_int z, unsigned char *buf, int len) { - mp_size need, i; - unsigned char *tmp; - mp_digit *dz; + mp_size need, + i; + unsigned char *tmp; + mp_digit *dz; + + CHECK(z != NULL && buf != NULL && len > 0); - CHECK(z != NULL && buf != NULL && len > 0); + /* Figure out how many digits are needed to represent this value */ + need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT; + if (!s_pad(z, need)) + return MP_MEMORY; - /* Figure out how many digits are needed to represent this value */ - need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT; - if(!s_pad(z, need)) - return MP_MEMORY; + mp_int_zero(z); - mp_int_zero(z); + /* + * If the high-order bit is set, take the 2's complement before reading + * the value (it will be restored afterward) + */ + if (buf[0] >> (CHAR_BIT - 1)) + { + MP_SIGN(z) = MP_NEG; + s_2comp(buf, len); + } - /* If the high-order bit is set, take the 2's complement before - reading the value (it will be restored afterward) */ - if(buf[0] >> (CHAR_BIT - 1)) { - MP_SIGN(z) = MP_NEG; - s_2comp(buf, len); - } - - dz = MP_DIGITS(z); - for(tmp = buf, i = len; i > 0; --i, ++tmp) { - s_qmul(z, (mp_size) CHAR_BIT); - *dz |= *tmp; - } + dz = MP_DIGITS(z); + for (tmp = buf, i = len; i > 0; --i, ++tmp) + { + s_qmul(z, (mp_size) CHAR_BIT); + *dz |= *tmp; + } - /* Restore 2's complement if we took it before */ - if(MP_SIGN(z) == MP_NEG) - s_2comp(buf, len); + /* Restore 2's complement if we took it before */ + if (MP_SIGN(z) == MP_NEG) + s_2comp(buf, len); - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_binary_len(z) */ -mp_result mp_int_binary_len(mp_int z) +mp_result +mp_int_binary_len(mp_int z) { - mp_result res = mp_int_count_bits(z); - int bytes = mp_int_unsigned_len(z); + mp_result res = mp_int_count_bits(z); + int bytes = mp_int_unsigned_len(z); - if(res <= 0) - return res; + if (res <= 0) + return res; - bytes = (res + (CHAR_BIT - 1)) / CHAR_BIT; + bytes = (res + (CHAR_BIT - 1)) / CHAR_BIT; - /* If the highest-order bit falls exactly on a byte boundary, we - need to pad with an extra byte so that the sign will be read - correctly when reading it back in. */ - if(bytes * CHAR_BIT == res) - ++bytes; + /* + * If the highest-order bit falls exactly on a byte boundary, we need to + * pad with an extra byte so that the sign will be read correctly when + * reading it back in. + */ + if (bytes * CHAR_BIT == res) + ++bytes; - return bytes; + return bytes; } /* }}} */ /* {{{ mp_int_to_unsigned(z, buf, limit) */ -mp_result mp_int_to_unsigned(mp_int z, unsigned char *buf, int limit) +mp_result +mp_int_to_unsigned(mp_int z, unsigned char *buf, int limit) { - static const int NO_PADDING = 0; + static const int NO_PADDING = 0; - CHECK(z != NULL && buf != NULL); + CHECK(z != NULL && buf != NULL); - return s_tobin(z, buf, &limit, NO_PADDING); + return s_tobin(z, buf, &limit, NO_PADDING); } /* }}} */ /* {{{ mp_int_read_unsigned(z, buf, len) */ -mp_result mp_int_read_unsigned(mp_int z, unsigned char *buf, int len) +mp_result +mp_int_read_unsigned(mp_int z, unsigned char *buf, int len) { - mp_size need, i; - unsigned char *tmp; - mp_digit *dz; + mp_size need, + i; + unsigned char *tmp; + mp_digit *dz; - CHECK(z != NULL && buf != NULL && len > 0); + CHECK(z != NULL && buf != NULL && len > 0); - /* Figure out how many digits are needed to represent this value */ - need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT; - if(!s_pad(z, need)) - return MP_MEMORY; + /* Figure out how many digits are needed to represent this value */ + need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT; + if (!s_pad(z, need)) + return MP_MEMORY; - mp_int_zero(z); + mp_int_zero(z); - dz = MP_DIGITS(z); - for(tmp = buf, i = len; i > 0; --i, ++tmp) { - (void) s_qmul(z, CHAR_BIT); - *dz |= *tmp; - } + dz = MP_DIGITS(z); + for (tmp = buf, i = len; i > 0; --i, ++tmp) + { + (void) s_qmul(z, CHAR_BIT); + *dz |= *tmp; + } - return MP_OK; + return MP_OK; } /* }}} */ /* {{{ mp_int_unsigned_len(z) */ -mp_result mp_int_unsigned_len(mp_int z) +mp_result +mp_int_unsigned_len(mp_int z) { - mp_result res = mp_int_count_bits(z); - int bytes; + mp_result res = mp_int_count_bits(z); + int bytes; - if(res <= 0) - return res; + if (res <= 0) + return res; - bytes = (res + (CHAR_BIT - 1)) / CHAR_BIT; + bytes = (res + (CHAR_BIT - 1)) / CHAR_BIT; - return bytes; + return bytes; } /* }}} */ /* {{{ mp_error_string(res) */ -const char *mp_error_string(mp_result res) +const char * +mp_error_string(mp_result res) { - int ix; - if(res > 0) - return s_unknown_err; + int ix; + + if (res > 0) + return s_unknown_err; - res = -res; - for(ix = 0; ix < res && s_error_msg[ix] != NULL; ++ix) - ; + res = -res; + for (ix = 0; ix < res && s_error_msg[ix] != NULL; ++ix) + ; - if(s_error_msg[ix] != NULL) - return s_error_msg[ix]; - else - return s_unknown_err; + if (s_error_msg[ix] != NULL) + return s_error_msg[ix]; + else + return s_unknown_err; } /* }}} */ /*------------------------------------------------------------------------*/ -/* Private functions for internal use. These make assumptions. */ +/* Private functions for internal use. These make assumptions. */ /* {{{ s_alloc(num) */ -static mp_digit *s_alloc(mp_size num) +static mp_digit * +s_alloc(mp_size num) { - mp_digit *out = px_alloc(num * sizeof(mp_digit)); + mp_digit *out = px_alloc(num * sizeof(mp_digit)); - assert(out != NULL); /* for debugging */ + assert(out != NULL); /* for debugging */ - return out; + return out; } /* }}} */ /* {{{ s_realloc(old, num) */ -static mp_digit *s_realloc(mp_digit *old, mp_size num) +static mp_digit * +s_realloc(mp_digit * old, mp_size num) { - mp_digit *new = px_realloc(old, num * sizeof(mp_digit)); + mp_digit *new = px_realloc(old, num * sizeof(mp_digit)); - assert(new != NULL); /* for debugging */ + assert(new != NULL); /* for debugging */ - return new; + return new; } /* }}} */ @@ -2071,9 +2308,10 @@ static mp_digit *s_realloc(mp_digit *old, mp_size num) /* {{{ s_free(ptr) */ #if TRACEABLE_FREE -static void s_free(void *ptr) +static void +s_free(void *ptr) { - px_free(ptr); + px_free(ptr); } #endif @@ -2081,20 +2319,22 @@ static void s_free(void *ptr) /* {{{ s_pad(z, min) */ -static int s_pad(mp_int z, mp_size min) +static int +s_pad(mp_int z, mp_size min) { - if(MP_ALLOC(z) < min) { - mp_size nsize = ROUND_PREC(min); - mp_digit *tmp = s_realloc(MP_DIGITS(z), nsize); + if (MP_ALLOC(z) < min) + { + mp_size nsize = ROUND_PREC(min); + mp_digit *tmp = s_realloc(MP_DIGITS(z), nsize); - if(tmp == NULL) - return 0; + if (tmp == NULL) + return 0; - MP_DIGITS(z) = tmp; - MP_ALLOC(z) = nsize; - } + MP_DIGITS(z) = tmp; + MP_ALLOC(z) = nsize; + } - return 1; + return 1; } /* }}} */ @@ -2102,15 +2342,16 @@ static int s_pad(mp_int z, mp_size min) /* {{{ s_clamp(z) */ #if TRACEABLE_CLAMP -static void s_clamp(mp_int z) +static void +s_clamp(mp_int z) { - mp_size uz = MP_USED(z); - mp_digit *zd = MP_DIGITS(z) + uz - 1; + mp_size uz = MP_USED(z); + mp_digit *zd = MP_DIGITS(z) + uz - 1; - while(uz > 1 && (*zd-- == 0)) - --uz; + while (uz > 1 && (*zd-- == 0)) + --uz; - MP_USED(z) = uz; + MP_USED(z) = uz; } #endif @@ -2118,614 +2359,711 @@ static void s_clamp(mp_int z) /* {{{ s_fake(z, value, vbuf) */ -static void s_fake(mp_int z, int value, mp_digit vbuf[]) +static void +s_fake(mp_int z, int value, mp_digit vbuf[]) { - mp_size uv = (mp_size)s_vpack(value, vbuf); + mp_size uv = (mp_size) s_vpack(value, vbuf); - z->used = uv; - z->alloc = MP_VALUE_DIGITS(value); - z->sign = (value < 0) ? MP_NEG : MP_ZPOS; - z->digits = vbuf; + z->used = uv; + z->alloc = MP_VALUE_DIGITS(value); + z->sign = (value < 0) ? MP_NEG : MP_ZPOS; + z->digits = vbuf; } /* }}} */ /* {{{ s_cdig(da, db, len) */ -static int s_cdig(mp_digit *da, mp_digit *db, mp_size len) +static int +s_cdig(mp_digit * da, mp_digit * db, mp_size len) { - mp_digit *dat = da + len - 1, *dbt = db + len - 1; + mp_digit *dat = da + len - 1, + *dbt = db + len - 1; - for(/* */; len != 0; --len, --dat, --dbt) { - if(*dat > *dbt) - return 1; - else if(*dat < *dbt) - return -1; - } + for ( /* */ ; len != 0; --len, --dat, --dbt) + { + if (*dat > *dbt) + return 1; + else if (*dat < *dbt) + return -1; + } - return 0; + return 0; } /* }}} */ /* {{{ s_vpack(v, t[]) */ -static int s_vpack(int v, mp_digit t[]) -{ - unsigned int uv = (unsigned int)((v < 0) ? -v : v); - int ndig = 0; - - if(uv == 0) - t[ndig++] = 0; - else { - while(uv != 0) { - t[ndig++] = (mp_digit) uv; - uv >>= MP_DIGIT_BIT/2; - uv >>= MP_DIGIT_BIT/2; - } - } +static int +s_vpack(int v, mp_digit t[]) +{ + unsigned int uv = (unsigned int) ((v < 0) ? -v : v); + int ndig = 0; + + if (uv == 0) + t[ndig++] = 0; + else + { + while (uv != 0) + { + t[ndig++] = (mp_digit) uv; + uv >>= MP_DIGIT_BIT / 2; + uv >>= MP_DIGIT_BIT / 2; + } + } - return ndig; + return ndig; } /* }}} */ /* {{{ s_ucmp(a, b) */ -static int s_ucmp(mp_int a, mp_int b) +static int +s_ucmp(mp_int a, mp_int b) { - mp_size ua = MP_USED(a), ub = MP_USED(b); - - if(ua > ub) - return 1; - else if(ub > ua) - return -1; - else - return s_cdig(MP_DIGITS(a), MP_DIGITS(b), ua); + mp_size ua = MP_USED(a), + ub = MP_USED(b); + + if (ua > ub) + return 1; + else if (ub > ua) + return -1; + else + return s_cdig(MP_DIGITS(a), MP_DIGITS(b), ua); } /* }}} */ /* {{{ s_vcmp(a, v) */ -static int s_vcmp(mp_int a, int v) +static int +s_vcmp(mp_int a, int v) { - mp_digit vdig[MP_VALUE_DIGITS(v)]; - int ndig = 0; - mp_size ua = MP_USED(a); + mp_digit vdig[MP_VALUE_DIGITS(v)]; + int ndig = 0; + mp_size ua = MP_USED(a); - ndig = s_vpack(v, vdig); + ndig = s_vpack(v, vdig); - if(ua > ndig) - return 1; - else if(ua < ndig) - return -1; - else - return s_cdig(MP_DIGITS(a), vdig, ndig); + if (ua > ndig) + return 1; + else if (ua < ndig) + return -1; + else + return s_cdig(MP_DIGITS(a), vdig, ndig); } /* }}} */ /* {{{ s_uadd(da, db, dc, size_a, size_b) */ -static mp_digit s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b) +static mp_digit +s_uadd(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b) { - mp_size pos; - mp_word w = 0; + mp_size pos; + mp_word w = 0; - /* Insure that da is the longer of the two to simplify later code */ - if(size_b > size_a) { - SWAP(mp_digit *, da, db); - SWAP(mp_size, size_a, size_b); - } + /* Insure that da is the longer of the two to simplify later code */ + if (size_b > size_a) + { + SWAP(mp_digit *, da, db); + SWAP(mp_size, size_a, size_b); + } - /* Add corresponding digits until the shorter number runs out */ - for(pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc) { - w = w + (mp_word)*da + (mp_word)*db; - *dc = LOWER_HALF(w); - w = UPPER_HALF(w); - } + /* Add corresponding digits until the shorter number runs out */ + for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc) + { + w = w + (mp_word) * da + (mp_word) * db; + *dc = LOWER_HALF(w); + w = UPPER_HALF(w); + } - /* Propagate carries as far as necessary */ - for(/* */; pos < size_a; ++pos, ++da, ++dc) { - w = w + *da; + /* Propagate carries as far as necessary */ + for ( /* */ ; pos < size_a; ++pos, ++da, ++dc) + { + w = w + *da; - *dc = LOWER_HALF(w); - w = UPPER_HALF(w); - } + *dc = LOWER_HALF(w); + w = UPPER_HALF(w); + } - /* Return carry out */ - return (mp_digit)w; + /* Return carry out */ + return (mp_digit) w; } /* }}} */ /* {{{ s_usub(da, db, dc, size_a, size_b) */ -static void s_usub(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b) +static void +s_usub(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b) { - mp_size pos; - mp_word w = 0; + mp_size pos; + mp_word w = 0; - /* We assume that |a| >= |b| so this should definitely hold */ - assert(size_a >= size_b); + /* We assume that |a| >= |b| so this should definitely hold */ + assert(size_a >= size_b); - /* Subtract corresponding digits and propagate borrow */ - for(pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc) { - w = ((mp_word)MP_DIGIT_MAX + 1 + /* MP_RADIX */ - (mp_word)*da) - w - (mp_word)*db; + /* Subtract corresponding digits and propagate borrow */ + for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc) + { + w = ((mp_word) MP_DIGIT_MAX + 1 + /* MP_RADIX */ + (mp_word) * da) - w - (mp_word) * db; - *dc = LOWER_HALF(w); - w = (UPPER_HALF(w) == 0); - } + *dc = LOWER_HALF(w); + w = (UPPER_HALF(w) == 0); + } - /* Finish the subtraction for remaining upper digits of da */ - for(/* */; pos < size_a; ++pos, ++da, ++dc) { - w = ((mp_word)MP_DIGIT_MAX + 1 + /* MP_RADIX */ - (mp_word)*da) - w; + /* Finish the subtraction for remaining upper digits of da */ + for ( /* */ ; pos < size_a; ++pos, ++da, ++dc) + { + w = ((mp_word) MP_DIGIT_MAX + 1 + /* MP_RADIX */ + (mp_word) * da) - w; - *dc = LOWER_HALF(w); - w = (UPPER_HALF(w) == 0); - } + *dc = LOWER_HALF(w); + w = (UPPER_HALF(w) == 0); + } - /* If there is a borrow out at the end, it violates the precondition */ - assert(w == 0); + /* If there is a borrow out at the end, it violates the precondition */ + assert(w == 0); } /* }}} */ /* {{{ s_kmul(da, db, dc, size_a, size_b) */ -static int s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b) +static int +s_kmul(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b) { - mp_size bot_size; - - /* Make sure b is the smaller of the two input values */ - if(size_b > size_a) { - SWAP(mp_digit *, da, db); - SWAP(mp_size, size_a, size_b); - } - - /* Insure that the bottom is the larger half in an odd-length split; - the code below relies on this being true. - */ - bot_size = (size_a + 1) / 2; - - /* If the values are big enough to bother with recursion, use the - Karatsuba algorithm to compute the product; otherwise use the - normal multiplication algorithm - */ - if(multiply_threshold && - size_a >= multiply_threshold && - size_b > bot_size) { - - mp_digit *t1, *t2, *t3, carry; - - mp_digit *a_top = da + bot_size; - mp_digit *b_top = db + bot_size; - - mp_size at_size = size_a - bot_size; - mp_size bt_size = size_b - bot_size; - mp_size buf_size = 2 * bot_size; - - /* Do a single allocation for all three temporary buffers needed; - each buffer must be big enough to hold the product of two - bottom halves, and one buffer needs space for the completed - product; twice the space is plenty. - */ - if((t1 = s_alloc(4 * buf_size)) == NULL) return 0; - t2 = t1 + buf_size; - t3 = t2 + buf_size; - ZERO(t1, 4 * buf_size); + mp_size bot_size; - /* t1 and t2 are initially used as temporaries to compute the inner product - (a1 + a0)(b1 + b0) = a1b1 + a1b0 + a0b1 + a0b0 - */ - carry = s_uadd(da, a_top, t1, bot_size, at_size); /* t1 = a1 + a0 */ - t1[bot_size] = carry; - - carry = s_uadd(db, b_top, t2, bot_size, bt_size); /* t2 = b1 + b0 */ - t2[bot_size] = carry; - - (void) s_kmul(t1, t2, t3, bot_size + 1, bot_size + 1); /* t3 = t1 * t2 */ - - /* Now we'll get t1 = a0b0 and t2 = a1b1, and subtract them out so that - we're left with only the pieces we want: t3 = a1b0 + a0b1 - */ - ZERO(t1, bot_size + 1); - ZERO(t2, bot_size + 1); - (void) s_kmul(da, db, t1, bot_size, bot_size); /* t1 = a0 * b0 */ - (void) s_kmul(a_top, b_top, t2, at_size, bt_size); /* t2 = a1 * b1 */ - - /* Subtract out t1 and t2 to get the inner product */ - s_usub(t3, t1, t3, buf_size + 2, buf_size); - s_usub(t3, t2, t3, buf_size + 2, buf_size); - - /* Assemble the output value */ - COPY(t1, dc, buf_size); - (void) s_uadd(t3, dc + bot_size, dc + bot_size, - buf_size + 1, buf_size + 1); + /* Make sure b is the smaller of the two input values */ + if (size_b > size_a) + { + SWAP(mp_digit *, da, db); + SWAP(mp_size, size_a, size_b); + } - (void) s_uadd(t2, dc + 2*bot_size, dc + 2*bot_size, - buf_size, buf_size); - - s_free(t1); /* note t2 and t3 are just internal pointers to t1 */ - } - else { - s_umul(da, db, dc, size_a, size_b); - } + /* + * Insure that the bottom is the larger half in an odd-length split; the + * code below relies on this being true. + */ + bot_size = (size_a + 1) / 2; + + /* + * If the values are big enough to bother with recursion, use the + * Karatsuba algorithm to compute the product; otherwise use the normal + * multiplication algorithm + */ + if (multiply_threshold && + size_a >= multiply_threshold && + size_b > bot_size) + { + + mp_digit *t1, + *t2, + *t3, + carry; + + mp_digit *a_top = da + bot_size; + mp_digit *b_top = db + bot_size; + + mp_size at_size = size_a - bot_size; + mp_size bt_size = size_b - bot_size; + mp_size buf_size = 2 * bot_size; + + /* + * Do a single allocation for all three temporary buffers needed; each + * buffer must be big enough to hold the product of two bottom halves, + * and one buffer needs space for the completed product; twice the + * space is plenty. + */ + if ((t1 = s_alloc(4 * buf_size)) == NULL) + return 0; + t2 = t1 + buf_size; + t3 = t2 + buf_size; + ZERO(t1, 4 * buf_size); + + /* + * t1 and t2 are initially used as temporaries to compute the inner + * product (a1 + a0)(b1 + b0) = a1b1 + a1b0 + a0b1 + a0b0 + */ + carry = s_uadd(da, a_top, t1, bot_size, at_size); /* t1 = a1 + a0 */ + t1[bot_size] = carry; + + carry = s_uadd(db, b_top, t2, bot_size, bt_size); /* t2 = b1 + b0 */ + t2[bot_size] = carry; + + (void) s_kmul(t1, t2, t3, bot_size + 1, bot_size + 1); /* t3 = t1 * t2 */ + + /* + * Now we'll get t1 = a0b0 and t2 = a1b1, and subtract them out so + * that we're left with only the pieces we want: t3 = a1b0 + a0b1 + */ + ZERO(t1, bot_size + 1); + ZERO(t2, bot_size + 1); + (void) s_kmul(da, db, t1, bot_size, bot_size); /* t1 = a0 * b0 */ + (void) s_kmul(a_top, b_top, t2, at_size, bt_size); /* t2 = a1 * b1 */ + + /* Subtract out t1 and t2 to get the inner product */ + s_usub(t3, t1, t3, buf_size + 2, buf_size); + s_usub(t3, t2, t3, buf_size + 2, buf_size); + + /* Assemble the output value */ + COPY(t1, dc, buf_size); + (void) s_uadd(t3, dc + bot_size, dc + bot_size, + buf_size + 1, buf_size + 1); + + (void) s_uadd(t2, dc + 2 * bot_size, dc + 2 * bot_size, + buf_size, buf_size); + + s_free(t1); /* note t2 and t3 are just internal pointers + * to t1 */ + } + else + { + s_umul(da, db, dc, size_a, size_b); + } - return 1; + return 1; } /* }}} */ /* {{{ s_umul(da, db, dc, size_a, size_b) */ -static void s_umul(mp_digit *da, mp_digit *db, mp_digit *dc, - mp_size size_a, mp_size size_b) +static void +s_umul(mp_digit * da, mp_digit * db, mp_digit * dc, + mp_size size_a, mp_size size_b) { - mp_size a, b; - mp_word w; + mp_size a, + b; + mp_word w; - for(a = 0; a < size_a; ++a, ++dc, ++da) { - mp_digit *dct = dc; - mp_digit *dbt = db; + for (a = 0; a < size_a; ++a, ++dc, ++da) + { + mp_digit *dct = dc; + mp_digit *dbt = db; - if(*da == 0) - continue; + if (*da == 0) + continue; - w = 0; - for(b = 0; b < size_b; ++b, ++dbt, ++dct) { - w = (mp_word)*da * (mp_word)*dbt + w + (mp_word)*dct; + w = 0; + for (b = 0; b < size_b; ++b, ++dbt, ++dct) + { + w = (mp_word) * da * (mp_word) * dbt + w + (mp_word) * dct; - *dct = LOWER_HALF(w); - w = UPPER_HALF(w); - } + *dct = LOWER_HALF(w); + w = UPPER_HALF(w); + } - *dct = (mp_digit)w; - } + *dct = (mp_digit) w; + } } /* }}} */ /* {{{ s_ksqr(da, dc, size_a) */ -static int s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a) -{ - if(multiply_threshold && size_a > multiply_threshold) { - mp_size bot_size = (size_a + 1) / 2; - mp_digit *a_top = da + bot_size; - mp_digit *t1, *t2, *t3; - mp_size at_size = size_a - bot_size; - mp_size buf_size = 2 * bot_size; - - if((t1 = s_alloc(4 * buf_size)) == NULL) return 0; - t2 = t1 + buf_size; - t3 = t2 + buf_size; - ZERO(t1, 4 * buf_size); - - (void) s_ksqr(da, t1, bot_size); /* t1 = a0 ^ 2 */ - (void) s_ksqr(a_top, t2, at_size); /* t2 = a1 ^ 2 */ - - (void) s_kmul(da, a_top, t3, bot_size, at_size); /* t3 = a0 * a1 */ - - /* Quick multiply t3 by 2, shifting left (can't overflow) */ - { - int i, top = bot_size + at_size; - mp_word w, save = 0; +static int +s_ksqr(mp_digit * da, mp_digit * dc, mp_size size_a) +{ + if (multiply_threshold && size_a > multiply_threshold) + { + mp_size bot_size = (size_a + 1) / 2; + mp_digit *a_top = da + bot_size; + mp_digit *t1, + *t2, + *t3; + mp_size at_size = size_a - bot_size; + mp_size buf_size = 2 * bot_size; + + if ((t1 = s_alloc(4 * buf_size)) == NULL) + return 0; + t2 = t1 + buf_size; + t3 = t2 + buf_size; + ZERO(t1, 4 * buf_size); + + (void) s_ksqr(da, t1, bot_size); /* t1 = a0 ^ 2 */ + (void) s_ksqr(a_top, t2, at_size); /* t2 = a1 ^ 2 */ + + (void) s_kmul(da, a_top, t3, bot_size, at_size); /* t3 = a0 * a1 */ + + /* Quick multiply t3 by 2, shifting left (can't overflow) */ + { + int i, + top = bot_size + at_size; + mp_word w, + save = 0; + + for (i = 0; i < top; ++i) + { + w = t3[i]; + w = (w << 1) | save; + t3[i] = LOWER_HALF(w); + save = UPPER_HALF(w); + } + t3[i] = LOWER_HALF(save); + } + + /* Assemble the output value */ + COPY(t1, dc, 2 * bot_size); + (void) s_uadd(t3, dc + bot_size, dc + bot_size, + buf_size + 1, buf_size + 1); + + (void) s_uadd(t2, dc + 2 * bot_size, dc + 2 * bot_size, + buf_size, buf_size); + + px_free(t1); /* note that t2 and t2 are internal pointers + * only */ - for(i = 0; i < top; ++i) { - w = t3[i]; - w = (w << 1) | save; - t3[i] = LOWER_HALF(w); - save = UPPER_HALF(w); - } - t3[i] = LOWER_HALF(save); - } - - /* Assemble the output value */ - COPY(t1, dc, 2 * bot_size); - (void) s_uadd(t3, dc + bot_size, dc + bot_size, - buf_size + 1, buf_size + 1); - - (void) s_uadd(t2, dc + 2*bot_size, dc + 2*bot_size, - buf_size, buf_size); - - px_free(t1); /* note that t2 and t2 are internal pointers only */ - - } - else { - s_usqr(da, dc, size_a); - } + } + else + { + s_usqr(da, dc, size_a); + } - return 1; + return 1; } /* }}} */ /* {{{ s_usqr(da, dc, size_a) */ -static void s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a) -{ - mp_size i, j; - mp_word w; - - for(i = 0; i < size_a; ++i, dc += 2, ++da) { - mp_digit *dct = dc, *dat = da; - - if(*da == 0) - continue; - - /* Take care of the first digit, no rollover */ - w = (mp_word)*dat * (mp_word)*dat + (mp_word)*dct; - *dct = LOWER_HALF(w); - w = UPPER_HALF(w); - ++dat; ++dct; - - for(j = i + 1; j < size_a; ++j, ++dat, ++dct) { - mp_word t = (mp_word)*da * (mp_word)*dat; - mp_word u = w + (mp_word)*dct, ov = 0; - - /* Check if doubling t will overflow a word */ - if(HIGH_BIT_SET(t)) - ov = 1; - - w = t + t; - - /* Check if adding u to w will overflow a word */ - if(ADD_WILL_OVERFLOW(w, u)) - ov = 1; - - w += u; - - *dct = LOWER_HALF(w); - w = UPPER_HALF(w); - if(ov) { - w += MP_DIGIT_MAX; /* MP_RADIX */ - ++w; - } - } - - w = w + *dct; - *dct = (mp_digit)w; - while((w = UPPER_HALF(w)) != 0) { - ++dct; w = w + *dct; - *dct = LOWER_HALF(w); - } - - assert(w == 0); - } +static void +s_usqr(mp_digit * da, mp_digit * dc, mp_size size_a) +{ + mp_size i, + j; + mp_word w; + + for (i = 0; i < size_a; ++i, dc += 2, ++da) + { + mp_digit *dct = dc, + *dat = da; + + if (*da == 0) + continue; + + /* Take care of the first digit, no rollover */ + w = (mp_word) * dat * (mp_word) * dat + (mp_word) * dct; + *dct = LOWER_HALF(w); + w = UPPER_HALF(w); + ++dat; + ++dct; + + for (j = i + 1; j < size_a; ++j, ++dat, ++dct) + { + mp_word t = (mp_word) * da * (mp_word) * dat; + mp_word u = w + (mp_word) * dct, + ov = 0; + + /* Check if doubling t will overflow a word */ + if (HIGH_BIT_SET(t)) + ov = 1; + + w = t + t; + + /* Check if adding u to w will overflow a word */ + if (ADD_WILL_OVERFLOW(w, u)) + ov = 1; + + w += u; + + *dct = LOWER_HALF(w); + w = UPPER_HALF(w); + if (ov) + { + w += MP_DIGIT_MAX; /* MP_RADIX */ + ++w; + } + } + + w = w + *dct; + *dct = (mp_digit) w; + while ((w = UPPER_HALF(w)) != 0) + { + ++dct; + w = w + *dct; + *dct = LOWER_HALF(w); + } + + assert(w == 0); + } } /* }}} */ /* {{{ s_dadd(a, b) */ -static void s_dadd(mp_int a, mp_digit b) +static void +s_dadd(mp_int a, mp_digit b) { - mp_word w = 0; - mp_digit *da = MP_DIGITS(a); - mp_size ua = MP_USED(a); + mp_word w = 0; + mp_digit *da = MP_DIGITS(a); + mp_size ua = MP_USED(a); - w = (mp_word)*da + b; - *da++ = LOWER_HALF(w); - w = UPPER_HALF(w); + w = (mp_word) * da + b; + *da++ = LOWER_HALF(w); + w = UPPER_HALF(w); - for(ua -= 1; ua > 0; --ua, ++da) { - w = (mp_word)*da + w; + for (ua -= 1; ua > 0; --ua, ++da) + { + w = (mp_word) * da + w; - *da = LOWER_HALF(w); - w = UPPER_HALF(w); - } + *da = LOWER_HALF(w); + w = UPPER_HALF(w); + } - if(w) { - *da = (mp_digit)w; - MP_USED(a) += 1; - } + if (w) + { + *da = (mp_digit) w; + MP_USED(a) += 1; + } } /* }}} */ /* {{{ s_dmul(a, b) */ -static void s_dmul(mp_int a, mp_digit b) +static void +s_dmul(mp_int a, mp_digit b) { - mp_word w = 0; - mp_digit *da = MP_DIGITS(a); - mp_size ua = MP_USED(a); + mp_word w = 0; + mp_digit *da = MP_DIGITS(a); + mp_size ua = MP_USED(a); - while(ua > 0) { - w = (mp_word)*da * b + w; - *da++ = LOWER_HALF(w); - w = UPPER_HALF(w); - --ua; - } + while (ua > 0) + { + w = (mp_word) * da * b + w; + *da++ = LOWER_HALF(w); + w = UPPER_HALF(w); + --ua; + } - if(w) { - *da = (mp_digit)w; - MP_USED(a) += 1; - } + if (w) + { + *da = (mp_digit) w; + MP_USED(a) += 1; + } } /* }}} */ /* {{{ s_dbmul(da, b, dc, size_a) */ -static void s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc, mp_size size_a) +static void +s_dbmul(mp_digit * da, mp_digit b, mp_digit * dc, mp_size size_a) { - mp_word w = 0; + mp_word w = 0; - while(size_a > 0) { - w = (mp_word)*da++ * (mp_word)b + w; + while (size_a > 0) + { + w = (mp_word) * da++ * (mp_word) b + w; - *dc++ = LOWER_HALF(w); - w = UPPER_HALF(w); - --size_a; - } + *dc++ = LOWER_HALF(w); + w = UPPER_HALF(w); + --size_a; + } - if(w) - *dc = LOWER_HALF(w); + if (w) + *dc = LOWER_HALF(w); } /* }}} */ /* {{{ s_ddiv(da, d, dc, size_a) */ -static mp_digit s_ddiv(mp_int a, mp_digit b) -{ - mp_word w = 0, qdigit; - mp_size ua = MP_USED(a); - mp_digit *da = MP_DIGITS(a) + ua - 1; - - for(/* */; ua > 0; --ua, --da) { - w = (w << MP_DIGIT_BIT) | *da; - - if(w >= b) { - qdigit = w / b; - w = w % b; - } - else { - qdigit = 0; - } - - *da = (mp_digit)qdigit; - } +static mp_digit +s_ddiv(mp_int a, mp_digit b) +{ + mp_word w = 0, + qdigit; + mp_size ua = MP_USED(a); + mp_digit *da = MP_DIGITS(a) + ua - 1; + + for ( /* */ ; ua > 0; --ua, --da) + { + w = (w << MP_DIGIT_BIT) | *da; + + if (w >= b) + { + qdigit = w / b; + w = w % b; + } + else + { + qdigit = 0; + } + + *da = (mp_digit) qdigit; + } - CLAMP(a); - return (mp_digit)w; + CLAMP(a); + return (mp_digit) w; } /* }}} */ /* {{{ s_qdiv(z, p2) */ -static void s_qdiv(mp_int z, mp_size p2) +static void +s_qdiv(mp_int z, mp_size p2) { - mp_size ndig = p2 / MP_DIGIT_BIT, nbits = p2 % MP_DIGIT_BIT; - mp_size uz = MP_USED(z); + mp_size ndig = p2 / MP_DIGIT_BIT, + nbits = p2 % MP_DIGIT_BIT; + mp_size uz = MP_USED(z); - if(ndig) { - mp_size mark; - mp_digit *to, *from; + if (ndig) + { + mp_size mark; + mp_digit *to, + *from; - if(ndig >= uz) { - mp_int_zero(z); - return; - } + if (ndig >= uz) + { + mp_int_zero(z); + return; + } - to = MP_DIGITS(z); from = to + ndig; + to = MP_DIGITS(z); + from = to + ndig; - for(mark = ndig; mark < uz; ++mark) - *to++ = *from++; + for (mark = ndig; mark < uz; ++mark) + *to++ = *from++; - MP_USED(z) = uz - ndig; - } + MP_USED(z) = uz - ndig; + } - if(nbits) { - mp_digit d = 0, *dz, save; - mp_size up = MP_DIGIT_BIT - nbits; + if (nbits) + { + mp_digit d = 0, + *dz, + save; + mp_size up = MP_DIGIT_BIT - nbits; - uz = MP_USED(z); - dz = MP_DIGITS(z) + uz - 1; + uz = MP_USED(z); + dz = MP_DIGITS(z) + uz - 1; - for(/* */; uz > 0; --uz, --dz) { - save = *dz; + for ( /* */ ; uz > 0; --uz, --dz) + { + save = *dz; - *dz = (*dz >> nbits) | (d << up); - d = save; - } + *dz = (*dz >> nbits) | (d << up); + d = save; + } - CLAMP(z); - } + CLAMP(z); + } - if(MP_USED(z) == 1 && z->digits[0] == 0) - MP_SIGN(z) = MP_ZPOS; + if (MP_USED(z) == 1 && z->digits[0] == 0) + MP_SIGN(z) = MP_ZPOS; } /* }}} */ /* {{{ s_qmod(z, p2) */ -static void s_qmod(mp_int z, mp_size p2) +static void +s_qmod(mp_int z, mp_size p2) { - mp_size start = p2 / MP_DIGIT_BIT + 1, rest = p2 % MP_DIGIT_BIT; - mp_size uz = MP_USED(z); - mp_digit mask = (1 << rest) - 1; + mp_size start = p2 / MP_DIGIT_BIT + 1, + rest = p2 % MP_DIGIT_BIT; + mp_size uz = MP_USED(z); + mp_digit mask = (1 << rest) - 1; - if(start <= uz) { - MP_USED(z) = start; - z->digits[start - 1] &= mask; - CLAMP(z); - } + if (start <= uz) + { + MP_USED(z) = start; + z->digits[start - 1] &= mask; + CLAMP(z); + } } /* }}} */ /* {{{ s_qmul(z, p2) */ -static int s_qmul(mp_int z, mp_size p2) -{ - mp_size uz, need, rest, extra, i; - mp_digit *from, *to, d; - - if(p2 == 0) - return 1; - - uz = MP_USED(z); - need = p2 / MP_DIGIT_BIT; rest = p2 % MP_DIGIT_BIT; - - /* Figure out if we need an extra digit at the top end; this occurs - if the topmost `rest' bits of the high-order digit of z are not - zero, meaning they will be shifted off the end if not preserved */ - extra = 0; - if(rest != 0) { - mp_digit *dz = MP_DIGITS(z) + uz - 1; - - if((*dz >> (MP_DIGIT_BIT - rest)) != 0) - extra = 1; - } - - if(!s_pad(z, uz + need + extra)) - return 0; +static int +s_qmul(mp_int z, mp_size p2) +{ + mp_size uz, + need, + rest, + extra, + i; + mp_digit *from, + *to, + d; + + if (p2 == 0) + return 1; + + uz = MP_USED(z); + need = p2 / MP_DIGIT_BIT; + rest = p2 % MP_DIGIT_BIT; + + /* + * Figure out if we need an extra digit at the top end; this occurs if the + * topmost `rest' bits of the high-order digit of z are not zero, meaning + * they will be shifted off the end if not preserved + */ + extra = 0; + if (rest != 0) + { + mp_digit *dz = MP_DIGITS(z) + uz - 1; + + if ((*dz >> (MP_DIGIT_BIT - rest)) != 0) + extra = 1; + } - /* If we need to shift by whole digits, do that in one pass, then - to back and shift by partial digits. - */ - if(need > 0) { - from = MP_DIGITS(z) + uz - 1; - to = from + need; + if (!s_pad(z, uz + need + extra)) + return 0; - for(i = 0; i < uz; ++i) - *to-- = *from--; + /* + * If we need to shift by whole digits, do that in one pass, then to back + * and shift by partial digits. + */ + if (need > 0) + { + from = MP_DIGITS(z) + uz - 1; + to = from + need; - ZERO(MP_DIGITS(z), need); - uz += need; - } + for (i = 0; i < uz; ++i) + *to-- = *from--; - if(rest) { - d = 0; - for(i = need, from = MP_DIGITS(z) + need; i < uz; ++i, ++from) { - mp_digit save = *from; - - *from = (*from << rest) | (d >> (MP_DIGIT_BIT - rest)); - d = save; - } + ZERO(MP_DIGITS(z), need); + uz += need; + } - d >>= (MP_DIGIT_BIT - rest); - if(d != 0) { - *from = d; - uz += extra; - } - } + if (rest) + { + d = 0; + for (i = need, from = MP_DIGITS(z) + need; i < uz; ++i, ++from) + { + mp_digit save = *from; + + *from = (*from << rest) | (d >> (MP_DIGIT_BIT - rest)); + d = save; + } + + d >>= (MP_DIGIT_BIT - rest); + if (d != 0) + { + *from = d; + uz += extra; + } + } - MP_USED(z) = uz; - CLAMP(z); + MP_USED(z) = uz; + CLAMP(z); - return 1; + return 1; } /* }}} */ @@ -2733,190 +3071,218 @@ static int s_qmul(mp_int z, mp_size p2) /* {{{ s_qsub(z, p2) */ /* Subtract |z| from 2^p2, assuming 2^p2 > |z|, and set z to be positive */ -static int s_qsub(mp_int z, mp_size p2) +static int +s_qsub(mp_int z, mp_size p2) { - mp_digit hi = (1 << (p2 % MP_DIGIT_BIT)), *zp; - mp_size tdig = (p2 / MP_DIGIT_BIT), pos; - mp_word w = 0; + mp_digit hi = (1 << (p2 % MP_DIGIT_BIT)), + *zp; + mp_size tdig = (p2 / MP_DIGIT_BIT), + pos; + mp_word w = 0; - if(!s_pad(z, tdig + 1)) - return 0; + if (!s_pad(z, tdig + 1)) + return 0; - for(pos = 0, zp = MP_DIGITS(z); pos < tdig; ++pos, ++zp) { - w = ((mp_word) MP_DIGIT_MAX + 1) - w - (mp_word)*zp; + for (pos = 0, zp = MP_DIGITS(z); pos < tdig; ++pos, ++zp) + { + w = ((mp_word) MP_DIGIT_MAX + 1) - w - (mp_word) * zp; - *zp = LOWER_HALF(w); - w = UPPER_HALF(w) ? 0 : 1; - } + *zp = LOWER_HALF(w); + w = UPPER_HALF(w) ? 0 : 1; + } + + w = ((mp_word) MP_DIGIT_MAX + 1 + hi) - w - (mp_word) * zp; + *zp = LOWER_HALF(w); - w = ((mp_word) MP_DIGIT_MAX + 1 + hi) - w - (mp_word)*zp; - *zp = LOWER_HALF(w); + assert(UPPER_HALF(w) != 0); /* no borrow out should be possible */ - assert(UPPER_HALF(w) != 0); /* no borrow out should be possible */ - - MP_SIGN(z) = MP_ZPOS; - CLAMP(z); + MP_SIGN(z) = MP_ZPOS; + CLAMP(z); - return 1; + return 1; } /* }}} */ /* {{{ s_dp2k(z) */ -static int s_dp2k(mp_int z) +static int +s_dp2k(mp_int z) { - int k = 0; - mp_digit *dp = MP_DIGITS(z), d; + int k = 0; + mp_digit *dp = MP_DIGITS(z), + d; - if(MP_USED(z) == 1 && *dp == 0) - return 1; + if (MP_USED(z) == 1 && *dp == 0) + return 1; - while(*dp == 0) { - k += MP_DIGIT_BIT; - ++dp; - } - - d = *dp; - while((d & 1) == 0) { - d >>= 1; - ++k; - } + while (*dp == 0) + { + k += MP_DIGIT_BIT; + ++dp; + } - return k; + d = *dp; + while ((d & 1) == 0) + { + d >>= 1; + ++k; + } + + return k; } /* }}} */ /* {{{ s_isp2(z) */ -static int s_isp2(mp_int z) +static int +s_isp2(mp_int z) { - mp_size uz = MP_USED(z), k = 0; - mp_digit *dz = MP_DIGITS(z), d; + mp_size uz = MP_USED(z), + k = 0; + mp_digit *dz = MP_DIGITS(z), + d; - while(uz > 1) { - if(*dz++ != 0) - return -1; - k += MP_DIGIT_BIT; - --uz; - } + while (uz > 1) + { + if (*dz++ != 0) + return -1; + k += MP_DIGIT_BIT; + --uz; + } - d = *dz; - while(d > 1) { - if(d & 1) - return -1; - ++k; d >>= 1; - } + d = *dz; + while (d > 1) + { + if (d & 1) + return -1; + ++k; + d >>= 1; + } - return (int) k; + return (int) k; } /* }}} */ /* {{{ s_2expt(z, k) */ -static int s_2expt(mp_int z, int k) +static int +s_2expt(mp_int z, int k) { - mp_size ndig, rest; - mp_digit *dz; + mp_size ndig, + rest; + mp_digit *dz; - ndig = (k + MP_DIGIT_BIT) / MP_DIGIT_BIT; - rest = k % MP_DIGIT_BIT; + ndig = (k + MP_DIGIT_BIT) / MP_DIGIT_BIT; + rest = k % MP_DIGIT_BIT; - if(!s_pad(z, ndig)) - return 0; + if (!s_pad(z, ndig)) + return 0; - dz = MP_DIGITS(z); - ZERO(dz, ndig); - *(dz + ndig - 1) = (1 << rest); - MP_USED(z) = ndig; + dz = MP_DIGITS(z); + ZERO(dz, ndig); + *(dz + ndig - 1) = (1 << rest); + MP_USED(z) = ndig; - return 1; + return 1; } /* }}} */ /* {{{ s_norm(a, b) */ -static int s_norm(mp_int a, mp_int b) +static int +s_norm(mp_int a, mp_int b) { - mp_digit d = b->digits[MP_USED(b) - 1]; - int k = 0; + mp_digit d = b->digits[MP_USED(b) - 1]; + int k = 0; - while(d < (mp_digit) (1 << (MP_DIGIT_BIT - 1))) { /* d < (MP_RADIX / 2) */ - d <<= 1; - ++k; - } + while (d < (mp_digit) (1 << (MP_DIGIT_BIT - 1))) + { /* d < (MP_RADIX / 2) */ + d <<= 1; + ++k; + } - /* These multiplications can't fail */ - if(k != 0) { - (void) s_qmul(a, (mp_size) k); - (void) s_qmul(b, (mp_size) k); - } + /* These multiplications can't fail */ + if (k != 0) + { + (void) s_qmul(a, (mp_size) k); + (void) s_qmul(b, (mp_size) k); + } - return k; + return k; } /* }}} */ /* {{{ s_brmu(z, m) */ -static mp_result s_brmu(mp_int z, mp_int m) +static mp_result +s_brmu(mp_int z, mp_int m) { - mp_size um = MP_USED(m) * 2; + mp_size um = MP_USED(m) * 2; - if(!s_pad(z, um)) - return MP_MEMORY; + if (!s_pad(z, um)) + return MP_MEMORY; - s_2expt(z, MP_DIGIT_BIT * um); - return mp_int_div(z, m, z, NULL); + s_2expt(z, MP_DIGIT_BIT * um); + return mp_int_div(z, m, z, NULL); } /* }}} */ /* {{{ s_reduce(x, m, mu, q1, q2) */ -static int s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2) +static int +s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2) { - mp_size um = MP_USED(m), umb_p1, umb_m1; + mp_size um = MP_USED(m), + umb_p1, + umb_m1; - umb_p1 = (um + 1) * MP_DIGIT_BIT; - umb_m1 = (um - 1) * MP_DIGIT_BIT; + umb_p1 = (um + 1) * MP_DIGIT_BIT; + umb_m1 = (um - 1) * MP_DIGIT_BIT; - if(mp_int_copy(x, q1) != MP_OK) - return 0; + if (mp_int_copy(x, q1) != MP_OK) + return 0; - /* Compute q2 = floor((floor(x / b^(k-1)) * mu) / b^(k+1)) */ - s_qdiv(q1, umb_m1); - UMUL(q1, mu, q2); - s_qdiv(q2, umb_p1); + /* Compute q2 = floor((floor(x / b^(k-1)) * mu) / b^(k+1)) */ + s_qdiv(q1, umb_m1); + UMUL(q1, mu, q2); + s_qdiv(q2, umb_p1); - /* Set x = x mod b^(k+1) */ - s_qmod(x, umb_p1); + /* Set x = x mod b^(k+1) */ + s_qmod(x, umb_p1); - /* Now, q is a guess for the quotient a / m. - Compute x - q * m mod b^(k+1), replacing x. This may be off - by a factor of 2m, but no more than that. - */ - UMUL(q2, m, q1); - s_qmod(q1, umb_p1); - (void) mp_int_sub(x, q1, x); /* can't fail */ + /* + * Now, q is a guess for the quotient a / m. Compute x - q * m mod + * b^(k+1), replacing x. This may be off by a factor of 2m, but no more + * than that. + */ + UMUL(q2, m, q1); + s_qmod(q1, umb_p1); + (void) mp_int_sub(x, q1, x); /* can't fail */ - /* The result may be < 0; if it is, add b^(k+1) to pin it in the - proper range. */ - if((CMPZ(x) < 0) && !s_qsub(x, umb_p1)) - return 0; + /* + * The result may be < 0; if it is, add b^(k+1) to pin it in the proper + * range. + */ + if ((CMPZ(x) < 0) && !s_qsub(x, umb_p1)) + return 0; - /* If x > m, we need to back it off until it is in range. - This will be required at most twice. */ - if(mp_int_compare(x, m) >= 0) - (void) mp_int_sub(x, m, x); - if(mp_int_compare(x, m) >= 0) - (void) mp_int_sub(x, m, x); + /* + * If x > m, we need to back it off until it is in range. This will be + * required at most twice. + */ + if (mp_int_compare(x, m) >= 0) + (void) mp_int_sub(x, m, x); + if (mp_int_compare(x, m) >= 0) + (void) mp_int_sub(x, m, x); - /* At this point, x has been properly reduced. */ - return 1; + /* At this point, x has been properly reduced. */ + return 1; } /* }}} */ @@ -2925,75 +3291,95 @@ static int s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2) /* Perform modular exponentiation using Barrett's method, where mu is the reduction constant for m. Assumes a < m, b > 0. */ -static mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c) -{ - mp_digit *db, *dbt, umu, d; - mpz_t temp[3]; - mp_result res; - int last = 0; - - umu = MP_USED(mu); db = MP_DIGITS(b); dbt = db + MP_USED(b) - 1; - - while(last < 3) - SETUP(mp_int_init_size(TEMP(last), 2 * umu), last); - - (void) mp_int_set_value(c, 1); - - /* Take care of low-order digits */ - while(db < dbt) { - int i; - - for(d = *db, i = MP_DIGIT_BIT; i > 0; --i, d >>= 1) { - if(d & 1) { - /* The use of a second temporary avoids allocation */ - UMUL(c, a, TEMP(0)); - if(!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) { - res = MP_MEMORY; goto CLEANUP; +static mp_result +s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c) +{ + mp_digit *db, + *dbt, + umu, + d; + mpz_t temp[3]; + mp_result res; + int last = 0; + + umu = MP_USED(mu); + db = MP_DIGITS(b); + dbt = db + MP_USED(b) - 1; + + while (last < 3) + SETUP(mp_int_init_size(TEMP(last), 2 * umu), last); + + (void) mp_int_set_value(c, 1); + + /* Take care of low-order digits */ + while (db < dbt) + { + int i; + + for (d = *db, i = MP_DIGIT_BIT; i > 0; --i, d >>= 1) + { + if (d & 1) + { + /* The use of a second temporary avoids allocation */ + UMUL(c, a, TEMP(0)); + if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) + { + res = MP_MEMORY; + goto CLEANUP; + } + mp_int_copy(TEMP(0), c); + } + + + USQR(a, TEMP(0)); + assert(MP_SIGN(TEMP(0)) == MP_ZPOS); + if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) + { + res = MP_MEMORY; + goto CLEANUP; + } + assert(MP_SIGN(TEMP(0)) == MP_ZPOS); + mp_int_copy(TEMP(0), a); + + + } + + ++db; } - mp_int_copy(TEMP(0), c); - } - - - USQR(a, TEMP(0)); - assert(MP_SIGN(TEMP(0)) == MP_ZPOS); - if(!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) { - res = MP_MEMORY; goto CLEANUP; - } - assert(MP_SIGN(TEMP(0)) == MP_ZPOS); - mp_int_copy(TEMP(0), a); + /* Take care of highest-order digit */ + d = *dbt; + for (;;) + { + if (d & 1) + { + UMUL(c, a, TEMP(0)); + if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) + { + res = MP_MEMORY; + goto CLEANUP; + } + mp_int_copy(TEMP(0), c); + } + + d >>= 1; + if (!d) + break; + + USQR(a, TEMP(0)); + if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) + { + res = MP_MEMORY; + goto CLEANUP; + } + (void) mp_int_copy(TEMP(0), a); + } - } - - ++db; - } - - /* Take care of highest-order digit */ - d = *dbt; - for(;;) { - if(d & 1) { - UMUL(c, a, TEMP(0)); - if(!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) { - res = MP_MEMORY; goto CLEANUP; - } - mp_int_copy(TEMP(0), c); - } - - d >>= 1; - if(!d) break; - - USQR(a, TEMP(0)); - if(!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) { - res = MP_MEMORY; goto CLEANUP; - } - (void) mp_int_copy(TEMP(0), a); - } +CLEANUP: + while (--last >= 0) + mp_int_clear(TEMP(last)); - CLEANUP: - while(--last >= 0) - mp_int_clear(TEMP(last)); - - return res; + return res; } /* }}} */ @@ -3003,92 +3389,109 @@ static mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c) /* Precondition: a >= b and b > 0 Postcondition: a' = a / b, b' = a % b */ -static mp_result s_udiv(mp_int a, mp_int b) -{ - mpz_t q, r, t; - mp_size ua, ub, qpos = 0; - mp_digit *da, btop; - mp_result res = MP_OK; - int k, skip = 0; - - /* Force signs to positive */ - MP_SIGN(a) = MP_ZPOS; - MP_SIGN(b) = MP_ZPOS; - - /* Normalize, per Knuth */ - k = s_norm(a, b); - - ua = MP_USED(a); ub = MP_USED(b); btop = b->digits[ub - 1]; - if((res = mp_int_init_size(&q, ua)) != MP_OK) return res; - if((res = mp_int_init_size(&t, ua + 1)) != MP_OK) goto CLEANUP; - - da = MP_DIGITS(a); - r.digits = da + ua - 1; /* The contents of r are shared with a */ - r.used = 1; - r.sign = MP_ZPOS; - r.alloc = MP_ALLOC(a); - ZERO(t.digits, t.alloc); - - /* Solve for quotient digits, store in q.digits in reverse order */ - while(r.digits >= da) { - assert(qpos <= q.alloc); - - if(s_ucmp(b, &r) > 0) { - r.digits -= 1; - r.used += 1; - - if(++skip > 1) - q.digits[qpos++] = 0; - - CLAMP(&r); - } - else { - mp_word pfx = r.digits[r.used - 1]; - mp_word qdigit; - - if(r.used > 1 && (pfx < btop || r.digits[r.used - 2] == 0)) { - pfx <<= MP_DIGIT_BIT / 2; - pfx <<= MP_DIGIT_BIT / 2; - pfx |= r.digits[r.used - 2]; - } - - qdigit = pfx / btop; - if(qdigit > MP_DIGIT_MAX) - qdigit = 1; - - s_dbmul(MP_DIGITS(b), (mp_digit) qdigit, t.digits, ub); - t.used = ub + 1; CLAMP(&t); - while(s_ucmp(&t, &r) > 0) { - --qdigit; - (void) mp_int_sub(&t, b, &t); /* cannot fail */ - } - - s_usub(r.digits, t.digits, r.digits, r.used, t.used); - CLAMP(&r); - - q.digits[qpos++] = (mp_digit) qdigit; - ZERO(t.digits, t.used); - skip = 0; - } - } - - /* Put quotient digits in the correct order, and discard extra zeroes */ - q.used = qpos; - REV(mp_digit, q.digits, qpos); - CLAMP(&q); - - /* Denormalize the remainder */ - CLAMP(a); - if(k != 0) - s_qdiv(a, k); - - mp_int_copy(a, b); /* ok: 0 <= r < b */ - mp_int_copy(&q, a); /* ok: q <= a */ - - mp_int_clear(&t); - CLEANUP: - mp_int_clear(&q); - return res; +static mp_result +s_udiv(mp_int a, mp_int b) +{ + mpz_t q, + r, + t; + mp_size ua, + ub, + qpos = 0; + mp_digit *da, + btop; + mp_result res = MP_OK; + int k, + skip = 0; + + /* Force signs to positive */ + MP_SIGN(a) = MP_ZPOS; + MP_SIGN(b) = MP_ZPOS; + + /* Normalize, per Knuth */ + k = s_norm(a, b); + + ua = MP_USED(a); + ub = MP_USED(b); + btop = b->digits[ub - 1]; + if ((res = mp_int_init_size(&q, ua)) != MP_OK) + return res; + if ((res = mp_int_init_size(&t, ua + 1)) != MP_OK) + goto CLEANUP; + + da = MP_DIGITS(a); + r.digits = da + ua - 1; /* The contents of r are shared with a */ + r.used = 1; + r.sign = MP_ZPOS; + r.alloc = MP_ALLOC(a); + ZERO(t.digits, t.alloc); + + /* Solve for quotient digits, store in q.digits in reverse order */ + while (r.digits >= da) + { + assert(qpos <= q.alloc); + + if (s_ucmp(b, &r) > 0) + { + r.digits -= 1; + r.used += 1; + + if (++skip > 1) + q.digits[qpos++] = 0; + + CLAMP(&r); + } + else + { + mp_word pfx = r.digits[r.used - 1]; + mp_word qdigit; + + if (r.used > 1 && (pfx < btop || r.digits[r.used - 2] == 0)) + { + pfx <<= MP_DIGIT_BIT / 2; + pfx <<= MP_DIGIT_BIT / 2; + pfx |= r.digits[r.used - 2]; + } + + qdigit = pfx / btop; + if (qdigit > MP_DIGIT_MAX) + qdigit = 1; + + s_dbmul(MP_DIGITS(b), (mp_digit) qdigit, t.digits, ub); + t.used = ub + 1; + CLAMP(&t); + while (s_ucmp(&t, &r) > 0) + { + --qdigit; + (void) mp_int_sub(&t, b, &t); /* cannot fail */ + } + + s_usub(r.digits, t.digits, r.digits, r.used, t.used); + CLAMP(&r); + + q.digits[qpos++] = (mp_digit) qdigit; + ZERO(t.digits, t.used); + skip = 0; + } + } + + /* Put quotient digits in the correct order, and discard extra zeroes */ + q.used = qpos; + REV(mp_digit, q.digits, qpos); + CLAMP(&q); + + /* Denormalize the remainder */ + CLAMP(a); + if (k != 0) + s_qdiv(a, k); + + mp_int_copy(a, b); /* ok: 0 <= r < b */ + mp_int_copy(&q, a); /* ok: q <= a */ + + mp_int_clear(&t); +CLEANUP: + mp_int_clear(&q); + return res; } /* }}} */ @@ -3096,133 +3499,147 @@ static mp_result s_udiv(mp_int a, mp_int b) /* {{{ s_outlen(z, r) */ /* Precondition: 2 <= r < 64 */ -static int s_outlen(mp_int z, mp_size r) +static int +s_outlen(mp_int z, mp_size r) { - mp_result bits; - double raw; + mp_result bits; + double raw; - bits = mp_int_count_bits(z); - raw = (double)bits * s_log2[r]; + bits = mp_int_count_bits(z); + raw = (double) bits *s_log2[r]; - return (int)(raw + 0.999999); + return (int) (raw + 0.999999); } /* }}} */ /* {{{ s_inlen(len, r) */ -static mp_size s_inlen(int len, mp_size r) +static mp_size +s_inlen(int len, mp_size r) { - double raw = (double)len / s_log2[r]; - mp_size bits = (mp_size)(raw + 0.5); + double raw = (double) len / s_log2[r]; + mp_size bits = (mp_size) (raw + 0.5); - return (mp_size)((bits + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT); + return (mp_size) ((bits + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT); } /* }}} */ /* {{{ s_ch2val(c, r) */ -static int s_ch2val(char c, int r) +static int +s_ch2val(char c, int r) { - int out; + int out; - if(isdigit((unsigned char)c)) - out = c - '0'; - else if(r > 10 && isalpha((unsigned char) c)) - out = toupper((unsigned char) c) - 'A' + 10; - else - return -1; + if (isdigit((unsigned char) c)) + out = c - '0'; + else if (r > 10 && isalpha((unsigned char) c)) + out = toupper((unsigned char) c) - 'A' + 10; + else + return -1; - return (out >= r) ? -1 : out; + return (out >= r) ? -1 : out; } /* }}} */ /* {{{ s_val2ch(v, caps) */ -static char s_val2ch(int v, int caps) +static char +s_val2ch(int v, int caps) { - assert(v >= 0); + assert(v >= 0); - if(v < 10) - return v + '0'; - else { - char out = (v - 10) + 'a'; + if (v < 10) + return v + '0'; + else + { + char out = (v - 10) + 'a'; - if(caps) - return toupper((unsigned char) out); - else - return out; - } + if (caps) + return toupper((unsigned char) out); + else + return out; + } } /* }}} */ /* {{{ s_2comp(buf, len) */ -static void s_2comp(unsigned char *buf, int len) +static void +s_2comp(unsigned char *buf, int len) { - int i; - unsigned short s = 1; + int i; + unsigned short s = 1; - for(i = len - 1; i >= 0; --i) { - unsigned char c = ~buf[i]; + for (i = len - 1; i >= 0; --i) + { + unsigned char c = ~buf[i]; - s = c + s; - c = s & UCHAR_MAX; - s >>= CHAR_BIT; + s = c + s; + c = s & UCHAR_MAX; + s >>= CHAR_BIT; - buf[i] = c; - } + buf[i] = c; + } - /* last carry out is ignored */ + /* last carry out is ignored */ } /* }}} */ /* {{{ s_tobin(z, buf, *limpos) */ -static mp_result s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad) +static mp_result +s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad) { - mp_size uz; - mp_digit *dz; - int pos = 0, limit = *limpos; + mp_size uz; + mp_digit *dz; + int pos = 0, + limit = *limpos; - uz = MP_USED(z); dz = MP_DIGITS(z); - while(uz > 0 && pos < limit) { - mp_digit d = *dz++; - int i; + uz = MP_USED(z); + dz = MP_DIGITS(z); + while (uz > 0 && pos < limit) + { + mp_digit d = *dz++; + int i; - for(i = sizeof(mp_digit); i > 0 && pos < limit; --i) { - buf[pos++] = (unsigned char)d; - d >>= CHAR_BIT; + for (i = sizeof(mp_digit); i > 0 && pos < limit; --i) + { + buf[pos++] = (unsigned char) d; + d >>= CHAR_BIT; - /* Don't write leading zeroes */ - if(d == 0 && uz == 1) - i = 0; /* exit loop without signaling truncation */ - } + /* Don't write leading zeroes */ + if (d == 0 && uz == 1) + i = 0; /* exit loop without signaling truncation */ + } - /* Detect truncation (loop exited with pos >= limit) */ - if(i > 0) break; + /* Detect truncation (loop exited with pos >= limit) */ + if (i > 0) + break; - --uz; - } + --uz; + } - if(pad != 0 && (buf[pos - 1] >> (CHAR_BIT - 1))) { - if(pos < limit) - buf[pos++] = 0; - else - uz = 1; - } + if (pad != 0 && (buf[pos - 1] >> (CHAR_BIT - 1))) + { + if (pos < limit) + buf[pos++] = 0; + else + uz = 1; + } - /* Digits are in reverse order, fix that */ - REV(unsigned char, buf, pos); + /* Digits are in reverse order, fix that */ + REV(unsigned char, buf, pos); - /* Return the number of bytes actually written */ - *limpos = pos; + /* Return the number of bytes actually written */ + *limpos = pos; - return (uz == 0) ? MP_OK : MP_TRUNC; + return (uz == 0) ? MP_OK : MP_TRUNC; } /* }}} */ @@ -3230,30 +3647,32 @@ static mp_result s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad) /* {{{ s_print(tag, z) */ #if 0 -void s_print(char *tag, mp_int z) +void +s_print(char *tag, mp_int z) { - int i; + int i; - fprintf(stderr, "%s: %c ", tag, - (MP_SIGN(z) == MP_NEG) ? '-' : '+'); + fprintf(stderr, "%s: %c ", tag, + (MP_SIGN(z) == MP_NEG) ? '-' : '+'); - for(i = MP_USED(z) - 1; i >= 0; --i) - fprintf(stderr, "%0*X", (int)(MP_DIGIT_BIT / 4), z->digits[i]); + for (i = MP_USED(z) - 1; i >= 0; --i) + fprintf(stderr, "%0*X", (int) (MP_DIGIT_BIT / 4), z->digits[i]); - fputc('\n', stderr); + fputc('\n', stderr); } -void s_print_buf(char *tag, mp_digit *buf, mp_size num) +void +s_print_buf(char *tag, mp_digit * buf, mp_size num) { - int i; + int i; - fprintf(stderr, "%s: ", tag); + fprintf(stderr, "%s: ", tag); - for(i = num - 1; i >= 0; --i) - fprintf(stderr, "%0*X", (int)(MP_DIGIT_BIT / 4), buf[i]); + for (i = num - 1; i >= 0; --i) + fprintf(stderr, "%0*X", (int) (MP_DIGIT_BIT / 4), buf[i]); - fputc('\n', stderr); + fputc('\n', stderr); } #endif diff --git a/contrib/pgcrypto/imath.h b/contrib/pgcrypto/imath.h index 67adb3bf45..f730b32050 100644 --- a/contrib/pgcrypto/imath.h +++ b/contrib/pgcrypto/imath.h @@ -1,8 +1,8 @@ /* - Name: imath.h - Purpose: Arbitrary precision integer arithmetic routines. - Author: M. J. Fromberger <http://www.dartmouth.edu/~sting/> - Info: Id: imath.h 21 2006-04-02 18:58:36Z sting + Name: imath.h + Purpose: Arbitrary precision integer arithmetic routines. + Author: M. J. Fromberger <http://www.dartmouth.edu/~sting/> + Info: Id: imath.h 21 2006-04-02 18:58:36Z sting Copyright (C) 2002 Michael J. Fromberger, All Rights Reserved. @@ -20,13 +20,13 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/* $PostgreSQL: pgsql/contrib/pgcrypto/imath.h,v 1.4 2006/07/19 17:05:50 neilc Exp $ */ +/* $PostgreSQL: pgsql/contrib/pgcrypto/imath.h,v 1.5 2006/10/04 00:29:46 momjian Exp $ */ #ifndef IMATH_H_ #define IMATH_H_ @@ -36,32 +36,36 @@ #include <limits.h> -typedef unsigned char mp_sign; -typedef unsigned int mp_size; -typedef int mp_result; +typedef unsigned char mp_sign; +typedef unsigned int mp_size; +typedef int mp_result; + #ifdef USE_LONG_LONG -typedef uint32 mp_digit; -typedef uint64 mp_word; -#define MP_DIGIT_MAX 0xFFFFFFFFULL -#define MP_WORD_MAX 0xFFFFFFFFFFFFFFFFULL +typedef uint32 mp_digit; +typedef uint64 mp_word; + +#define MP_DIGIT_MAX 0xFFFFFFFFULL +#define MP_WORD_MAX 0xFFFFFFFFFFFFFFFFULL #else -typedef uint16 mp_digit; -typedef uint32 mp_word; -#define MP_DIGIT_MAX 0xFFFFUL -#define MP_WORD_MAX 0xFFFFFFFFUL +typedef uint16 mp_digit; +typedef uint32 mp_word; + +#define MP_DIGIT_MAX 0xFFFFUL +#define MP_WORD_MAX 0xFFFFFFFFUL #endif -typedef struct mpz { - mp_digit *digits; - mp_size alloc; - mp_size used; - mp_sign sign; -} mpz_t, *mp_int; +typedef struct mpz +{ + mp_digit *digits; + mp_size alloc; + mp_size used; + mp_sign sign; +} mpz_t, *mp_int; #define MP_DIGITS(Z) ((Z)->digits) #define MP_ALLOC(Z) ((Z)->alloc) -#define MP_USED(Z) ((Z)->used) -#define MP_SIGN(Z) ((Z)->sign) +#define MP_USED(Z) ((Z)->used) +#define MP_SIGN(Z) ((Z)->sign) extern const mp_result MP_OK; extern const mp_result MP_FALSE; @@ -72,131 +76,140 @@ extern const mp_result MP_UNDEF; extern const mp_result MP_TRUNC; extern const mp_result MP_BADARG; -#define MP_DIGIT_BIT (sizeof(mp_digit) * CHAR_BIT) -#define MP_WORD_BIT (sizeof(mp_word) * CHAR_BIT) +#define MP_DIGIT_BIT (sizeof(mp_digit) * CHAR_BIT) +#define MP_WORD_BIT (sizeof(mp_word) * CHAR_BIT) -#define MP_MIN_RADIX 2 -#define MP_MAX_RADIX 36 +#define MP_MIN_RADIX 2 +#define MP_MAX_RADIX 36 -extern const mp_sign MP_NEG; -extern const mp_sign MP_ZPOS; +extern const mp_sign MP_NEG; +extern const mp_sign MP_ZPOS; #define mp_int_is_odd(Z) ((Z)->digits[0] & 1) #define mp_int_is_even(Z) !((Z)->digits[0] & 1) -mp_size mp_get_default_precision(void); -void mp_set_default_precision(mp_size s); -mp_size mp_get_multiply_threshold(void); -void mp_set_multiply_threshold(mp_size s); - -mp_result mp_int_init(mp_int z); -mp_int mp_int_alloc(void); -mp_result mp_int_init_size(mp_int z, mp_size prec); -mp_result mp_int_init_copy(mp_int z, mp_int old); -mp_result mp_int_init_value(mp_int z, int value); -mp_result mp_int_set_value(mp_int z, int value); -void mp_int_clear(mp_int z); -void mp_int_free(mp_int z); - -mp_result mp_int_copy(mp_int a, mp_int c); /* c = a */ -void mp_int_swap(mp_int a, mp_int c); /* swap a, c */ -void mp_int_zero(mp_int z); /* z = 0 */ -mp_result mp_int_abs(mp_int a, mp_int c); /* c = |a| */ -mp_result mp_int_neg(mp_int a, mp_int c); /* c = -a */ -mp_result mp_int_add(mp_int a, mp_int b, mp_int c); /* c = a + b */ -mp_result mp_int_add_value(mp_int a, int value, mp_int c); -mp_result mp_int_sub(mp_int a, mp_int b, mp_int c); /* c = a - b */ -mp_result mp_int_sub_value(mp_int a, int value, mp_int c); -mp_result mp_int_mul(mp_int a, mp_int b, mp_int c); /* c = a * b */ -mp_result mp_int_mul_value(mp_int a, int value, mp_int c); -mp_result mp_int_mul_pow2(mp_int a, int p2, mp_int c); -mp_result mp_int_sqr(mp_int a, mp_int c); /* c = a * a */ -mp_result mp_int_div(mp_int a, mp_int b, /* q = a / b */ - mp_int q, mp_int r); /* r = a % b */ -mp_result mp_int_div_value(mp_int a, int value, /* q = a / value */ - mp_int q, int *r); /* r = a % value */ -mp_result mp_int_div_pow2(mp_int a, int p2, /* q = a / 2^p2 */ - mp_int q, mp_int r); /* r = q % 2^p2 */ -mp_result mp_int_mod(mp_int a, mp_int m, mp_int c); /* c = a % m */ +mp_size mp_get_default_precision(void); +void mp_set_default_precision(mp_size s); +mp_size mp_get_multiply_threshold(void); +void mp_set_multiply_threshold(mp_size s); + +mp_result mp_int_init(mp_int z); +mp_int mp_int_alloc(void); +mp_result mp_int_init_size(mp_int z, mp_size prec); +mp_result mp_int_init_copy(mp_int z, mp_int old); +mp_result mp_int_init_value(mp_int z, int value); +mp_result mp_int_set_value(mp_int z, int value); +void mp_int_clear(mp_int z); +void mp_int_free(mp_int z); + +mp_result mp_int_copy(mp_int a, mp_int c); /* c = a */ +void mp_int_swap(mp_int a, mp_int c); /* swap a, c */ +void mp_int_zero(mp_int z); /* z = 0 */ +mp_result mp_int_abs(mp_int a, mp_int c); /* c = |a| */ +mp_result mp_int_neg(mp_int a, mp_int c); /* c = -a */ +mp_result mp_int_add(mp_int a, mp_int b, mp_int c); /* c = a + b */ +mp_result mp_int_add_value(mp_int a, int value, mp_int c); +mp_result mp_int_sub(mp_int a, mp_int b, mp_int c); /* c = a - b */ +mp_result mp_int_sub_value(mp_int a, int value, mp_int c); +mp_result mp_int_mul(mp_int a, mp_int b, mp_int c); /* c = a * b */ +mp_result mp_int_mul_value(mp_int a, int value, mp_int c); +mp_result mp_int_mul_pow2(mp_int a, int p2, mp_int c); +mp_result mp_int_sqr(mp_int a, mp_int c); /* c = a * a */ +mp_result +mp_int_div(mp_int a, mp_int b, /* q = a / b */ + mp_int q, mp_int r); /* r = a % b */ +mp_result +mp_int_div_value(mp_int a, int value, /* q = a / value */ + mp_int q, int *r); /* r = a % value */ +mp_result +mp_int_div_pow2(mp_int a, int p2, /* q = a / 2^p2 */ + mp_int q, mp_int r); /* r = q % 2^p2 */ +mp_result mp_int_mod(mp_int a, mp_int m, mp_int c); /* c = a % m */ + #define mp_int_mod_value(A, V, R) mp_int_div_value((A), (V), 0, (R)) -mp_result mp_int_expt(mp_int a, int b, mp_int c); /* c = a^b */ -mp_result mp_int_expt_value(int a, int b, mp_int c); /* c = a^b */ +mp_result mp_int_expt(mp_int a, int b, mp_int c); /* c = a^b */ +mp_result mp_int_expt_value(int a, int b, mp_int c); /* c = a^b */ -int mp_int_compare(mp_int a, mp_int b); /* a <=> b */ -int mp_int_compare_unsigned(mp_int a, mp_int b); /* |a| <=> |b| */ -int mp_int_compare_zero(mp_int z); /* a <=> 0 */ -int mp_int_compare_value(mp_int z, int value); /* a <=> v */ +int mp_int_compare(mp_int a, mp_int b); /* a <=> b */ +int mp_int_compare_unsigned(mp_int a, mp_int b); /* |a| <=> |b| */ +int mp_int_compare_zero(mp_int z); /* a <=> 0 */ +int mp_int_compare_value(mp_int z, int value); /* a <=> v */ /* Returns true if v|a, false otherwise (including errors) */ -int mp_int_divisible_value(mp_int a, int v); +int mp_int_divisible_value(mp_int a, int v); /* Returns k >= 0 such that z = 2^k, if one exists; otherwise < 0 */ -int mp_int_is_pow2(mp_int z); +int mp_int_is_pow2(mp_int z); -mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m, - mp_int c); /* c = a^b (mod m) */ -mp_result mp_int_exptmod_evalue(mp_int a, int value, - mp_int m, mp_int c); /* c = a^v (mod m) */ -mp_result mp_int_exptmod_bvalue(int value, mp_int b, - mp_int m, mp_int c); /* c = v^b (mod m) */ -mp_result mp_int_exptmod_known(mp_int a, mp_int b, - mp_int m, mp_int mu, - mp_int c); /* c = a^b (mod m) */ -mp_result mp_int_redux_const(mp_int m, mp_int c); +mp_result +mp_int_exptmod(mp_int a, mp_int b, mp_int m, + mp_int c); /* c = a^b (mod m) */ +mp_result +mp_int_exptmod_evalue(mp_int a, int value, + mp_int m, mp_int c); /* c = a^v (mod m) */ +mp_result +mp_int_exptmod_bvalue(int value, mp_int b, + mp_int m, mp_int c); /* c = v^b (mod m) */ +mp_result +mp_int_exptmod_known(mp_int a, mp_int b, + mp_int m, mp_int mu, + mp_int c); /* c = a^b (mod m) */ +mp_result mp_int_redux_const(mp_int m, mp_int c); -mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c); /* c = 1/a (mod m) */ +mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c); /* c = 1/a (mod m) */ -mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c); /* c = gcd(a, b) */ +mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c); /* c = gcd(a, b) */ -mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c, /* c = gcd(a, b) */ - mp_int x, mp_int y); /* c = ax + by */ +mp_result +mp_int_egcd(mp_int a, mp_int b, mp_int c, /* c = gcd(a, b) */ + mp_int x, mp_int y); /* c = ax + by */ -mp_result mp_int_sqrt(mp_int a, mp_int c); /* c = floor(sqrt(q)) */ +mp_result mp_int_sqrt(mp_int a, mp_int c); /* c = floor(sqrt(q)) */ /* Convert to an int, if representable (returns MP_RANGE if not). */ -mp_result mp_int_to_int(mp_int z, int *out); +mp_result mp_int_to_int(mp_int z, int *out); /* Convert to nul-terminated string with the specified radix, writing at most limit characters including the nul terminator */ -mp_result mp_int_to_string(mp_int z, mp_size radix, - char *str, int limit); +mp_result mp_int_to_string(mp_int z, mp_size radix, + char *str, int limit); -/* Return the number of characters required to represent +/* Return the number of characters required to represent z in the given radix. May over-estimate. */ -mp_result mp_int_string_len(mp_int z, mp_size radix); +mp_result mp_int_string_len(mp_int z, mp_size radix); /* Read zero-terminated string into z */ -mp_result mp_int_read_string(mp_int z, mp_size radix, const char *str); -mp_result mp_int_read_cstring(mp_int z, mp_size radix, const char *str, |