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

gbfrtf.cpp

00001 /******************************************************************************
00002  *
00003  * gbfrtf -     SWFilter decendant to convert all GBF tags to RTF tags
00004  */
00005 
00006 
00007 #include <stdlib.h>
00008 #include <string.h>
00009 #include <gbfrtf.h>
00010 #include <ctype.h>
00011 
00012 GBFRTF::GBFRTF() {
00013 }
00014 
00015 
00016 char GBFRTF::ProcessText(char *text, int maxlen, const SWKey *key, const SWModule *module)
00017 {
00018         unsigned char *to, *from;
00019         char token[2048];
00020         int tokpos = 0;
00021         bool intoken = false;
00022         int len;
00023         const char *tok;
00024 
00025         len = strlen(text) + 1;                                         // shift string to right of buffer
00026         if (len < maxlen) {
00027                 memmove(&text[maxlen - len], text, len);
00028                 from = (unsigned char *)&text[maxlen - len];
00029         }
00030         else    from = (unsigned char *)text;                                                   // -------------------------------
00031         for (to = (unsigned char *)text; *from; from++) {
00032                 if (*from == '<') {
00033                         intoken = true;
00034                         tokpos = 0;
00035                         token[0] = 0;
00036                         token[1] = 0;
00037                         token[2] = 0;
00038                         continue;
00039                 }
00040                 if (*from == '>') {
00041                         intoken = false;
00042                                                 // process desired tokens
00043                         switch (*token) {
00044                         case 'W':       // Strongs
00045                                 switch(token[1]) {
00046                                 case 'G':               // Greek
00047                                 case 'H':               // Hebrew
00048                                         *to++ = '{';
00049                                         *to++ = '\\';
00050                                         *to++ = 'f';
00051                                         *to++ = 's';
00052                                         *to++ = '1';
00053                                         *to++ = '7';
00054                                         *to++ = ' ';
00055                                         *to++ = '<';
00056                                         for (tok = token + 2; *tok; tok++)
00057                                                 *to++ = *tok;
00058                                         *to++ = '>';
00059                                         *to++ = '}';
00060                                         continue;
00061 
00062                                 case 'T':               // Tense
00063                                         *to++ = '{';
00064                                         *to++ = '\\';
00065                                         *to++ = 'f';
00066                                         *to++ = 's';
00067                                         *to++ = '1';
00068                                         *to++ = '7';
00069                                         *to++ = ' ';
00070                                         *to++ = '(';
00071                                         bool separate = false;
00072                                         for (tok = token + 2; *tok; tok++) {
00073                                                 if (separate) {
00074                                                         *to++ = ';';
00075                                                         *to++ = ' ';
00076                                                         separate = false;
00077                                                 }
00078                                                 switch (*tok) {
00079                                                 case 'G':
00080                                                 case 'H':
00081                                                         for (tok++; *tok; tok++) {
00082                                                                 if (isdigit(*tok)) {
00083                                                                         *to++ = *tok;
00084                                                                         separate = true;
00085                                                                 }
00086                                                                 else {
00087                                                                         tok--;
00088                                                                         break;
00089                                                                 }
00090                                                         }
00091                                                         break;
00092                                                 default:
00093                                                         for (; *tok; tok++) {
00094                                                                *to++ = *tok;
00095                                                         }
00096                                                 }
00097                                         }
00098                                         *to++ = ')';
00099                                         *to++ = '}';
00100                                         continue;
00101                                 }
00102                                 break;
00103                         case 'R':
00104                                 switch(token[1]) {
00105                                 case 'X':
00106                                   *to++ = '#';
00107                                   continue;
00108                                 case 'x':
00109                                   *to++ = '|';
00110                                   continue;
00111                                 case 'F':               // footnote begin
00112                                         *to++ = '{';
00113                                         *to++ = '\\';
00114                                         *to++ = 'i';
00115                                         *to++ = '1';
00116                                         *to++ = ' ';
00117                                         *to++ = '\\';
00118                                         *to++ = 'f';
00119                                         *to++ = 's';
00120                                         *to++ = '1';
00121                                         *to++ = '7';
00122                                         *to++ = ' ';
00123                                         *to++ = '(';
00124                                         continue;
00125                                 case 'f':               // footnote end
00126                                         *to++ = ')';
00127                                         *to++ = ' ';
00128                                         *to++ = '}';
00129                                         continue;
00130                                 }
00131                                 break;
00132                         case 'F':                       // font tags
00133                                 switch(token[1]) {
00134                                 case 'I':               // italic start
00135                                         *to++ = '\\';
00136                                         *to++ = 'i';
00137                                         *to++ = '1';
00138                                         *to++ = ' ';
00139                                         continue;
00140                                 case 'i':               // italic end
00141                                         *to++ = '\\';
00142                                         *to++ = 'i';
00143                                         *to++ = '0';
00144                                         *to++ = ' ';
00145                                         continue;
00146                                 case 'B':               // bold start
00147                                         *to++ = '\\';
00148                                         *to++ = 'b';
00149                                         *to++ = '1';
00150                                         *to++ = ' ';
00151                                         continue;
00152                                 case 'b':               // bold end
00153                                         *to++ = '\\';
00154                                         *to++ = 'b';
00155                                         *to++ = '0';
00156                                         *to++ = ' ';
00157                                         continue;
00158                                 case 'N':
00159                                         *to++ = '{';
00160                                         if (!strnicmp(token+2, "Symbol", 6)) {
00161                                           *to++ = '\\';
00162                                           *to++ = 'f';
00163                                           *to++ = '7';
00164                                           *to++ = ' ';
00165                                         }
00166                                         continue;
00167                                 case 'n':
00168                                         *to++ = '}';
00169                                         continue;
00170                                 case 'S':
00171                                         *to++ = '{';
00172                                         *to++ = '\\';
00173                                         *to++ = 's';
00174                                         *to++ = 'u';
00175                                         *to++ = 'p';
00176                                         *to++ = 'e';
00177                                         *to++ = 'r';
00178                                         *to++ = ' ';
00179                                         continue;
00180                                 case 's':
00181                                         *to++ = '}';
00182                                         continue;
00183                                 case 'R':
00184                                         *to++ = '{';
00185                                         *to++ = '\\';
00186                                         *to++ = 'c';
00187                                         *to++ = 'f';
00188                                         *to++ = '6';
00189                                         *to++ = ' ';
00190                                         continue;
00191                                 case 'r':
00192                                         *to++ = '}';
00193                                         continue;
00194                                 }
00195                                 break;
00196                         case 'C':                       // special character tags
00197                                 switch(token[1]) {
00198                                 case 'A':               // ASCII value
00199                                         *to++ = (char)atoi(&token[2]);
00200                                         continue;
00201                                 case 'G':
00202                                         *to++ = '>';
00203                                         continue;
00204                                 case 'L':               // line break
00205                                         *to++ = '\\';
00206                                         *to++ = 'l';
00207                                         *to++ = 'i';
00208                                         *to++ = 'n';
00209                                         *to++ = 'e';
00210                                         *to++ = ' ';
00211                                         continue;
00212                                 case 'M':               // new paragraph
00213                                         *to++ = '\\';
00214                                         *to++ = 'p';
00215                                         *to++ = 'a';
00216                                         *to++ = 'r';
00217                                         *to++ = ' ';
00218                                         continue;
00219                                 case 'T':
00220                                         *to++ = '<';
00221                                 }
00222                                 break;
00223                         case 'T':                       // title formatting
00224                           switch(token[1])
00225                             {
00226                             case 'T':               // Book title begin
00227                               *to++ = '{';
00228                               *to++ = '\\';
00229                               *to++ = 'f';
00230                               *to++ = 's';
00231                               *to++ = '2';
00232                               *to++ = '2';
00233                               *to++ = ' ';
00234                               continue;
00235                             case 't':
00236                               *to++ = '}';
00237                               continue;
00238                             case 'S':
00239                               *to++ = '\\';
00240                               *to++ = 'p';
00241                               *to++ = 'a';
00242                               *to++ = 'r';
00243                               *to++ = ' ';
00244                               *to++ = '{';
00245                               *to++ = '\\';
00246                               *to++ = 'i';
00247                               *to++ = '1';
00248                               *to++ = '\\';
00249                               *to++ = 'b';
00250                               *to++ = '1';
00251                               *to++ = ' ';
00252                               continue;
00253                             case 's':
00254                               *to++ = '}';
00255                               *to++ = '\\';
00256                               *to++ = 'p';
00257                               *to++ = 'a';
00258                               *to++ = 'r';
00259                               *to++ = ' ';
00260                               continue;
00261                             }
00262                           break;
00263 
00264                         }
00265                         continue;
00266                 }
00267                 if (intoken) {
00268                         if (tokpos < 2045)
00269                                 token[tokpos++] = *from;
00270                                 token[tokpos+2] = 0;
00271                 }
00272                 else    *to++ = *from;
00273         }
00274         *to++ = 0;
00275         *to = 0;
00276         return 0;
00277 }

Generated on Wed Apr 3 22:34:13 2002 for The Sword Project by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002