[sword-devel] Strong's numbers: Numbers or strings

Troy A. Griffitts scribe at crosswire.org
Thu Jan 27 12:53:33 EST 2022

Dear Karl,

I also just realized I answered the inversion of your question.

You are not attempting to go from Bible to Lexicon, but from Lexicon to Bible.

I am sorry for not taking more time to think about your example.

Yes, you are correct, we don't yet have an inverse solution, but we could add one by using the same strongsPad function during the lemma search or lemma index creation.

Let me have a bit more time to think through this.


On January 27, 2022 10:01:52 AM MST, "Troy A. Griffitts" <scribe at crosswire.org> wrote:
>Hi Karl,
>Yes, this history of how to record Strong's numbers has a long and 
>inglorious history.  The zero prefix was how the "Online Bible", from 
>which came most free online Bible resources back in the 1980s, recorded 
>Hebrew Strong's.  The Bible Foundation (the primary initial provider of 
>data for the Online Bible), trusted us with their data they provided to 
>the Online Bible for the open source community.  Most modules we 
>distributed from 1980-1990 were sourced from the Bible Foundation.
>I can't remember when we began using G and H prefixes to disambiguation 
>Strong's Hebrew numbers from Strong's Greek numbers-- it may have been 
>in the KJV2003 project.  We later adopted logic to allow Strong's 
>numbers to have suffixes like 1234b and OSIS allow '!' to split 
>suffixes, so we allowed 1234!c, but enough about history.
>Today, we have this odd bit of code in the engine to try to fix all of 
>this for the frontend developer, such that they shouldn't need to do 
>anything special, but simply use any 'G' or 'H' prefix to determine 
>which module you want to use for resolution, and pass the remainder to 
>the module:
>scroll to the bottom, to the function strongsPad
>It should do exactly what is required for you and you shouldn't need to 
>do any special logic.
>Again, the frontend code probably should be something like:
>SWModule *lex = verseKey.getTestament() == 2 || 
>strongsKey.startsWith("G") ? strongGreek : strongsHebrew;
>if (strongsKey.startsWith("G") || strongsKey.startsWith("H")) strongsKey 
><< 1;  // shift the buffer left by one; i.e., drop the G or H
>I know it's convoluted, but the history explains a bit of all the cases 
>we need to handle and we try to shield the frontend developer the best 
>we can:
>On 1/27/22 06:27, Karl Kleinpaste wrote:
>> I have a Xiphos bug <https://github.com/crosswire/xiphos/issues/1107> 
>> in which the facility to take a Strong's dict entry and search the 
>> Bible module for all its occurrences sometimes works and sometimes 
>> doesn't.
>> The mechanism is straightforward: Take the key from the dict pane, 
>> note whether this is Heb or Grk, construct e.g. lemma:Hxxxxx, stuff 
>> that into the sidebar search, and execute the search. No sweat.
>> The problem is with Heb refs. Because of the ancient habit that Heb 
>> Strong's refs are given a leading zero prefix (e.g. "07225") as a weak 
>> discriminant from Grk refs in the same number space, I actually handle 
>> this case explicitly. Strong's module keys are fixed, 5-digit strings, 
>> and the dict pane always shows this. When that key is taken to build 
>> the lemma search, I specifically include the last leading zero in the 
>> Heb case.
>> This works in KJV and ESV where we find "<w savlm="strong:H07225">In 
>> the beginning</w>".
>> This fails in NASB and OSHB where we find "<w savlm="strong:H7225">In 
>> the beginning</w>".
>> Note H07225 vs H7225.
>> The question revolves around what a Strong's ref ontologically is. 
>> Seriously, what is it?
>> Is it a number, written naturally with minimal required digits, stored 
>> for convenience in a character string?
>> Or is it a specific and fixed string of characters?
>> In terms of module keys, it's a string of characters.
>> In terms of Bible markup, well... Opinion varies. As we see in this 
>> case, some Bibles encode as a natural number, occupying the normal 
>> (minimal) digits needed, but others take the fixed string approach so 
>> as to include a leading zero, but note that it's not a full, fixed, 
>> 5-digit string to match a dict key; it's just one leading zero, no 
>> matter how many natural digits follow. KJV encodes the 1st Heb ref as 
>> "01". Not "1" (natural number) and not "00001" (module key); just "01".
>> Result is that, by constructing zero-prefixed searches, such searches 
>> always fail in Bibles using natural/minimal digits because there's 
>> never a zero-prefixed match.
>> This is different from Grk refs, which are stored in dict modules the 
>> same as Heb dict keys -- fixed 5-digit -- but are always marked up as 
>> natural numbers using minimal digits.
>> As matters stand, I have no /a priori/ means by which to determine 
>> what to expect in a Bible's Heb Strong's markup. The dict pane's key 
>> from which to construct the search is fixed 5 digits. That is at first 
>> trimmed to natural, minimal digits...and then the trouble starts 
>> because I don't have anything like a module conf directive to tell me 
>> whether the module uses zero-prefixed Heb refs or not. I'm also not 
>> aware that we have any standard for such markup to which I can point 
>> to say, "NASB's markup is wrong because it lacks zero-prefixing on Heb 
>> refs."
>> Help.
>> _______________________________________________
>> sword-devel mailing list:sword-devel at crosswire.org
>> http://crosswire.org/mailman/listinfo/sword-devel
>> Instructions to unsubscribe/change your settings at above page
Sent from my Android device with K-9 Mail. Please excuse my brevity.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://crosswire.org/pipermail/sword-devel/attachments/20220127/da7141f9/attachment.html>

More information about the sword-devel mailing list