sprint/utils/string.h

/******************************************************************************
*   SPRINT::utils::string
*
*   Copyright (C) 2005-2010  Paolo Medici <www.pmx.it>
*
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_UTILS_STRING_H
#define _SPRINT_UTILS_STRING_H

#include "hex.h"

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>

#define PARSE_UNKNOWN   -1

int strlistcmp(const char *string, const char **list);

int strlisticmp(const char *string, const char **list);

int strlistcmpex(const char *string, const char **list);

int strarraycmp(const char *string, const char **array, unsigned int nitem);

void strtolower(char *str);
char *remove_endl(char *src);

int findendl(char *src, int pos);

int remove_lastchar(char *buffer);

unsigned int parse_vector(void *data, const char *str, unsigned int item_size);

unsigned int parse_byte_vector(unsigned char *ptr, const char *str, unsigned int max_item);

unsigned int parse_hexbyte_vector(unsigned char *ptr, const char *str, unsigned int max_item);
unsigned int hextoarray(const char *hex, unsigned char *array, unsigned int array_size);

unsigned int flagtoui(const char *src);
unsigned int itoflag(char *buffer, unsigned int flag);

int parse_bitvector(const char *string);

unsigned int parse_stringvector(const char *string, const char **list);

int split_string(char *string, char **argv, unsigned int max_argc);

char *compose_string(char *buffer, unsigned int buf_size, const char **argv, unsigned int argc, char sep=' ');



char *strnav(char **_string);

int split_assign(char *string, char **data);
void split_assign_special(char *line, char **data);

const char *skip_to_next_line(const char *ptr);

char *skipspace(char *src);

char *reverseskipspace(char *src);

char *splitstr(char *src, char separator);

/* ******************************************************* */

bool atobool(const char* iBool);

const char *find_next_valid_line(const char *buffer);
int count_valid_line(const char *buffer);
int split_txt_buffer(char *buffer, char **ptr, int list_size);

/* ******************************************************* */
const char *memchrr(const char *src, char c, int len);
int crlfstr(char *dst, const char *src, int line_size);

const char *strextract(char *out, const char *src);

int memextract(char *out, const char *src, int max_len);

const char *strccpy(char *varbuffer, const char *ptr, int character, int buf_size);

char *strcpyv(char *dst, char *src);

void smemcpy(char *dst, char *src, char *end);

char *memrnchr(char *start, char c);

char *nstrchr(char *start, char c);

int strcount(char *string, int c);

/* ******************************************************* */

typedef int (* EXTERNALPARAMPROC) (void *param, const char *variable);

int parse_formula(const char *formula, EXTERNALPARAMPROC proc, void *param);


int strcmpex(const char *src, const char *target);
int stricmpex(const char *src, const char *target);

int strword(const char *src, const char *target);

int strwildcardcmp(const char *src, const char *target);

#define CMP_DIFFERENT           0
#define CMP_EQUAL                       1
#define CMP_SRC_MORE_LONG       2
#define CMP_TRG_MORE_LONG       3

/* *********************************************************** */

char *fcfgparse(char *buffer, unsigned int buffer_size, FILE *fp);

#ifdef __cplusplus
}
#endif


#ifdef __cplusplus

class CFormula {
  private:
  int parse(const char **data);
  public:
  virtual ~CFormula() {}
  virtual int get(const char *variable) = 0;
  
  int operator() (const char *formula)
    {
    return parse(&formula);
    }
};


#endif

#endif