The SWORD Project  1.9.0.svnversion
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
OSISCGI Class Reference

#include <osiscgi.h>

+ Inheritance diagram for OSISCGI:
+ Collaboration diagram for OSISCGI:

Classes

class  MyUserData
 

Public Member Functions

virtual const char * getHeader () const
 
 OSISCGI ()
 
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 BasicFilterUserDatacreateUserData (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 OSIS text to Diatheke/CGI format

Definition at line 34 of file osiscgi.h.

Constructor & Destructor Documentation

OSISCGI::OSISCGI ( )

Definition at line 38 of file osiscgi.cpp.

38  {
39  setTokenStart("<");
40  setTokenEnd(">");
41 
42  setEscapeStart("&");
43  setEscapeEnd(";");
44 
46 
47  addEscapeStringSubstitute("amp", "&");
48  addEscapeStringSubstitute("apos", "'");
49  addEscapeStringSubstitute("lt", "<");
50  addEscapeStringSubstitute("gt", ">");
51  addEscapeStringSubstitute("quot", "\"");
52  addTokenSubstitute("lg", "<br />");
53  addTokenSubstitute("/lg", "<br />");
54 
56 }
void setTokenEnd(const char *tokenEnd)
void setTokenCaseSensitive(bool val)
void setEscapeStart(const char *escStart)
void addEscapeStringSubstitute(const char *findString, const char *replaceString)
void setTokenStart(const char *tokenStart)
void setEscapeStringCaseSensitive(bool val)
void addTokenSubstitute(const char *findString, const char *replaceString)
void setEscapeEnd(const char *escEnd)

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 }
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
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 }
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
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 }
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
bool tokenCaseSensitive
Definition: swbasicfilter.h:75
DualStringMap tokenSubMap
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
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 }
virtual BasicFilterUserData* OSISCGI::createUserData ( const SWModule module,
const SWKey key 
)
inlineprotectedvirtual

Reimplemented from SWBasicFilter.

Definition at line 45 of file osiscgi.h.

45  {
46  return new MyUserData(module, key);
47  }
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 }
bool substituteEscapeString(SWBuf &buf, const char *escString)
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 }
bool passThruNumericEsc
Definition: swbasicfilter.h:78
void appendEscapeString(SWBuf &buf, const char *escString)
bool OSISCGI::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 59 of file osiscgi.cpp.

59  {
60  // manually process if it wasn't a simple substitution
61  if (!substituteToken(buf, token)) {
62  MyUserData *u = (MyUserData *)userData;
63  XMLTag tag(token);
64 
65  // <w> tag
66  if (!strcmp(tag.getName(), "w")) {
67 
68  // start <w> tag
69  if ((!tag.isEmpty()) && (!tag.isEndTag())) {
70  u->w = token;
71  }
72 
73  // end or empty <w> tag
74  else {
75  bool endTag = tag.isEndTag();
76  SWBuf lastText;
77  bool show = true; // to handle unplaced article in kjv2003-- temporary till combined
78 
79  if (endTag) {
80  tag = u->w.c_str();
81  lastText = u->lastTextNode.c_str();
82  }
83  else lastText = "stuff";
84 
85  const char *attrib;
86  const char *val;
87  if ((attrib = tag.getAttribute("xlit"))) {
88  val = strchr(attrib, ':');
89  val = (val) ? (val + 1) : attrib;
90  buf.appendFormatted(" %s", val);
91  }
92  if ((attrib = tag.getAttribute("gloss"))) {
93  val = strchr(attrib, ':');
94  val = (val) ? (val + 1) : attrib;
95  buf.appendFormatted(" %s", val);
96  }
97  if ((attrib = tag.getAttribute("lemma"))) {
98  int count = tag.getAttributePartCount("lemma");
99  int i = (count > 1) ? 0 : -1; // -1 for whole value cuz it's faster, but does the same thing as 0
100  do {
101  attrib = tag.getAttribute("lemma", i);
102  if (i < 0) i = 0; // to handle our -1 condition
103  val = strchr(attrib, ':');
104  val = (val) ? (val + 1) : attrib;
105  const char *val2 = val;
106  if ((strchr("GH", *val)) && (isdigit(val[1])))
107  val2++;
108  if ((!strcmp(val2, "3588")) && (lastText.length() < 1))
109  show = false;
110  else {
111  if (!strchr("G", *val)) {
112  buf.appendFormatted(" <small><em>&lt;<a href=\"!DIATHEKE_URL!StrongsGreek=on&verse=%s\">%s</a>&gt;</em></small> ", val2, val);
113  }
114  else {
115  buf.appendFormatted(" <small><em>&lt;<a href=\"!DIATHEKE_URL!StrongsHebrew=on&verse=%s\">%s</a>&gt;</em></small> ", val2, val);
116  }
117  }
118  } while (++i < count);
119  }
120  if ((attrib = tag.getAttribute("morph")) && (show)) {
121  SWBuf savelemma = tag.getAttribute("savlm");
122  if ((strstr(savelemma.c_str(), "3588")) && (lastText.length() < 1))
123  show = false;
124  if (show) {
125  int count = tag.getAttributePartCount("morph");
126  int i = (count > 1) ? 0 : -1; // -1 for whole value cuz it's faster, but does the same thing as 0
127  do {
128  attrib = tag.getAttribute("morph", i);
129  if (i < 0) i = 0; // to handle our -1 condition
130  val = strchr(attrib, ':');
131  val = (val) ? (val + 1) : attrib;
132  const char *val2 = val;
133  if ((*val == 'T') && (strchr("GH", val[1])) && (isdigit(val[2])))
134  val2+=2;
135  if (!strchr("G", *val)) {
136  buf.appendFormatted(" <small><em>(;<a href=\"!DIATHEKE_URL!StrongsGreek=on&verse=%s\">%s</a>)</em></small> ", val+1, tag.getAttribute("morph"));
137  }
138  else if (!strchr("H", *val)) {
139  buf.appendFormatted(" <small><em>(<a href=\"!DIATHEKE_URL!StrongsHebrew=on&verse=%s\">%s</a>)</em></small> ", val+1, tag.getAttribute("morph"));
140  }
141  else {
142  buf.appendFormatted(" <small><em>(<a href=\"!DIATHEKE_URL!Packard=on&verse=%s\">%s</a>)</em></small> ", val, tag.getAttribute("morph"));
143  }
144  } while (++i < count);
145  }
146  }
147  if ((attrib = tag.getAttribute("POS"))) {
148  val = strchr(attrib, ':');
149  val = (val) ? (val + 1) : attrib;
150  buf.appendFormatted(" %s", val);
151  }
152 
153  /*if (endTag)
154  buf += "}";*/
155  }
156  }
157 
158  // <note> tag
159  else if (!strcmp(tag.getName(), "note")) {
160  if (!tag.isEndTag()) {
161  if (!tag.isEmpty()) {
162  SWBuf type = tag.getAttribute("type");
163 
164  if (type != "x-strongsMarkup" && // leave strong's markup notes out, in the future we'll probably have different option filters to turn different note types on or off
165  type != "strongsMarkup") { // deprecated
166  SWBuf footnoteNumber = tag.getAttribute("swordFootnote");
167  const VerseKey *vkey = NULL;
168  // see if we have a VerseKey * or descendant
169  SWTRY {
170  vkey = SWDYNAMIC_CAST(const VerseKey, u->key);
171  }
172  SWCATCH ( ... ) { }
173  if (vkey) {
174  char ch = ((tag.getAttribute("type") && (!strcmp(tag.getAttribute("type"), "crossReference"))) ? 'x':'n');
175  buf.appendFormatted("<a href=\"noteID=%s.%c.%s\"><small><sup>*%c</sup></small></a> ", vkey->getText(), ch, footnoteNumber.c_str(), ch);
176  }
177  }
178  u->suspendTextPassThru = true;
179  }
180  }
181  if (tag.isEndTag()) {
182  u->suspendTextPassThru = false;
183  }
184  }
185 
186  // <p> paragraph tag
187  else if (!strcmp(tag.getName(), "p")) {
188  if ((!tag.isEndTag()) && (!tag.isEmpty())) { // non-empty start tag
189  buf += "<p><br />";
190  }
191  else if (tag.isEndTag()) { // end tag
192  buf += "</p><br />";
193  userData->supressAdjacentWhitespace = true;
194  }
195  else { // empty paragraph break marker
196  buf += "<p><br />";
197  userData->supressAdjacentWhitespace = true;
198  }
199  }
200 
201  // <reference> tag
202  else if (!strcmp(tag.getName(), "reference")) {
203  const char *attrib;
204  const char *val;
205 
206  if ((!tag.isEndTag()) && (!tag.isEmpty())) {
207  buf += "<a href=\"!DIATHEKE_URL!verse=";
208  if ((attrib = tag.getAttribute("osisRef"))) {
209  val = strchr(attrib, ':');
210  val = (val) ? (val + 1) : attrib;
211  buf.appendFormatted("%s", val);
212  }
213  buf += "\">";
214  }
215  else if (tag.isEndTag()) {
216  buf += "</a>";
217  }
218  }
219 
220  // <l> poetry, etc
221  else if (!strcmp(tag.getName(), "l")) {
222  if (tag.isEmpty()) {
223  buf += "<br />";
224  }
225  else if (tag.isEndTag()) {
226  buf += "<br />";
227  }
228  else if (tag.getAttribute("sID")) { // empty line marker
229  buf += "<br />";
230  }
231  }
232 
233  // <milestone type="line"/> or <lb.../>
234  else if ((!strcmp(tag.getName(), "lb")) || ((!strcmp(tag.getName(), "milestone")) && (tag.getAttribute("type")) && (!strcmp(tag.getAttribute("type"), "line")))) {
235  buf += "<br />";
236  userData->supressAdjacentWhitespace = true;
237  }
238 
239  // <title>
240  else if (!strcmp(tag.getName(), "title")) {
241  if ((!tag.isEndTag()) && (!tag.isEmpty())) {
242  buf += "<b>";
243  }
244  else if (tag.isEndTag()) {
245  buf += "</b><br />";
246  }
247  }
248 
249  // <hi> hi? hi contrast?
250  else if (!strcmp(tag.getName(), "hi")) {
251  SWBuf type = tag.getAttribute("type");
252  if ((!tag.isEndTag()) && (!tag.isEmpty())) {
253  if (type == "bold" || type == "x-b") {
254  buf += "<b> ";
255  u->inBold = true;
256  }
257  else { // all other types
258  buf += "<i> ";
259  u->inBold = false;
260  }
261  }
262  else if (tag.isEndTag()) {
263  if(u->inBold) {
264  buf += "</b>";
265  u->inBold = false;
266  }
267  else
268  buf += "</i>";
269  }
270  else { // empty hi marker
271  // what to do? is this even valid?
272  }
273  }
274 
275  // <q> quote
276  else if (!strcmp(tag.getName(), "q")) {
277  SWBuf type = tag.getAttribute("type");
278  SWBuf who = tag.getAttribute("who");
279  const char *lev = tag.getAttribute("level");
280  int level = (lev) ? atoi(lev) : 1;
281 
282  if ((!tag.isEndTag()) && (!tag.isEmpty())) {
283  /*buf += "{";*/
284 
285  //alternate " and '
286  if (u->osisQToTick)
287  buf += (level % 2) ? '\"' : '\'';
288 
289  if (who == "Jesus") {
290  buf += "<font color=\"red\"> ";
291  }
292  }
293  else if (tag.isEndTag()) {
294  //alternate " and '
295  if (u->osisQToTick)
296  buf += (level % 2) ? '\"' : '\'';
297  //buf += "</font>";
298  }
299  else { // empty quote marker
300  //alternate " and '
301  if (u->osisQToTick)
302  buf += (level % 2) ? '\"' : '\'';
303  }
304  }
305 
306  // <transChange>
307  else if (!strcmp(tag.getName(), "transChange")) {
308  SWBuf type = tag.getAttribute("type");
309 
310  if ((!tag.isEndTag()) && (!tag.isEmpty())) {
311 
312 // just do all transChange tags this way for now
313 // if (type == "supplied")
314  buf += "<i>";
315  }
316  else if (tag.isEndTag()) {
317  buf += "</i>";
318  }
319  else { // empty transChange marker?
320  }
321  }
322 
323  else {
324  return false; // we still didn't handle token
325  }
326  }
327  return true;
328 }
SWBuf & appendFormatted(const char *format,...)
Definition: swbuf.cpp:81
Definition: swbuf.h:47
unsigned long length() const
Definition: swbuf.h:197
Definition: utilxml.h:38
#define SWTRY
Definition: defs.h:57
bool substituteToken(SWBuf &buf, const char *token)
virtual const char * getText() const
Definition: versekey.cpp:1242
#define SWCATCH(x)
Definition: defs.h:58
return NULL
Definition: regex.c:7953
const char * c_str() const
Definition: swbuf.h:158
#define SWDYNAMIC_CAST(className, object)
Definition: defs.h:47
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 }
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
Private * p
Definition: swbasicfilter.h:82
void appendEscapeString(SWBuf &buf, const char *escString)
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 }
static const char PRECHAR
Definition: swbasicfilter.h:97
Definition: swbuf.h:47
static const char POSTCHAR
Definition: swbasicfilter.h:98
char * tokenStart
Definition: swbasicfilter.h:64
virtual bool handleToken(SWBuf &buf, const char *token, BasicFilterUserData *userData)
bool passThruUnknownEsc
Definition: swbasicfilter.h:77
virtual bool handleEscapeString(SWBuf &buf, const char *escString, BasicFilterUserData *userData)
bool passThruUnknownToken
Definition: swbasicfilter.h:76
static const char FINALIZE
Definition: swbasicfilter.h:99
char * getRawData()
Definition: swbuf.h:379
SWBuf & append(const char *str, long max=-1)
Definition: swbuf.h:274
virtual bool processStage(char, SWBuf &, char *&, BasicFilterUserData *)
virtual BasicFilterUserData * createUserData(const SWModule *module, const SWKey *key)
Definition: swbasicfilter.h:91
unsigned long size() const
Definition: swbuf.h:185
static const char INITIALIZE
Definition: swbasicfilter.h:96
void appendEscapeString(SWBuf &buf, const char *escString)
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 }
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 }
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 }
DualStringMap tokenSubMap
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 }
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 }
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  {
133 }
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 }
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 }
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 }
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 }
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 }
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 }
char * tokenStart
Definition: swbasicfilter.h:64
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 }
virtual bool handleNumericEscapeString(SWBuf &buf, const char *escString)
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
const char * c_str() const
Definition: swbuf.h:158
bool escStringCaseSensitive
Definition: swbasicfilter.h:74
bool passAllowedEscapeString(SWBuf &buf, const char *escString)
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
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 }
SWORD_NAMESPACE_START char * stdstr(char **ipstr, const char *istr, unsigned int memPadFactor=1)
Definition: utilstr.h:44
const char * c_str() const
Definition: swbuf.h:158
bool tokenCaseSensitive
Definition: swbasicfilter.h:75
DualStringMap tokenSubMap
char * toupperstr(char *t, unsigned int max=0)
Definition: stringmgr.h:107
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: