embedded-postgres 18.6.0__py3-none-win_amd64.whl

embedded_postgres/pginstall/include/server/postmaster/syslogger.h

@@ -0,0 +1,105 @@
+/*-------------------------------------------------------------------------
+ *
+ * syslogger.h
+ *	  Exports from postmaster/syslogger.c.
+ *
+ * Copyright (c) 2004-2025, PostgreSQL Global Development Group
+ *
+ * src/include/postmaster/syslogger.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _SYSLOGGER_H
+#define _SYSLOGGER_H
+
+#include <limits.h>				/* for PIPE_BUF */
+
+
+/*
+ * Primitive protocol structure for writing to syslogger pipe(s).  The idea
+ * here is to divide long messages into chunks that are not more than
+ * PIPE_BUF bytes long, which according to POSIX spec must be written into
+ * the pipe atomically.  The pipe reader then uses the protocol headers to
+ * reassemble the parts of a message into a single string.  The reader can
+ * also cope with non-protocol data coming down the pipe, though we cannot
+ * guarantee long strings won't get split apart.
+ *
+ * We use non-nul bytes in is_last to make the protocol a tiny bit
+ * more robust against finding a false double nul byte prologue. But
+ * we still might find it in the len and/or pid bytes unless we're careful.
+ */
+
+#ifdef PIPE_BUF
+/* Are there any systems with PIPE_BUF > 64K?  Unlikely, but ... */
+#if PIPE_BUF > 65536
+#define PIPE_CHUNK_SIZE  65536
+#else
+#define PIPE_CHUNK_SIZE  ((int) PIPE_BUF)
+#endif
+#else							/* not defined */
+/* POSIX says the value of PIPE_BUF must be at least 512, so use that */
+#define PIPE_CHUNK_SIZE  512
+#endif
+
+typedef struct
+{
+	char		nuls[2];		/* always \0\0 */
+	uint16		len;			/* size of this chunk (counts data only) */
+	int32		pid;			/* writer's pid */
+	bits8		flags;			/* bitmask of PIPE_PROTO_* */
+	char		data[FLEXIBLE_ARRAY_MEMBER];	/* data payload starts here */
+} PipeProtoHeader;
+
+typedef union
+{
+	PipeProtoHeader proto;
+	char		filler[PIPE_CHUNK_SIZE];
+} PipeProtoChunk;
+
+#define PIPE_HEADER_SIZE  offsetof(PipeProtoHeader, data)
+#define PIPE_MAX_PAYLOAD  ((int) (PIPE_CHUNK_SIZE - PIPE_HEADER_SIZE))
+
+/* flag bits for PipeProtoHeader->flags */
+#define PIPE_PROTO_IS_LAST	0x01	/* last chunk of message? */
+/* log destinations */
+#define PIPE_PROTO_DEST_STDERR	0x10
+#define PIPE_PROTO_DEST_CSVLOG	0x20
+#define PIPE_PROTO_DEST_JSONLOG	0x40
+
+/* GUC options */
+extern PGDLLIMPORT bool Logging_collector;
+extern PGDLLIMPORT int Log_RotationAge;
+extern PGDLLIMPORT int Log_RotationSize;
+extern PGDLLIMPORT char *Log_directory;
+extern PGDLLIMPORT char *Log_filename;
+extern PGDLLIMPORT bool Log_truncate_on_rotation;
+extern PGDLLIMPORT int Log_file_mode;
+
+#ifdef EXEC_BACKEND
+extern PGDLLIMPORT pg_time_t first_syslogger_file_time;
+#endif
+
+#ifndef WIN32
+extern PGDLLIMPORT int syslogPipe[2];
+#else
+extern PGDLLIMPORT HANDLE syslogPipe[2];
+#endif
+
+
+extern int	SysLogger_Start(int child_slot);
+
+extern void write_syslogger_file(const char *buffer, int count, int destination);
+
+pg_noreturn extern void SysLoggerMain(const void *startup_data, size_t startup_data_len);
+
+extern bool CheckLogrotateSignal(void);
+extern void RemoveLogrotateSignalFiles(void);
+
+/*
+ * Name of files saving meta-data information about the log
+ * files currently in use by the syslogger
+ */
+#define LOG_METAINFO_DATAFILE  "current_logfiles"
+#define LOG_METAINFO_DATAFILE_TMP  LOG_METAINFO_DATAFILE ".tmp"
+
+#endif							/* _SYSLOGGER_H */

embedded_postgres/pginstall/include/server/postmaster/walsummarizer.h

@@ -0,0 +1,35 @@
+/*-------------------------------------------------------------------------
+ *
+ * walsummarizer.h
+ *
+ * Header file for background WAL summarization process.
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ *	  src/include/postmaster/walsummarizer.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef WALSUMMARIZER_H
+#define WALSUMMARIZER_H
+
+#include "access/xlogdefs.h"
+
+extern PGDLLIMPORT bool summarize_wal;
+extern PGDLLIMPORT int wal_summary_keep_time;
+
+extern Size WalSummarizerShmemSize(void);
+extern void WalSummarizerShmemInit(void);
+pg_noreturn extern void WalSummarizerMain(const void *startup_data, size_t startup_data_len);
+
+extern void GetWalSummarizerState(TimeLineID *summarized_tli,
+								  XLogRecPtr *summarized_lsn,
+								  XLogRecPtr *pending_lsn,
+								  int *summarizer_pid);
+extern XLogRecPtr GetOldestUnsummarizedLSN(TimeLineID *tli,
+										   bool *lsn_is_exact);
+extern void WakeupWalSummarizer(void);
+extern void WaitForWalSummarization(XLogRecPtr lsn);
+
+#endif

embedded_postgres/pginstall/include/server/postmaster/walwriter.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * walwriter.h
+ *	  Exports from postmaster/walwriter.c.
+ *
+ * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
+ *
+ * src/include/postmaster/walwriter.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _WALWRITER_H
+#define _WALWRITER_H
+
+#define DEFAULT_WAL_WRITER_FLUSH_AFTER ((1024 * 1024) / XLOG_BLCKSZ)
+
+/* GUC options */
+extern PGDLLIMPORT int WalWriterDelay;
+extern PGDLLIMPORT int WalWriterFlushAfter;
+
+pg_noreturn extern void WalWriterMain(const void *startup_data, size_t startup_data_len);
+
+#endif							/* _WALWRITER_H */

embedded_postgres/pginstall/include/server/regex/regcustom.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ *
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them.
+ *
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ *
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * src/include/regex/regcustom.h
+ */
+
+/* headers if any */
+
+/*
+ * It's against Postgres coding conventions to include postgres.h in a
+ * header file, but we allow the violation here because the regexp library
+ * files specifically intend this file to supply application-dependent
+ * headers, and are careful to include this file before anything else.
+ */
+#include "postgres.h"
+
+#include <ctype.h>
+#include <limits.h>
+#include <wctype.h>
+
+#include "mb/pg_wchar.h"
+
+#include "miscadmin.h"			/* needed by rstacktoodeep */
+
+
+/* overrides for regguts.h definitions, if any */
+#define FUNCPTR(name, args) (*name) args
+#define MALLOC(n)		palloc_extended((n), MCXT_ALLOC_NO_OOM)
+#define FREE(p)			pfree(VS(p))
+#define REALLOC(p,n)	repalloc_extended(VS(p),(n), MCXT_ALLOC_NO_OOM)
+#define MALLOC_ARRAY(type, n) palloc_array_extended(type, n, MCXT_ALLOC_NO_OOM)
+#define REALLOC_ARRAY(p, type, n) repalloc_array_extended(p, type, n, MCXT_ALLOC_NO_OOM)
+#define INTERRUPT(re)	CHECK_FOR_INTERRUPTS()
+#define assert(x)		Assert(x)
+
+/* internal character type and related */
+typedef pg_wchar chr;			/* the type itself */
+typedef unsigned uchr;			/* unsigned type that will hold a chr */
+
+#define CHR(c)	((unsigned char) (c))	/* turn char literal into chr literal */
+#define DIGITVAL(c) ((c)-'0')	/* turn chr digit into its value */
+#define CHRBITS 32				/* bits in a chr; must not use sizeof */
+#define CHR_MIN 0x00000000		/* smallest and largest chr; the value */
+#define CHR_MAX 0x7ffffffe		/* CHR_MAX-CHR_MIN+1 must fit in an int, and
+								 * CHR_MAX+1 must fit in a chr variable */
+
+/*
+ * Check if a chr value is in range.  Ideally we'd just write this as
+ *		((c) >= CHR_MIN && (c) <= CHR_MAX)
+ * However, if chr is unsigned and CHR_MIN is zero, the first part of that
+ * is a no-op, and certain overly-nannyish compilers give warnings about it.
+ * So we leave that out here.  If you want to make chr signed and/or CHR_MIN
+ * not zero, redefine this macro as above.  Callers should assume that the
+ * macro may multiply evaluate its argument, even though it does not today.
+ */
+#define CHR_IS_IN_RANGE(c)	((c) <= CHR_MAX)
+
+/*
+ * MAX_SIMPLE_CHR is the cutoff between "simple" and "complicated" processing
+ * in the color map logic.  It should usually be chosen high enough to ensure
+ * that all common characters are <= MAX_SIMPLE_CHR.  However, very large
+ * values will be counterproductive since they cause more regex setup time.
+ * Also, small values can be helpful for testing the high-color-map logic
+ * with plain old ASCII input.
+ */
+#define MAX_SIMPLE_CHR	0x7FF	/* suitable value for Unicode */
+
+/* functions operating on chr */
+#define iscalnum(x) pg_wc_isalnum(x)
+#define iscalpha(x) pg_wc_isalpha(x)
+#define iscdigit(x) pg_wc_isdigit(x)
+#define iscspace(x) pg_wc_isspace(x)
+
+/* and pick up the standard header */
+#include "regex.h"

embedded_postgres/pginstall/include/server/regex/regerrs.h

@@ -0,0 +1,83 @@
+/*
+ * src/include/regex/regerrs.h
+ */
+
+{
+	REG_OKAY, "REG_OKAY", "no errors detected"
+},
+
+{
+	REG_NOMATCH, "REG_NOMATCH", "failed to match"
+},
+
+{
+	REG_BADPAT, "REG_BADPAT", "invalid regexp (reg version 0.8)"
+},
+
+{
+	REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element"
+},
+
+{
+	REG_ECTYPE, "REG_ECTYPE", "invalid character class"
+},
+
+{
+	REG_EESCAPE, "REG_EESCAPE", "invalid escape \\ sequence"
+},
+
+{
+	REG_ESUBREG, "REG_ESUBREG", "invalid backreference number"
+},
+
+{
+	REG_EBRACK, "REG_EBRACK", "brackets [] not balanced"
+},
+
+{
+	REG_EPAREN, "REG_EPAREN", "parentheses () not balanced"
+},
+
+{
+	REG_EBRACE, "REG_EBRACE", "braces {} not balanced"
+},
+
+{
+	REG_BADBR, "REG_BADBR", "invalid repetition count(s)"
+},
+
+{
+	REG_ERANGE, "REG_ERANGE", "invalid character range"
+},
+
+{
+	REG_ESPACE, "REG_ESPACE", "out of memory"
+},
+
+{
+	REG_BADRPT, "REG_BADRPT", "quantifier operand invalid"
+},
+
+{
+	REG_ASSERT, "REG_ASSERT", "\"cannot happen\" -- you found a bug"
+},
+
+{
+	REG_INVARG, "REG_INVARG", "invalid argument to regex function"
+},
+
+{
+	REG_MIXED, "REG_MIXED", "character widths of regex and string differ"
+},
+
+{
+	REG_BADOPT, "REG_BADOPT", "invalid embedded option"
+},
+
+{
+	REG_ETOOBIG, "REG_ETOOBIG", "regular expression is too complex"
+},
+
+{
+	REG_ECOLORS, "REG_ECOLORS", "too many colors"
+},

embedded_postgres/pginstall/include/server/regex/regex.h

@@ -0,0 +1,272 @@
+#ifndef _PG_REGEX_H_
+#define _PG_REGEX_H_			/* never again */
+/*
+ * regular expressions
+ *
+ * Copyright (c) 1998, 1999 Henry Spencer.  All rights reserved.
+ *
+ * Development of this software was funded, in part, by Cray Research Inc.,
+ * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
+ * Corporation, none of whom are responsible for the results.  The author
+ * thanks all of them.
+ *
+ * Redistribution and use in source and binary forms -- with or without
+ * modification -- are permitted for any purpose, provided that
+ * redistributions in source form retain this entire copyright notice and
+ * indicate the origin and nature of any modifications.
+ *
+ * I'd appreciate being given credit for this package in the documentation
+ * of software which uses it, but that is not a requirement.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * src/include/regex/regex.h
+ */
+
+/*
+ * This is an implementation of POSIX regex_t, so it clashes with the
+ * system-provided <regex.h> header.  That header might be unintentionally
+ * included already, so we force that to happen now on all systems to show that
+ * we can cope and that we completely replace the system regex interfaces.
+ *
+ * Note that we avoided using _REGEX_H_ as an include guard, as that confuses
+ * matters on BSD family systems including macOS that use the same include
+ * guard.
+ */
+#ifndef _WIN32
+#include <regex.h>
+#endif
+
+/* Avoid redefinition errors due to the system header. */
+#undef REG_UBACKREF
+#undef REG_ULOOKAROUND
+#undef REG_UBOUNDS
+#undef REG_UBRACES
+#undef REG_UBSALNUM
+#undef REG_UPBOTCH
+#undef REG_UBBS
+#undef REG_UNONPOSIX
+#undef REG_UUNSPEC
+#undef REG_UUNPORT
+#undef REG_ULOCALE
+#undef REG_UEMPTYMATCH
+#undef REG_UIMPOSSIBLE
+#undef REG_USHORTEST
+#undef REG_BASIC
+#undef REG_EXTENDED
+#undef REG_ADVF
+#undef REG_ADVANCED
+#undef REG_QUOTE
+#undef REG_NOSPEC
+#undef REG_ICASE
+#undef REG_NOSUB
+#undef REG_EXPANDED
+#undef REG_NLSTOP
+#undef REG_NLANCH
+#undef REG_NEWLINE
+#undef REG_PEND
+#undef REG_EXPECT
+#undef REG_BOSONLY
+#undef REG_DUMP
+#undef REG_FAKE
+#undef REG_PROGRESS
+#undef REG_NOTBOL
+#undef REG_NOTEOL
+#undef REG_STARTEND
+#undef REG_FTRACE
+#undef REG_MTRACE
+#undef REG_SMALL
+#undef REG_OKAY
+#undef REG_NOMATCH
+#undef REG_BADPAT
+#undef REG_ECOLLATE
+#undef REG_ECTYPE
+#undef REG_EESCAPE
+#undef REG_ESUBREG
+#undef REG_EBRACK
+#undef REG_EPAREN
+#undef REG_EBRACE
+#undef REG_BADBR
+#undef REG_ERANGE
+#undef REG_ESPACE
+#undef REG_BADRPT
+#undef REG_ASSERT
+#undef REG_INVARG
+#undef REG_MIXED
+#undef REG_BADOPT
+#undef REG_ETOOBIG
+#undef REG_ECOLORS
+#undef REG_ATOI
+#undef REG_ITOA
+#undef REG_PREFIX
+#undef REG_EXACT
+
+/*
+ * Add your own defines, if needed, here.
+ */
+#include "mb/pg_wchar.h"
+
+/*
+ * interface types etc.
+ */
+
+/*
+ * regoff_t has to be large enough to hold either off_t or ssize_t,
+ * and must be signed; it's only a guess that long is suitable.
+ */
+typedef long pg_regoff_t;
+
+/*
+ * other interface types
+ */
+
+/* the biggie, a compiled RE (or rather, a front end to same) */
+typedef struct
+{
+	int			re_magic;		/* magic number */
+	size_t		re_nsub;		/* number of subexpressions */
+	long		re_info;		/* bitmask of the following flags: */
+#define  REG_UBACKREF		000001	/* has back-reference (\n) */
+#define  REG_ULOOKAROUND	000002	/* has lookahead/lookbehind constraint */
+#define  REG_UBOUNDS		000004	/* has bounded quantifier ({m,n}) */
+#define  REG_UBRACES		000010	/* has { that doesn't begin a quantifier */
+#define  REG_UBSALNUM		000020	/* has backslash-alphanumeric in non-ARE */
+#define  REG_UPBOTCH		000040	/* has unmatched right paren in ERE (legal
+									 * per spec, but that was a mistake) */
+#define  REG_UBBS			000100	/* has backslash within bracket expr */
+#define  REG_UNONPOSIX		000200	/* has any construct that extends POSIX */
+#define  REG_UUNSPEC		000400	/* has any case disallowed by POSIX, e.g.
+									 * an empty branch */
+#define  REG_UUNPORT		001000	/* has numeric character code dependency */
+#define  REG_ULOCALE		002000	/* has locale dependency */
+#define  REG_UEMPTYMATCH	004000	/* can match a zero-length string */
+#define  REG_UIMPOSSIBLE	010000	/* provably cannot match anything */
+#define  REG_USHORTEST		020000	/* has non-greedy quantifier */
+	int			re_csize;		/* sizeof(character) */
+	char	   *re_endp;		/* backward compatibility kludge */
+	Oid			re_collation;	/* Collation that defines LC_CTYPE behavior */
+	/* the rest is opaque pointers to hidden innards */
+	char	   *re_guts;		/* `char *' is more portable than `void *' */
+	char	   *re_fns;
+} pg_regex_t;
+
+/* result reporting (may acquire more fields later) */
+typedef struct
+{
+	pg_regoff_t rm_so;			/* start of substring */
+	pg_regoff_t rm_eo;			/* end of substring */
+} pg_regmatch_t;
+
+/* supplementary control and reporting */
+typedef struct
+{
+	pg_regmatch_t rm_extend;	/* see REG_EXPECT */
+} rm_detail_t;
+
+
+
+/*
+ * regex compilation flags
+ */
+#define REG_BASIC	000000		/* BREs (convenience) */
+#define REG_EXTENDED	000001	/* EREs */
+#define REG_ADVF	000002		/* advanced features in EREs */
+#define REG_ADVANCED	000003	/* AREs (which are also EREs) */
+#define REG_QUOTE	000004		/* no special characters, none */
+#define REG_NOSPEC	REG_QUOTE	/* historical synonym */
+#define REG_ICASE	000010		/* ignore case */
+#define REG_NOSUB	000020		/* caller doesn't need subexpr match data */
+#define REG_EXPANDED	000040	/* expanded format, white space & comments */
+#define REG_NLSTOP	000100		/* \n doesn't match . or [^ ] */
+#define REG_NLANCH	000200		/* ^ matches after \n, $ before */
+#define REG_NEWLINE 000300		/* newlines are line terminators */
+#define REG_PEND	000400		/* ugh -- backward-compatibility hack */
+#define REG_EXPECT	001000		/* report details on partial/limited matches */
+#define REG_BOSONLY 002000		/* temporary kludge for BOS-only matches */
+#define REG_DUMP	004000		/* none of your business :-) */
+#define REG_FAKE	010000		/* none of your business :-) */
+#define REG_PROGRESS	020000	/* none of your business :-) */
+
+
+
+/*
+ * regex execution flags
+ */
+#define REG_NOTBOL	0001		/* BOS is not BOL */
+#define REG_NOTEOL	0002		/* EOS is not EOL */
+#define REG_STARTEND	0004	/* backward compatibility kludge */
+#define REG_FTRACE	0010		/* none of your business */
+#define REG_MTRACE	0020		/* none of your business */
+#define REG_SMALL	0040		/* none of your business */
+
+
+/*
+ * error reporting
+ * Be careful if modifying the list of error codes -- the table used by
+ * regerror() is generated automatically from this file!
+ */
+#define REG_OKAY	 0			/* no errors detected */
+#define REG_NOMATCH  1			/* failed to match */
+#define REG_BADPAT	 2			/* invalid regexp */
+#define REG_ECOLLATE	 3		/* invalid collating element */
+#define REG_ECTYPE	 4			/* invalid character class */
+#define REG_EESCAPE  5			/* invalid escape \ sequence */
+#define REG_ESUBREG  6			/* invalid backreference number */
+#define REG_EBRACK	 7			/* brackets [] not balanced */
+#define REG_EPAREN	 8			/* parentheses () not balanced */
+#define REG_EBRACE	 9			/* braces {} not balanced */
+#define REG_BADBR	10			/* invalid repetition count(s) */
+#define REG_ERANGE	11			/* invalid character range */
+#define REG_ESPACE	12			/* out of memory */
+#define REG_BADRPT	13			/* quantifier operand invalid */
+#define REG_ASSERT	15			/* "can't happen" -- you found a bug */
+#define REG_INVARG	16			/* invalid argument to regex function */
+#define REG_MIXED	17			/* character widths of regex and string differ */
+#define REG_BADOPT	18			/* invalid embedded option */
+#define REG_ETOOBIG 19			/* regular expression is too complex */
+#define REG_ECOLORS 20			/* too many colors */
+/* two specials for debugging and testing */
+#define REG_ATOI	101			/* convert error-code name to number */
+#define REG_ITOA	102			/* convert error-code number to name */
+/* non-error result codes for pg_regprefix */
+#define REG_PREFIX	(-1)		/* identified a common prefix */
+#define REG_EXACT	(-2)		/* identified an exact match */
+
+
+/* Redirect the standard typenames to our typenames. */
+#define regoff_t pg_regoff_t
+#define regex_t pg_regex_t
+#define regmatch_t pg_regmatch_t
+
+
+/*
+ * the prototypes for exported functions
+ */
+
+/* regcomp.c */
+extern int	pg_regcomp(regex_t *re, const pg_wchar *string, size_t len,
+					   int flags, Oid collation);
+extern int	pg_regexec(regex_t *re, const pg_wchar *string, size_t len,
+					   size_t search_start, rm_detail_t *details,
+					   size_t nmatch, regmatch_t pmatch[], int flags);
+extern int	pg_regprefix(regex_t *re, pg_wchar **string, size_t *slength);
+extern void pg_regfree(regex_t *re);
+extern size_t pg_regerror(int errcode, const regex_t *preg, char *errbuf,
+						  size_t errbuf_size);
+
+/* regexp.c */
+extern regex_t *RE_compile_and_cache(text *text_re, int cflags, Oid collation);
+extern bool RE_compile_and_execute(text *text_re, char *dat, int dat_len,
+								   int cflags, Oid collation,
+								   int nmatch, regmatch_t *pmatch);
+
+#endif							/* _PG_REGEX_H_ */

embedded_postgres/pginstall/include/server/regex/regexport.h

@@ -0,0 +1,61 @@
+/*-------------------------------------------------------------------------
+ *
+ * regexport.h
+ *	  Declarations for exporting info about a regex's NFA (nondeterministic
+ *	  finite automaton)
+ *
+ * The functions declared here provide accessors to extract the NFA state
+ * graph and color character sets of a successfully-compiled regex.
+ *
+ * An NFA contains one or more states, numbered 0..N-1.  There is an initial
+ * state, as well as a final state --- reaching the final state denotes
+ * successful matching of an input string.  Each state except the final one
+ * has some out-arcs that lead to successor states, each arc being labeled
+ * with a color that represents one or more concrete character codes.
+ * (The colors of a state's out-arcs need not be distinct, since this is an
+ * NFA not a DFA.)	There are also "pseudocolors" representing start/end of
+ * line and start/end of string.  Colors are numbered 0..C-1, but note that
+ * color 0 is "white" (all unused characters) and can generally be ignored.
+ *
+ * Portions Copyright (c) 2013-2025, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1998, 1999 Henry Spencer
+ *
+ * IDENTIFICATION
+ *	  src/include/regex/regexport.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef _REGEXPORT_H_
+#define _REGEXPORT_H_
+
+#include "regex/regex.h"
+
+/* These macros must match corresponding ones in regguts.h: */
+#define COLOR_WHITE		0		/* color for chars not appearing in regex */
+#define COLOR_RAINBOW	(-2)	/* represents all colors except pseudocolors */
+
+/* information about one arc of a regex's NFA */
+typedef struct
+{
+	int			co;				/* label (character-set color) of arc */
+	int			to;				/* next state number */
+} regex_arc_t;
+
+
+/* Functions for gathering information about NFA states and arcs */
+extern int	pg_reg_getnumstates(const regex_t *regex);
+extern int	pg_reg_getinitialstate(const regex_t *regex);
+extern int	pg_reg_getfinalstate(const regex_t *regex);
+extern int	pg_reg_getnumoutarcs(const regex_t *regex, int st);
+extern void pg_reg_getoutarcs(const regex_t *regex, int st,
+							  regex_arc_t *arcs, int arcs_len);
+
+/* Functions for gathering information about colors */
+extern int	pg_reg_getnumcolors(const regex_t *regex);
+extern int	pg_reg_colorisbegin(const regex_t *regex, int co);
+extern int	pg_reg_colorisend(const regex_t *regex, int co);
+extern int	pg_reg_getnumcharacters(const regex_t *regex, int co);
+extern void pg_reg_getcharacters(const regex_t *regex, int co,
+								 pg_wchar *chars, int chars_len);
+
+#endif							/* _REGEXPORT_H_ */