int FileMgr::removeDir(const char *targetDir) {
DIR *dir = opendir(targetDir);
struct dirent *ent;
if (dir) {
rewinddir(dir);
while ((ent = readdir(dir))) {
if ((strcmp(ent->d_name, ".")) && (strcmp(ent->d_name, ".."))) {
SWBuf targetPath = (SWBuf)targetDir + (SWBuf)"/" + ent->d_name;
if (!isDirectory(targetPath.c_str())) {
FileMgr::removeFile(targetPath.c_str());
}
else {
FileMgr::removeDir(targetPath.c_str());
}
}
}
closedir(dir);
FileMgr::removeFile(targetDir);
/*
int status = FileMgr::removeFile(targetDir);
int stuff = errno;
char *err = strerror(errno);
int x = stuff;
*/
}
return 0;
}
void SWMgr::loadConfigDir(const char *ipath)
{
DIR *dir;
struct dirent *ent;
SWBuf newmodfile;
if ((dir = opendir(ipath))) {
rewinddir(dir);
while ((ent = readdir(dir))) {
//check whether it ends with .conf, if it doesn't skip it!
if (!ent->d_name || (strlen(ent->d_name) <= 5) || strncmp(".conf", (ent->d_name + strlen(ent->d_name) - 5), 5 )) {
continue;
}
newmodfile = ipath;
if ((ipath[strlen(ipath)-1] != '\\') && (ipath[strlen(ipath)-1] != '/'))
newmodfile += "/";
newmodfile += ent->d_name;
if (config) {
SWConfig tmpConfig(newmodfile.c_str());
*config += tmpConfig;
}
else config = myconfig = new SWConfig(newmodfile.c_str());
}
closedir(dir);
if (!config) { // if no .conf file exist yet, create a default
newmodfile = ipath;
if ((ipath[strlen(ipath)-1] != '\\') && (ipath[strlen(ipath)-1] != '/'))
newmodfile += "/";
newmodfile += "globals.conf";
config = myconfig = new SWConfig(newmodfile.c_str());
}
}
}
void SWMgr::AddStripFilters(SWModule *module, ConfigEntMap §ion)
{
SWBuf sourceformat;
ConfigEntMap::iterator entry;
sourceformat = ((entry = section.find("SourceType")) != section.end()) ? (*entry).second : (SWBuf)"";
// Temporary: To support old module types
if (!sourceformat.length()) {
sourceformat = ((entry = section.find("ModDrv")) != section.end()) ? (*entry).second : (SWBuf)"";
if (!stricmp(sourceformat.c_str(), "RawGBF"))
sourceformat = "GBF";
else sourceformat = "";
}
if (!stricmp(sourceformat.c_str(), "GBF")) {
module->addStripFilter(gbfplain);
}
else if (!stricmp(sourceformat.c_str(), "ThML")) {
module->addStripFilter(thmlplain);
}
else if (!stricmp(sourceformat.c_str(), "OSIS")) {
module->addStripFilter(osisplain);
}
else if (!stricmp(sourceformat.c_str(), "TEI")) {
module->addStripFilter(teiplain);
}
if (filterMgr)
filterMgr->AddStripFilters(module, section);
}
int InstallMgr::refreshRemoteSource(InstallSource *is) {
// assert user disclaimer has been confirmed
if (!isUserDisclaimerConfirmed()) return -1;
SWBuf root = (SWBuf)privatePath + (SWBuf)"/" + is->uid.c_str();
removeTrailingSlash(root);
SWBuf target = root + "/mods.d";
int errorCode = -1; //0 means successful
FileMgr::removeDir(target.c_str());
if (!FileMgr::existsDir(target))
FileMgr::createPathAndFile(target+"/globals.conf");
#ifndef EXCLUDEZLIB
SWBuf archive = root + "/mods.d.tar.gz";
errorCode = ftpCopy(is, "mods.d.tar.gz", archive.c_str(), false);
if (!errorCode) { //sucessfully downloaded the tar,gz of module configs
FileDesc *fd = FileMgr::getSystemFileMgr()->open(archive.c_str(), FileMgr::RDONLY);
untargz(fd->getFd(), root.c_str());
FileMgr::getSystemFileMgr()->close(fd);
}
else
#endif
errorCode = ftpCopy(is, "mods.d", target.c_str(), true, ".conf"); //copy the whole directory
is->flush();
return errorCode;
}
void normalizeInput(SWKey &key, SWBuf &text) {
#ifdef _ICU_
int utf8State = detectUTF8(text.c_str());
if (normalize) {
// Don't need to normalize text that is ASCII
// But assume other non-UTF-8 text is Latin1 (cp1252) and convert it to UTF-8
if (!utf8State) {
cout << "Warning: " << key << ": Converting to UTF-8 (" << text << ")" << endl;
converter.processText(text, (SWKey *)2); // note the hack of 2 to mimic a real key. TODO: remove all hacks
converted++;
// Prepare for double check. This probably can be removed.
// But for now we are running the check again.
// This is to determine whether we need to normalize output of the conversion.
utf8State = detectUTF8(text.c_str());
}
// Double check. This probably can be removed.
if (!utf8State) {
cout << "Error: " << key << ": Converting to UTF-8 (" << text << ")" << endl;
}
if (utf8State > 0) {
SWBuf before = text;
normalizer.processText(text, (SWKey *)2); // note the hack of 2 to mimic a real key. TODO: remove all hacks
if (before != text) {
normalized++;
}
}
}
#endif
}
char ThMLVariants::processText(SWBuf &text, const SWKey *key, const SWModule *module)
{
if ( option == 0 || option == 1) { //we want primary or variant only
bool intoken = false;
bool hide = false;
bool invar = false;
SWBuf token;
SWBuf orig = text;
const char *from = orig.c_str();
//we use a fixed comparision string to make sure the loop is as fast as the original two blocks with almost the same code
const char* variantCompareString = (option == 0) ? "div type=\"variant\" class=\"1\"" : "div type=\"variant\" class=\"2\"";
for (text = ""; *from; from++) {
if (*from == '<') {
intoken = true;
token = "";
continue;
}
else if (*from == '>') { // process tokens
intoken = false;
if ( !strncmp(token.c_str(), variantCompareString, 28)) { //only one of the variants, length of the two strings is 28 in both cases
invar = true;
hide = true;
continue;
}
if (!strncmp(token.c_str(), "div type=\"variant\"", 18)) {
invar = true;
continue;
}
if (!strncmp(token.c_str(), "/div", 4)) {
hide = false;
if (invar) {
invar = false;
continue;
}
}
if (!hide) {
text += '<';
text.append(token);
text += '>';
}
continue;
}
if (intoken) {
token += *from;
}
else if (!hide) {
text += *from;
}
}
}
return 0;
}
void SWMgr::augmentModules(const char *ipath, bool multiMod) {
SWBuf path = ipath;
if ((ipath[strlen(ipath)-1] != '\\') && (ipath[strlen(ipath)-1] != '/'))
path += "/";
if (FileMgr::existsDir(path.c_str(), "mods.d")) {
char *savePrefixPath = 0;
char *saveConfigPath = 0;
SWConfig *saveConfig = 0;
stdstr(&savePrefixPath, prefixPath);
stdstr(&prefixPath, path.c_str());
path += "mods.d";
stdstr(&saveConfigPath, configPath);
stdstr(&configPath, path.c_str());
saveConfig = config;
config = myconfig = 0;
loadConfigDir(configPath);
if (multiMod) {
// fix config's Section names to rename modules which are available more than once
// find out which sections are in both config objects
// inserting all configs first is not good because that overwrites old keys and new modules would share the same config
for (SectionMap::iterator it = config->Sections.begin(); it != config->Sections.end();) {
if (saveConfig->Sections.find( (*it).first ) != saveConfig->Sections.end()) { //if the new section is already present rename it
ConfigEntMap entMap((*it).second);
SWBuf name;
int i = 1;
do { //module name already used?
name.setFormatted("%s_%d", (*it).first.c_str(), i);
i++;
} while (config->Sections.find(name) != config->Sections.end());
config->Sections.insert(SectionMap::value_type(name, entMap) );
SectionMap::iterator toErase = it++;
config->Sections.erase(toErase);
}
else ++it;
}
}
CreateMods(multiMod);
stdstr(&prefixPath, savePrefixPath);
delete []savePrefixPath;
stdstr(&configPath, saveConfigPath);
delete []saveConfigPath;
(*saveConfig) += *config;
homeConfig = myconfig;
config = myconfig = saveConfig;
}
}
char UTF16UTF8::processText(SWBuf &text, const SWKey *key, const SWModule *module)
{
unsigned short *from;
int len;
unsigned long uchar;
unsigned short schar;
len = 0;
from = (unsigned short*) text.c_str();
while (*from) {
len += 2;
from++;
}
SWBuf orig = text;
from = (unsigned short*)orig.c_str();
// -------------------------------
for (text = ""; *from; from++) {
uchar = 0;
if (*from < 0xD800 || *from > 0xDFFF) {
uchar = *from;
}
else if (*from >= 0xD800 && *from <= 0xDBFF) {
uchar = *from;
schar = *(from+1);
if (uchar < 0xDC00 || uchar > 0xDFFF) {
//error, do nothing
continue;
}
uchar &= 0x03ff;
schar &= 0x03ff;
uchar <<= 10;
uchar |= schar;
uchar += 0x10000;
from++;
}
else {
//error, do nothing
continue;
}
if (uchar < 0x80) {
text += uchar;
}
else if (uchar < 0x800) {
text += 0xc0 | (uchar >> 6);
text += 0x80 | (uchar & 0x3f);
}
else if (uchar < 0x10000) {
void EncodingFilterMgr::AddRawFilters(SWModule *module, ConfigEntMap §ion) {
ConfigEntMap::iterator entry;
SWBuf encoding = ((entry = section.find("Encoding")) != section.end()) ? (*entry).second : (SWBuf)"";
if (!encoding.length() || !stricmp(encoding.c_str(), "Latin-1")) {
module->addRawFilter(latin1utf8);
}
else if (!stricmp(encoding.c_str(), "SCSU")) {
module->addRawFilter(scsuutf8);
}
}
char OSISRedLetterWords::processText(SWBuf &text, const SWKey *key, const SWModule *module) {
if (option) //leave in the red lettered words
return 0;
SWBuf token;
bool intoken = false;
SWBuf orig = text;
const char *from = orig.c_str();
//taken out of the loop
const char* start = 0;
const char* end = 0;
for (text = ""; *from; from++) {
if (*from == '<') {
intoken = true;
token = "";
continue;
}
else if (*from == '>') { // process tokens
intoken = false;
if ((token[0] == 'q') && (token[1] == ' ')) { //q tag
start = strstr(token.c_str(), " who=\"Jesus\"");
if (start && (strlen(start) >= 12)) { //we found a quote of Jesus Christ
end = start+12; //marks the end of the who attribute value
text.append('<');
text.append(token, start - (token.c_str())); //the text before the who attr
text.append(end, token.c_str() + token.length() - end); //text after the who attr
text.append('>');
continue;
}
}
//token not processed, append it. We don't want to alter the text
text.append('<');
text.append(token);
text.append('>');
continue;
}
if (intoken) { //copy token
token.append(*from);
}
else { //copy text which is not inside a token
text.append(*from);
}
}
return 0;
}
/**
* Returns the value of an URL parameter. For the URL "http://www.crosswire.org/index.jsp?page=test&user=nobody" the value of the parameter "page" would be "test".
* If the parameter is not set an empty string is returned.
*/
const char *URL::getParameterValue(const char *name) const {
static SWBuf emptyStr("");
ParameterMap::const_iterator it = parameterMap.find(name);
static SWBuf retVal;
if (it != parameterMap.end())
retVal = it->second.c_str();
else
retVal = emptyStr.c_str();
return retVal.c_str();
}
JNIEXPORT jobjectArray JNICALL Java_org_crosswire_android_sword_SWMgr_getModInfoList
(JNIEnv *env, jobject) {
init();
int size = 0;
for (sword::ModMap::iterator it = mgr->Modules.begin(); it != mgr->Modules.end(); ++it) {
if ((!(it->second->getConfigEntry("CipherKey"))) || (*(it->second->getConfigEntry("CipherKey"))))
size++;
}
SWLog::getSystemLog()->logDebug("getModInfoList returning %d length array\n", size);
jclass clazzModInfo = env->FindClass("org/crosswire/android/sword/SWMgr$ModInfo");
jfieldID nameID = env->GetFieldID(clazzModInfo, "name", "Ljava/lang/String;");
jfieldID descID = env->GetFieldID(clazzModInfo, "description", "Ljava/lang/String;");
jfieldID catID = env->GetFieldID(clazzModInfo, "category", "Ljava/lang/String;");
jfieldID langID = env->GetFieldID(clazzModInfo, "language", "Ljava/lang/String;");
jfieldID versionID = env->GetFieldID(clazzModInfo, "version", "Ljava/lang/String;");
jfieldID deltaID = env->GetFieldID(clazzModInfo, "delta", "Ljava/lang/String;");
jobjectArray ret = (jobjectArray) env->NewObjectArray(size, clazzModInfo, NULL);
int i = 0;
for (sword::ModMap::iterator it = mgr->Modules.begin(); it != mgr->Modules.end(); ++it) {
SWModule *module = it->second;
if ((!(module->getConfigEntry("CipherKey"))) || (*(module->getConfigEntry("CipherKey")))) {
SWBuf type = module->Type();
SWBuf cat = module->getConfigEntry("Category");
SWBuf version = module->getConfigEntry("Version");
if (cat.length() > 0) type = cat;
jobject modInfo = env->AllocObject(clazzModInfo);
jstring val;
val = env->NewStringUTF(assureValidUTF8(module->getName())); env->SetObjectField(modInfo, nameID , val); env->DeleteLocalRef(val);
val = env->NewStringUTF(assureValidUTF8(module->getDescription())); env->SetObjectField(modInfo, descID , val); env->DeleteLocalRef(val);
val = env->NewStringUTF(assureValidUTF8(type.c_str())); env->SetObjectField(modInfo, catID , val); env->DeleteLocalRef(val);
val = env->NewStringUTF(assureValidUTF8(module->getLanguage())); env->SetObjectField(modInfo, langID , val); env->DeleteLocalRef(val);
val = env->NewStringUTF(assureValidUTF8(version.c_str())); env->SetObjectField(modInfo, versionID, val); env->DeleteLocalRef(val);
val = env->NewStringUTF(assureValidUTF8("")); env->SetObjectField(modInfo, deltaID , val); env->DeleteLocalRef(val);
env->SetObjectArrayElement(ret, i++, modInfo);
env->DeleteLocalRef(modInfo);
}
}
return ret;
}
bool ThMLRTF::handleToken(SWBuf &buf, const char *token, BasicFilterUserData *userData) {
if (!substituteToken(buf, token)) { // manually process if it wasn't a simple substitution
MyUserData *u = (MyUserData *)userData;
XMLTag tag(token);
if ((!tag.isEndTag()) && (!tag.isEmpty()))
u->startTag = tag;
if (tag.getName() && !strcmp(tag.getName(), "sync")) {
SWBuf value = tag.getAttribute("value");
if (tag.getAttribute("type") && !strcmp(tag.getAttribute("type"), "morph")) { //>
buf.appendFormatted(" {\\cf4 \\sub (%s)}", value.c_str());
}
else if( tag.getAttribute("type") && !strcmp(tag.getAttribute("type"), "Strongs")) {
if (value[0] == 'H' || value[0] == 'G' || value[0] == 'A') {
value<<1;
buf.appendFormatted(" {\\cf3 \\sub <%s>}", value.c_str());
}
else if (value[0] == 'T') {
value<<1;
buf.appendFormatted(" {\\cf4 \\sub (%s)}", value.c_str());
}
}
else if (tag.getAttribute("type") && !strcmp(tag.getAttribute("type"), "Dict")) {
if (!tag.isEndTag())
buf += "{\\b ";
else buf += "}";
}
}
// <note> tag
else if (!strcmp(tag.getName(), "note")) {
if (!tag.isEndTag()) {
if (!tag.isEmpty()) {
SWBuf type = tag.getAttribute("type");
SWBuf footnoteNumber = tag.getAttribute("swordFootnote");
VerseKey *vkey = NULL;
// see if we have a VerseKey * or descendant
SWTRY {
vkey = SWDYNAMIC_CAST(VerseKey, u->key);
}
SWCATCH ( ... ) { }
if (vkey) {
// leave this special osis type in for crossReference notes types? Might thml use this some day? Doesn't hurt.
char ch = ((tag.getAttribute("type") && ((!strcmp(tag.getAttribute("type"), "crossReference")) || (!strcmp(tag.getAttribute("type"), "x-cross-ref")))) ? 'x':'n');
buf.appendFormatted("{\\super <a href=\"\">*%c%i.%s</a>} ", ch, vkey->Verse(), footnoteNumber.c_str());
}
u->suspendTextPassThru = true;
}
}
if (tag.isEndTag()) {
u->suspendTextPassThru = false;
}
}
void SWMgr::InstallScan(const char *dirname)
{
DIR *dir;
struct dirent *ent;
FileDesc *conffd = 0;
SWBuf newmodfile;
SWBuf targetName;
if (FileMgr::existsDir(dirname)) {
if ((dir = opendir(dirname))) {
rewinddir(dir);
while ((ent = readdir(dir))) {
if ((strcmp(ent->d_name, ".")) && (strcmp(ent->d_name, ".."))) {
newmodfile = dirname;
if ((dirname[strlen(dirname)-1] != '\\') && (dirname[strlen(dirname)-1] != '/'))
newmodfile += "/";
newmodfile += ent->d_name;
// mods.d
if (configType) {
if (conffd)
FileMgr::getSystemFileMgr()->close(conffd);
targetName = configPath;
if ((configPath[strlen(configPath)-1] != '\\') && (configPath[strlen(configPath)-1] != '/'))
targetName += "/";
targetName += ent->d_name;
conffd = FileMgr::getSystemFileMgr()->open(targetName.c_str(), FileMgr::WRONLY|FileMgr::CREAT, FileMgr::IREAD|FileMgr::IWRITE);
}
// mods.conf
else {
if (!conffd) {
conffd = FileMgr::getSystemFileMgr()->open(config->filename.c_str(), FileMgr::WRONLY|FileMgr::APPEND);
if (conffd > 0)
conffd->seek(0L, SEEK_END);
else {
FileMgr::getSystemFileMgr()->close(conffd);
conffd = 0;
}
}
}
AddModToConfig(conffd, newmodfile.c_str());
FileMgr::removeFile(newmodfile.c_str());
}
}
if (conffd)
FileMgr::getSystemFileMgr()->close(conffd);
closedir(dir);
}
}
}
char UTF8HTML::processText(SWBuf &text, const SWKey *key, const SWModule *module)
{
unsigned char *from;
int len;
char digit[10];
unsigned long ch;
if ((unsigned long)key < 2) // hack, we're en(1)/de(0)ciphering
return (char)-1;
len = strlen(text.c_str()) + 2; // shift string to right of buffer
SWBuf orig = text;
from = (unsigned char *)orig.c_str();
// -------------------------------
for (text = ""; *from; from++) {
ch = 0;
if ((*from & 128) != 128) {
// if (*from != ' ')
text += *from;
continue;
}
if ((*from & 128) && ((*from & 64) != 64)) {
// error
*from = 'x';
continue;
}
*from <<= 1;
int subsequent;
for (subsequent = 1; (*from & 128); subsequent++) {
*from <<= 1;
from[subsequent] &= 63;
ch <<= 6;
ch |= from[subsequent];
}
subsequent--;
*from <<=1;
char significantFirstBits = 8 - (2+subsequent);
ch |= (((short)*from) << (((6*subsequent)+significantFirstBits)-8));
from += subsequent;
text += '&';
text += '#';
sprintf(digit, "%ld", ch);
for (char *dig = digit; *dig; dig++)
text += *dig;
text += ';';
}
return 0;
}
void RawStr::readText(__u32 istart, __u16 *isize, char **idxbuf, SWBuf &buf) const
{
unsigned int ch;
char *idxbuflocal = 0;
getIDXBufDat(istart, &idxbuflocal);
__u32 start = istart;
do {
if (*idxbuf)
delete [] *idxbuf;
buf = "";
buf.setFillByte(0);
buf.setSize(++(*isize));
*idxbuf = new char [ (*isize) ];
datfd->seek(start, SEEK_SET);
datfd->read(buf.getRawData(), (int)((*isize) - 1));
for (ch = 0; buf[ch]; ch++) { // skip over index string
if (buf[ch] == 10) {
ch++;
break;
}
}
buf = SWBuf(buf.c_str()+ch);
// resolve link
if (!strncmp(buf.c_str(), "@LINK", 5)) {
for (ch = 0; buf[ch]; ch++) { // null before nl
if (buf[ch] == 10) {
buf[ch] = 0;
break;
}
}
findOffset(buf.c_str() + 6, &start, isize);
}
else break;
}
while (true); // while we're resolving links
if (idxbuflocal) {
int localsize = strlen(idxbuflocal);
localsize = (localsize < (*isize - 1)) ? localsize : (*isize - 1);
strncpy(*idxbuf, idxbuflocal, localsize);
(*idxbuf)[localsize] = 0;
free(idxbuflocal);
}
}
ModInfoList *SWMgr_impl::getModInfoList() throw(CORBA::SystemException) {
ModInfoList *milist = new ModInfoList;
sword::SWModule *module = 0;
int size = 0;
for (sword::ModMap::iterator it = delegate->Modules.begin(); it != delegate->Modules.end(); it++) {
if ((!(it->second->getConfigEntry("CipherKey"))) || (*(it->second->getConfigEntry("CipherKey"))))
size++;
}
milist->length(size);
int i = 0;
for (sword::ModMap::iterator it = delegate->Modules.begin(); it != delegate->Modules.end(); it++) {
module = it->second;
if ((!(module->getConfigEntry("CipherKey"))) || (*(module->getConfigEntry("CipherKey")))) {
SWBuf type = module->Type();
SWBuf cat = module->getConfigEntry("Category");
if (cat.length() > 0)
type = cat;
(*milist)[i].name = CORBA::string_dup(module->Name());
(*milist)[i].description = CORBA::string_dup(module->Description());
(*milist)[i].category = CORBA::string_dup(type.c_str());
(*milist)[i++].language = CORBA::string_dup(module->Lang());
}
}
return milist;
}
int main(int argc, char **argv)
{
if (argc != 2) {
fprintf(stderr, "usage: %s <lex path>\n\n", *argv);
exit(-1);
}
RawStr mod(argv[1]);
char buf[127];
sprintf(buf, "%s.idx", argv[1]);
FileDesc *idxfd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::RDONLY, true);
long maxoff = idxfd->seek(0, SEEK_END) - 6;
FileMgr::getSystemFileMgr()->close(idxfd);
SWBuf last = "";
bool first = true;
char *trybuf = 0;
for (long index = 0; index < maxoff; index+=6) {
mod.getIDXBuf(index, &trybuf);
if (!first) {
if (strcmp(trybuf, last.c_str()) < 0) {
printf("entry %ld(offset: %ld) (%s) is less than previous entry (%s)\n\n", index/6, index, trybuf, last.c_str());
exit(-3);
}
}
else first = false;
last = trybuf;
}
if (trybuf)
delete [] trybuf;
return 0;
}
char UTF8UTF16::processText(SWBuf &text, const SWKey *key, const SWModule *module) {
const unsigned char *from;
SWBuf orig = text;
from = (const unsigned char *)orig.c_str();
// -------------------------------
text = "";
while (*from) {
__u32 ch = getUniCharFromUTF8(&from);
if (!ch) continue; // invalid char
if (ch < 0x10000) {
text.setSize(text.size()+2);
*((__u16 *)(text.getRawData()+(text.size()-2))) = (__u16)ch;
}
else {
__u16 utf16;
utf16 = (__s16)((ch - 0x10000) / 0x400 + 0xD800);
text.setSize(text.size()+4);
*((__u16 *)(text.getRawData()+(text.size()-4))) = utf16;
utf16 = (__s16)((ch - 0x10000) % 0x400 + 0xDC00);
*((__u16 *)(text.getRawData()+(text.size()-2))) = utf16;
}
}
text.setSize(text.size()+2);
*((__u16 *)(text.getRawData()+(text.size()-2))) = (__u16)0;
text.setSize(text.size()-2);
return 0;
}
SWBuf &RawFiles::getRawEntryBuf() {
FileDesc *datafile;
long start = 0;
unsigned short size = 0;
VerseKey *key = &getVerseKey();
findOffset(key->Testament(), key->TestamentIndex(), &start, &size);
entryBuf = "";
if (size) {
SWBuf tmpbuf = path;
tmpbuf += '/';
readText(key->Testament(), start, size, entryBuf);
tmpbuf += entryBuf;
entryBuf = "";
datafile = FileMgr::getSystemFileMgr()->open(tmpbuf.c_str(), FileMgr::RDONLY);
if (datafile->getFd() > 0) {
size = datafile->seek(0, SEEK_END);
char *tmpBuf = new char [ size + 1 ];
memset(tmpBuf, 0, size + 1);
datafile->seek(0, SEEK_SET);
datafile->read(tmpBuf, size);
entryBuf = tmpBuf;
delete [] tmpBuf;
// preptext(entrybuf);
}
FileMgr::getSystemFileMgr()->close(datafile);
}
return entryBuf;
}
char *SWModule_impl::getCategory() throw(CORBA::SystemException) {
SWBuf type = delegate->Type();
SWBuf cat = delegate->getConfigEntry("Category");
if (cat.length() > 0)
type = cat;
return CORBA::string_dup((char *)type.c_str());
}
int main(int argc, char **argv)
{
// SWMgr manager(0, 0, true, new MarkupFilterMgr(FMT_RTF, ENC_RTF));
SWMgr manager;
if ((argc < 3) || (argc > 3)) {
usage();
exit(-1);
}
int stripFilters = atoi(argv[1]);
if ((stripFilters < 1) || (stripFilters > 15)) {
usage();
exit(-1);
}
SWBuf stripTerm = argv[2];
manager.setGlobalOption("Greek Accents", "Off");
manager.setGlobalOption("Arabic Vowel Points", "Off");
manager.setGlobalOption("Hebrew Vowel Points", "Off");
manager.setGlobalOption("Hebrew Cantillation", "Off");
if (stripFilters & (1 << 3)) manager.filterText("Hebrew Cantillation", stripTerm);
if (stripFilters & (1 << 2)) manager.filterText("Hebrew Vowel Points", stripTerm);
if (stripFilters & (1 << 1)) manager.filterText("Arabic Vowel Points", stripTerm);
if (stripFilters & (1 << 0)) manager.filterText("Greek Accents", stripTerm);
fprintf(stdout,"%s\n",stripTerm.c_str());
return 0;
}
void linkToEntry(const SWBuf &keyBuf, const SWBuf &linkBuf) {
SWKey tmpkey = linkBuf.c_str();
module->linkEntry(&tmpkey);
#ifdef DEBUG
cout << "(" << entryCount << ") " << "Linking: " << linkBuf << endl;
#endif
}
const char *SWModule_getEntryAttributes(SWHANDLE hmodule, const char *level1, const char *level2, const char *level3) {
SWModule *module = (SWModule *)hmodule;
static SWBuf retval;
module->renderText();
retval = module->getEntryAttributes()[level1][level2][level3].c_str();
return (retval.length()) ? (const char*)retval.c_str() : NULL;
}
/************************************************************************
* getModuleStatus - compare the modules of two SWMgrs and return a
* vector describing the status of each. See MODSTAT_*
*/
map<SWModule *, int> InstallMgr::getModuleStatus(const SWMgr &base, const SWMgr &other) {
map<SWModule *, int> retVal;
SWBuf targetVersion;
SWBuf sourceVersion;
SWBuf softwareVersion;
bool cipher;
bool keyPresent;
int modStat;
for (ModMap::const_iterator mod = other.Modules.begin(); mod != other.Modules.end(); mod++) {
modStat = 0;
cipher = false;
keyPresent = false;
const char *v = mod->second->getConfigEntry("CipherKey");
if (v) {
cipher = true;
keyPresent = *v;
}
targetVersion = "0.0";
sourceVersion = "1.0";
softwareVersion = (const char *)SWVersion::currentVersion;
v = mod->second->getConfigEntry("Version");
if (v) sourceVersion = v;
v = mod->second->getConfigEntry("MinimumVersion");
if (v) softwareVersion = v;
const SWModule *baseMod = base.getModule(mod->first);
if (baseMod) {
targetVersion = "1.0";
v = baseMod->getConfigEntry("Version");
if (v) targetVersion = v;
modStat |= (SWVersion(sourceVersion.c_str()) > SWVersion(targetVersion.c_str())) ? MODSTAT_UPDATED : (SWVersion(sourceVersion.c_str()) < SWVersion(targetVersion.c_str())) ? MODSTAT_OLDER : MODSTAT_SAMEVERSION;
}
else modStat |= MODSTAT_NEW;
if (cipher) modStat |= MODSTAT_CIPHERED;
if (keyPresent) modStat |= MODSTAT_CIPHERKEYPRESENT;
retVal[mod->second] = modStat;
}
return retVal;
}
char GBFHeadings::processText(SWBuf &text, const SWKey *key, const SWModule *module) {
if (!option) { // if we don't want headings
char token[2048]; // cheese. Fix.
int tokpos = 0;
bool intoken = false;
bool hide = false;
const char *from;
SWBuf orig = text;
from = orig.c_str();
for (text = ""; *from; from++) {
if (*from == '<') {
intoken = true;
tokpos = 0;
// memset(token, 0, 2048);
token[0] = 0;
token[1] = 0;
token[2] = 0;
continue;
}
if (*from == '>') { // process tokens
intoken = false;
switch (*token) {
case 'T': // Reference
switch(token[1]) {
case 'S': // Begin heading
hide = true;
break;
case 's': // end heading
hide = false;
break;
}
continue; // skip token
}
// if not a heading token, keep token in text
if (!hide) {
text += '<';
for (char *tok = token; *tok; tok++)
text += *tok;
text += '>';
}
continue;
}
if (intoken) {
if (tokpos < 2045) {
token[tokpos++] = *from;
// TODO: why is this + 2 ?
token[tokpos+2] = 0;
}
}
else {
if (!hide) {
text += *from;
}
}
}
}
return 0;
}
static void initInstall() {
if (!installMgr) {
SWBuf baseDir = "/sdcard/sword/InstallMgr";
SWBuf confPath = baseDir + "/InstallMgr.conf";
// be sure we have at least some config file already out there
if (!FileMgr::existsFile(confPath.c_str())) {
FileMgr::createParent(confPath.c_str());
remove(confPath.c_str());
SWConfig config(confPath.c_str());
config["General"]["PassiveFTP"] = "true";
config.Save();
}
installMgr = new InstallMgr(baseDir);
}
}
static void init() {
if (!mgr) {
SWLog::setSystemLog(new AndroidLogger());
SWLog::getSystemLog()->setLogLevel(SWLog::LOG_DEBUG);
SWBuf baseDir = "/sdcard/sword";
SWBuf confPath = baseDir + "/mods.d/globals.conf";
// be sure we have at least some config file already out there
if (!FileMgr::existsFile(confPath.c_str())) {
FileMgr::createParent(confPath.c_str());
remove(confPath.c_str());
SWConfig config(confPath.c_str());
config["Globals"]["HiAndroid"] = "weeee";
config.Save();
}
mgr = new WebMgr("/sdcard/sword");
}
}
const char *SWModule_getFootnoteType(SWHANDLE hmodule, const char *key, const char *note) {
SWModule *module = (SWModule *)hmodule;
static SWBuf type;
module->popError();
module->setKey(key);
module->renderText();
type = module->getEntryAttributes()["Footnote"][note]["type"].c_str();
return (type) ? (const char*)type.c_str() : NULL;
}
const char *SWModule_getFootnoteRefList(SWHANDLE hmodule, const char *key, const char *note) {
SWModule *module = (SWModule *)hmodule;
static SWBuf refList;
module->popError();
module->setKey(key);
module->renderText();
refList = module->getEntryAttributes()["Footnote"][note]["refList"].c_str();
return (refList) ? (const char*)refList.c_str() : NULL;
}
