work in progress, cleaned up the directories and split them up into folder which make more sense, Still need to compile libvitaboy and all the tools

deps/libpq/include/lib/dllist.h

@@ -0,0 +1,85 @@
+/*-------------------------------------------------------------------------
+ *
+ * dllist.h
+ *		simple doubly linked list primitives
+ *		the elements of the list are void* so the lists can contain anything
+ *		Dlelem can only be in one list at a time
+ *
+ *
+ *	 Here's a small example of how to use Dllists:
+ *
+ *	 Dllist *lst;
+ *	 Dlelem *elt;
+ *	 void	*in_stuff;	  -- stuff to stick in the list
+ *	 void	*out_stuff
+ *
+ *	 lst = DLNewList();				   -- make a new dllist
+ *	 DLAddHead(lst, DLNewElem(in_stuff)); -- add a new element to the list
+ *											 with in_stuff as the value
+ *	  ...
+ *	 elt = DLGetHead(lst);			   -- retrieve the head element
+ *	 out_stuff = (void*)DLE_VAL(elt);  -- get the stuff out
+ *	 DLRemove(elt);					   -- removes the element from its list
+ *	 DLFreeElem(elt);				   -- free the element since we don't
+ *										  use it anymore
+ *
+ *
+ * It is also possible to use Dllist objects that are embedded in larger
+ * structures instead of being separately malloc'd.  To do this, use
+ * DLInitElem() to initialize a Dllist field within a larger object.
+ * Don't forget to DLRemove() each field from its list (if any) before
+ * freeing the larger object!
+ *
+ *
+ * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/lib/dllist.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DLLIST_H
+#define DLLIST_H
+
+struct Dllist;
+struct Dlelem;
+
+typedef struct Dlelem
+{
+	struct Dlelem *dle_next;	/* next element */
+	struct Dlelem *dle_prev;	/* previous element */
+	void	   *dle_val;		/* value of the element */
+	struct Dllist *dle_list;	/* what list this element is in */
+} Dlelem;
+
+typedef struct Dllist
+{
+	Dlelem	   *dll_head;
+	Dlelem	   *dll_tail;
+} Dllist;
+
+extern Dllist *DLNewList(void); /* allocate and initialize a list header */
+extern void DLInitList(Dllist *list);	/* init a header alloced by caller */
+extern void DLFreeList(Dllist *list);	/* free up a list and all the nodes in
+										 * it */
+extern Dlelem *DLNewElem(void *val);
+extern void DLInitElem(Dlelem *e, void *val);
+extern void DLFreeElem(Dlelem *e);
+extern void DLRemove(Dlelem *e);	/* removes node from list */
+extern void DLAddHead(Dllist *list, Dlelem *node);
+extern void DLAddTail(Dllist *list, Dlelem *node);
+extern Dlelem *DLRemHead(Dllist *list); /* remove and return the head */
+extern Dlelem *DLRemTail(Dllist *list);
+extern void DLMoveToFront(Dlelem *e);	/* move node to front of its list */
+
+/* These are macros for speed */
+#define DLGetHead(list)  ((list)->dll_head)
+#define DLGetTail(list)  ((list)->dll_tail)
+#define DLGetSucc(elem)  ((elem)->dle_next)
+#define DLGetPred(elem)  ((elem)->dle_prev)
+#define DLGetListHdr(elem)	((elem)->dle_list)
+
+#define DLE_VAL(elem)	((elem)->dle_val)
+
+#endif   /* DLLIST_H */

deps/libpq/include/lib/stringinfo.h

@@ -0,0 +1,154 @@
+/*-------------------------------------------------------------------------
+ *
+ * stringinfo.h
+ *	  Declarations/definitions for "StringInfo" functions.
+ *
+ * StringInfo provides an indefinitely-extensible string data type.
+ * It can be used to buffer either ordinary C strings (null-terminated text)
+ * or arbitrary binary data.  All storage is allocated with palloc().
+ *
+ * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/lib/stringinfo.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef STRINGINFO_H
+#define STRINGINFO_H
+
+/*-------------------------
+ * StringInfoData holds information about an extensible string.
+ *		data	is the current buffer for the string (allocated with palloc).
+ *		len		is the current string length.  There is guaranteed to be
+ *				a terminating '\0' at data[len], although this is not very
+ *				useful when the string holds binary data rather than text.
+ *		maxlen	is the allocated size in bytes of 'data', i.e. the maximum
+ *				string size (including the terminating '\0' char) that we can
+ *				currently store in 'data' without having to reallocate
+ *				more space.  We must always have maxlen > len.
+ *		cursor	is initialized to zero by makeStringInfo or initStringInfo,
+ *				but is not otherwise touched by the stringinfo.c routines.
+ *				Some routines use it to scan through a StringInfo.
+ *-------------------------
+ */
+typedef struct StringInfoData
+{
+	char	   *data;
+	int			len;
+	int			maxlen;
+	int			cursor;
+} StringInfoData;
+
+typedef StringInfoData *StringInfo;
+
+
+/*------------------------
+ * There are two ways to create a StringInfo object initially:
+ *
+ * StringInfo stringptr = makeStringInfo();
+ *		Both the StringInfoData and the data buffer are palloc'd.
+ *
+ * StringInfoData string;
+ * initStringInfo(&string);
+ *		The data buffer is palloc'd but the StringInfoData is just local.
+ *		This is the easiest approach for a StringInfo object that will
+ *		only live as long as the current routine.
+ *
+ * To destroy a StringInfo, pfree() the data buffer, and then pfree() the
+ * StringInfoData if it was palloc'd.  There's no special support for this.
+ *
+ * NOTE: some routines build up a string using StringInfo, and then
+ * release the StringInfoData but return the data string itself to their
+ * caller.	At that point the data string looks like a plain palloc'd
+ * string.
+ *-------------------------
+ */
+
+/*------------------------
+ * makeStringInfo
+ * Create an empty 'StringInfoData' & return a pointer to it.
+ */
+extern StringInfo makeStringInfo(void);
+
+/*------------------------
+ * initStringInfo
+ * Initialize a StringInfoData struct (with previously undefined contents)
+ * to describe an empty string.
+ */
+extern void initStringInfo(StringInfo str);
+
+/*------------------------
+ * resetStringInfo
+ * Clears the current content of the StringInfo, if any. The
+ * StringInfo remains valid.
+ */
+extern void resetStringInfo(StringInfo str);
+
+/*------------------------
+ * appendStringInfo
+ * Format text data under the control of fmt (an sprintf-style format string)
+ * and append it to whatever is already in str.  More space is allocated
+ * to str if necessary.  This is sort of like a combination of sprintf and
+ * strcat.
+ */
+extern void
+appendStringInfo(StringInfo str, const char *fmt,...)
+/* This extension allows gcc to check the format string */
+__attribute__((format(PG_PRINTF_ATTRIBUTE, 2, 3)));
+
+/*------------------------
+ * appendStringInfoVA
+ * Attempt to format text data under the control of fmt (an sprintf-style
+ * format string) and append it to whatever is already in str.	If successful
+ * return true; if not (because there's not enough space), return false
+ * without modifying str.  Typically the caller would enlarge str and retry
+ * on false return --- see appendStringInfo for standard usage pattern.
+ */
+extern bool appendStringInfoVA(StringInfo str, const char *fmt, va_list args);
+
+/*------------------------
+ * appendStringInfoString
+ * Append a null-terminated string to str.
+ * Like appendStringInfo(str, "%s", s) but faster.
+ */
+extern void appendStringInfoString(StringInfo str, const char *s);
+
+/*------------------------
+ * appendStringInfoChar
+ * Append a single byte to str.
+ * Like appendStringInfo(str, "%c", ch) but much faster.
+ */
+extern void appendStringInfoChar(StringInfo str, char ch);
+
+/*------------------------
+ * appendStringInfoCharMacro
+ * As above, but a macro for even more speed where it matters.
+ * Caution: str argument will be evaluated multiple times.
+ */
+#define appendStringInfoCharMacro(str,ch) \
+	(((str)->len + 1 >= (str)->maxlen) ? \
+	 appendStringInfoChar(str, ch) : \
+	 (void)((str)->data[(str)->len] = (ch), (str)->data[++(str)->len] = '\0'))
+
+/*------------------------
+ * appendStringInfoSpaces
+ * Append a given number of spaces to str.
+ */
+extern void appendStringInfoSpaces(StringInfo str, int count);
+
+/*------------------------
+ * appendBinaryStringInfo
+ * Append arbitrary binary data to a StringInfo, allocating more space
+ * if necessary.
+ */
+extern void appendBinaryStringInfo(StringInfo str,
+					   const char *data, int datalen);
+
+/*------------------------
+ * enlargeStringInfo
+ * Make sure a StringInfo's buffer can hold at least 'needed' more bytes.
+ */
+extern void enlargeStringInfo(StringInfo str, int needed);
+
+#endif   /* STRINGINFO_H */