int main(int argc, char **argv) {
SWMgr manager(new MarkupFilterMgr(sword::FMT_HTMLHREF, sword::ENC_UTF16));
const char *bookName = (argc > 1) ? argv[1] : "WLC";
SWModule *b = manager.getModule(bookName);
if (!b) return -1;
SWModule &book = *b;
book.setProcessEntryAttributes(false);
VerseKey *vk = SWDYNAMIC_CAST(VerseKey, book.getKey());
// find the first non-zero entry
for (book = TOP; !book.popError() && !book.getRawEntryBuf().size(); book++);
if (!book.getRawEntryBuf().size()) return -2; // empty module
for (;!book.popError(); book++) {
cout << "$$$";
if (vk) cout << vk->getOSISRef();
else cout << book.getKeyText();
cout << "\n" << book.renderText() << "\n\n";
}
return 0;
}
std::string parseRangeKey(const char* keyValue, const char* locale) {
const char* oldLocale = LocaleMgr::getSystemLocaleMgr()->getDefaultLocaleName();
LocaleMgr::getSystemLocaleMgr()->setDefaultLocaleName(locale);
std::string ret;
VerseKey DefaultVSKey;
DefaultVSKey = "jas3:1";
ListKey verses = DefaultVSKey.ParseVerseList(keyValue, DefaultVSKey, true);
for (int i = 0; i < verses.Count(); i++) {
VerseKey *element = dynamic_cast<VerseKey *>(verses.GetElement(i));
if (element) {
if (ret.length()) {
ret.append(" ");
}
ret.appendFormatted( "%s - %s;", (const char*)element->LowerBound(), (const char*)element->UpperBound() );
}
else {
if (ret.length()) {
ret.append(" ");
}
ret.appendFormatted("%s;", (const char *)*verses.GetElement(i));
}
}
// cout << ret.c_str() << endl;
LocaleMgr::getSystemLocaleMgr()->setDefaultLocaleName(oldLocale);
return ret;
};
void RawCom4::increment(int steps) {
long start;
unsigned long size;
VerseKey *tmpkey = &getVerseKey();
findOffset(tmpkey->getTestament(), tmpkey->getTestamentIndex(), &start, &size);
SWKey lastgood = *tmpkey;
while (steps) {
long laststart = start;
unsigned long lastsize = size;
SWKey lasttry = *tmpkey;
(steps > 0) ? ++(*key) : --(*key);
tmpkey = &getVerseKey();
if ((error = key->popError())) {
*key = lastgood;
break;
}
long index = tmpkey->getTestamentIndex();
findOffset(tmpkey->getTestament(), index, &start, &size);
if (
(((laststart != start) || (lastsize != size)) // we're a different entry
// && (start > 0)
&& (size)) // and we actually have a size
||(!skipConsecutiveLinks)) { // or we don't want to skip consecutive links
steps += (steps < 0) ? 1 : -1;
lastgood = *tmpkey;
}
}
error = (error) ? KEYERR_OUTOFBOUNDS : 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;
}
void writeidx(VerseKey &key1, VerseKey &key2, VerseKey &key3, long offset, short size)
{
long pos;
short tmp;
for (; ((key1 <= key3) && (key1.popError() != KEYERR_OUTOFBOUNDS) && (key1.getTestament() == testmnt)); key1+=1) {
if (key1.getVerse() == 1) { // new chapter
if (key1.getChapter() == 1) { // new book
pos = lseek(cfp, 0, SEEK_CUR);
write(bfp, &pos, 4);
pos = lseek(vfp, 0, SEEK_CUR); /* Book intro (cps) */
write(cfp, &pos, 4);
write(vfp, &chapoffset, 4); /* Book intro (vss) set to same as chap for now(it should be chap 1 which usually contains the book into anyway)*/
write(vfp, &chapsize, 2);
}
pos = lseek(vfp, 0, SEEK_CUR);
write(cfp, &pos, 4);
write(vfp, &chapoffset, 4); /* Chapter intro */
write(vfp, &chapsize, 2);
}
if (key1 >= key2) {
write(vfp, &offset, 4);
write(vfp, &size, 2);
}
else {
pos = 0;
tmp = 0;
write(vfp, &pos, 4);
write(vfp, &tmp, 2);
}
}
}
int main(int argc, char **argv)
{
const char *range = (argc > 1) ? argv[1] : "Mat 2:10,12-15";
VerseKey parser;
ListKey result;
result = parser.parseVerseList(range, parser.getText().c_str(), true);
// let's iterate the key and display
for (result.positionToTop(); !result.popError(); result.increment()) {
cout << result.getText() << "\n";
}
cout << endl;
// Now let's output a module with the entries from the result
// we'll initialize our library of books
SWMgr library(std::make_shared<MarkupFilterMgr>(FMT_PLAIN)); // render plain without fancy markup
// Let's get a book;
auto const book(library.getModule("KJV"));
// couldn't find our test module
if (!book) return -1;
// now let's iterate the book and display
for (result.positionToTop(); !result.popError(); result.increment()) {
book->setKey(result);
cout << "*** " << book->getKeyText() << ": " << book->renderText() << "\n";
}
return 0;
}
void writeEntry(SWModule & module,
std::string const & key,
std::string const & entry,
bool const replace)
{
if (key.size() && entry.size()) {
std::cout << "from file: " << key << std::endl;
VerseKey *vkey = (VerseKey *)module.getKey();
std::unique_ptr<VerseKey> linkMaster(
static_cast<VerseKey *>(module.createKey().release()));
ListKey listKey = vkey->parseVerseList(key.c_str(), "Gen1:1", true);
bool first = true;
for (listKey.positionToTop(); !listKey.popError(); listKey.increment()) {
vkey->positionFrom(listKey);
if (first) {
*linkMaster = *vkey;
std::string text;
if (!replace)
text = module.getRawEntry();
text += entry;
std::cout << "adding entry: " << vkey->getText() << " length " << entry.size() << "/" << (unsigned short)text.size() << std::endl;
module.setEntry(text.c_str());
first = false;
}
else {
std::cout << "linking entry: " << vkey->getText() << " to " << linkMaster->getText() << std::endl;
module.linkEntry(*linkMaster);
}
}
}
}
SWKey *SWText::createKey() const {
VerseKey *vk = new VerseKey();
vk->setVersificationSystem(versification);
return vk;
}
bool RawCom4::hasEntry(const SWKey *k) const {
long start;
unsigned long size;
VerseKey *vk = &getVerseKey(k);
findOffset(vk->getTestament(), vk->getTestamentIndex(), &start, &size);
return size;
}
void SWCom::setIndex(long iindex) {
VerseKey *key = &getVerseKey();
key->setTestament(1);
key->setIndex(iindex);
if (key != this->key) {
this->key->copyFrom(*key);
}
}
bool zCom::hasEntry(const SWKey *k) const {
long start;
unsigned short size;
unsigned long buffnum;
VerseKey *vk = &getVerseKey(k);
findOffset(vk->Testament(), vk->TestamentIndex(), &start, &size, &buffnum);
return size;
}
void zCom::linkEntry(const SWKey *inkey) {
VerseKey *destkey = &getVerseKey();
const VerseKey *srckey = &getVerseKey(inkey);
doLinkEntry(destkey->Testament(), destkey->TestamentIndex(), srckey->TestamentIndex());
if (inkey != srckey) // free our key if we created a VerseKey
delete srckey;
}
SWHANDLE listkey_getVerselistIterator(const char *list, const char *key, const char *v11n) {
VerseKey versekey;
versekey.setVersificationSystem(v11n);
static ListKey verses;
versekey.setText(key);
verses.clear();
verses = versekey.parseVerseList(list, versekey);
return (SWHANDLE)&verses;
}
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;
}
}
int main(int argc, char **argv) {
SWMgr mymgr;
SWModule *bbe = mymgr.Modules["BBE"];
if (bbe) {
VerseKey vk;
vk.setPersist(true);
bbe->setKey(vk);
for (; !bbe->popError(); (*bbe)++ ) {
std::cout << vk.getIndex() << std::endl;
}
}
return 0;
}
void zCom::setEntry(const char *inbuf, long len) {
VerseKey *key = &getVerseKey();
// see if we've jumped across blocks since last write
if (lastWriteKey) {
if (!sameBlock(lastWriteKey, key)) {
flushCache();
}
delete lastWriteKey;
}
doSetText(key->Testament(), key->TestamentIndex(), inbuf, len);
lastWriteKey = (VerseKey *)key->clone(); // must delete
}
int main(int argc, char **argv)
{
const char *range = (argc > 1) ? argv[1] : "Mat 2:10,12-15";
VerseKey parser;
ListKey result;
result = parser.parseVerseList(range, parser, true);
// let's iterate the key and display
for (result = TOP; !result.popError(); result++) {
cout << result << "\n";
}
cout << endl;
// Now if we'd like persist this key for use inside of a book...
result.setPersist(true);
// Let's get a book;
SWMgr library(new MarkupFilterMgr(FMT_PLAIN)); // render plain without fancy markup
SWModule *book = library.getModule("KJV");
// and set our limited key inside
book->setKey(result);
// now let's iterate the book and display
for ((*book) = TOP; !book->popError(); (*book)++) {
cout << "*** " << book->getKeyText() << ": " << book->renderText() << "\n";
}
// Since we've told our result key to persist in book, we can reuse our
// setup by simply resetting result, e.g.
//
// result = parser.ParseVerseList(someNewRange, parser, true);
//
// Now an iteration of book will give us our new range.
//
// To stop persistence of our custom key, we'll need to set our book's key
// to something simple:
//
// book->setKey("gen.1.1");
//
// Resetting our book object's key to something not persistent will revert our book object to using its default key for positioning
//
//
return 0;
}
VerseKey &SWText::getVerseKey(const SWKey *keyToConvert) const {
SWKey const * tmp = keyToConvert ? keyToConvert : this->key;
/// \bug remove const_cast:
SWKey * thisKey = const_cast<SWKey *>(tmp);
if (VerseKey * const key = dynamic_cast<VerseKey *>(thisKey))
return *key;
if (ListKey * const lkTest = dynamic_cast<ListKey *>(thisKey))
if (VerseKey * const key =
dynamic_cast<VerseKey *>(lkTest->getElement()))
return *key;
VerseKey * retKey = (tmpSecond) ? tmpVK1 : tmpVK2;
tmpSecond = !tmpSecond;
retKey->setLocale(LocaleMgr::getSystemLocaleMgr()->getDefaultLocaleName());
(*retKey) = *thisKey;
return (*retKey);
}
int main(int argc, char **argv) {
const char *modName = "HunKar";
SWMgr library;
SWModule *book = library.getModule(modName);
if (!book) {
cerr << "Can't find module: " << modName << endl;
return -1;
}
VerseKey* key = ((VerseKey *)book->getKey());
key->setIntros(true);
book->setSkipConsecutiveLinks(true);
book->setPosition(TOP);
cout << *key << endl;
return 0;
}
/******************************************************************************
* zCom::getRawEntry - Returns the correct verse when char * cast
* is requested
*
* RET: string buffer with verse
*/
SWBuf &zCom::getRawEntryBuf() {
long start = 0;
unsigned short size = 0;
unsigned long buffnum;
VerseKey *key = &getVerseKey();
findOffset(key->Testament(), key->TestamentIndex(), &start, &size, &buffnum);
entrySize = size; // support getEntrySize call
entryBuf = "";
zReadText(key->Testament(), start, size, buffnum, entryBuf);
rawFilter(entryBuf, key);
// if (!isUnicode())
prepText(entryBuf);
return entryBuf;
}
SWBuf &RawCom4::getRawEntryBuf() const {
long start = 0;
unsigned long size = 0;
VerseKey *key = &getVerseKey();
findOffset(key->getTestament(), key->getTestamentIndex(), &start, &size);
entrySize = size; // support getEntrySize call
entryBuf = "";
readText(key->getTestament(), start, size, entryBuf);
rawFilter(entryBuf, 0); // hack, decipher
rawFilter(entryBuf, key);
// if (!isUnicode())
prepText(entryBuf);
return entryBuf;
}
int main(int argc, char **argv) {
if (argc < 2) {
fprintf(stderr, "usage: %s <Mod Name>\n", argv[0]);
std::exit(-1);
}
SWMgr mgr;
auto const it = mgr.modules().find(argv[1]);
if (it == mgr.modules().end()) {
fprintf(stderr, "error: %s: couldn't find module: %s \n", argv[0], argv[1]);
std::exit(-2);
}
SWModule & mod = *it->second;
SWKey *key = mod.getKey();
VerseKey * vkey = nullptr;
try {
vkey = dynamic_cast<VerseKey *>(key);
}
catch (...) {}
if (!vkey) {
fprintf(stderr, "error: %s: %s module is not keyed to verses \n", argv[0], argv[1]);
std::exit(-3);
}
vkey->setIntros(false); // turn on mod/testmnt/book/chap headings
mod.positionToTop();
while (!mod.popError()) {
if (vkey->getVerse()) {
if (!mod.renderText().length()) {
std::cout << vkey->getText() << std::endl;
}
mod.increment();
}
}
}
int main(int argc, char **argv) {
if (argc < 2) {
fprintf(stderr, "usage: %s <Mod Name>\n", argv[0]);
exit(-1);
}
SWMgr mgr;
ModMap::iterator it = mgr.Modules.find(argv[1]);
if (it == mgr.Modules.end()) {
fprintf(stderr, "error: %s: couldn't find module: %s \n", argv[0], argv[1]);
exit(-2);
}
SWModule *mod = it->second;
SWKey *key = (*mod);
VerseKey *vkey = 0;
SWTRY {
vkey = dynamic_cast<VerseKey *>(key);
}
SWCATCH (...) {}
if (!vkey) {
fprintf(stderr, "error: %s: %s module is not keyed to verses \n", argv[0], argv[1]);
exit(-3);
}
vkey->setIntros(false); // turn on mod/testmnt/book/chap headings
(*mod) = TOP;
while (!mod->popError()) {
if (vkey->getVerse())
if (!mod->renderText().length())
std::cout << *vkey << std::endl;
(*mod)++;
}
}
void RawFiles::setEntry(const char *inbuf, long len) {
FileDesc *datafile;
long start;
unsigned short size;
VerseKey *key = &getVerseKey();
len = (len<0)?strlen(inbuf):len;
findOffset(key->Testament(), key->TestamentIndex(), &start, &size);
if (size) {
SWBuf tmpbuf;
entryBuf = path;
entryBuf += '/';
readText(key->Testament(), start, size, tmpbuf);
entryBuf += tmpbuf;
}
else {
SWBuf tmpbuf;
entryBuf = path;
entryBuf += '/';
tmpbuf = getNextFilename();
doSetText(key->Testament(), key->TestamentIndex(), tmpbuf);
entryBuf += tmpbuf;
}
datafile = FileMgr::getSystemFileMgr()->open(entryBuf, FileMgr::CREAT|FileMgr::WRONLY|FileMgr::TRUNC);
if (datafile->getFd() > 0) {
datafile->write(inbuf, len);
}
FileMgr::getSystemFileMgr()->close(datafile);
}
SWBuf &HREFCom::getRawEntryBuf() const {
long start;
unsigned short size;
VerseKey *key = 0;
key = &getVerseKey();
findOffset(key->getTestament(), key->getTestamentIndex(), &start, &size);
entrySize = size; // support getEntrySize call
SWBuf tmpbuf;
readText(key->getTestament(), start, size, tmpbuf);
entryBuf = prefix;
entryBuf += tmpbuf.c_str();
prepText(entryBuf);
if (key != this->key)
delete key;
return entryBuf;
}
int main(int argc, char **argv) {
cout << "\n";
const char *modName = (argc > 1) ? argv[1] : "KJV";
SWMgr manager;
SWModule *bible = manager.getModule(modName);
if (!bible) {
cout << modName << " module is not installed.\nPlease install to show versification (v11n) from this specific Bible.\nShowing builtin KJV v11n scheme..\n\n";
}
VerseKey *vk = (bible) ? (VerseKey *)bible->getKey() : new VerseKey();
for ((*vk) = TOP; !vk->popError(); vk->setBook(vk->getBook()+1)) {
cout << vk->getBookName() << "\n";
}
// if we 'new'ed a VerseKey unassociated with a module, above, then we should delete it.
if (!bible) delete vk;
return 0;
}
int main(int argc, char **argv) {
if ((argc < 2) || (argc > 4)) {
fprintf(stderr, "usage: %s <\"string to parse\"> [locale_name] [test-in-set-verse]\n", *argv);
exit(-1);
}
if (argc > 2)
LocaleMgr::getSystemLocaleMgr()->setDefaultLocaleName(argv[2]);
VerseKey DefaultVSKey;
DefaultVSKey = "jas3:1";
ListKey verses = DefaultVSKey.parseVerseList(argv[1], DefaultVSKey, true);
std::cout << verses.getOSISRefRangeText() << "\n";
if (argc > 3) {
verses.setText(argv[3]);
std::cout << "Verse is" << ((verses.popError()) ? " NOT" : "") << " in set.\n\n";
}
return 0;
}
int main(int argc, char **argv) {
SWMgr library;
SWModule *kjv = library.getModule((argc > 1)?argv[1]:"KJV");
kjv->setKey(argc > 2 ? argv[2] : "Jn.3.16");
VerseKey *key = (VerseKey *)kjv->getKey();
int curVerse = key->getVerse();
int curChapter = key->getChapter();
int curBook = key->getBook();
for (key->setVerse(1);
(key->getBook() == curBook) &&
(key->getChapter() == curChapter) &&
!kjv->popError();
(*kjv)++) {
if (key->getVerse() == curVerse) cout << "* ";
cout << key->getVerse() << " " << kjv->stripText() << "\n";
}
return 0;
}
int main() {
SWMgr library;
auto const book(library.getModule("KJV"));
VerseKey *vk = (VerseKey *) book->getKey();
for (;!vk->popError();vk->setChapter(vk->getChapter()+1)) {
vk->setVerse(vk->getVerseMax());
std::string text = book->stripText();
trimString(text);
if (!text.empty() && (*text.rbegin()) == ',') {
cout << vk->getText() << ":\n\n";
cout << text << endl;
}
}
return 0;
}
int main(int argc, char **argv) {
SWMgr library;
SWModule *book = library.getModule("KJV");
VerseKey *vk = (VerseKey *) book->getKey();
for (;!vk->popError();vk->setChapter(vk->getChapter()+1)) {
vk->setVerse(vk->getVerseMax());
SWBuf text = book->stripText();
text = text.trim();
if (text.endsWith(",")) {
cout << vk->getText() << ":\n\n";
cout << text << endl;
}
}
return 0;
}
