YQ Connector:Use docker-compose in integrational tests

7 files changed, 771 insertions, 0 deletions

diff --git a/contrib/tools/ragel5/common/buffer.h b/contrib/tools/ragel5/common/buffer.h
new file mode 100644
index 0000000000..99c4e82d49
--- /dev/null
+++ b/contrib/tools/ragel5/common/buffer.h
@@ -0,0 +1,55 @@
+/*
+ *  Copyright 2003 Adrian Thurston <thurston@cs.queensu.ca>
+ */
+
+/*  This file is part of Ragel.
+ *
+ *  Ragel is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ * 
+ *  Ragel is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with Ragel; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+
+#ifndef _BUFFER_H
+#define _BUFFER_H
+
+#define BUFFER_INITIAL_SIZE 4096
+
+/* An automatically grown buffer for collecting tokens. Always reuses space;
+ * never down resizes. */
+struct Buffer
+{
+	Buffer()
+	{
+		data = (char*) malloc( BUFFER_INITIAL_SIZE );
+		allocated = BUFFER_INITIAL_SIZE;
+		length = 0;
+	}
+	~Buffer() { free(data); }
+
+	void append( char p )
+	{
+		if ( length == allocated ) {
+			allocated *= 2;
+			data = (char*) realloc( data, allocated );
+		}
+		data[length++] = p;
+	}
+		
+	void clear() { length = 0; }
+
+	char *data;
+	int allocated;
+	int length;
+};
+
+#endif /* _BUFFER_H */
diff --git a/contrib/tools/ragel5/common/common.cpp b/contrib/tools/ragel5/common/common.cpp
new file mode 100644
index 0000000000..4484dcbd73
--- /dev/null
+++ b/contrib/tools/ragel5/common/common.cpp
@@ -0,0 +1,296 @@
+/*
+ *  Copyright 2006-2007 Adrian Thurston <thurston@cs.queensu.ca>
+ */
+
+/*  This file is part of Ragel.
+ *
+ *  Ragel is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ * 
+ *  Ragel is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with Ragel; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+
+#include "pcheck.h"
+#include "common.h"
+#include <string.h>
+#include <assert.h>
+
+#ifdef _WIN32

+#include <malloc.h>

+#else

+#include <alloca.h>

+#endif
+
+HostType hostTypesC[] =
+{
+	{ "char",     0,       true,   CHAR_MIN,  CHAR_MAX,   sizeof(char) },
+	{ "unsigned", "char",  false,  0,         UCHAR_MAX,  sizeof(unsigned char) },
+	{ "short",    0,       true,   SHRT_MIN,  SHRT_MAX,   sizeof(short) },
+	{ "unsigned", "short", false,  0,         USHRT_MAX,  sizeof(unsigned short) },
+	{ "int",      0,       true,   INT_MIN,   INT_MAX,    sizeof(int) },
+	{ "unsigned", "int",   false,  0,         UINT_MAX,   sizeof(unsigned int) },
+	{ "long",     0,       true,   LONG_MIN,  LONG_MAX,   sizeof(long) },
+	{ "unsigned", "long",  false,  0,         (long long)ULONG_MAX,  sizeof(unsigned long) }
+};
+
+HostType hostTypesD[] =
+{
+	{ "byte",     0,  true,   CHAR_MIN,  CHAR_MAX,    1 },
+	{ "ubyte",    0,  false,  0,         UCHAR_MAX,   1 },
+	{ "char",     0,  false,  0,         UCHAR_MAX,   1 },
+	{ "short",    0,  true,   SHRT_MIN,  SHRT_MAX,    2 },
+	{ "ushort",   0,  false,  0,         USHRT_MAX,   2 },
+	{ "wchar",    0,  false,  0,         USHRT_MAX,   2 },
+	{ "int",      0,  true,   INT_MIN,   INT_MAX,     4 },
+	{ "uint",     0,  false,  0,         UINT_MAX,    4 },
+	{ "dchar",    0,  false,  0,         UINT_MAX,    4 }
+};
+
+HostType hostTypesJava[] = 
+{
+	{ "byte",     0,  true,   CHAR_MIN,  CHAR_MAX,    1 },
+	{ "short",    0,  true,   SHRT_MIN,  SHRT_MAX,    2 },
+	{ "char",     0,  false,  0,         USHRT_MAX,   2 },
+	{ "int",      0,  true,   INT_MIN,   INT_MAX,     4 },
+};
+
+HostType hostTypesRuby[] = 
+{
+	{ "byte",     0,  true,   CHAR_MIN,  CHAR_MAX,    1 },
+	{ "short",    0,  true,   SHRT_MIN,  SHRT_MAX,    2 },
+	{ "char",     0,  false,  0,         USHRT_MAX,   2 },
+	{ "int",      0,  true,   INT_MIN,   INT_MAX,     4 },
+};
+
+HostLang hostLangC =    { hostTypesC,    8, hostTypesC+0,    true };
+HostLang hostLangD =    { hostTypesD,    9, hostTypesD+2,    true };
+HostLang hostLangJava = { hostTypesJava, 4, hostTypesJava+2, false };
+HostLang hostLangRuby = { hostTypesRuby, 4, hostTypesRuby+2, false };
+
+HostLang *hostLang = &hostLangC;
+HostLangType hostLangType = CCode;
+
+/* Construct a new parameter checker with for paramSpec. */
+ParamCheck::ParamCheck(const char *paramSpec, int argc, char **argv)
+:
+	state(noparam),
+	argOffset(0),
+	curArg(0),
+	iCurArg(1),
+	paramSpec(paramSpec), 
+	argc(argc), 
+	argv(argv)
+{
+}
+
+/* Check a single option. Returns the index of the next parameter.  Sets p to
+ * the arg character if valid, 0 otherwise.  Sets parg to the parameter arg if
+ * there is one, NULL otherwise. */
+bool ParamCheck::check()
+{
+	bool requiresParam;
+
+	if ( iCurArg >= argc ) {            /* Off the end of the arg list. */
+		state = noparam;
+		return false;
+	}
+
+	if ( argOffset != 0 && *argOffset == 0 ) {
+		/* We are at the end of an arg string. */
+		iCurArg += 1;
+		if ( iCurArg >= argc ) {
+			state = noparam;
+			return false;
+		}
+		argOffset = 0;
+	}
+
+	if ( argOffset == 0 ) {
+		/* Set the current arg. */
+		curArg = argv[iCurArg];
+
+		/* We are at the beginning of an arg string. */
+		if ( argv[iCurArg] == 0 ||        /* Argv[iCurArg] is null. */
+			 argv[iCurArg][0] != '-' ||   /* Not a param. */
+			 argv[iCurArg][1] == 0 ) {    /* Only a dash. */
+			parameter = 0;
+			parameterArg = 0;
+
+			iCurArg += 1;
+			state = noparam;
+			return true;
+		}
+		argOffset = argv[iCurArg] + 1;
+	}
+
+	/* Get the arg char. */
+	char argChar = *argOffset;
+	
+	/* Loop over all the parms and look for a match. */
+	const char *pSpec = paramSpec;
+	while ( *pSpec != 0 ) {
+		char pSpecChar = *pSpec;
+
+		/* If there is a ':' following the char then
+		 * it requires a parm.  If a parm is required
+		 * then move ahead two in the parmspec. Otherwise
+		 * move ahead one in the parm spec. */
+		if ( pSpec[1] == ':' ) {
+			requiresParam = true;
+			pSpec += 2;
+		}
+		else {
+			requiresParam = false;
+			pSpec += 1;
+		}
+
+		/* Do we have a match. */
+		if ( argChar == pSpecChar ) {
+			if ( requiresParam ) {
+				if ( argOffset[1] == 0 ) {
+					/* The param must follow. */
+					if ( iCurArg + 1 == argc ) {
+						/* We are the last arg so there
+						 * cannot be a parameter to it. */
+						parameter = argChar;
+						parameterArg = 0;
+						iCurArg += 1;
+						argOffset = 0;
+						state = invalid;
+						return true;
+					}
+					else {
+						/* the parameter to the arg is the next arg. */
+						parameter = pSpecChar;
+						parameterArg = argv[iCurArg + 1];
+						iCurArg += 2;
+						argOffset = 0;
+						state = match;
+						return true;
+					}
+				}
+				else {
+					/* The param for the arg is built in. */
+					parameter = pSpecChar;
+					parameterArg = argOffset + 1;
+					iCurArg += 1;
+					argOffset = 0;
+					state = match;
+					return true;
+				}
+			}
+			else {
+				/* Good, we matched the parm and no
+				 * arg is required. */
+				parameter = pSpecChar;
+				parameterArg = 0;
+				argOffset += 1;
+				state = match;
+				return true;
+			}
+		}
+	}
+
+	/* We did not find a match. Bad Argument. */
+	parameter = argChar;
+	parameterArg = 0;
+	argOffset += 1;
+	state = invalid;
+	return true;
+}
+
+void NormalizeWinPath(char* input) {
+    const size_t len = strlen(input);
+    char* res = static_cast<char*>(alloca(len + 1));
+    for (size_t i = 0, j = 0; i <= len; ++i, ++j) {
+        if (input[i] == '\\') {
+            res[j] = '/';
+            if (i < len - 2 && input[i + 1] == '\\')
+                ++i;
+            } else {
+                res[j] = input[i];
+            }
+    }
+    strcpy(input, res);
+}
+
+/* Counts newlines before sending sync. */
+int output_filter::sync( )
+{
+	line += 1;
+	return std::filebuf::sync();
+}
+
+/* Counts newlines before sending data out to file. */
+std::streamsize output_filter::xsputn( const char *s, std::streamsize n )
+{
+	for ( int i = 0; i < n; i++ ) {
+		if ( s[i] == '\n' )
+			line += 1;
+	}
+	return std::filebuf::xsputn( s, n );
+}
+
+/* Scans a string looking for the file extension. If there is a file
+ * extension then pointer returned points to inside the string
+ * passed in. Otherwise returns null. */
+char *findFileExtension( char *stemFile )
+{
+	char *ppos = stemFile + strlen(stemFile) - 1;
+
+	/* Scan backwards from the end looking for the first dot.
+	 * If we encounter a '/' before the first dot, then stop the scan. */
+	while ( 1 ) {
+		/* If we found a dot or got to the beginning of the string then
+		 * we are done. */
+		if ( ppos == stemFile || *ppos == '.' )
+			break;
+
+		/* If we hit a / then there is no extension. Done. */
+		if ( *ppos == '/' ) {
+			ppos = stemFile;
+			break;
+		}
+		ppos--;
+	} 
+
+	/* If we got to the front of the string then bail we 
+	 * did not find an extension  */
+	if ( ppos == stemFile )
+		ppos = 0;
+
+	return ppos;
+}
+
+/* Make a file name from a stem. Removes the old filename suffix and
+ * replaces it with a new one. Returns a newed up string. */
+char *fileNameFromStem( char *stemFile, const char *suffix )
+{
+	int len = strlen( stemFile );
+	assert( len > 0 );
+
+	/* Get the extension. */
+	char *ppos = findFileExtension( stemFile );
+
+	/* If an extension was found, then shorten what we think the len is. */
+	if ( ppos != 0 )
+		len = ppos - stemFile;
+
+	/* Make the return string from the stem and the suffix. */
+	char *retVal = new char[ len + strlen( suffix ) + 1 ];
+	strncpy( retVal, stemFile, len );
+	strcpy( retVal + len, suffix );
+
+	return retVal;
+}
+
+
diff --git a/contrib/tools/ragel5/common/common.h b/contrib/tools/ragel5/common/common.h
new file mode 100644
index 0000000000..aae6f85add
--- /dev/null
+++ b/contrib/tools/ragel5/common/common.h
@@ -0,0 +1,308 @@
+/*
+ *  Copyright 2001-2006 Adrian Thurston <thurston@cs.queensu.ca>
+ */
+
+/*  This file is part of Ragel.
+ *
+ *  Ragel is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ * 
+ *  Ragel is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with Ragel; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+
+#ifndef _COMMON_H
+#define _COMMON_H
+
+#include <fstream>
+#include <climits>
+#include "dlist.h"
+
+typedef unsigned long long Size;
+
+struct Key
+{
+private:
+	long key;
+
+public:
+	friend inline Key operator+(const Key key1, const Key key2);
+	friend inline Key operator-(const Key key1, const Key key2);
+	friend inline Key operator/(const Key key1, const Key key2);
+	friend inline long operator&(const Key key1, const Key key2);
+
+	friend inline bool operator<( const Key key1, const Key key2 );
+	friend inline bool operator<=( const Key key1, const Key key2 );
+	friend inline bool operator>( const Key key1, const Key key2 );
+	friend inline bool operator>=( const Key key1, const Key key2 );
+	friend inline bool operator==( const Key key1, const Key key2 );
+	friend inline bool operator!=( const Key key1, const Key key2 );
+
+	friend struct KeyOps;
+	
+	Key( ) {}
+	Key( const Key &key ) : key(key.key) {}
+	Key( long key ) : key(key) {}
+
+	/* Returns the value used to represent the key. This value must be
+	 * interpreted based on signedness. */
+	long getVal() const { return key; };
+
+	/* Returns the key casted to a long long. This form of the key does not
+	 * require and signedness interpretation. */
+	long long getLongLong() const;
+
+	bool isUpper() const { return ( 'A' <= key && key <= 'Z' ); }
+	bool isLower() const { return ( 'a' <= key && key <= 'z' ); }
+	bool isPrintable() const
+	{
+	    return ( 7 <= key && key <= 13 ) || ( 32 <= key && key < 127 );
+	}
+
+	Key toUpper() const
+		{ return Key( 'A' + ( key - 'a' ) ); }
+	Key toLower() const
+		{ return Key( 'a' + ( key - 'A' ) ); }
+
+	void operator+=( const Key other )
+	{
+		/* FIXME: must be made aware of isSigned. */
+		key += other.key;
+	}
+
+	void operator-=( const Key other )
+	{
+		/* FIXME: must be made aware of isSigned. */
+		key -= other.key;
+	}
+
+	void operator|=( const Key other )
+	{
+		/* FIXME: must be made aware of isSigned. */
+		key |= other.key;
+	}
+
+	/* Decrement. Needed only for ranges. */
+	inline void decrement();
+	inline void increment();
+};
+
+struct HostType
+{
+	const char *data1;
+	const char *data2;
+	bool isSigned;
+	long long minVal;
+	long long maxVal;
+	unsigned int size;
+};
+
+struct HostLang
+{
+	HostType *hostTypes;
+	int numHostTypes;
+	HostType *defaultAlphType;
+	bool explicitUnsigned;
+};
+
+
+/* Target language. */
+enum HostLangType
+{
+	CCode,
+	DCode,
+	JavaCode,
+	RubyCode
+};
+
+extern HostLang *hostLang;
+extern HostLangType hostLangType;
+
+extern HostLang hostLangC;
+extern HostLang hostLangD;
+extern HostLang hostLangJava;
+extern HostLang hostLangRuby;
+
+/* An abstraction of the key operators that manages key operations such as
+ * comparison and increment according the signedness of the key. */
+struct KeyOps
+{
+	/* Default to signed alphabet. */
+	KeyOps() :
+		isSigned(true),
+		alphType(0)
+	{}
+
+	/* Default to signed alphabet. */
+	KeyOps( bool isSigned ) 
+		:isSigned(isSigned) {}
+
+	bool isSigned;
+	Key minKey, maxKey;
+	HostType *alphType;
+
+	void setAlphType( HostType *alphType )
+	{
+		this->alphType = alphType;
+		isSigned = alphType->isSigned;
+		if ( isSigned ) {
+			minKey = (long) alphType->minVal;
+			maxKey = (long) alphType->maxVal;
+		}
+		else {
+			minKey = (long) (unsigned long) alphType->minVal; 
+			maxKey = (long) (unsigned long) alphType->maxVal;
+		}
+	}
+
+	/* Compute the distance between two keys. */
+	Size span( Key key1, Key key2 )
+	{
+		return isSigned ? 
+			(unsigned long long)(
+				(long long)key2.key - 
+				(long long)key1.key + 1) : 
+			(unsigned long long)(
+				(unsigned long)key2.key) - 
+				(unsigned long long)((unsigned long)key1.key) + 1;
+	}
+
+	Size alphSize()
+		{ return span( minKey, maxKey ); }
+
+	HostType *typeSubsumes( long long maxVal )
+	{
+		for ( int i = 0; i < hostLang->numHostTypes; i++ ) {
+			if ( maxVal <= hostLang->hostTypes[i].maxVal )
+				return hostLang->hostTypes + i;
+		}
+		return 0;
+	}
+
+	HostType *typeSubsumes( bool isSigned, long long maxVal )
+	{
+		for ( int i = 0; i < hostLang->numHostTypes; i++ ) {
+			if ( ( isSigned == hostLang->hostTypes[i].isSigned ) &&
+					maxVal <= hostLang->hostTypes[i].maxVal )
+				return hostLang->hostTypes + i;
+		}
+		return 0;
+	}
+};
+
+extern KeyOps *keyOps;
+
+inline bool operator<( const Key key1, const Key key2 )
+{
+	return keyOps->isSigned ? key1.key < key2.key : 
+		(unsigned long)key1.key < (unsigned long)key2.key;
+}
+
+inline bool operator<=( const Key key1, const Key key2 )
+{
+	return keyOps->isSigned ?  key1.key <= key2.key : 
+		(unsigned long)key1.key <= (unsigned long)key2.key;
+}
+
+inline bool operator>( const Key key1, const Key key2 )
+{
+	return keyOps->isSigned ? key1.key > key2.key : 
+		(unsigned long)key1.key > (unsigned long)key2.key;
+}
+
+inline bool operator>=( const Key key1, const Key key2 )
+{
+	return keyOps->isSigned ? key1.key >= key2.key : 
+		(unsigned long)key1.key >= (unsigned long)key2.key;
+}
+
+inline bool operator==( const Key key1, const Key key2 )
+{
+	return key1.key == key2.key;
+}
+
+inline bool operator!=( const Key key1, const Key key2 )
+{
+	return key1.key != key2.key;
+}
+
+/* Decrement. Needed only for ranges. */
+inline void Key::decrement()
+{
+	key = keyOps->isSigned ? key - 1 : ((unsigned long)key)-1;
+}
+
+/* Increment. Needed only for ranges. */
+inline void Key::increment()
+{
+	key = keyOps->isSigned ? key+1 : ((unsigned long)key)+1;
+}
+
+inline long long Key::getLongLong() const
+{
+	return keyOps->isSigned ? (long long)key : (long long)(unsigned long)key;
+}
+
+inline Key operator+(const Key key1, const Key key2)
+{
+	/* FIXME: must be made aware of isSigned. */
+	return Key( key1.key + key2.key );
+}
+
+inline Key operator-(const Key key1, const Key key2)
+{
+	/* FIXME: must be made aware of isSigned. */
+	return Key( key1.key - key2.key );
+}
+
+inline long operator&(const Key key1, const Key key2)
+{
+	/* FIXME: must be made aware of isSigned. */
+	return key1.key & key2.key;
+}
+
+inline Key operator/(const Key key1, const Key key2)
+{
+	/* FIXME: must be made aware of isSigned. */
+	return key1.key / key2.key;
+}
+
+/* Filter on the output stream that keeps track of the number of lines
+ * output. */
+class output_filter : public std::filebuf
+{
+public:
+	output_filter( char *fileName ) : fileName(fileName), line(1) { }
+
+	virtual int sync();
+	virtual std::streamsize xsputn(const char* s, std::streamsize n);
+
+	char *fileName;
+	int line;
+};
+
+char *findFileExtension( char *stemFile );
+char *fileNameFromStem( char *stemFile, const char *suffix );
+
+struct Export
+{
+	Export(const char *name, Key key )
+		: name(name), key(key) {}
+
+	const char *name;
+	Key key;
+
+	Export *prev, *next;
+};
+
+typedef DList<Export> ExportList;
+
+#endif /* _COMMON_H */
diff --git a/contrib/tools/ragel5/common/config.h b/contrib/tools/ragel5/common/config.h
new file mode 100644
index 0000000000..405cfd6c3b
--- /dev/null
+++ b/contrib/tools/ragel5/common/config.h
@@ -0,0 +1,39 @@
+/* common/config.h.  Generated by configure.  */
+/*
+ *  Copyright 2001 Adrian Thurston <thurston@cs.queensu.ca>
+ */
+
+/*  This file is part of Ragel.
+ *
+ *  Ragel is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Ragel is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Ragel; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+
+/* Programs. */
+/* #undef GDC */
+#define GOBJC gcc -x objective-c
+#define CXX c++
+#define CC cc
+/* #undef JAVAC */
+/* #undef TXL */
+/* #undef RUBY */
+
+#ifdef WIN32
+#define strcasecmp _stricmp
+#endif
+
+#endif /* _CONFIG_H */
diff --git a/contrib/tools/ragel5/common/pcheck.h b/contrib/tools/ragel5/common/pcheck.h
new file mode 100644
index 0000000000..5f95dc3c12
--- /dev/null
+++ b/contrib/tools/ragel5/common/pcheck.h
@@ -0,0 +1,51 @@
+/*
+ *  Copyright 2001, 2002 Adrian Thurston <thurston@cs.queensu.ca>
+ */
+
+/*  This file is part of Ragel.
+ *
+ *  Ragel is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ * 
+ *  Ragel is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with Ragel; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+
+#ifndef _PCHECK_H
+#define _PCHECK_H
+
+class ParamCheck
+{
+public:
+	ParamCheck(const char *paramSpec, int argc, char **argv);
+
+	bool check();
+
+	char *parameterArg; /* The argument to the parameter. */
+	char parameter;     /* The parameter matched. */
+	enum { match, invalid, noparam } state;
+
+	char *argOffset;    /* If we are reading params inside an
+	                     * arg this points to the offset. */
+
+	char *curArg;       /* Pointer to the current arg. */
+	int iCurArg;        /* Index to the current arg. */
+
+private:
+	const char *paramSpec;    /* Parameter spec supplied by the coder. */
+	int argc;           /* Arguement data from the command line. */
+	char **argv;
+
+};
+
+void NormalizeWinPath(char* input);
+
+#endif /* _PCHECK_H */
diff --git a/contrib/tools/ragel5/common/version.h b/contrib/tools/ragel5/common/version.h
new file mode 100644
index 0000000000..dba4eb2154
--- /dev/null
+++ b/contrib/tools/ragel5/common/version.h
@@ -0,0 +1,2 @@
+#define VERSION "5.19"
+#define PUBDATE "March 2007"
diff --git a/contrib/tools/ragel5/common/ya.make b/contrib/tools/ragel5/common/ya.make
new file mode 100644
index 0000000000..7448cd2af3
--- /dev/null
+++ b/contrib/tools/ragel5/common/ya.make
@@ -0,0 +1,20 @@
+LIBRARY()
+
+LICENSE(GPL-2.0-or-later)
+
+NO_UTIL()
+NO_COMPILER_WARNINGS()
+
+ADDINCL(
+    GLOBAL contrib/tools/ragel5/common
+)
+
+PEERDIR(
+    contrib/tools/ragel5/aapl
+)
+
+SRCS(
+    common.cpp
+)
+
+END()