From f76049422899dc19abe597d990e6ca9ec391c962 Mon Sep 17 00:00:00 2001 From: Gregor Beck Date: Mon, 20 Sep 2010 14:37:07 +0200 Subject: s3-lib: add srprs, primitives to build simple recursive parsers Signed-off-by: Michael Adam --- source3/lib/srprs.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++ source3/lib/srprs.h | 181 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 366 insertions(+) create mode 100644 source3/lib/srprs.c create mode 100644 source3/lib/srprs.h (limited to 'source3/lib') diff --git a/source3/lib/srprs.c b/source3/lib/srprs.c new file mode 100644 index 0000000000..77464f5f3a --- /dev/null +++ b/source3/lib/srprs.c @@ -0,0 +1,185 @@ +/* + * Samba Unix/Linux SMB client library + * + * Copyright (C) Gregor Beck 2010 + * + * 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 . + */ + +/** + * @file srprs.c + * @author Gregor Beck + * @date Aug 2010 + * @brief A simple recursive parser. + */ + +#include "srprs.h" +#include "cbuf.h" +#include +#include +#include +#include + +bool srprs_skipws(const char** ptr) { + while (isspace(**ptr)) + ++(*ptr); + return true; +} + +bool srprs_char(const char** ptr, char c) { + if (**ptr == c) { + ++(*ptr); + return true; + } + return false; +} + +bool srprs_str(const char** ptr, const char* str, size_t len) +{ + if (len == -1) + len = strlen(str); + + if (memcmp(*ptr, str, len) == 0) { + *ptr += len; + return true; + } + return false; +} + +bool srprs_charset(const char** ptr, const char* set, cbuf* oss) +{ + const char* p = strchr(set, **ptr); + if (p != NULL && *p != '\0') { + cbuf_putc(oss, **ptr); + ++(*ptr); + return true; + } + return false; +} + +bool srprs_charsetinv(const char** ptr, const char* set, cbuf* oss) +{ + if ((**ptr != '\0') && (strchr(set, **ptr) == NULL)) { + cbuf_putc(oss, **ptr); + ++(*ptr); + return true; + } + return false; +} + + + +bool srprs_quoted_string(const char** ptr, cbuf* str, bool* cont) +{ + const char* pos = *ptr; + const size_t spos = cbuf_getpos(str); + + if (cont == NULL || *cont == false) { + if (!srprs_char(&pos, '\"')) + goto fail; + } + + while (true) { + while (srprs_charsetinv(&pos, "\\\"", str)) + ; + + switch (*pos) { + case '\0': + if (cont == NULL) { + goto fail; + } else { + *ptr = pos; + *cont = true; + return true; + } + case '\"': + *ptr = pos+1; + if (cont != NULL) { + *cont = false; + } + return true; + + case '\\': + pos++; + if (!srprs_charset(&pos, "\\\"", str)) + goto fail; + break; + + default: + assert(false); + } + } + +fail: + cbuf_setpos(str, spos); + return false; +} + +bool srprs_hex(const char** ptr, size_t len, unsigned* u) +{ + static const char* FMT[] = { + "%1x","%2x","%3x","%4x","%5x","%6x","%7x","%8x", + "%9x","%10x","%11x","%12x","%13x","%14x","%15x","%16x" + }; + + const char* pos = *ptr; + int ret; + int i; + + assert((len > 0) + && (len <= 2*sizeof(unsigned)) + && (len <= sizeof(FMT)/sizeof(const char*))); + + for (i=0; i. + */ + +/** + * @file srprs.h + * @author Gregor Beck + * @date Aug 2010 + * + * @brief A simple recursive parser. + * + * This file contains functions which may be used to build a simple recursive + * parser. They all take the parse position as their first argument. If they + * match the parse position and the output arguments are updated accordingly and + * true is returned else no argument is altered. For arguments of type @ref cbuf + * this may hold only up to the current write position. + */ + +#ifndef __SRPRS_H +#define __SRPRS_H + +#include +#include +#include +struct cbuf; + +/** + * Matches any amount of whitespace. + * + * @see isspace + * @param ptr parse position + * + * @return true + */ +bool srprs_skipws(const char** ptr); + +/** + * Match a single character. + * + * @param[in,out] ptr parse position + * @param c the character to match + * + * @return true if matched + */ +bool srprs_char(const char** ptr, char c); + +/** + * Match a string. + * + * @param[in,out] ptr parse position + * @param str string to match + * @param len number of bytes to compare, -1 means strlen(str) + * + * @return true if matched + */ +bool srprs_str(const char** ptr, const char* str, size_t len); + +/** + * Match a single character from a set. + * Didn't match '\\0' + * + * @param[in,out] ptr parse position + * @param[in] set the character set to look for + * @param[out] oss output buffer where to put the match, may be NULL + * + * @return true if matched + */ +bool srprs_charset(const char** ptr, const char* set, struct cbuf* oss); + +/** + * Match a single character not in set. + * Didn't match '\\0' + * + * @param[in,out] ptr parse position + * @param[in] set the character set to look for + * @param[out] oss output buffer where to put the match, may be NULL + * + * @return true if matched + */ +bool srprs_charsetinv(const char** ptr, const char* set, struct cbuf* oss); + +/** + * Match a quoted string. + * + * + * If cont is not NULL the match may span multiple invocations. + * @code + * const char* start = "\"start..."; + * const char* cont = "continued..."; + * const char* end = "end\""; + * bool cont = false; + * cbuf* out = cbuf_new(talloc_tos()); + * srprs_quoted_string(&start, out, &cont); + * assert(*cont == true); + * srprs_quoted_string(&cont, out, &cont); + * assert(*cont == true); + * srprs_quoted_string(&end, out, &cont); + * assert(*cont == false); + * assert(strcmp(cbuf_gets(out, 0), "start...continued...end")==0); + * @endcode + * + * @param[in,out] ptr parse position + * @param[out] str output buffer where to put the match, may be NULL + * @param[in,out] cont + * + * @return true if matched + */ +bool srprs_quoted_string(const char** ptr, struct cbuf* str, bool* cont); + +/** + * Match a hex string. + * + * @param[in,out] ptr parse position + * @param len maximum number of diggits to match + * @param[out] u value of the match + * + * @return true if matched + */ +bool srprs_hex(const char** ptr, size_t len, unsigned* u); + +/** + * Match the empty string at End Of String. + * It doesn't consume the '\\0' unlike + * @code + * srprs_char(ptr, '\0', NULL); + * @endcode + * + * @param[in,out] ptr parse position + * + * @return true if **ptr == '\\0' + */ +bool srprs_eos(const char** ptr); + +/** + * Match a newline. + * A newline is either '\\n' (LF), '\\r' (CR), or "\r\n" (CRLF) + * + * @param[in,out] ptr parse position + * @param[out] nl output buffer where to put the match, may be NULL + * + * @return true if matched + */ +bool srprs_nl(const char** ptr, struct cbuf* nl); + +/** + * Match a newline or eos. + * + * @param ptr parse position + * @param nl output buffer where to put the match, may be NULL + * + * @return true if matched + */ +bool srprs_eol(const char** ptr, struct cbuf* nl); + +/** + * Match a line up to but not including the newline. + * + * @param[in,out] ptr parse position + * @param[out] str output buffer where to put the match, may be NULL + * + * @return true + */ +bool srprs_line(const char** ptr, struct cbuf* str); + + +#endif /* __SRPRS_H */ -- cgit