eruta-c/include/slre.h

// Copyright (c) 2004-2012 Sergey Lyubka <valenok@gmail.com>
// All rights reserved
//
// Enhanced and modified by beoran@gmail.com, 2013.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

#ifndef SLRE_HEADER_DEFINED
#define SLRE_HEADER_DEFINED

// This is a regular expression library that implements a subset of Perl RE.
// Please refer to http://slre.googlecode.com for detailed description.
//
// Supported syntax:
//    ^        Match beginning of a buffer
//    $        Match end of a buffer
//    ()       Grouping and substring capturing
//    [...]    Match any character from set
//    [^...]   Match any character but ones from set
//    \s       Match whitespace
//    \S       Match non-whitespace
//    \d       Match decimal digit
//    \D       Match anything but a decimal digit
//    \a       Match alphabetical character
//    \A       Match anything but an alphabetical character
//    \w       Match alphanumerical character
//    \W       Match anything but an alphanumerical character
//    \b       Match a blank character, i.e. space or tab
//    \B       Match anything but a blank character
//    \x       Match a hexadecimal digit
//    \X       Match anything but a hexadecimal digit
//    \t       Match a tab
//    \r       Match carriage return
//    \n       Match newline
//    +        Match one or more times (greedy)
//    +?       Match one or more times (non-greedy)
//    *        Match zero or more times (greedy)
//    *?       Match zero or more times (non-greedy)
//    ?        Match zero or once
//    \xDD     Match byte with hex value 0xDD
//    \meta    Match one of the meta character: ^$().[*+\?

// Match string buffer "buf" of length "buf_len" against "regexp", which should
// conform the syntax outlined above. "options" could be either 0 or
// SLRE_CASE_INSENSITIVE for case-insensitive match. If regular expression
// "regexp" contains brackets, slre_match() will capture the respective
// substring into the passed placeholder. Thus, each opening parenthesis
// should correspond to three arguments passed:
//   placeholder_type, placeholder_size, placeholder_address
//
// Usage example: parsing HTTP request line.
//
//  char method[10], uri[100];
//  int http_version_minor, http_version_major;
//  const char *error;
//  const char *request = " \tGET /index.html HTTP/1.0\r\n\r\n";

//  error = slre_match(0, "^\\s*(GET|POST)\\s+(\\S+)\\s+HTTP/(\\d)\\.(\\d)",
//                     request, strlen(request),
//                     SLRE_STRING,  sizeof(method), method,
//                     SLRE_STRING, sizeof(uri), uri,
//                     SLRE_INT,sizeof(http_version_major),&http_version_major,
//                     SLRE_INT,sizeof(http_version_minor),&http_version_minor);
//
//  if (error != NULL) {
//    printf("Error parsing HTTP request: %s\n", error);
//  } else {
//    printf("Requested URI: %s\n", uri);
//  }
//
// If the option SLRE_NO_CAPTURE is passed, captures are not stored.
//
// If SLRE_CALLBACK is passed as the first variable arument, then the 2 next 
// arguments must be a function pointer of the type * slre_callback, and a void *
// that points to extra data or to NULL. The callback will be called once 
// for every match. It should return 0 to signal success or any of slre_result
// to signal failure. The nonzero result of the callback will be returned from 
// slre_match().
//
// If SLRE_CAPTURED is passed, addresses to slre_captured structs must be passed 
// for storage of the results.
// 
// If SLRE_IGNORE is passed, then all further captures are ignored.
//
// Return:
//   NULL: string matched and all captures successfully made
//   non-NULL: in this case, the return value is an error string

/* Match options. */
enum slre_option { 
  SLRE_CASE_INSENSITIVE = 1, SLRE_NO_CAPTURE = 2
};

/* Possible capture types. */
enum slre_capture { 
   SLRE_STRING, SLRE_INT, SLRE_FLOAT, SLRE_CALLBACK, SLRE_CAPTURED, SLRE_IGNORE
};

/* Captured substring */
struct slre_captured {
  const char *ptr;  // Pointer to the substring
  int len;          // Substring length
};


/* Possible results of slre_match. */
enum slre_result {
  SLRE_OK                       = 0,
  SLRE_ERROR_NO_MATCH           = 1,      
  SLRE_ERROR_JUMP_OFFSET        = 2,
  SLRE_ERROR_CODE_TOO_LONG      = 3,     
  SLRE_ERROR_DATA_TOO_LONG      = 4,
  SLRE_ERROR_NO_PAREN           = 5,      
  SLRE_ERROR_BAD_PAREN          = 6,     
  SLRE_ERROR_NO_BRACKET         = 7,    
  SLRE_ERROR_TOO_MANY_PAREN     = 8,
  SLRE_ERROR_INT_FAILED         = 9,  
  SLRE_ERROR_INT_SIZE           = 10,    
  SLRE_ERROR_FLOAT_SIZE         = 11,  
  SLRE_ERROR_FLOAT_FAILED       = 12,
  SLRE_ERROR_STRING_SIZE        = 13, 
  SLRE_ERROR_UNKNOWN_TYPE       = 14,
  SLRE_ERROR_TEXT_TOO_LONG      = 15,    
  SLRE_ERROR_NULL_CAPTURED      = 16,
  SLRE_ERROR_LAST               = 225,
};

/* Maximum amount of captures. */
#ifndef SLRE_CAPURES_MAX
#define SLRE_CAPURES_MAX 64
#endif


/* Callback type to use for SLRE_CALLBACK. */
typedef int slre_callback(int index, const char * capture, int size, void * data);

/* Matching function. */
int slre_match(enum slre_option options, const char *regexp,
                       const char *buf, int buf_len, ...);

/* Converts error code to string or NULL if not known. */
const char * slre_error(int code);

#endif /* SLRE_HEADER_DEFINED */