Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members  

swbasicfilter.cpp

00001 /******************************************************************************
00002  *  swbasicfilter.h     - definition of class SWBasicFilter.  An SWFilter
00003  *                              impl that provides some basic methods that
00004  *                              many filters will need and can use as a starting
00005  *                              point. 
00006  *
00007  * $Id: swbasicfilter_8cpp-source.html,v 1.3 2002/06/20 20:23:10 mgruner Exp $
00008  *
00009  * Copyright 2001 CrossWire Bible Society (http://www.crosswire.org)
00010  *      CrossWire Bible Society
00011  *      P. O. Box 2528
00012  *      Tempe, AZ  85280-2528
00013  *
00014  * This program is free software; you can redistribute it and/or modify it
00015  * under the terms of the GNU General Public License as published by the
00016  * Free Software Foundation version 2.
00017  *
00018  * This program is distributed in the hope that it will be useful, but
00019  * WITHOUT ANY WARRANTY; without even the implied warranty of
00020  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00021  * General Public License for more details.
00022  *
00023  */
00024 
00025 #include <stdlib.h>
00026 #include <string.h>
00027 #include <swbasicfilter.h>
00028 #include <stdio.h>
00029 #include <stdarg.h>
00030 
00031 SWBasicFilter::SWBasicFilter() {
00032         tokenStart = 0;
00033         tokenEnd = 0;
00034         escStart = 0;
00035         escEnd = 0;
00036 
00037         setTokenStart("<");
00038         setTokenEnd(">");
00039         setEscapeStart("&");
00040         setEscapeEnd(";");
00041 
00042         escStringCaseSensitive = false;
00043         tokenCaseSensitive = false;
00044         passThruUnknownToken = false;
00045         passThruUnknownEsc = false;
00046 }
00047 
00048 
00049 void SWBasicFilter::setPassThruUnknownToken(bool val) {
00050         passThruUnknownToken = val;
00051 }
00052 
00053 
00054 void SWBasicFilter::setPassThruUnknownEscapeString(bool val) {
00055         passThruUnknownEsc = val;
00056 }
00057 
00058 
00059 void SWBasicFilter::setTokenCaseSensitive(bool val) {
00060         tokenCaseSensitive = val;
00061 }
00062 
00063 
00064 void SWBasicFilter::setEscapeStringCaseSensitive(bool val) {
00065         escStringCaseSensitive = val;
00066 }
00067 
00068 
00069 SWBasicFilter::~SWBasicFilter() {
00070         if (tokenStart)
00071                 delete [] tokenStart;
00072 
00073         if (tokenEnd)
00074                 delete [] tokenEnd;
00075 
00076         if (escStart)
00077                 delete [] escStart;
00078 
00079         if (escEnd)
00080                 delete [] escEnd;
00081 }
00082 
00083 
00084 void SWBasicFilter::addTokenSubstitute(const char *findString, const char *replaceString) {
00085         char *buf = 0;
00086 
00087         if (!tokenCaseSensitive) {
00088                 stdstr(&buf, findString);
00089                 toupperstr(buf);
00090                 tokenSubMap.insert(DualStringMap::value_type(buf, replaceString));
00091                 delete [] buf;
00092         }
00093         else tokenSubMap.insert(DualStringMap::value_type(findString, replaceString));
00094 }
00095 
00096 
00097 void SWBasicFilter::addEscapeStringSubstitute(const char *findString, const char *replaceString) {
00098         char *buf = 0;
00099 
00100         if (!escStringCaseSensitive) {
00101                 stdstr(&buf, findString);
00102                 toupperstr(buf);
00103                 escSubMap.insert(DualStringMap::value_type(buf, replaceString));
00104                 delete [] buf;
00105         }
00106         else escSubMap.insert(DualStringMap::value_type(findString, replaceString));
00107 }
00108 
00109 
00110 void SWBasicFilter::pushString(char **buf, const char *format, ...) {
00111   va_list argptr;
00112 
00113   va_start(argptr, format);
00114   *buf += vsprintf(*buf, format, argptr);
00115   va_end(argptr);
00116 
00117 //  *buf += strlen(*buf);
00118 }
00119 
00120 
00121 bool SWBasicFilter::substituteToken(char **buf, const char *token) {
00122         DualStringMap::iterator it;
00123 
00124         if (!tokenCaseSensitive) {
00125                 char *tmp = 0;
00126                 stdstr(&tmp, token);
00127                 toupperstr(tmp);
00128                 it = tokenSubMap.find(tmp);
00129                 delete [] tmp;
00130         } else
00131         it = tokenSubMap.find(token);
00132 
00133         if (it != tokenSubMap.end()) {
00134                 pushString(buf, it->second.c_str());
00135                 return true;
00136         }
00137         return false;
00138 }
00139 
00140 
00141 bool SWBasicFilter::substituteEscapeString(char **buf, const char *escString) {
00142         DualStringMap::iterator it;
00143 
00144         if (!escStringCaseSensitive) {
00145                 char *tmp = 0;
00146                 stdstr(&tmp, escString);
00147                 toupperstr(tmp);
00148                 it = escSubMap.find(tmp);
00149                 delete [] tmp;
00150         } else 
00151         it = escSubMap.find(escString);
00152 
00153         if (it != escSubMap.end()) {
00154                 pushString(buf, it->second.c_str());
00155                 return true;
00156         }
00157         return false;
00158 }
00159 
00160 
00161 bool SWBasicFilter::handleToken(char **buf, const char *token, DualStringMap &userData) {
00162         return substituteToken(buf, token);
00163 }
00164 
00165 
00166 bool SWBasicFilter::handleEscapeString(char **buf, const char *escString, DualStringMap &userData) {
00167         return substituteEscapeString(buf, escString);
00168 }
00169 
00170 
00171 void SWBasicFilter::setEscapeStart(const char *escStart) {
00172         stdstr(&(this->escStart), escStart);
00173 }
00174 
00175 
00176 void SWBasicFilter::setEscapeEnd(const char *escEnd) {
00177         stdstr(&(this->escEnd), escEnd);
00178 }
00179 
00180 
00181 void SWBasicFilter::setTokenStart(const char *tokenStart) {
00182         stdstr(&(this->tokenStart), tokenStart);
00183 }
00184 
00185 
00186 void SWBasicFilter::setTokenEnd(const char *tokenEnd) {
00187         stdstr(&(this->tokenEnd), tokenEnd);
00188 }
00189 
00190 
00191 char SWBasicFilter::ProcessText(char *text, int maxlen, const SWKey *key, const SWModule *module) {
00192         this->key = key;
00193         this->module = module;
00194         char *to, *from, token[4096];
00195         int tokpos = 0;
00196         bool intoken    = false;
00197         int len;
00198         bool inEsc = false;
00199         char escStartLen = strlen(escStart);
00200         char escEndLen   = strlen(escEnd);
00201         char escStartPos = 0, escEndPos = 0;
00202         char tokenStartLen = strlen(tokenStart);
00203         char tokenEndLen   = strlen(tokenEnd);
00204         char tokenStartPos = 0, tokenEndPos = 0;
00205         DualStringMap userData;
00206         string lastTextNode;
00207 
00208         bool suspendTextPassThru = false;
00209         userData["suspendTextPassThru"] = "false";
00210 
00211         len = strlen(text) + 1;         // shift string to right of buffer
00212         if (len < maxlen) {
00213                 memmove(&text[maxlen - len], text, len);
00214                 from = &text[maxlen - len];
00215         }
00216         else    from = text;                    // -------------------------------
00217 
00218         resultBuffer = text;
00219 
00220         for (to = text; *from; from++) {
00221                 if (*from == tokenStart[tokenStartPos]) {
00222                         if (tokenStartPos == (tokenStartLen - 1)) {
00223                                 intoken = true;
00224                                 tokpos = 0;
00225                                 token[0] = 0;
00226                                 token[1] = 0;
00227                                 token[2] = 0;
00228                                 inEsc = false;
00229                         }
00230                         else tokenStartPos++;
00231                         continue;
00232                 }
00233 
00234                 if (*from == escStart[escStartPos]) {
00235                         if (escStartPos == (escStartLen - 1)) {
00236                                 intoken = true;
00237                                 tokpos = 0;
00238                                 token[0] = 0;
00239                                 token[1] = 0;
00240                                 token[2] = 0;
00241                                 inEsc = true;
00242                         }
00243                         else escStartPos++;
00244                         continue;
00245                 }
00246 
00247                 if (inEsc) {
00248                         if (*from == escEnd[escEndPos]) {
00249                                 if (escEndPos == (escEndLen - 1)) {
00250                                         intoken = false;
00251                                         userData["lastTextNode"] = lastTextNode;
00252                                         if ((!handleEscapeString(&to, token, userData)) && (passThruUnknownEsc)) {
00253                                                 pushString(&to, escStart);
00254                                                 pushString(&to, token);
00255                                                 pushString(&to, escEnd);
00256                                         }
00257                                         escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
00258                                         lastTextNode = "";
00259                                         suspendTextPassThru = (!userData["suspendTextPassThru"].compare("true"));
00260                                         continue;
00261                                 }
00262                         }
00263                 }
00264 
00265                 if (!inEsc) {
00266                         if (*from == tokenEnd[tokenEndPos]) {
00267                                 if (tokenEndPos == (tokenEndLen - 1)) {
00268                                         intoken = false;
00269                                         userData["lastTextNode"] = lastTextNode;
00270                                         if ((!handleToken(&to, token, userData)) && (passThruUnknownToken)) {
00271                                                 pushString(&to, tokenStart);
00272                                                 pushString(&to, token);
00273                                                 pushString(&to, tokenEnd);
00274                                         }
00275                                         escEndPos = escStartPos = tokenEndPos = tokenStartPos = 0;
00276                                         lastTextNode = "";
00277                                         suspendTextPassThru = (!userData["suspendTextPassThru"].compare("true"));
00278                                         continue;
00279                                 }
00280                         }
00281                 }
00282 
00283                 if (intoken) {
00284                         if (tokpos < 4090)
00285                                 token[tokpos++] = *from;
00286                                 token[tokpos+2] = 0;
00287                 }
00288                 else {
00289                         if (!suspendTextPassThru)
00290                                 *to++ = *from;
00291                         lastTextNode += *from;
00292                 }
00293         }
00294         *to++ = 0;
00295         *to = 0;
00296         return 0;
00297 }
00298 
00299 
00300 

Generated on Thu Jun 20 22:13:00 2002 for The Sword Project by doxygen1.2.15