
#include <stdlib.h>
#include <string.h>
#include "pg.h"
#include "libpq-int.h"

/* Supports 250 columns worth of params.  If more are needed,
 * memory is allocated ... very rare case.
 */
#define COLSTACKSIZE 4096

#define CHKPARAMPTR(p) do{ \
	if(!(p)) \
	{ \
		errno = EINVAL; \
		strcpy((p)->errmsg, libpq_gettext("PGparam pointer is NULL")); \
		return 0; \
	} \
}while(0)

#define PARAM_ARRAY_DECL \
	char _stackbuffer[COLSTACKSIZE]; \
	char *buf   = _stackbuffer; \
  char **vals = NULL; \
	int *lens   = NULL; \
	int *fmts   = NULL

#define PARAM_ARRAY_ASSIGN do{ \
	if(param) \
	{ \
		int n = (int)((sizeof(void *) * param->vcnt) + \
			((sizeof(int) * 2) * param->vcnt)); \
		if(n > COLSTACKSIZE) \
		{ \
			buf = (char *)malloc(n); \
			if(!buf) \
			{ \
				printfPQExpBuffer(&conn->errorMessage, \
					libpq_gettext("cannot allocate parameter column arrays\n")); \
				return 0; \
			} \
		} \
		vals = (char **)buf; \
		lens = (int *)(buf + (sizeof(void *) * param->vcnt)); \
		fmts = lens + param->vcnt; \
	  for(n=0; n < param->vcnt; n++) \
	  { \
	    vals[n] = param->vals[n].data; \
	    lens[n] = param->vals[n].datal; \
	    fmts[n] = param->vals[n].format; \
	  }	\
	} \
}while(0)

#define PARAM_ARRAY_FREE do{ \
	if(buf != _stackbuffer) \
		free(buf); \
}while(0)

typedef struct
{
	int ptrl;
  void *ptr;
	int datal;
  char *data;
  int format;
} PGvalue;

struct pg_param
{
  int vcnt;
  int vmax;
  PGvalue *vals;
	int slabsize;
	char *slab;
	char errmsg[128];
};


PGparam *PQparamCreate(void)
{
	return (PGparam *)calloc(1, sizeof(PGparam));
}

void PQparamReset(PGparam *param)
{
	if(param)
		param->vcnt = 0;
}

char *PQparamErrorMessage(PGparam *param)
{
	if(!param)
		return libpq_gettext("PGparam pointer is NULL\n");
	return param->errmsg;
}

void PQparamClear(PGparam *param)
{
	if(param)
	{
		int i;

		for(i=0; i < param->vmax; i++)
			if(param->vals[i].ptr)
				free(param->vals[i].ptr);

		if(param->vals)
			free(param->vals);

		if(param->slab)
			free(param->slab);

		free(param);
	}
}

int PQparamExec(
  PGconn *conn,
  const char *command,
  PGparam *param,
  int resultFormat,
  PGresult **resultp)
{
  PGresult *res;
	PARAM_ARRAY_DECL;

	if(resultp)
		*resultp = NULL;

	PARAM_ARRAY_ASSIGN;

  res = PQexecParams(
    conn,
    command,
    param ? param->vcnt : 0,
    (const Oid *)NULL,
    (const char * const *)vals,
    (const int *)lens,
    (const int *)fmts,
    resultFormat);

	PARAM_ARRAY_FREE;

  if(!res)
  	return 0;

  /* If caller doesn't want result, clear it. */
  if(!resultp)
    PQclear(res);
  else
    *resultp = res;

  return 1;
}

int PQparamExecPrepared(
  PGconn *conn,
  const char *stmtName,
  PGparam *param,
  int resultFormat,
  PGresult **resultp)
{
  PGresult *res;
	PARAM_ARRAY_DECL;

  if(resultp)
    *resultp = NULL;

	PARAM_ARRAY_ASSIGN;

  res = PQexecPrepared(
    conn,
    stmtName,
    param ? param->vcnt : 0,
    (const char * const *)vals,
    (const int *)lens,
    (const int *)fmts,
    resultFormat);

	PARAM_ARRAY_FREE;

  if(!res)
  	return 0;

  /* If caller doesn't want result, clear it. */
  if(!resultp)
    PQclear(res);
  else
    *resultp = res;

  return 1;
}

int PQparamSend(
  PGconn *conn,
  const char *command,
  PGparam *param,
  int resultFormat)
{
	int r;
	PARAM_ARRAY_DECL;

	PARAM_ARRAY_ASSIGN;

  r = PQsendQueryParams(
		conn,
		command,
		param ? param->vcnt : 0,
		(const Oid *)NULL,
		(const char * const *)vals,
		(const int *)lens,
		(const int *)fmts,
		resultFormat);

	PARAM_ARRAY_FREE;
	return r;
}

int PQparamSendPrepared(
  PGconn *conn,
  const char *stmtName,
  PGparam *param,
  int resultFormat)
{
	int r;
	PARAM_ARRAY_DECL;

	PARAM_ARRAY_ASSIGN;

  r = PQsendQueryPrepared(
		conn,
		stmtName,
		param ? param->vcnt : 0,
		(const char * const *)vals,
		(const int *)lens,
		(const int *)fmts,
		resultFormat);

	PARAM_ARRAY_FREE;
	return r;
}

int PQparamPutChar(PGparam *param, unsigned char ch)
{
	CHKPARAMPTR(param);
	return PQparamPut(param, (const void *)&ch, 1, 1);
}

int PQparamPutInt2(PGparam *param, unsigned short i2)
{
	CHKPARAMPTR(param);
	i2 = htons(i2);
	return PQparamPut(param, (const void *)&i2, 2, 1);
}

int PQparamPutInt4(PGparam *param, unsigned int i4)
{
	CHKPARAMPTR(param);
	i4 = htonl(i4);
	return PQparamPut(param, (const void *)&i4, 4, 1);
}

int PQparamPutInt8(PGparam *param, void *i8p)
{
	unsigned int v[2];
	unsigned int *i8;

	CHKPARAMPTR(param);

	if(!i8p)
	{
		errno = EINVAL;
		strcpy(param->errmsg,
			libpq_gettext("PQparamPutInt8: int64 ptr argument cannot be null"));
		return 0;
	}

	i8 = (unsigned int *)i8p;
	if(1 != htonl(1))
	{
		v[0] = htonl(i8[1]);
		v[1] = htonl(i8[0]);
	}
	else
	{
		v[0] = i8[0];
		v[1] = i8[1];
	}

	return PQparamPut(param, (const void *)&v, 8, 1);
}

int PQparamPutFloat(PGparam *param, float f)
{
  void* vp = &f;
  return PQparamPutInt4(param, *(unsigned int *)vp);
}

int PQparamPutDouble(PGparam *param, double d)
{
  return PQparamPutInt8(param, &d);
}

int PQparamPutString(PGparam *param, const char *str, int strl)
{
	CHKPARAMPTR(param);

	if(str && strl < 0)
		strl = (int)strlen(str);

	return PQparamPut(param, str, strl, 0);
}

int PQparamPut(
	PGparam *param,
	const void *data,
	int datal,
	int format)
{
  PGvalue *v;

	CHKPARAMPTR(param);

  if(param->vcnt == param->vmax)
  {
    PGvalue *vals;
    int vmax = param->vmax ? (param->vmax * 3) / 2 : 16;

    if(!(vals = (PGvalue *)realloc(param->vals, sizeof(PGvalue) * vmax)))
    {
			strcpy(param->errmsg,
				libpq_gettext("cannot grow parameter param"));
      return 0;
    }

    memset(vals + param->vcnt, 0, (vmax - param->vcnt) * sizeof(PGvalue));
    param->vmax = vmax;
		param->vals = vals;
  }

  v = &param->vals[param->vcnt];

	if(!data)
		datal = 0;

  if(v->ptrl < datal)
  {
    char *ptr = (char *)realloc(v->ptr, datal);

    if(!ptr)
    {
			strcpy(param->errmsg,
				libpq_gettext("cannot enlarge parameter data pointer"));
      return 0;
    }

    v->ptrl = datal;
    v->ptr = ptr;
  }

	param->vcnt++;
  v->datal = datal;
	v->format = format;
	v->data = data ? (char *)memcpy(v->ptr, data, datal) : NULL;

	return 1;
}
