parser3/src/include/pa_string.h - diff

Return to pa_string.h CVS log

Up to [parser3project] / parser3 / src / include

Diff for /parser3/src/include/pa_string.h between versions 1.78 and 1.102

version 1.78, 2001/04/09 14:31:40	version 1.102, 2001/09/11 09:20:57
Line 12	Line 12
#define PA_STRING_H	#define PA_STRING_H

#include "pa_config_includes.h"	#include "pa_config_includes.h"

#include <string.h>
#include <stddef.h>

#include "pa_pool.h"	#include "pa_pool.h"
#include "pa_types.h"	#include "pa_types.h"

class Table;	class Table;

/**	/**
$MAIN:html-typo table elements must enlarge string not more that that	$MAIN:html-typo table elements must enlarge string not more that that.

that's a tradeoff - otherwise we'd have to scan string twice:	that's a tradeoff - otherwise we'd have to scan string twice:
- first for buffer length	- first for buffer length
- second for replacements themselves	- second for replacements themselves
Line 46 class Table;	Line 43 class Table;
# define APPEND(src, size, lang, file, line) \	# define APPEND(src, size, lang, file, line) \
real_append(src, size, lang)	real_append(src, size, lang)
#endif	#endif
/// appends clean piece to String @see String::real_append	/// appends clean piece to String @see String::real_append
#define APPEND_CLEAN(src, size, file, line) \	#define APPEND_CLEAN(src, size, file, line) \
APPEND(src, size, String::UL_CLEAN, file, line)	APPEND(src, size, String::UL_CLEAN, file, line)
	/// appends piece to String as-is @see String::real_append
	#define APPEND_AS_IS(src, size, file, line) \
	APPEND(src, size, String::UL_AS_IS, file, line)
/// appends tainted piece to String @see String::real_append	/// appends tainted piece to String @see String::real_append
#define APPEND_TAINTED(src, size, file, line) \	#define APPEND_TAINTED(src, size, file, line) \
APPEND(src, size, String::UL_TAINTED, file, line)	APPEND(src, size, String::UL_TAINTED, file, line)
/// handy: appends const char* piece to String @see String::real_append	/// handy: appends const char* piece to String @see String::real_append
#define APPEND_CONST(src) APPEND_CLEAN(src, 0, 0, 0)	#define APPEND_CONST(src) APPEND_AS_IS(src, 0, 0, 0)

class Array;	class Array;
class SQL_Connection;	class SQL_Connection;
	class Dictionary;

/**	/**
Pooled string.	Pooled string.
Line 82 class String : public Pooled {	Line 83 class String : public Pooled {
public:	public:

enum {	enum {
CR_PREALLOCATED_COUNT=5, ///< default preallocated item count	CR_PREALLOCATED_COUNT=2, ///< default preallocated item count
CR_GROW_PERCENT=60 ///< each time the Array chunk_is_full() array expanded()	CR_GROW_COUNT=2 ///< each time the String chunk_is_full() string expanded()
};	};

/// piece is tainted or not. the language to use when detaint	/// piece is tainted or not. the language to use when detaint
Line 105 public:	Line 106 public:
UL_TABLE, ///< ^table:set body	UL_TABLE, ///< ^table:set body
UL_SQL, ///< ^table:sql body	UL_SQL, ///< ^table:sql body
UL_JS, ///< JavaScript code	UL_JS, ///< JavaScript code
	UL_XML, ///< ^dom:set xml
UL_HTML, ///< HTML code (for editing)	UL_HTML, ///< HTML code (for editing)
UL_HTML_TYPO ///< HTML code with TYPOgraphic replacements (for showing)	UL_USER_HTML ///< HTML code with USER chars
};	};

public:	public:
Line 114 public:	Line 116 public:
String(Pool& apool, const char *src=0, size_t src_size=0, bool tainted=false);	String(Pool& apool, const char *src=0, size_t src_size=0, bool tainted=false);
String(const String& src);	String(const String& src);
size_t size() const { return fsize; }	size_t size() const { return fsize; }
/// convert to C string, store to 'dest' which must be big enough for proper untaint	/// makes store_to produce origin:text\n output
char store_to(char dest,	void set_origins_mode(bool aorigins_mode) const { forigins_mode=aorigins_mode; }
Untaint_lang lang=UL_UNSPECIFIED, SQL_Connection *connection=0) const;
/// convert to C string. if 'lang' known, forcing 'lang' to it	/// convert to C string. if 'lang' known, forcing 'lang' to it
char cstr(Untaint_lang lang=UL_UNSPECIFIED, SQL_Connection connection=0) const {	char *cstr(Untaint_lang lang=UL_UNSPECIFIED,
char result=(char )malloc(size()*UNTAINT_TIMES_BIGGER+1);	SQL_Connection *connection=0,
char *eol=store_to(result, lang, connection);	const char *charset=0) const {

	char result=(char )malloc(cstr_bufsize(lang));
	char *eol=store_to(result, lang, connection, charset);
*eol=0;	*eol=0;
return result;	return result;
}	}
/** append fragment	/** append fragment
@see APPEND_CLEAN, APPEND_TAINTED, APPEND_CONST	@see APPEND_AS_IS, APPEND_CLEAN, APPEND_TAINTED, APPEND_CONST
*/	*/
String& real_append(STRING_APPEND_PARAMS);	String& real_append(STRING_APPEND_PARAMS);
/// @return <0 ==0 or >0 depending on comparison result	/// @return <0 ==0 or >0 depending on comparison result
Line 159 public:	Line 163 public:
int partial; // unused	int partial; // unused
return cmp(partial, src_ptr, src_size)==0;	return cmp(partial, src_ptr, src_size)==0;
}	}
	bool operator != (const char* src_ptr) const {
	int partial; // unused
	return cmp(partial, src_ptr, 0)!=0;
	}


/**	/**
appends other String.	appends other String.
Line 173 public:	Line 182 public:
/// simple hash code of string. used by Hash	/// simple hash code of string. used by Hash
uint hash_code() const;	uint hash_code() const;

	/// extracts first char of a string
	char first_char() const;

/// extracts [start, finish) piece of string	/// extracts [start, finish) piece of string
String& mid(size_t start, size_t finish) const;	String& mid(size_t start, size_t finish) const;

Line 180 public:	Line 192 public:
int pos(const String& substr,	int pos(const String& substr,
size_t this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;	size_t this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;
/// @return position of substr in string, -1 means "not found" [const char* version]	/// @return position of substr in string, -1 means "not found" [const char* version]
int pos(const char *substr, size_t substr_size,	int pos(const char *substr, size_t substr_size=0,
size_t this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;	size_t this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;

void split(Array& result,	void split(Array& result,
size_t *pos_after_ref,	size_t *pos_after_ref,
const char *delim, size_t delim_size,	const char *delim, size_t delim_size,
Untaint_lang lang, int limit=-1) const;	Untaint_lang lang=UL_UNSPECIFIED, int limit=-1) const;
void split(Array& result,	void split(Array& result,
size_t *pos_after_ref,	size_t *pos_after_ref,
const String& delim,	const String& delim,
Untaint_lang lang, int limit=-1) const;	Untaint_lang lang=UL_UNSPECIFIED, int limit=-1) const;

typedef void (Row_action)(Table& table, Array row, int start, int finish,	typedef void (Row_action)(Table& table, Array row, int start, int finish,
void *info);	void *info);
bool match(const String *aorigin,	/**
	@return true if fills table.
	table format is defined and fixed[can be used by others]:
	@verbatim
	prematch/match/postmatch/1/2/3/...
	@endverbatim
	*/
	bool match(const unsigned char *pcre_tables,
	const String *aorigin,
const String& regexp,	const String& regexp,
const String *options,	const String *options,
Table **table,	Table **table,
Row_action row_action, void *info) const;	Row_action row_action, void *info,
	bool *was_global=0) const;
	enum Change_case_kind {
	CC_UPPER,
	CC_LOWER
	};
	String& change_case(Pool& pool, const unsigned char *pcre_tables,
	Change_case_kind kind) const;
	String& replace(Pool& pool, Dictionary& dict) const;
	double as_double() const;
	int as_int() const;

#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
/// origin of string. calculated by first row	/// origin of string. calculated by first row
Line 207 public:	Line 237 public:

private:	private:

	/// several String fragments
struct Chunk {	struct Chunk {
// the number of rows in chunk	size_t count; ///< the number of rows in chunk
size_t count;	/// string fragment or a link to next chunk union
union Row {	union Row {
// fragment	/// fragment
struct {	struct {
const char *ptr; // pointer to the start	const char *ptr; ///< pointer to the start
size_t size; // length	size_t size; ///< length
Untaint_lang lang; // untaint flag, later untaint language	Untaint_lang lang; ///< untaint flag, later untaint language
#ifndef NO_STRING_ORIGIN	#ifndef NO_STRING_ORIGIN
Origin origin; // origin	Origin origin; ///< origin
#endif	#endif
} item;	} item;
Chunk *link; // link to the next chunk in chain	Chunk *link; ///< link to the next chunk in chain
} rows[CR_PREALLOCATED_COUNT];	} rows[CR_PREALLOCATED_COUNT];
// next rows are here	Chunk *preallocated_link; ///< next rows are here
Chunk *preallocated_link;
}	}
head; // the head chunk of the chunk chain	head; ///< the head chunk of the chunk chain

// next append would write to this record	/// next append would write to this record
Chunk::Row *append_here;	Chunk::Row *append_here;

// the address of place where lies address	/** the address of place where lies address
// of the link to the next chunk to allocate	of the link to the next chunk to allocate
	*/
Chunk::Row *link_row;	Chunk::Row *link_row;

private:	private:
Line 244 private:	Line 275 private:
// used rows in all chunks	// used rows in all chunks
int fused_rows;	int fused_rows;

	/// origins_mode changes behaviour of store_to[cstr()]
	mutable bool forigins_mode;

private:	private:

bool chunk_is_full() {	bool chunk_is_full() {
Line 251 private:	Line 285 private:
}	}
void expand();	void expand();

	size_t cstr_bufsize(Untaint_lang lang) const;
	/// convert to C string, store to 'dest' which must be big enough for proper untaint
	char store_to(char dest, Untaint_lang lang=UL_UNSPECIFIED,
	SQL_Connection *connection=0,
	const char *charset=0) const;

private: //disabled	private: //disabled

String& operator = (const String&) { return *this; }	String& operator = (const String&) { return *this; }

E-mail:

Removed from v.1.78
changed lines
	Added in v.1.102