/* function prototypes */
static void help(const char *progname);
void get_opts(int, char **, struct options *);
-void *pg_malloc(size_t size);
-void *pg_realloc(void *ptr, size_t size);
-char *pg_strdup(const char *str);
void add_one_elt(char *eltname, eary *eary);
char *get_comma_elts(eary *eary);
PGconn *sql_conn(struct options *);
progname, progname);
}
-void *
-pg_malloc(size_t size)
-{
- void *ptr;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- ptr = malloc(size);
- if (!ptr)
- {
- fprintf(stderr, "out of memory\n");
- exit(1);
- }
- return ptr;
-}
-
-void *
-pg_realloc(void *ptr, size_t size)
-{
- void *result;
-
- /* Avoid unportable behavior of realloc(NULL, 0) */
- if (ptr == NULL && size == 0)
- size = 1;
- result = realloc(ptr, size);
- if (!result)
- {
- fprintf(stderr, "out of memory\n");
- exit(1);
- }
- return result;
-}
-
-char *
-pg_strdup(const char *str)
-{
- char *result = strdup(str);
-
- if (!result)
- {
- fprintf(stderr, "out of memory\n");
- exit(1);
- }
- return result;
-}
-
/*
* add_one_elt
*
* contrib/pg_upgrade/check.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/controldata.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/dump.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/exec.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/file.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/function.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/info.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/option.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "miscadmin.h"
* contrib/pg_upgrade/page.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/parallel.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
prep_status(const char *fmt,...)
__attribute__((format(PG_PRINTF_ATTRIBUTE, 1, 2)));
void check_ok(void);
-char *pg_strdup(const char *s);
-void *pg_malloc(size_t size);
-void *pg_realloc(void *ptr, size_t size);
-void pg_free(void *ptr);
const char *getErrorText(int errNum);
unsigned int str2uint(const char *str);
void pg_putenv(const char *var, const char *val);
* contrib/pg_upgrade/relfilenode.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/server.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/tablespace.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/util.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
}
-void *
-pg_malloc(size_t size)
-{
- void *p;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- p = malloc(size);
- if (p == NULL)
- pg_log(PG_FATAL, "%s: out of memory\n", os_info.progname);
- return p;
-}
-
-void *
-pg_realloc(void *ptr, size_t size)
-{
- void *p;
-
- /* Avoid unportable behavior of realloc(NULL, 0) */
- if (ptr == NULL && size == 0)
- size = 1;
- p = realloc(ptr, size);
- if (p == NULL)
- pg_log(PG_FATAL, "%s: out of memory\n", os_info.progname);
- return p;
-}
-
-
-void
-pg_free(void *ptr)
-{
- if (ptr != NULL)
- free(ptr);
-}
-
-
-char *
-pg_strdup(const char *s)
-{
- char *result = strdup(s);
-
- if (result == NULL)
- pg_log(PG_FATAL, "%s: out of memory\n", os_info.progname);
-
- return result;
-}
-
-
/*
* getErrorText()
*
* contrib/pg_upgrade/version.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
* contrib/pg_upgrade/version_old_8_3.c
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "pg_upgrade.h"
static void setalarm(int seconds);
static void *threadRun(void *arg);
-
-/*
- * routines to check mem allocations and fail noisily.
- */
-static void *
-pg_malloc(size_t size)
-{
- void *result;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- result = malloc(size);
- if (!result)
- {
- fprintf(stderr, "out of memory\n");
- exit(1);
- }
- return result;
-}
-
-static void *
-pg_realloc(void *ptr, size_t size)
-{
- void *result;
-
- /* Avoid unportable behavior of realloc(NULL, 0) */
- if (ptr == NULL && size == 0)
- size = 1;
- result = realloc(ptr, size);
- if (!result)
- {
- fprintf(stderr, "out of memory\n");
- exit(1);
- }
- return result;
-}
-
-static char *
-pg_strdup(const char *s)
-{
- char *result;
-
- result = strdup(s);
- if (!result)
- {
- fprintf(stderr, "out of memory\n");
- exit(1);
- }
- return result;
-}
-
-
static void
usage(void)
{
include Makefile.global
SUBDIRS = \
+ common \
port \
timezone \
backend \
with_gnu_ld = @with_gnu_ld@
ld_R_works = @ld_R_works@
-# We want -L for libpgport.a to be first in LDFLAGS. We also need LDFLAGS
-# to be a "recursively expanded" variable, else adjustments to rpathdir
-# don't work right. So we must NOT do LDFLAGS := something, meaning this has
-# to be done first and elsewhere we must only do LDFLAGS += something.
+# We want -L for libpgport.a and libpgcommon.a to be first in LDFLAGS. We
+# also need LDFLAGS to be a "recursively expanded" variable, else adjustments
+# to rpathdir don't work right. So we must NOT do LDFLAGS := something,
+# meaning this has to be done first and elsewhere we must only do LDFLAGS +=
+# something.
ifdef PGXS
LDFLAGS = -L$(libdir)
else
- LDFLAGS = -L$(top_builddir)/src/port
+ LDFLAGS = -L$(top_builddir)/src/port -L$(top_builddir)/src/common
endif
LDFLAGS += @LDFLAGS@
libpq = -L$(libpq_builddir) -lpq
# This macro is for use by client executables (not libraries) that use libpq.
-# We force clients to pull symbols from the non-shared library libpgport
-# rather than pulling some libpgport symbols from libpq just because
-# libpq uses those functions too. This makes applications less
+# We force clients to pull symbols from the non-shared libraries libpgport
+# and libpgcommon rather than pulling some libpgport symbols from libpq just
+# because libpq uses those functions too. This makes applications less
# dependent on changes in libpq's usage of pgport. To do this we link to
# pgport before libpq. This does cause duplicate -lpgport's to appear
# on client link lines.
ifdef PGXS
-libpq_pgport = -L$(libdir) -lpgport $(libpq)
+libpq_pgport = -L$(libdir) -lpgport -lpgcommon $(libpq)
else
-libpq_pgport = -L$(top_builddir)/src/port -lpgport $(libpq)
+libpq_pgport = -L$(top_builddir)/src/port -lpgport \
+ -L$(top_builddir)/src/common -lpgcommon $(libpq)
endif
submake-libpgport:
$(MAKE) -C $(top_builddir)/src/port all
+ $(MAKE) -C $(top_builddir)/src/common all
.PHONY: submake-libpq submake-libpgport
LIBOBJS = @LIBOBJS@
-LIBS := -lpgport $(LIBS)
+LIBS := -lpgport -lpgcommon $(LIBS)
# to make ws2_32.lib the last library, and always link with shfolder,
# so SHGetFolderName isn't picked up from shell32.dll
#include "storage/fd.h"
#include "miscadmin.h"
-/*
- * On Windows, call non-macro versions of palloc; we can't reference
- * CurrentMemoryContext in this file because of PGDLLIMPORT conflict.
- */
-#if defined(WIN32) || defined(__CYGWIN__)
-#undef palloc
-#undef pstrdup
-#define palloc(sz) pgport_palloc(sz)
-#define pstrdup(str) pgport_pstrdup(str)
-#endif
-
static void fsync_fname(char *fname, bool isdir);
return ret;
}
+void *
+palloc(Size size)
+{
+ /* duplicates MemoryContextAlloc to avoid increased overhead */
+ AssertArg(MemoryContextIsValid(CurrentMemoryContext));
+
+ if (!AllocSizeIsValid(size))
+ elog(ERROR, "invalid memory alloc request size %lu",
+ (unsigned long) size);
+
+ CurrentMemoryContext->isReset = false;
+
+ return (*CurrentMemoryContext->methods->alloc) (CurrentMemoryContext, size);
+}
+
+void *
+palloc0(Size size)
+{
+ /* duplicates MemoryContextAllocZero to avoid increased overhead */
+ void *ret;
+
+ AssertArg(MemoryContextIsValid(CurrentMemoryContext));
+
+ if (!AllocSizeIsValid(size))
+ elog(ERROR, "invalid memory alloc request size %lu",
+ (unsigned long) size);
+
+ CurrentMemoryContext->isReset = false;
+
+ ret = (*CurrentMemoryContext->methods->alloc) (CurrentMemoryContext, size);
+
+ MemSetAligned(ret, 0, size);
+
+ return ret;
+}
+
/*
* pfree
* Release an allocated chunk.
return nstr;
}
+char *
+pstrdup(const char *in)
+{
+ return MemoryContextStrdup(CurrentMemoryContext, in);
+}
+
/*
* pnstrdup
* Like pstrdup(), but append null byte to a
out[len] = '\0';
return out;
}
-
-
-#if defined(WIN32) || defined(__CYGWIN__)
-/*
- * Memory support routines for libpgport on Win32
- *
- * Win32 can't load a library that PGDLLIMPORTs a variable
- * if the link object files also PGDLLIMPORT the same variable.
- * For this reason, libpgport can't reference CurrentMemoryContext
- * in the palloc macro calls.
- *
- * To fix this, we create several functions here that allow us to
- * manage memory without doing the inline in libpgport.
- */
-void *
-pgport_palloc(Size sz)
-{
- return palloc(sz);
-}
-
-
-char *
-pgport_pstrdup(const char *str)
-{
- return pstrdup(str);
-}
-
-
-/* Doesn't reference a PGDLLIMPORT variable, but here for completeness. */
-void
-pgport_pfree(void *pointer)
-{
- pfree(pointer);
-}
-
-#endif
static char bin_path[MAXPGPATH];
static char backend_exec[MAXPGPATH];
-static void *pg_malloc(size_t size);
-static char *pg_strdup(const char *s);
static char **replace_token(char **lines,
const char *token, const char *replacement);
#define DIR_SEP "\\"
#endif
-/*
- * routines to check mem allocations and fail noisily.
- *
- * Note that we can't call exit_nicely() on a memory failure, as it calls
- * rmtree() which needs memory allocation. So we just exit with a bang.
- */
-static void *
-pg_malloc(size_t size)
-{
- void *result;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- result = malloc(size);
- if (!result)
- {
- fprintf(stderr, _("%s: out of memory\n"), progname);
- exit(1);
- }
- return result;
-}
-
-static char *
-pg_strdup(const char *s)
-{
- char *result;
-
- result = strdup(s);
- if (!result)
- {
- fprintf(stderr, _("%s: out of memory\n"), progname);
- exit(1);
- }
- return result;
-}
-
static char *
escape_quotes(const char *src)
{
static char *dbpassword = NULL;
PGconn *conn = NULL;
-/*
- * strdup() and malloc() replacements that print an error and exit
- * if something goes wrong. Can never return NULL.
- */
-char *
-pg_strdup(const char *s)
-{
- char *result;
-
- result = strdup(s);
- if (!result)
- {
- fprintf(stderr, _("%s: out of memory\n"), progname);
- exit(1);
- }
- return result;
-}
-
-void *
-pg_malloc0(size_t size)
-{
- void *result;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- result = malloc(size);
- if (!result)
- {
- fprintf(stderr, _("%s: out of memory\n"), progname);
- exit(1);
- }
- MemSet(result, 0, size);
- return result;
-}
-
-
/*
* Connect to the server. Returns a valid PGconn pointer if connected,
* or NULL on non-permanent error. On permanent error, the function will
exit(code); \
}
-
-extern char *pg_strdup(const char *s);
-extern void *pg_malloc0(size_t size);
-
extern PGconn *GetConnection(void);
/* This extension allows gcc to check the format string for consistency with
the supplied arguments. */
__attribute__((format(PG_PRINTF_ATTRIBUTE, 1, 2)));
-static void *pg_malloc(size_t size);
-static char *pg_strdup(const char *s);
static void do_advice(void);
static void do_help(void);
static void set_mode(char *modeopt);
va_end(ap);
}
-/*
- * routines to check memory allocations and fail noisily.
- */
-
-static void *
-pg_malloc(size_t size)
-{
- void *result;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- result = malloc(size);
- if (!result)
- {
- write_stderr(_("%s: out of memory\n"), progname);
- exit(1);
- }
- return result;
-}
-
-
-static char *
-pg_strdup(const char *s)
-{
- char *result;
-
- result = strdup(s);
- if (!result)
- {
- write_stderr(_("%s: out of memory\n"), progname);
- exit(1);
- }
- return result;
-}
-
/*
* Given an already-localized string, print it to stdout unless the
* user has specified that no messages should be printed.
OBJS= pg_backup_archiver.o pg_backup_db.o pg_backup_custom.o \
pg_backup_null.o pg_backup_tar.o \
- pg_backup_directory.o dumpmem.o dumputils.o compress_io.o $(WIN32RES)
+ pg_backup_directory.o dumputils.o compress_io.o $(WIN32RES)
KEYWRDOBJS = keywords.o kwlookup.o
pg_restore: pg_restore.o $(OBJS) $(KEYWRDOBJS) | submake-libpq submake-libpgport
$(CC) $(CFLAGS) pg_restore.o $(KEYWRDOBJS) $(OBJS) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
-pg_dumpall: pg_dumpall.o dumputils.o dumpmem.o $(KEYWRDOBJS) | submake-libpq submake-libpgport
- $(CC) $(CFLAGS) pg_dumpall.o dumputils.o dumpmem.o $(KEYWRDOBJS) $(WIN32RES) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
+pg_dumpall: pg_dumpall.o dumputils.o $(KEYWRDOBJS) | submake-libpq submake-libpgport
+ $(CC) $(CFLAGS) pg_dumpall.o dumputils.o $(KEYWRDOBJS) $(WIN32RES) $(libpq_pgport) $(LDFLAGS) $(LDFLAGS_EX) $(LIBS) -o $@$(X)
install: all installdirs
$(INSTALL_PROGRAM) pg_dump$(X) '$(DESTDIR)$(bindir)'/pg_dump$(X)
#include <ctype.h>
#include "catalog/pg_class.h"
-#include "dumpmem.h"
-#include "dumputils.h"
/*
*/
#include "compress_io.h"
-#include "dumpmem.h"
#include "dumputils.h"
/*----------------------
+++ /dev/null
-/*-------------------------------------------------------------------------
- *
- * dumpmem.c
- * Memory allocation routines used by pg_dump, pg_dumpall, and pg_restore
- *
- * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- *
- * IDENTIFICATION
- * src/bin/pg_dump/dumpmem.c
- *
- *-------------------------------------------------------------------------
- */
-#include "postgres_fe.h"
-
-#include "dumputils.h"
-#include "dumpmem.h"
-
-
-/*
- * Safer versions of some standard C library functions. If an
- * out-of-memory condition occurs, these functions will bail out via exit();
- *therefore, their return value is guaranteed to be non-NULL.
- */
-
-char *
-pg_strdup(const char *string)
-{
- char *tmp;
-
- if (!string)
- exit_horribly(NULL, "cannot duplicate null pointer\n");
- tmp = strdup(string);
- if (!tmp)
- exit_horribly(NULL, "out of memory\n");
- return tmp;
-}
-
-void *
-pg_malloc(size_t size)
-{
- void *tmp;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- tmp = malloc(size);
- if (!tmp)
- exit_horribly(NULL, "out of memory\n");
- return tmp;
-}
-
-void *
-pg_malloc0(size_t size)
-{
- void *tmp;
-
- tmp = pg_malloc(size);
- MemSet(tmp, 0, size);
- return tmp;
-}
-
-void *
-pg_realloc(void *ptr, size_t size)
-{
- void *tmp;
-
- /* Avoid unportable behavior of realloc(NULL, 0) */
- if (ptr == NULL && size == 0)
- size = 1;
- tmp = realloc(ptr, size);
- if (!tmp)
- exit_horribly(NULL, "out of memory\n");
- return tmp;
-}
+++ /dev/null
-/*-------------------------------------------------------------------------
- *
- * dumpmem.h
- * Memory allocation routines used by pg_dump, pg_dumpall, and pg_restore
- *
- * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * src/bin/pg_dump/dumpmem.h
- *
- *-------------------------------------------------------------------------
- */
-
-#ifndef DUMPMEM_H
-#define DUMPMEM_H
-
-extern char *pg_strdup(const char *string);
-extern void *pg_malloc(size_t size);
-extern void *pg_malloc0(size_t size);
-extern void *pg_realloc(void *ptr, size_t size);
-
-#endif /* DUMPMEM_H */
#include <ctype.h>
#include "dumputils.h"
-#include "dumpmem.h"
#include "parser/keywords.h"
AVAIL_LANGUAGES = de es fr it ja ko pt_BR sv tr zh_CN zh_TW
GETTEXT_FILES = pg_backup_archiver.c pg_backup_db.c pg_backup_custom.c \
pg_backup_null.c pg_backup_tar.c \
- pg_backup_directory.c dumpmem.c dumputils.c compress_io.c \
+ pg_backup_directory.c dumputils.c compress_io.c \
pg_dump.c common.c pg_dump_sort.c \
pg_restore.c pg_dumpall.c \
../../port/exec.c
*/
#include "pg_backup_db.h"
-#include "dumpmem.h"
#include "dumputils.h"
#include <ctype.h>
#include "compress_io.h"
#include "dumputils.h"
-#include "dumpmem.h"
/*--------
* Routines in the format interface
*/
#include "pg_backup_db.h"
-#include "dumpmem.h"
#include "dumputils.h"
#include <unistd.h>
*/
#include "compress_io.h"
-#include "dumpmem.h"
#include "dumputils.h"
#include <dirent.h>
*/
#include "pg_backup_archiver.h"
-#include "dumpmem.h"
#include "dumputils.h"
#include <unistd.h> /* for dup */
#include "pg_backup.h"
#include "pg_backup_archiver.h"
#include "pg_backup_tar.h"
-#include "dumpmem.h"
#include "dumputils.h"
#include "pgtar.h"
#include "pg_backup_archiver.h"
#include "pg_backup_db.h"
-#include "dumpmem.h"
#include "dumputils.h"
extern char *optarg;
*/
#include "pg_backup_archiver.h"
#include "dumputils.h"
-#include "dumpmem.h"
/* translator: this is a module name */
static const char *modulename = gettext_noop("sorter");
#include "getopt_long.h"
#include "dumputils.h"
-#include "dumpmem.h"
#include "pg_backup.h"
/* version string we expect back from pg_dump */
#include "pg_backup_archiver.h"
-#include "dumpmem.h"
#include "dumputils.h"
#include <ctype.h>
#include "access/xlog_internal.h"
#include "catalog/catversion.h"
#include "catalog/pg_control.h"
+#include "common/fe_memutils.h"
extern int optind;
extern char *optarg;
}
/* Use malloc to ensure we have a maxaligned buffer */
- buffer = (char *) malloc(PG_CONTROL_SIZE);
+ buffer = (char *) pg_malloc(PG_CONTROL_SIZE);
len = read(fd, buffer, PG_CONTROL_SIZE);
if (len < 0)
int nbytes;
/* Use malloc() to ensure buffer is MAXALIGNED */
- buffer = (char *) malloc(XLOG_BLCKSZ);
+ buffer = (char *) pg_malloc(XLOG_BLCKSZ);
page = (XLogPageHeader) buffer;
memset(buffer, 0, XLOG_BLCKSZ);
static bool command_no_begin(const char *query);
static bool is_select_command(const char *query);
-/*
- * "Safe" wrapper around strdup()
- */
-char *
-pg_strdup(const char *string)
-{
- char *tmp;
-
- if (!string)
- {
- psql_error("%s: pg_strdup: cannot duplicate null pointer (internal error)\n",
- pset.progname);
- exit(EXIT_FAILURE);
- }
- tmp = strdup(string);
- if (!tmp)
- {
- psql_error("out of memory\n");
- exit(EXIT_FAILURE);
- }
- return tmp;
-}
-
-void *
-pg_malloc(size_t size)
-{
- void *tmp;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- tmp = malloc(size);
- if (!tmp)
- {
- psql_error("out of memory\n");
- exit(EXIT_FAILURE);
- }
- return tmp;
-}
-
-void *
-pg_malloc0(size_t size)
-{
- void *tmp;
-
- tmp = pg_malloc(size);
- MemSet(tmp, 0, size);
- return tmp;
-}
-
/*
* setQFout
* -- handler for -o command line option and \o command
#define atooid(x) ((Oid) strtoul((x), NULL, 10))
-/*
- * Safer versions of some standard C library functions. If an
- * out-of-memory condition occurs, these functions will bail out
- * safely; therefore, their return value is guaranteed to be non-NULL.
- */
-extern char *pg_strdup(const char *string);
-extern void *pg_malloc(size_t size);
-extern void *pg_malloc0(size_t size);
-
extern bool setQFout(const char *fname);
extern void
return r;
}
-/*
- * "Safe" wrapper around strdup(). Pulled from psql/common.c
- */
-char *
-pg_strdup(const char *string)
-{
- char *tmp;
-
- if (!string)
- {
- fprintf(stderr, _("pg_strdup: cannot duplicate null pointer (internal error)\n"));
- exit(EXIT_FAILURE);
- }
- tmp = strdup(string);
- if (!tmp)
- {
- fprintf(stderr, _("out of memory\n"));
- exit(EXIT_FAILURE);
- }
- return tmp;
-}
-
-void *
-pg_malloc(size_t size)
-{
- void *tmp;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- tmp = malloc(size);
- if (!tmp)
- {
- fprintf(stderr, _("out of memory\n"));
- exit(EXIT_FAILURE);
- }
- return tmp;
-}
-
-void *
-pg_malloc0(size_t size)
-{
- void *tmp;
-
- tmp = pg_malloc(size);
- MemSet(tmp, 0, size);
- return tmp;
-}
-
/*
* Check yes/no answer in a localized way. 1=yes, 0=no, -1=neither.
*/
extern void setup_cancel_handler(void);
-extern char *pg_strdup(const char *string);
-extern void *pg_malloc(size_t size);
-extern void *pg_malloc0(size_t size);
-
#endif /* COMMON_H */
--- /dev/null
+#-------------------------------------------------------------------------
+#
+# Makefile
+# Makefile for src/common
+#
+# This makefile generates two outputs:
+#
+# libpgcommon.a - contains object files with FRONTEND defined,
+# for use by client application and libraries
+#
+# libpgcommon_srv.a - contains object files without FRONTEND defined,
+# for use only by the backend binaries
+#
+# IDENTIFICATION
+# src/common/Makefile
+#
+#-------------------------------------------------------------------------
+
+subdir = src/common
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+
+override CPPFLAGS := -DFRONTEND $(CPPFLAGS)
+LIBS += $(PTHREAD_LIBS)
+
+OBJS_COMMON =
+
+OBJS_FRONTEND = $(OBJS_COMMON) fe_memutils.o
+
+OBJS_SRV = $(OBJS_COMMON:%.o=%_srv.o)
+
+all: libpgcommon.a libpgcommon_srv.a
+
+# libpgcommon is needed by some contrib
+install: all installdirs
+ $(INSTALL_STLIB) libpgcommon.a '$(DESTDIR)$(libdir)/libpgcommon.a'
+
+installdirs:
+ $(MKDIR_P) '$(DESTDIR)$(libdir)'
+
+uninstall:
+ rm -f '$(DESTDIR)$(libdir)/libpgcommon.a'
+
+libpgcommon.a: $(OBJS_FRONTEND)
+ $(AR) $(AROPT) $@ $^
+
+#
+# Server versions of object files
+#
+
+libpgcommon_srv.a: $(OBJS_SRV)
+ $(AR) $(AROPT) $@ $^
+
+# Because this uses its own compilation rule, it doesn't use the
+# dependency tracking logic from Makefile.global. To make sure that
+# dependency tracking works anyway for the *_srv.o files, depend on
+# their *.o siblings as well, which do have proper dependencies. It's
+# a hack that might fail someday if there is a *_srv.o without a
+# corresponding *.o, but it works for now.
+%_srv.o: %.c %.o
+ $(CC) $(CFLAGS) $(subst -DFRONTEND,, $(CPPFLAGS)) -c $< -o $@
+
+clean distclean maintainer-clean:
+ rm -f libpgcommon.a libpgcommon_srv.a $(OBJS_FRONTEND) $(OBJS_SRV)
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * fe_memutils.c
+ * memory management support for frontend code
+ *
+ * Portions Copyright (c) 1996-2013, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ * src/common/fe_memutils.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef FRONTEND
+#error "This file is not expected to be compiled for backend code"
+#endif
+
+#include "postgres_fe.h"
+
+void *
+pg_malloc(size_t size)
+{
+ void *tmp;
+
+ /* Avoid unportable behavior of malloc(0) */
+ if (size == 0)
+ size = 1;
+ tmp = malloc(size);
+ if (!tmp)
+ {
+ fprintf(stderr, _("out of memory\n"));
+ exit(EXIT_FAILURE);
+ }
+ return tmp;
+}
+
+void *
+pg_malloc0(size_t size)
+{
+ void *tmp;
+
+ tmp = pg_malloc(size);
+ MemSet(tmp, 0, size);
+ return tmp;
+}
+
+void *
+pg_realloc(void *ptr, size_t size)
+{
+ void *tmp;
+
+ /* Avoid unportable behavior of realloc(NULL, 0) */
+ if (ptr == NULL && size == 0)
+ size = 1;
+ tmp = realloc(ptr, size);
+ if (!tmp)
+ {
+ fprintf(stderr, _("out of memory\n"));
+ exit(EXIT_FAILURE);
+ }
+ return tmp;
+}
+
+/*
+ * "Safe" wrapper around strdup().
+ */
+char *
+pg_strdup(const char *string)
+{
+ char *tmp;
+
+ if (!string)
+ {
+ fprintf(stderr,
+ _("cannot duplicate null pointer (internal error)\n"));
+ exit(EXIT_FAILURE);
+ }
+ tmp = strdup(string);
+ if (!tmp)
+ {
+ fprintf(stderr, _("out of memory\n"));
+ exit(EXIT_FAILURE);
+ }
+ return tmp;
+}
+
+void
+pg_free(void *ptr)
+{
+ if (ptr != NULL)
+ free(ptr);
+}
+
+/*
+ * Frontend emulation of backend memory management functions. Useful for
+ * programs that compile backend files.
+ */
+void *
+palloc(Size size)
+{
+ return pg_malloc(size);
+}
+
+void *
+palloc0(Size size)
+{
+ return pg_malloc0(size);
+}
+
+void
+pfree(void *pointer)
+{
+ pg_free(pointer);
+}
+
+char *
+pstrdup(const char *string)
+{
+ return pg_strdup(string);
+}
+
+void *
+repalloc(void *pointer, Size size)
+{
+ return pg_realloc(pointer, size);
+}
--- /dev/null
+/*
+ * fe_memutils.h
+ * memory management support for frontend code
+ *
+ * Copyright (c) 2003-2013, PostgreSQL Global Development Group
+ *
+ * src/include/common/fe_memutils.h
+ */
+#ifndef FE_MEMUTILS_H
+#define FE_MEMUTILS_H
+
+extern char *pg_strdup(const char *string);
+extern void *pg_malloc(size_t size);
+extern void *pg_malloc0(size_t size);
+extern void *pg_realloc(void *pointer, size_t size);
+extern void pg_free(void *pointer);
+
+#include "utils/palloc.h"
+
+#endif /* FE_MEMUTILS_H */
#include "c.h"
+#include "common/fe_memutils.h"
+
#endif /* POSTGRES_FE_H */
#ifndef PALLOC_H
#define PALLOC_H
+#ifndef FRONTEND
+
/*
* Type MemoryContextData is declared in nodes/memnodes.h. Most users
* of memory allocation should just treat it as an abstract type, so we
extern void *MemoryContextAllocZero(MemoryContext context, Size size);
extern void *MemoryContextAllocZeroAligned(MemoryContext context, Size size);
-#define palloc(sz) MemoryContextAlloc(CurrentMemoryContext, (sz))
-
-#define palloc0(sz) MemoryContextAllocZero(CurrentMemoryContext, (sz))
-
/*
* The result of palloc() is always word-aligned, so we can skip testing
* alignment of the pointer when deciding which MemSet variant to use.
MemoryContextAllocZeroAligned(CurrentMemoryContext, sz) : \
MemoryContextAllocZero(CurrentMemoryContext, sz) )
-extern void pfree(void *pointer);
-
-extern void *repalloc(void *pointer, Size size);
-
/*
* MemoryContextSwitchTo can't be a macro in standard C compilers.
* But we can make it an inline function if the compiler supports it.
* See STATIC_IF_INLINE in c.h.
- *
- * This file has to be includable by some non-backend code such as
- * pg_resetxlog, so don't expose the CurrentMemoryContext reference
- * if FRONTEND is defined.
*/
-#ifndef FRONTEND
#ifndef PG_USE_INLINE
extern MemoryContext MemoryContextSwitchTo(MemoryContext context);
return old;
}
#endif /* PG_USE_INLINE || MCXT_INCLUDE_DEFINITIONS */
-#endif /* !FRONTEND */
/*
* These are like standard strdup() except the copied string is
* allocated in a context, not with malloc().
*/
extern char *MemoryContextStrdup(MemoryContext context, const char *string);
+#endif /* !FRONTEND */
-#define pstrdup(str) MemoryContextStrdup(CurrentMemoryContext, (str))
-
+extern char *pstrdup(const char *in);
extern char *pnstrdup(const char *in, Size len);
-
-#if defined(WIN32) || defined(__CYGWIN__)
-extern void *pgport_palloc(Size sz);
-extern char *pgport_pstrdup(const char *str);
-extern void pgport_pfree(void *pointer);
-#endif
+extern void *palloc(Size size);
+extern void *palloc0(Size size);
+extern void pfree(void *pointer);
+extern void *repalloc(void *pointer, Size size);
#endif /* PALLOC_H */
#endif
#endif
-
-#ifndef FRONTEND
-
-/*
- * On Windows, call non-macro versions of palloc; we can't reference
- * CurrentMemoryContext in this file because of PGDLLIMPORT conflict.
- */
-#if defined(WIN32) || defined(__CYGWIN__)
-#undef palloc
-#undef pstrdup
-#define palloc(sz) pgport_palloc(sz)
-#define pstrdup(str) pgport_pstrdup(str)
-#endif
-#else /* FRONTEND */
-
-/*
- * In frontend, fake palloc behavior with these
- */
-#undef palloc
-#undef pstrdup
-#define palloc(sz) fe_palloc(sz)
-#define pstrdup(str) fe_pstrdup(str)
-#define repalloc(pointer,sz) fe_repalloc(pointer,sz)
-#define pfree(pointer) free(pointer)
-
-static void *
-fe_palloc(Size size)
-{
- void *res;
-
- /* Avoid unportable behavior of malloc(0) */
- if (size == 0)
- size = 1;
- res = malloc(size);
- if (res == NULL)
- {
- fprintf(stderr, _("out of memory\n"));
- exit(1);
- }
- return res;
-}
-
-static char *
-fe_pstrdup(const char *string)
-{
- char *res;
-
- if ((res = strdup(string)) == NULL)
- {
- fprintf(stderr, _("out of memory\n"));
- exit(1);
- }
- return res;
-}
-
-static void *
-fe_repalloc(void *pointer, Size size)
-{
- void *res;
-
- /* Avoid unportable behavior of realloc(NULL, 0) */
- if (pointer == NULL && size == 0)
- size = 1;
- res = realloc(pointer, size);
- if (res == NULL)
- {
- fprintf(stderr, _("out of memory\n"));
- exit(1);
- }
- return res;
-}
-#endif /* FRONTEND */
-
-
#if defined(WIN32) || defined(__CYGWIN__)
/*
'Import libraries', $target . '/lib/',
"$conf\\", "postgres\\postgres.lib",
"libpq\\libpq.lib", "libecpg\\libecpg.lib",
+ "libpgcommon\\libpgcommon.lib",
"libpgport\\libpgport.lib", "libpgtypes\\libpgtypes.lib",
"libecpg_compat\\libecpg_compat.lib");
CopySetOfFiles(
my $solution;
my $libpgport;
+my $libpgcommon;
my $postgres;
my $libpq;
'pg_standby', 'pg_archivecleanup',
'pg_test_fsync', 'pg_test_timing',
'pg_upgrade', 'vacuumlo');
+my @contrib_uselibpgcommon = (
+ 'oid2name', 'pgbench',
+ 'pg_standby', 'pg_archivecleanup',
+ 'pg_test_fsync', 'pg_test_timing',
+ 'pg_upgrade', 'vacuumlo');
my $contrib_extralibs = { 'pgbench' => ['wsock32.lib'] };
my $contrib_extraincludes =
{ 'tsearch2' => ['contrib/tsearch2'], 'dblink' => ['src/backend'] };
sprompt.c tar.c thread.c getopt.c getopt_long.c dirent.c rint.c win32env.c
win32error.c win32setlocale.c);
+ our @pgcommonfiles = qw(
+ fe_memutils.c);
+
+ our @pgcommonbkndfiles = qw();
+
$libpgport = $solution->AddProject('libpgport', 'lib', 'misc');
$libpgport->AddDefine('FRONTEND');
$libpgport->AddFiles('src\port', @pgportfiles);
+ $libpgcommon = $solution->AddProject('libpgcommon', 'lib', 'misc');
+ $libpgcommon->AddDefine('FRONTEND');
+ $libpgcommon->AddFiles('src\common', @pgcommonfiles);
+
$postgres = $solution->AddProject('postgres', 'exe', '', 'src\backend');
$postgres->AddIncludeDir('src\backend');
$postgres->AddDir('src\backend\port\win32');
$postgres->ReplaceFile('src\backend\port\pg_latch.c',
'src\backend\port\win32_latch.c');
$postgres->AddFiles('src\port', @pgportfiles);
+ $postgres->AddFiles('src\common', @pgcommonbkndfiles);
$postgres->AddDir('src\timezone');
$postgres->AddFiles('src\backend\parser', 'scan.l', 'gram.y');
$postgres->AddFiles('src\backend\bootstrap', 'bootscanner.l',
$ecpg->AddDefine('MINOR_VERSION=9');
$ecpg->AddDefine('PATCHLEVEL=0');
$ecpg->AddDefine('ECPG_COMPILE');
- $ecpg->AddReference($libpgport);
+ $ecpg->AddReference($libpgport, $libpgcommon);
my $pgregress_ecpg =
$solution->AddProject('pg_regress_ecpg', 'exe', 'misc');
$pgregress_ecpg->AddIncludeDir('src\test\regress');
$pgregress_ecpg->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
$pgregress_ecpg->AddDefine('FRONTEND');
- $pgregress_ecpg->AddReference($libpgport);
+ $pgregress_ecpg->AddReference($libpgport, $libpgcommon);
my $isolation_tester =
$solution->AddProject('isolationtester', 'exe', 'misc');
$pgregress_isolation->AddIncludeDir('src\test\regress');
$pgregress_isolation->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
$pgregress_isolation->AddDefine('FRONTEND');
- $pgregress_isolation->AddReference($libpgport);
+ $pgregress_isolation->AddReference($libpgport, $libpgcommon);
# src/bin
my $initdb = AddSimpleFrontend('initdb');
$pgdumpall->AddIncludeDir('src\backend');
$pgdumpall->AddFile('src\bin\pg_dump\pg_dumpall.c');
$pgdumpall->AddFile('src\bin\pg_dump\dumputils.c');
- $pgdumpall->AddFile('src\bin\pg_dump\dumpmem.c');
$pgdumpall->AddFile('src\bin\pg_dump\keywords.c');
$pgdumpall->AddFile('src\backend\parser\kwlookup.c');
my $zic = $solution->AddProject('zic', 'exe', 'utils');
$zic->AddFiles('src\timezone', 'zic.c', 'ialloc.c', 'scheck.c',
'localtime.c');
- $zic->AddReference($libpgport);
+ $zic->AddReference($libpgport, $libpgcommon);
if ($solution->{options}->{xml})
{
$proj->AddIncludeDir('src\interfaces\libpq');
$proj->AddIncludeDir('src\bin\pg_dump');
$proj->AddIncludeDir('src\bin\psql');
- $proj->AddReference($libpq, $libpgport);
+ $proj->AddReference($libpq, $libpgport, $libpgcommon);
$proj->AddResourceFile('src\bin\scripts', 'PostgreSQL Utility');
}
$pgregress->AddFile('src\test\regress\pg_regress_main.c');
$pgregress->AddIncludeDir('src\port');
$pgregress->AddDefine('HOST_TUPLE="i686-pc-win32vc"');
- $pgregress->AddReference($libpgport);
+ $pgregress->AddReference($libpgport, $libpgcommon);
$solution->Save();
return $solution->{vcver};
my $p = $solution->AddProject($n, 'exe', 'bin');
$p->AddDir('src\bin\\' . $n);
- $p->AddReference($libpgport);
+ $p->AddReference($libpgport, $libpgcommon);
if ($uselibpq)
{
$p->AddIncludeDir('src\interfaces\libpq');
{
$proj->AddReference($libpgport);
}
+ if (grep { /^$n$/ } @contrib_uselibpgcommon)
+ {
+ $proj->AddReference($libpgcommon);
+ }
if ($contrib_extralibs->{$n})
{
foreach my $l (@{ $contrib_extralibs->{$n} })
if ($filter eq "LIBOBJS")
{
- if (grep(/$p/, @main::pgportfiles) == 1)
+ if (grep(/$p/, @main::pgportfiles, @main::pgcommonfiles) == 1)
{
$p =~ s/\.c/\.o/;
$matches .= $p . " ";
projects / users / c2main / postgres.git / commitdiff