#include <swbasicfilter.h>

Inheritance diagram for SWBasicFilter:

Collaboration diagram for SWBasicFilter:

Classes
class	Private

Public Member Functions
virtual const char *	getHeader () const

virtual char	processText (SWBuf &text, const SWKey key=0, const SWModule module=0)

	SWBasicFilter ()

virtual	~SWBasicFilter ()

Protected Member Functions
void	addAllowedEscapeString (const char *findString)

void	addEscapeStringSubstitute (const char findString, const char replaceString)

void	addTokenSubstitute (const char findString, const char replaceString)

void	appendEscapeString (SWBuf &buf, const char *escString)

virtual BasicFilterUserData *	createUserData (const SWModule module, const SWKey key)

virtual bool	handleEscapeString (SWBuf &buf, const char escString, BasicFilterUserData userData)

virtual bool	handleNumericEscapeString (SWBuf &buf, const char *escString)

virtual bool	handleToken (SWBuf &buf, const char token, BasicFilterUserData userData)

bool	passAllowedEscapeString (SWBuf &buf, const char *escString)

virtual bool	processStage (char, SWBuf &, char &, BasicFilterUserData )

void	removeAllowedEscapeString (const char *findString)

void	removeEscapeStringSubstitute (const char *findString)

void	removeTokenSubstitute (const char *findString)

void	setEscapeEnd (const char *escEnd)

void	setEscapeStart (const char *escStart)

void	setEscapeStringCaseSensitive (bool val)

void	setPassThruNumericEscapeString (bool val)

void	setPassThruUnknownEscapeString (bool val)

void	setPassThruUnknownToken (bool val)

virtual void	setStageProcessing (char stages)

void	setTokenCaseSensitive (bool val)

void	setTokenEnd (const char *tokenEnd)

void	setTokenStart (const char *tokenStart)

bool	substituteEscapeString (SWBuf &buf, const char *escString)

bool	substituteToken (SWBuf &buf, const char *token)

Static Protected Attributes
static const char	FINALIZE = 8

static const char	INITIALIZE = 1

static const char	POSTCHAR = 4

static const char	PRECHAR = 2

Private Attributes
char *	escEnd

char	escEndLen

char *	escStart

char	escStartLen

bool	escStringCaseSensitive

Private *	p

bool	passThruNumericEsc

bool	passThruUnknownEsc

bool	passThruUnknownToken

char	processStages

bool	tokenCaseSensitive

char *	tokenEnd

char	tokenEndLen

char *	tokenStart

char	tokenStartLen

Detailed Description

A filter providing commonly used functionality. This filter has facilities for handling SGML/HTML/XML like tokens and escape strings (like SGML entities). It has the facility for just substituting the given tokens and escape strings to other strings and for "manual" custom token handling.

In this class the functions with arguments looking as char **buf write a character sequnce at address specified by *buf address and change *buf to point past the last char of the written sequence.

Definition at line 62 of file swbasicfilter.h.

Constructor & Destructor Documentation

SWBasicFilter::SWBasicFilter ( )

Definition at line 71 of file swbasicfilter.cpp.

                              {
 
     p = new Private;
 
     processStages = 0;
     tokenStart    = 0;
     tokenEnd      = 0;
     escStart      = 0;
     escEnd        = 0;
 
     setTokenStart("<");
     setTokenEnd(">");
     setEscapeStart("&");
     setEscapeEnd(";");
 
     escStringCaseSensitive = false;
     tokenCaseSensitive     = false;
     passThruUnknownToken   = false;
     passThruUnknownEsc     = false;
     passThruNumericEsc     = false;
 }

SWBasicFilter::~SWBasicFilter ( )

virtual

Definition at line 94 of file swbasicfilter.cpp.

                               {
     if (tokenStart)
         delete [] tokenStart;
 
     if (tokenEnd)
         delete [] tokenEnd;
 
     if (escStart)
         delete [] escStart;
 
     if (escEnd)
         delete [] escEnd;
 
     delete p;
 }

Member Function Documentation

void SWBasicFilter::addAllowedEscapeString ( const char * findString )

protected

Registers an esc control sequence that can pass unchanged

Definition at line 156 of file swbasicfilter.cpp.

                                                                  {
     char *buf = 0;
 
     if (!escStringCaseSensitive) {
         stdstr(&buf, findString);
         toupperstr(buf);
         p->escPassSet.insert(StringSet::value_type(buf));
         delete [] buf;
     }
     else p->escPassSet.insert(StringSet::value_type(findString));
 }

void SWBasicFilter::addEscapeStringSubstitute	(	const char *	findString,
		const char *	replaceString
	)

protected

Registers an esc control sequence

Definition at line 176 of file swbasicfilter.cpp.

                                                                                                {
     char *buf = 0;
 
     if (!escStringCaseSensitive) {
         stdstr(&buf, findString);
         toupperstr(buf);
         p->escSubMap.insert(DualStringMap::value_type(buf, replaceString));
         delete [] buf;
     }
     else p->escSubMap.insert(DualStringMap::value_type(findString, replaceString));
 }

void SWBasicFilter::addTokenSubstitute	(	const char *	findString,
		const char *	replaceString
	)

protected

Registers a simple token substitutions. Usually called from the c-tor of a subclass

Definition at line 136 of file swbasicfilter.cpp.

                                                                                         {
     char *buf = 0;
 
     if (!tokenCaseSensitive) {
         stdstr(&buf, findString);
         toupperstr(buf);
         p->tokenSubMap[buf] = replaceString;
         delete [] buf;
     }
     else p->tokenSubMap[findString] = replaceString;
 }

void SWBasicFilter::appendEscapeString	(	SWBuf &	buf,
		const char *	escString
	)

protected

This appends escString to buf as an entity

Definition at line 216 of file swbasicfilter.cpp.

                                                                         {
     buf += escStart;
     buf += escString;
     buf += escEnd;
 }

virtual BasicFilterUserData* SWBasicFilter::createUserData	(	const SWModule *	module,
		const SWKey *	key
	)

inlineprotectedvirtual

Reimplemented in OSISHTMLHREF, ThMLHTMLHREF, ThMLLaTeX, ThMLXHTML, TEILaTeX, TEIXHTML, OSISOSIS, TEIHTMLHREF, TEIRTF, ThMLRTF, OSISCGI, GBFHTML, GBFHTMLHREF, GBFLaTeX, GBFXHTML, TEIPlain, ThMLHTML, OSISLaTeX, OSISXHTML, OSISWEBIF, OSISHeadings, OSISPlain, OSISRTF, GBFCGI, and ThMLCGI.

Definition at line 91 of file swbasicfilter.h.

                                                                                           {
         return new BasicFilterUserData(module, key);
     }

virtual const char* SWFilter::getHeader ( ) const

inlinevirtualinherited

This method can supply a header associated with the processing done with this filter. A typical example is a suggested CSS style block for classed containers.

Reimplemented in OSISLaTeX, OSISXHTML, ThMLLaTeX, ThMLXHTML, TEIXHTML, GBFLaTeX, and GBFXHTML.

Definition at line 62 of file swfilter.h.

62 { return ""; }

bool SWBasicFilter::handleEscapeString	(	SWBuf &	buf,
		const char *	escString,
		BasicFilterUserData *	userData
	)

protectedvirtual

This function is called for every escape sequence encountered in the input text.

Parameters

buf	the output buffer
escString	the escape sequence (e.g. `"amp"` for &)
userData	user storage space for data transient to 1 full buffer parse

Returns: false if was not handled and should be handled in; subclasses should return true if they handled the esc seq, or false if they did not.

Definition at line 286 of file swbasicfilter.cpp.

                                                                                                        {
     return substituteEscapeString(buf, escString);
 }

bool SWBasicFilter::handleNumericEscapeString	(	SWBuf &	buf,
		const char *	escString
	)

protectedvirtual

This function is called for all numeric escape sequences. If passThrough

Parameters

buf	the output buffer
escString	the escape sequence (e.g. `"#235"` for &235;)

Returns: subclasses should return true if they handled the esc seq, or false if they did not.

Definition at line 244 of file swbasicfilter.cpp.

                                                                                {
     if (passThruNumericEsc) {
         appendEscapeString(buf, escString);
         return true;
     }
     return false;
 }

bool SWBasicFilter::handleToken	(	SWBuf &	buf,
		const char *	token,
		BasicFilterUserData *	userData
	)

protectedvirtual

This function is called for every token encountered in the input text.

Parameters

buf	the output buffer
token	the token (e.g. `"p align='left'"`
userData	user storage space for data transient to 1 full buffer parse

Returns: subclasses should return true if they handled the token, or false if they did not.

Reimplemented in OSISHTMLHREF, ThMLHTMLHREF, ThMLLaTeX, ThMLXHTML, TEILaTeX, OSISOSIS, TEIXHTML, TEIHTMLHREF, ThMLRTF, TEIRTF, OSISCGI, ThMLHTML, GBFHTML, GBFHTMLHREF, GBFLaTeX, GBFXHTML, TEIPlain, OSISLaTeX, OSISXHTML, OSISWEBIF, ThMLWEBIF, GBFWEBIF, OSISHeadings, OSISPlain, OSISRTF, GBFCGI, and ThMLCGI.

Definition at line 281 of file swbasicfilter.cpp.

                                                                                             {
     return substituteToken(buf, token);
 }

bool SWBasicFilter::passAllowedEscapeString	(	SWBuf &	buf,
		const char *	escString
	)

protected

This passes allowed escapeStrings

Definition at line 223 of file swbasicfilter.cpp.

                                                                              {
     StringSet::iterator it;
 
     if (!escStringCaseSensitive) {
             char *tmp = 0;
         stdstr(&tmp, escString);
         toupperstr(tmp);
         it = p->escPassSet.find(tmp);
         delete [] tmp;
     } else 
         it = p->escPassSet.find(escString);
 
     if (it != p->escPassSet.end()) {
         appendEscapeString(buf, escString);
         return true;
     }
 
     return false;
 }

virtual bool SWBasicFilter::processStage	(	char	,
		SWBuf &	,
		char *&	,
		BasicFilterUserData *
	)

inlineprotectedvirtual

Reimplemented in OSISPlain.

Definition at line 185 of file swbasicfilter.h.

185 { return false; }

char SWBasicFilter::processText	(	SWBuf &	text,
		const SWKey *	key = `0`,
		const SWModule *	module = `0`
	)

virtual

This method processes and appropriately modifies the text given it for a particular filter task

Parameters

text	The text to be filtered/converted
key	Current key That was used.
module	Current module.

Returns: 0

Implements SWFilter.

Reimplemented in ThMLRTF, OSISOSIS, and OSISRTF.

Definition at line 315 of file swbasicfilter.cpp.

                                                                                      {
     char *from;
     char token[4096];
     int tokpos = 0;
     bool intoken = false;
     bool inEsc = false;
     int escStartPos = 0, escEndPos = 0;
     int tokenStartPos = 0, tokenEndPos = 0;
     SWBuf lastTextNode;
     BasicFilterUserData *userData = createUserData(module, key);
 
     SWBuf orig = text;
     from = orig.getRawData();
     text = "";
 
     if (processStages & INITIALIZE) {
         if (processStage(INITIALIZE, text, from, userData)) {   // processStage handled it all
             delete userData;
             return 0;
         }
     }
 
     for (;*from; from++) {
 
         if (processStages & PRECHAR) {
             if (processStage(PRECHAR, text, from, userData))    // processStage handled this char
                 continue;
         }
 
         if (*from == tokenStart[tokenStartPos]) {
             if (tokenStartPos == (tokenStartLen - 1)) {
                 intoken = true;
                 tokpos = 0;
                 token[0] = 0;
                 token[1] = 0;
                 token[2] = 0;
                 inEsc = false;
             }
             else tokenStartPos++;
             continue;
         }
 
         if (*from == escStart[escStartPos]) {
             if (escStartPos == (escStartLen - 1)) {
                 intoken = true;
                 tokpos = 0;
                 token[0] = 0;
                 token[1] = 0;
                 token[2] = 0;
                 inEsc = true;
             }
             else escStartPos++;
             continue;
         }
 
         if (inEsc) {
             if (*from == escEnd[escEndPos]) {
                 if (escEndPos == (escEndLen - 1)) {
                     intoken = inEsc = false;
                     userData->lastTextNode = lastTextNode;
                     
                     if (!userData->suspendTextPassThru)  { //if text through is disabled no tokens should pass, too
                         if ((!handleEscapeString(text, token, userData)) && (passThruUnknownEsc)) {
                             appendEscapeString(text, token);
                         }
                     }
                     escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
                     lastTextNode = "";
                     continue;
                 }
             }
         }
 
         if (!inEsc) {
             if (*from == tokenEnd[tokenEndPos]) {
                 if (tokenEndPos == (tokenEndLen - 1)) {
                     intoken = false;
                     userData->lastTextNode = lastTextNode;
                     if ((!handleToken(text, token, userData)) && (passThruUnknownToken)) {
                         text += tokenStart;
                         text += token;
                         text += tokenEnd;
                     }
                     escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
                     lastTextNode = "";
                     if (!userData->suspendTextPassThru) {
                         userData->lastSuspendSegment.size(0);
                     }
                     continue;
                 }
             }
         }
 
         if (intoken) {
             if (tokpos < 4090) {
                 token[tokpos++] = *from;
                 token[tokpos+2] = 0;
             }
         }
         else {
             if ((!userData->supressAdjacentWhitespace) || (*from != ' ')) {
                 if (!userData->suspendTextPassThru) {
                     text.append(*from);
                 }
                 else    userData->lastSuspendSegment.append(*from);
                 lastTextNode.append(*from);
             }
             userData->supressAdjacentWhitespace = false;
         }
 
         if (processStages & POSTCHAR)
             processStage(POSTCHAR, text, from, userData);
 
     }
 
     if (processStages & FINALIZE)
         processStage(FINALIZE, text, from, userData);
 
     delete userData;
     return 0;
 }

void SWBasicFilter::removeAllowedEscapeString ( const char * findString )

protected

Unregisters an esc control sequence that can pass unchanged

Definition at line 169 of file swbasicfilter.cpp.

                                                                     {
     if (p->escPassSet.find(findString) != p->escPassSet.end()) {
         p->escPassSet.erase( p->escPassSet.find(findString) );
     }
 }

void SWBasicFilter::removeEscapeStringSubstitute ( const char * findString )

protected

Unregisters an esc control sequence

Definition at line 189 of file swbasicfilter.cpp.

                                                                        {
     if (p->escSubMap.find(findString) != p->escSubMap.end()) {
         p->escSubMap.erase( p->escSubMap.find(findString) );
     }
 }

void SWBasicFilter::removeTokenSubstitute ( const char * findString )

protected

Unregisters a simple token substitute

Definition at line 149 of file swbasicfilter.cpp.

                                                                 {
     if (p->tokenSubMap.find(findString) != p->tokenSubMap.end()) {
         p->tokenSubMap.erase( p->tokenSubMap.find(findString) );
     }
 }

void SWBasicFilter::setEscapeEnd ( const char * escEnd )

protected

Sets the end of escape sequence (by default ";").

Definition at line 297 of file swbasicfilter.cpp.

                                                    {
     stdstr(&(this->escEnd), escEnd);
     escEndLen   = strlen(escEnd);
 }

void SWBasicFilter::setEscapeStart ( const char * escStart )

protected

Sets the beginning of escape sequence (by default "&").

Definition at line 291 of file swbasicfilter.cpp.

                                                        {
     stdstr(&(this->escStart), escStart);
     escStartLen = strlen(escStart);
 }

void SWBasicFilter::setEscapeStringCaseSensitive ( bool val )

protected

Are escapeStrings case sensitive or not? Call this function before addEscapeStingSubstitute()

Definition at line 131 of file swbasicfilter.cpp.

                                                          {
     escStringCaseSensitive = val;
 }

void SWBasicFilter::setPassThruNumericEscapeString ( bool val )

protected

Sets whether to pass thru a numeric escape sequence unchanged or allow it to be handled otherwise. Default is false.

Definition at line 121 of file swbasicfilter.cpp.

                                                            {
     passThruUnknownEsc = val;
 }

void SWBasicFilter::setPassThruUnknownEscapeString ( bool val )

protected

Sets whether to pass thru an unknown escape sequence unchanged or just remove it. Default is false.

Definition at line 116 of file swbasicfilter.cpp.

                                                            {
     passThruUnknownEsc = val;
 }

void SWBasicFilter::setPassThruUnknownToken ( bool val )

protected

Sets whether to pass thru an unknown token unchanged or just remove it. Default is false.

Definition at line 111 of file swbasicfilter.cpp.

                                                     {
     passThruUnknownToken = val;
 }

virtual void SWBasicFilter::setStageProcessing ( char stages )

inlineprotectedvirtual

Definition at line 186 of file swbasicfilter.h.

186 { processStages = stages; } // see STATICs up above

SWBasicFilter::processStages

char processStages

Definition: swbasicfilter.h:79

void SWBasicFilter::setTokenCaseSensitive ( bool val )

protected

Are tokens case sensitive (like in GBF) or not? Call this function before addTokenSubstitute()

Definition at line 126 of file swbasicfilter.cpp.

                                                   {
     tokenCaseSensitive = val;
 }

void SWBasicFilter::setTokenEnd ( const char * tokenEnd )

protected

Sets the end of token start sequence (by default ">").

Definition at line 309 of file swbasicfilter.cpp.

                                                     {
     stdstr(&(this->tokenEnd), tokenEnd);
     tokenEndLen   = strlen(tokenEnd);
 }

void SWBasicFilter::setTokenStart ( const char * tokenStart )

protected

Sets the beginning of token start sequence (by default "<").

Definition at line 303 of file swbasicfilter.cpp.

                                                         {
     stdstr(&(this->tokenStart), tokenStart);
     tokenStartLen = strlen(tokenStart);
 }

bool SWBasicFilter::substituteEscapeString	(	SWBuf &	buf,
		const char *	escString
	)

protected

This function performs the substitution of escapeStrings

Definition at line 253 of file swbasicfilter.cpp.

                                                                             {
     DualStringMap::iterator it;
 
     if (*escString == '#') {
         return handleNumericEscapeString(buf, escString);
     }
 
     if (passAllowedEscapeString(buf, escString)) {
         return true;
     }
 
     if (!escStringCaseSensitive) {
             char *tmp = 0;
         stdstr(&tmp, escString);
         toupperstr(tmp);
         it = p->escSubMap.find(tmp);
         delete [] tmp;
     } else 
     it = p->escSubMap.find(escString);
 
     if (it != p->escSubMap.end()) {
         buf += it->second.c_str();
         return true;
     }
     return false;
 }

bool SWBasicFilter::substituteToken	(	SWBuf &	buf,
		const char *	token
	)

protected

This function performs the substitution of tokens

Definition at line 196 of file swbasicfilter.cpp.

                                                                  {
     DualStringMap::iterator it;
 
     if (!tokenCaseSensitive) {
             char *tmp = 0;
         stdstr(&tmp, token);
         toupperstr(tmp);
         it = p->tokenSubMap.find(tmp);
         delete [] tmp;
     } else
     it = p->tokenSubMap.find(token);
 
     if (it != p->tokenSubMap.end()) {
         buf += it->second.c_str();
         return true;
     }
     return false;
 }

Member Data Documentation

char* SWBasicFilter::escEnd

private

Definition at line 69 of file swbasicfilter.h.

char SWBasicFilter::escEndLen

private

Definition at line 71 of file swbasicfilter.h.

char* SWBasicFilter::escStart

private

Definition at line 68 of file swbasicfilter.h.

char SWBasicFilter::escStartLen

private

Definition at line 70 of file swbasicfilter.h.

bool SWBasicFilter::escStringCaseSensitive

private

Definition at line 74 of file swbasicfilter.h.

const char SWBasicFilter::FINALIZE = 8

staticprotected

Definition at line 99 of file swbasicfilter.h.

const char SWBasicFilter::INITIALIZE = 1

staticprotected

Definition at line 96 of file swbasicfilter.h.

Private* SWBasicFilter::p

private

Definition at line 82 of file swbasicfilter.h.

bool SWBasicFilter::passThruNumericEsc

private

Definition at line 78 of file swbasicfilter.h.

bool SWBasicFilter::passThruUnknownEsc

private

Definition at line 77 of file swbasicfilter.h.

bool SWBasicFilter::passThruUnknownToken

private

Definition at line 76 of file swbasicfilter.h.

const char SWBasicFilter::POSTCHAR = 4

staticprotected

Definition at line 98 of file swbasicfilter.h.

const char SWBasicFilter::PRECHAR = 2

staticprotected

Definition at line 97 of file swbasicfilter.h.

char SWBasicFilter::processStages

private

Definition at line 79 of file swbasicfilter.h.

bool SWBasicFilter::tokenCaseSensitive

private

Definition at line 75 of file swbasicfilter.h.

char* SWBasicFilter::tokenEnd

private

Definition at line 67 of file swbasicfilter.h.

char SWBasicFilter::tokenEndLen

private

Definition at line 73 of file swbasicfilter.h.

char* SWBasicFilter::tokenStart

private

Definition at line 64 of file swbasicfilter.h.

char SWBasicFilter::tokenStartLen

private

Definition at line 72 of file swbasicfilter.h.

The documentation for this class was generated from the following files:

include/swbasicfilter.h
src/modules/filters/swbasicfilter.cpp

Classes

Public Member Functions

Protected Member Functions

Static Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation