Initial commit

engines/glk/tads/tads2/regex.h

@@ -0,0 +1,199 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef GLK_TADS_TADS2_REGEX
+#define GLK_TADS_TADS2_REGEX
+
+#include "common/array.h"
+#include "glk/tads/tads2/error_handling.h"
+
+namespace Glk {
+namespace TADS {
+namespace TADS2 {
+
+
+/* state ID */
+typedef int re_state_id;
+
+/* invalid state ID - used to mark null machines */
+#define RE_STATE_INVALID   ((re_state_id)-1)
+
+/* first valid state ID */
+#define RE_STATE_FIRST_VALID  ((re_state_id)0)
+
+
+/* ------------------------------------------------------------------------ */
+/*
+ *   Group register structure.  Each register keeps track of the starting
+ *   and ending offset of the group's text.
+ */
+typedef struct _re_group_register
+{
+	const char *start_ofs;
+	const char *end_ofs;
+
+	_re_group_register() : start_ofs(nullptr), end_ofs(nullptr) {}
+
+	void clear() {
+		start_ofs = nullptr;
+		end_ofs = nullptr;
+	}
+} re_group_register;
+
+/* number of group registers we keep */
+#define RE_GROUP_REG_CNT  10
+
+
+/* ------------------------------------------------------------------------ */
+/*
+ *   Denormalized state transition tuple.  Each tuple represents the
+ *   complete set of transitions out of a particular state.  A particular
+ *   state can have one character transition, or two epsilon transitions.
+ *   Note that we don't need to store the state ID in the tuple, because
+ *   the state ID is the index of the tuple in an array of state tuples.
+ */
+typedef struct
+{
+	/* the character we must match to transition to the target state */
+	char ch;
+
+	/* the target states */
+	re_state_id next_state_1;
+	re_state_id next_state_2;
+
+	/* character range match table, if used */
+	unsigned char *char_range;
+
+	/* flags */
+	unsigned char flags;
+} re_tuple;
+
+
+/*
+ *   Tuple flags
+ */
+
+/* this state is the start of a group - the 'ch' value is the group ID */
+#define RE_STATE_GROUP_BEGIN  0x02
+
+/* this state is the end of a group - 'ch' is the group ID */
+#define RE_STATE_GROUP_END    0x04
+
+
+/* ------------------------------------------------------------------------ */
+/*
+ *   Regular expression compilation context structure.  This tracks the
+ *   state of the compilation and stores the resources associated with the
+ *   compiled expression.
+ */
+typedef struct _re_context
+{
+	/* error context */
+	errcxdef *errctx;
+
+	/* next available state ID */
+	re_state_id next_state;
+
+	/*
+	 *   The array of transition tuples.  We'll allocate this array and
+	 *   expand it as necessary.
+	 */
+	re_tuple *tuple_arr;
+
+	/* number of transition tuples allocated in the array */
+	int tuples_alloc;
+
+	/* current group ID */
+	int cur_group;
+
+	/* group registers */
+	re_group_register regs[RE_GROUP_REG_CNT];
+
+	/*
+	 *   Buffer for retaining a copy of the last string we scanned.  We
+	 *   retain our own copy of each string, and point the group registers
+	 *   into this copy rather than the caller's original string -- this
+	 *   ensures that the group registers remain valid even after the
+	 *   caller has deallocated the original string.
+	 */
+	char *strbuf;
+
+	/* length of the string currently in the buffer */
+	size_t curlen;
+
+	/* size of the buffer allocated to strbuf */
+	size_t strbufsiz;
+
+	_re_context() : errctx(nullptr), next_state(0), tuple_arr(nullptr), tuples_alloc(0), cur_group(0), strbuf(nullptr), curlen(0), strbufsiz(0) {}
+} re_context;
+
+
+/* ------------------------------------------------------------------------ */
+/*
+ *   Status codes
+ */
+typedef enum
+{
+	/* success */
+	RE_STATUS_SUCCESS = 0,
+
+	/* compilation error - group nesting too deep */
+	RE_STATUS_GROUP_NESTING_TOO_DEEP
+} re_status_t;
+
+
+/* ------------------------------------------------------------------------ */
+/*
+ *   Initialize the context.  The memory for the context structure itself
+ *   must be allocated and maintained by the caller.
+ */
+void re_init(re_context *ctx, errcxdef *errctx);
+
+/*
+ *   Delete the context - frees structures associated with the context.
+ *   Does NOT free the memory used by the context structure itself.
+ */
+void re_delete(re_context *ctx);
+
+/*
+ *   Compile an expression and search for a match within the given string.
+ *   Returns the offset of the match, or -1 if no match was found.
+ */
+int re_compile_and_search(re_context *ctx,
+						  const char *pattern, size_t patlen,
+						  const char *searchstr, size_t searchlen,
+						  int *result_len);
+
+/*
+ *   Compile an expression and check for a match.  Returns the length of
+ *   the match if we found a match, -1 if we found no match.  This is not
+ *   a search function; we merely match the leading substring of the given
+ *   string to the given pattern.
+ */
+int re_compile_and_match(re_context *ctx,
+						 const char *pattern, size_t patlen,
+						 const char *searchstr, size_t searchlen);
+
+} // End of namespace TADS2
+} // End of namespace TADS
+} // End of namespace Glk
+
+#endif