The SWORD Project  1.9.0.svnversion
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | Static Protected Attributes | List of all members
GBFCGI Class Reference

#include <gbfcgi.h>

+ Inheritance diagram for GBFCGI:
+ Collaboration diagram for GBFCGI:

Public Member Functions

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

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
 

Detailed Description

this filter converts GBF text to Diatheke/CGI format

Definition at line 33 of file gbfcgi.h.

Constructor & Destructor Documentation

GBFCGI::GBFCGI ( )

Definition at line 45 of file gbfcgi.cpp.

45  {
46  setTokenStart("<");
47  setTokenEnd(">");
48 
49  setTokenCaseSensitive(true);
50 
51  addTokenSubstitute("Rf", ")</small></font>");
52  addTokenSubstitute("FI", "<i>"); // italics begin
53  addTokenSubstitute("Fi", "</i>");
54  addTokenSubstitute("FB", "<n>"); // bold begin
55  addTokenSubstitute("Fb", "</n>");
56  addTokenSubstitute("FR", "<font color=\"#FF0000\">"); // words of Jesus begin
57  addTokenSubstitute("Fr", "</font>");
58  addTokenSubstitute("FU", "<u>"); // underline begin
59  addTokenSubstitute("Fu", "</u>");
60  addTokenSubstitute("FO", "<cite>"); // Old Testament quote begin
61  addTokenSubstitute("Fo", "</cite>");
62  addTokenSubstitute("FS", "<sup>"); // Superscript begin// Subscript begin
63  addTokenSubstitute("Fs", "</sup>");
64  addTokenSubstitute("FV", "<sub>"); // Subscript begin
65  addTokenSubstitute("Fv", "</sub>");
66  addTokenSubstitute("TT", "<big>"); // Book title begin
67  addTokenSubstitute("Tt", "</big>");
68  addTokenSubstitute("PP", "<cite>"); // poetry begin
69  addTokenSubstitute("Pp", "</cite>");
70  addTokenSubstitute("Fn", "</font>"); // font end
71  addTokenSubstitute("CL", "<br />"); // new line
72  addTokenSubstitute("CM", "<br />"); // paragraph
73  addTokenSubstitute("CG", "&gt;"); // ???
74  addTokenSubstitute("CT", "&lt;"); // ???
75  addTokenSubstitute("JR", "<div align=\"right\">"); // right align begin
76  addTokenSubstitute("JC", "<div align=\"center\">"); // center align begin
77  addTokenSubstitute("JL", "</div>"); // align end
78 
79 }
SWBasicFilter::setTokenEnd
void setTokenEnd(const char *tokenEnd)
Definition: swbasicfilter.cpp:309
SWBasicFilter::setTokenCaseSensitive
void setTokenCaseSensitive(bool val)
Definition: swbasicfilter.cpp:126
SWBasicFilter::setTokenStart
void setTokenStart(const char *tokenStart)
Definition: swbasicfilter.cpp:303
SWBasicFilter::addTokenSubstitute
void addTokenSubstitute(const char *findString, const char *replaceString)
Definition: swbasicfilter.cpp:136

Member Function Documentation

void SWBasicFilter::addAllowedEscapeString ( const char *  findString)
protectedinherited

Registers an esc control sequence that can pass unchanged

Definition at line 156 of file swbasicfilter.cpp.

156  {
157  char *buf = 0;
158 
159  if (!escStringCaseSensitive) {
160  stdstr(&buf, findString);
161  toupperstr(buf);
162  p->escPassSet.insert(StringSet::value_type(buf));
163  delete [] buf;
164  }
165  else p->escPassSet.insert(StringSet::value_type(findString));
166 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
SWBasicFilter::escStringCaseSensitive
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
toupperstr
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
void SWBasicFilter::addEscapeStringSubstitute ( const char *  findString,
const char *  replaceString 
)
protectedinherited

Registers an esc control sequence

Definition at line 176 of file swbasicfilter.cpp.

176  {
177  char *buf = 0;
178 
179  if (!escStringCaseSensitive) {
180  stdstr(&buf, findString);
181  toupperstr(buf);
182  p->escSubMap.insert(DualStringMap::value_type(buf, replaceString));
183  delete [] buf;
184  }
185  else p->escSubMap.insert(DualStringMap::value_type(findString, replaceString));
186 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
SWBasicFilter::escStringCaseSensitive
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
toupperstr
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
void SWBasicFilter::addTokenSubstitute ( const char *  findString,
const char *  replaceString 
)
protectedinherited

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

Definition at line 136 of file swbasicfilter.cpp.

136  {
137  char *buf = 0;
138 
139  if (!tokenCaseSensitive) {
140  stdstr(&buf, findString);
141  toupperstr(buf);
142  p->tokenSubMap[buf] = replaceString;
143  delete [] buf;
144  }
145  else p->tokenSubMap[findString] = replaceString;
146 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
SWBasicFilter::tokenCaseSensitive
bool tokenCaseSensitive
Definition: swbasicfilter.h:75
SWBasicFilter::Private::tokenSubMap
DualStringMap tokenSubMap
Definition: swbasicfilter.cpp:46
toupperstr
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
void SWBasicFilter::appendEscapeString ( SWBuf &  buf,
const char *  escString 
)
protectedinherited

This appends escString to buf as an entity

Definition at line 216 of file swbasicfilter.cpp.

216  {
217  buf += escStart;
218  buf += escString;
219  buf += escEnd;
220 }
BasicFilterUserData * GBFCGI::createUserData ( const SWModule *  module,
const SWKey *  key 
)
protectedvirtual

Reimplemented from SWBasicFilter.

Definition at line 41 of file gbfcgi.cpp.

41  {
42  return new MyUserData(module, key);
43 }
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 
)
protectedvirtualinherited

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

Parameters
bufthe output buffer
escStringthe escape sequence (e.g. "amp" for &amp;)
userDatauser 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.

286  {
287  return substituteEscapeString(buf, escString);
288 }
SWBasicFilter::substituteEscapeString
bool substituteEscapeString(SWBuf &buf, const char *escString)
Definition: swbasicfilter.cpp:253
bool SWBasicFilter::handleNumericEscapeString ( SWBuf &  buf,
const char *  escString 
)
protectedvirtualinherited

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

Parameters
bufthe output buffer
escStringthe 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.

244  {
245  if (passThruNumericEsc) {
246  appendEscapeString(buf, escString);
247  return true;
248  }
249  return false;
250 }
SWBasicFilter::passThruNumericEsc
bool passThruNumericEsc
Definition: swbasicfilter.h:78
SWBasicFilter::appendEscapeString
void appendEscapeString(SWBuf &buf, const char *escString)
Definition: swbasicfilter.cpp:216
bool GBFCGI::handleToken ( SWBuf &  buf,
const char *  token,
BasicFilterUserData *  userData 
)
protectedvirtual

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

Parameters
bufthe output buffer
tokenthe token (e.g. "p align='left'"
userDatauser 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 from SWBasicFilter.

Definition at line 82 of file gbfcgi.cpp.

82  {
83  MyUserData *userData = (MyUserData *) baseUserData;
84  unsigned long i;
85  if (!substituteToken(buf, token)) {
86  if (!strncmp(token, "WG", 2) || !strncmp(token, "WH", 2)) { // strong's numbers
87  buf += " <small><em>&lt;<a href=\"!DIATHEKE_URL!";
88  if (token[1] == 'H') {
89  buf += "StrongsHebrew";
90  }
91  else if (token[1] == 'G') {
92  buf += "StrongsGreek";
93  }
94  buf += "=on&verse=";
95  for (i = 2; i < strlen(token); i++)
96  buf += token[i];
97  buf += "\">";
98  for (i = 2; i < strlen(token); i++)
99  buf += token[i];
100  buf += "</a>&gt;</em></small>";
101  }
102 
103  else if (!strncmp(token, "WTG", 3) || !strncmp(token, "WTH", 3)) { // strong's numbers tense
104  buf += " <small><em>&lt;<a href=\"!DIATHEKE_URL!";
105  if (token[2] == 'H') {
106  buf += "StrongsHebrew";
107  }
108  else if (token[2] == 'G') {
109  buf += "StrongsGreek";
110  }
111  buf += "=on&verse=";
112  for (i = 3; i < strlen(token); i++)
113  buf += token[i];
114  buf += "\">";
115  for (i = 3; i < strlen(token); i++)
116  buf += token[i];
117  buf += "</a>&gt;</em></small>";
118  }
119 
120  else if (!strncmp(token, "WT", 2)) { // morph tags
121  buf += " <small><em>(<a href=\"!DIATHEKE_URL!Packard=on&verse=";
122  for (i = 1; i < strlen(token); i++)
123  buf += token[i];
124  buf += "\">";
125  for (i = 1; i < strlen(token); i++)
126  buf += token[i];
127  buf += "</a>)</em></small>";
128  }
129 
130  else if (!strncmp(token, "RB", 2)) {
131  buf += "<i>";
132  userData->properties["hasFootnotePreTag"] = "true";
133  }
134 
135  else if (!strncmp(token, "RF", 2)) {
136  if(userData->properties["hasFootnotePreTag"] == "true") {
137  userData->properties["hasFootnotePreTag"] = "false";
138  buf += "</i> ";
139  }
140  buf += "<font color=\"#800000\"><small> (";
141  }
142 
143  else if (!strncmp(token, "FN", 2)) {
144  buf += "<font face=\"";
145  for (i = 2; i < strlen(token); i++)
146  buf += token[i];
147  buf += "\">";
148  }
149 
150  else if (!strncmp(token, "CA", 2)) { // ASCII value
151  buf += (char)atoi(&token[2]);
152  }
153 
154  else {
155  return false;
156  }
157  }
158  return true;
159 }
SWBasicFilter::substituteToken
bool substituteToken(SWBuf &buf, const char *token)
Definition: swbasicfilter.cpp:196
bool SWBasicFilter::passAllowedEscapeString ( SWBuf &  buf,
const char *  escString 
)
protectedinherited

This passes allowed escapeStrings

Definition at line 223 of file swbasicfilter.cpp.

223  {
224  StringSet::iterator it;
225 
226  if (!escStringCaseSensitive) {
227  char *tmp = 0;
228  stdstr(&tmp, escString);
229  toupperstr(tmp);
230  it = p->escPassSet.find(tmp);
231  delete [] tmp;
232  } else
233  it = p->escPassSet.find(escString);
234 
235  if (it != p->escPassSet.end()) {
236  appendEscapeString(buf, escString);
237  return true;
238  }
239 
240  return false;
241 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
SWBasicFilter::escStringCaseSensitive
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
toupperstr
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
SWBasicFilter::appendEscapeString
void appendEscapeString(SWBuf &buf, const char *escString)
Definition: swbasicfilter.cpp:216
virtual bool SWBasicFilter::processStage ( char  ,
SWBuf &  ,
char *&  ,
BasicFilterUserData *   
)
inlineprotectedvirtualinherited

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 
)
virtualinherited

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

Parameters
textThe text to be filtered/converted
keyCurrent key That was used.
moduleCurrent module.
Returns
0

Implements SWFilter.

Reimplemented in ThMLRTF, OSISOSIS, and OSISRTF.

Definition at line 315 of file swbasicfilter.cpp.

315  {
316  char *from;
317  char token[4096];
318  int tokpos = 0;
319  bool intoken = false;
320  bool inEsc = false;
321  int escStartPos = 0, escEndPos = 0;
322  int tokenStartPos = 0, tokenEndPos = 0;
323  SWBuf lastTextNode;
324  BasicFilterUserData *userData = createUserData(module, key);
325 
326  SWBuf orig = text;
327  from = orig.getRawData();
328  text = "";
329 
330  if (processStages & INITIALIZE) {
331  if (processStage(INITIALIZE, text, from, userData)) { // processStage handled it all
332  delete userData;
333  return 0;
334  }
335  }
336 
337  for (;*from; from++) {
338 
339  if (processStages & PRECHAR) {
340  if (processStage(PRECHAR, text, from, userData)) // processStage handled this char
341  continue;
342  }
343 
344  if (*from == tokenStart[tokenStartPos]) {
345  if (tokenStartPos == (tokenStartLen - 1)) {
346  intoken = true;
347  tokpos = 0;
348  token[0] = 0;
349  token[1] = 0;
350  token[2] = 0;
351  inEsc = false;
352  }
353  else tokenStartPos++;
354  continue;
355  }
356 
357  if (*from == escStart[escStartPos]) {
358  if (escStartPos == (escStartLen - 1)) {
359  intoken = true;
360  tokpos = 0;
361  token[0] = 0;
362  token[1] = 0;
363  token[2] = 0;
364  inEsc = true;
365  }
366  else escStartPos++;
367  continue;
368  }
369 
370  if (inEsc) {
371  if (*from == escEnd[escEndPos]) {
372  if (escEndPos == (escEndLen - 1)) {
373  intoken = inEsc = false;
374  userData->lastTextNode = lastTextNode;
375 
376  if (!userData->suspendTextPassThru) { //if text through is disabled no tokens should pass, too
377  if ((!handleEscapeString(text, token, userData)) && (passThruUnknownEsc)) {
378  appendEscapeString(text, token);
379  }
380  }
381  escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
382  lastTextNode = "";
383  continue;
384  }
385  }
386  }
387 
388  if (!inEsc) {
389  if (*from == tokenEnd[tokenEndPos]) {
390  if (tokenEndPos == (tokenEndLen - 1)) {
391  intoken = false;
392  userData->lastTextNode = lastTextNode;
393  if ((!handleToken(text, token, userData)) && (passThruUnknownToken)) {
394  text += tokenStart;
395  text += token;
396  text += tokenEnd;
397  }
398  escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
399  lastTextNode = "";
400  if (!userData->suspendTextPassThru) {
401  userData->lastSuspendSegment.size(0);
402  }
403  continue;
404  }
405  }
406  }
407 
408  if (intoken) {
409  if (tokpos < 4090) {
410  token[tokpos++] = *from;
411  token[tokpos+2] = 0;
412  }
413  }
414  else {
415  if ((!userData->supressAdjacentWhitespace) || (*from != ' ')) {
416  if (!userData->suspendTextPassThru) {
417  text.append(*from);
418  }
419  else userData->lastSuspendSegment.append(*from);
420  lastTextNode.append(*from);
421  }
422  userData->supressAdjacentWhitespace = false;
423  }
424 
425  if (processStages & POSTCHAR)
426  processStage(POSTCHAR, text, from, userData);
427 
428  }
429 
430  if (processStages & FINALIZE)
431  processStage(FINALIZE, text, from, userData);
432 
433  delete userData;
434  return 0;
435 }
SWBasicFilter::PRECHAR
static const char PRECHAR
Definition: swbasicfilter.h:97
SWBuf
Definition: swbuf.h:47
SWBasicFilter::POSTCHAR
static const char POSTCHAR
Definition: swbasicfilter.h:98
SWBasicFilter::tokenStart
char * tokenStart
Definition: swbasicfilter.h:64
SWBasicFilter::handleToken
virtual bool handleToken(SWBuf &buf, const char *token, BasicFilterUserData *userData)
Definition: swbasicfilter.cpp:281
SWBasicFilter::passThruUnknownEsc
bool passThruUnknownEsc
Definition: swbasicfilter.h:77
SWBasicFilter::handleEscapeString
virtual bool handleEscapeString(SWBuf &buf, const char *escString, BasicFilterUserData *userData)
Definition: swbasicfilter.cpp:286
SWBasicFilter::passThruUnknownToken
bool passThruUnknownToken
Definition: swbasicfilter.h:76
SWBasicFilter::FINALIZE
static const char FINALIZE
Definition: swbasicfilter.h:99
SWBuf::getRawData
char * getRawData()
Definition: swbuf.h:379
SWBuf::append
SWBuf & append(const char *str, long max=-1)
Definition: swbuf.h:274
SWBasicFilter::processStage
virtual bool processStage(char, SWBuf &, char *&, BasicFilterUserData *)
Definition: swbasicfilter.h:185
SWBasicFilter::createUserData
virtual BasicFilterUserData * createUserData(const SWModule *module, const SWKey *key)
Definition: swbasicfilter.h:91
SWBuf::size
unsigned long size() const
Definition: swbuf.h:185
SWBasicFilter::INITIALIZE
static const char INITIALIZE
Definition: swbasicfilter.h:96
SWBasicFilter::appendEscapeString
void appendEscapeString(SWBuf &buf, const char *escString)
Definition: swbasicfilter.cpp:216
void SWBasicFilter::removeAllowedEscapeString ( const char *  findString)
protectedinherited

Unregisters an esc control sequence that can pass unchanged

Definition at line 169 of file swbasicfilter.cpp.

169  {
170  if (p->escPassSet.find(findString) != p->escPassSet.end()) {
171  p->escPassSet.erase( p->escPassSet.find(findString) );
172  }
173 }
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
void SWBasicFilter::removeEscapeStringSubstitute ( const char *  findString)
protectedinherited

Unregisters an esc control sequence

Definition at line 189 of file swbasicfilter.cpp.

189  {
190  if (p->escSubMap.find(findString) != p->escSubMap.end()) {
191  p->escSubMap.erase( p->escSubMap.find(findString) );
192  }
193 }
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
void SWBasicFilter::removeTokenSubstitute ( const char *  findString)
protectedinherited

Unregisters a simple token substitute

Definition at line 149 of file swbasicfilter.cpp.

149  {
150  if (p->tokenSubMap.find(findString) != p->tokenSubMap.end()) {
151  p->tokenSubMap.erase( p->tokenSubMap.find(findString) );
152  }
153 }
SWBasicFilter::Private::tokenSubMap
DualStringMap tokenSubMap
Definition: swbasicfilter.cpp:46
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
void SWBasicFilter::setEscapeEnd ( const char *  escEnd)
protectedinherited

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

Definition at line 297 of file swbasicfilter.cpp.

297  {
298  stdstr(&(this->escEnd), escEnd);
299  escEndLen = strlen(escEnd);
300 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
void SWBasicFilter::setEscapeStart ( const char *  escStart)
protectedinherited

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

Definition at line 291 of file swbasicfilter.cpp.

291  {
292  stdstr(&(this->escStart), escStart);
293  escStartLen = strlen(escStart);
294 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
void SWBasicFilter::setEscapeStringCaseSensitive ( bool  val)
protectedinherited

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

Definition at line 131 of file swbasicfilter.cpp.

131  {
132  escStringCaseSensitive = val;
133 }
SWBasicFilter::escStringCaseSensitive
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
void SWBasicFilter::setPassThruNumericEscapeString ( bool  val)
protectedinherited

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.

121  {
122  passThruUnknownEsc = val;
123 }
SWBasicFilter::passThruUnknownEsc
bool passThruUnknownEsc
Definition: swbasicfilter.h:77
void SWBasicFilter::setPassThruUnknownEscapeString ( bool  val)
protectedinherited

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.

116  {
117  passThruUnknownEsc = val;
118 }
SWBasicFilter::passThruUnknownEsc
bool passThruUnknownEsc
Definition: swbasicfilter.h:77
void SWBasicFilter::setPassThruUnknownToken ( bool  val)
protectedinherited

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

Definition at line 111 of file swbasicfilter.cpp.

111  {
112  passThruUnknownToken = val;
113 }
SWBasicFilter::passThruUnknownToken
bool passThruUnknownToken
Definition: swbasicfilter.h:76
virtual void SWBasicFilter::setStageProcessing ( char  stages)
inlineprotectedvirtualinherited

Definition at line 186 of file swbasicfilter.h.

186 { processStages = stages; } // see STATICs up above
void SWBasicFilter::setTokenCaseSensitive ( bool  val)
protectedinherited

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

Definition at line 126 of file swbasicfilter.cpp.

126  {
127  tokenCaseSensitive = val;
128 }
SWBasicFilter::tokenCaseSensitive
bool tokenCaseSensitive
Definition: swbasicfilter.h:75
void SWBasicFilter::setTokenEnd ( const char *  tokenEnd)
protectedinherited

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

Definition at line 309 of file swbasicfilter.cpp.

309  {
310  stdstr(&(this->tokenEnd), tokenEnd);
311  tokenEndLen = strlen(tokenEnd);
312 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
void SWBasicFilter::setTokenStart ( const char *  tokenStart)
protectedinherited

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

Definition at line 303 of file swbasicfilter.cpp.

303  {
304  stdstr(&(this->tokenStart), tokenStart);
305  tokenStartLen = strlen(tokenStart);
306 }
SWBasicFilter::tokenStart
char * tokenStart
Definition: swbasicfilter.h:64
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
bool SWBasicFilter::substituteEscapeString ( SWBuf &  buf,
const char *  escString 
)
protectedinherited

This function performs the substitution of escapeStrings

Definition at line 253 of file swbasicfilter.cpp.

253  {
254  DualStringMap::iterator it;
255 
256  if (*escString == '#') {
257  return handleNumericEscapeString(buf, escString);
258  }
259 
260  if (passAllowedEscapeString(buf, escString)) {
261  return true;
262  }
263 
264  if (!escStringCaseSensitive) {
265  char *tmp = 0;
266  stdstr(&tmp, escString);
267  toupperstr(tmp);
268  it = p->escSubMap.find(tmp);
269  delete [] tmp;
270  } else
271  it = p->escSubMap.find(escString);
272 
273  if (it != p->escSubMap.end()) {
274  buf += it->second.c_str();
275  return true;
276  }
277  return false;
278 }
SWBasicFilter::handleNumericEscapeString
virtual bool handleNumericEscapeString(SWBuf &buf, const char *escString)
Definition: swbasicfilter.cpp:244
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
SWBuf::c_str
const char * c_str() const
Definition: swbuf.h:158
SWBasicFilter::escStringCaseSensitive
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
SWBasicFilter::passAllowedEscapeString
bool passAllowedEscapeString(SWBuf &buf, const char *escString)
Definition: swbasicfilter.cpp:223
toupperstr
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82
bool SWBasicFilter::substituteToken ( SWBuf &  buf,
const char *  token 
)
protectedinherited

This function performs the substitution of tokens

Definition at line 196 of file swbasicfilter.cpp.

196  {
197  DualStringMap::iterator it;
198 
199  if (!tokenCaseSensitive) {
200  char *tmp = 0;
201  stdstr(&tmp, token);
202  toupperstr(tmp);
203  it = p->tokenSubMap.find(tmp);
204  delete [] tmp;
205  } else
206  it = p->tokenSubMap.find(token);
207 
208  if (it != p->tokenSubMap.end()) {
209  buf += it->second.c_str();
210  return true;
211  }
212  return false;
213 }
stdstr
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
SWBuf::c_str
const char * c_str() const
Definition: swbuf.h:158
SWBasicFilter::tokenCaseSensitive
bool tokenCaseSensitive
Definition: swbasicfilter.h:75
SWBasicFilter::Private::tokenSubMap
DualStringMap tokenSubMap
Definition: swbasicfilter.cpp:46
toupperstr
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
SWBasicFilter::p
Private * p
Definition: swbasicfilter.h:82

Member Data Documentation

const char SWBasicFilter::FINALIZE = 8
staticprotectedinherited

Definition at line 99 of file swbasicfilter.h.

const char SWBasicFilter::INITIALIZE = 1
staticprotectedinherited

Definition at line 96 of file swbasicfilter.h.

const char SWBasicFilter::POSTCHAR = 4
staticprotectedinherited

Definition at line 98 of file swbasicfilter.h.

const char SWBasicFilter::PRECHAR = 2
staticprotectedinherited

Definition at line 97 of file swbasicfilter.h.

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