enum TToken {
tokNull, tokEOF, tokHeader, tokContent, tokTail, tokStyle,
	      tokWord, tokSpace, tokSync, tokControl, tokChar, tokFont};

enum TCharacterAttribute { caBold, caSmallCaps, caItalic, caOTQuote, caRed,
			    caSuperscript, caUnderline, caSubscript};

//    TCharAttribs = set of TCharacterAttribute;


struct TBookNameRec {
	string Name, Abbr;
	char Num;
}

const struct TBookNameRec TBookAbbr[116] = {
	{"1 Chronicles",    "1CH", 13},   //0
	{"1 Corinthians",   "1CO", 70},   //1
	{"1 Esdras",        "1E", 52},    //2
	{"1 John",          "1J", 86},    //3
	{"1 Kings",         "1K", 11},    //4
	{"1 Maccabees",     "1M", 50},    //5
	{"1 Peter",         "1P", 84},    //6
	{"1 Samuel",        "1S", 9},     //7
	{"1 Thessalonians", "1TH", 76},   //8
	{"1 Timothy",       "1TI", 78},   //9
	{"2 Chronicles",    "2CH", 14},   //10
	{"2 Corinthians",   "2CO", 71},   //11
	{"2 Esdras",        "2E", 56},    //12
	{"2 John",          "2J", 87},    //13
	{"2 Kings",         "2K", 12},    //14
	{"2 Maccabees",     "2M", 51},    //15
	{"2 Peter",         "2P", 85},    //16
	{"2 Samuel",        "2S", 10},    //17
	{"2 Thessalonians", "2TH", 77},   //18
	{"2 Timothy",       "2TI", 79},   //19
	{"3 John",          "3J", 88},    //20
	{"3 Maccabees",     "3M", 55},    //21
	{"4 Maccabees",     "4M", 57},    //22
	{"1 Chronicles",    "1 CH", 13},   //0
	{"1 Corinthians",   "1 CO", 70},   //1
	{"1 Esdras",        "1 E", 52},    //2
	{"1 John",          "1 J", 86},    //3
	{"1 Kings",         "1 K", 11},    //4
	{"1 Maccabees",     "1 M", 50},    //5
	{"1 Peter",         "1 P", 84},    //6
	{"1 Samuel",        "1 S", 9},     //7
	{"1 Thessalonians", "1 TH", 76},   //8
	{"1 Timothy",       "1 TI", 78},   //9
	{"2 Chronicles",    "2 CH", 14},   //10
	{"2 Corinthians",   "2 CO", 71},   //11
	{"2 Esdras",        "2 E", 56},    //12
	{"2 John",          "2 J", 87},    //13
	{"2 Kings",         "2 K", 12},    //14
	{"2 Maccabees",     "2 M", 51},    //15
	{"2 Peter",         "2 P", 85},    //16
	{"2 Samuel",        "2 S", 10},    //17
	{"2 Thessalonians", "2 TH", 77},   //18
	{"2 Timothy",       "2 TI", 79},   //19
	{"3 John",          "3 J", 88},    //20
	{"3 Maccabees",     "3 M", 55},    //21
	{"4 Maccabees",     "4 M", 57},    //22
	{"Acts",            "AC", 68},    //23
	{"Amos",            "AM", 30},    //24
	{"Prayer of Asariah and the Song of the Three Jews", "AZ", 47},
	{"Baruch",          "BA", 45},    //26
	{"Bel and the Dragon","BE", 49},  //27
	{"Colossians",      "CO", 75},    //28
	{"Daniel",          "DA", 27},    //29
	{"Deuteronomy",     "DE", 5},     //30
	{"Deuteronomy",     "DT", 5},     //31
	{"Ecclesiasties",   "EC", 21},    //32
	{"Esther",          "ES", 17},    //33
	{"Exodus",          "EX", 2},     //34
	{"Ezekiel",         "EZE", 26},   //35
	{"Ezra",            "EZR", 15},   //36
	{"Galatians",       "GA", 72},    //37
	{"Genesis",         "GE", 1},     //38
	{"Genesis",         "GN", 1},     //39
	{"Ephesians",       "EP", 73},    //40
	{"Esther (Greek}",  "GR", 42),    //41
	{"Habakkuk",        "HAB", 35},   //42
	{"Haggai",          "HAG", 37},   //43
	{"Hebrews",         "HE", 82},    //44
	{"Hosea",           "HO", 28},    //45
	{"Isaiah",          "IS", 23},    //46
	{"James",           "JA", 83},    //47
	{"Jeremiah",        "JE", 24},    //48
	{"Job",             "JOB", 18},   //49
	{"Joel",            "JOE", 29},   //50
	{"John",            "JOH", 67},   //51
	{"Jonah",           "JON", 32},   //52
	{"Joshua",          "JOS", 6},    //53
	{"Jude",            "JUDE", 89},  //54
	{"Judges",          "JUDG", 7},   //55
	{"Judith",          "JUDI", 41},  //56
	{"Lamentations",    "LA", 25},    //57
	{"Letter of Jeremiah",Abbr:"LET", 46},  //58
	{"Leviticus",       "LEV", 3},    //59
	{"Luke",            "LK", 66},    //60
	{"Leviticus",       "LV", 3},     //61
	{"Luke",            "LU", 66},    //62
	{"Malachi",         "MAL", 39},   //63
	{"Prayer of Manasseh",Abbr:"MAN", 53},  //64
	{"Mark",            "MAR", 65},   //65
	{"Matthew",         "MAT", 64},   //66
	{"Micah",           "MI", 33},    //67
	{"Nahum",           "NA", 34},    //68
	{"Nehemiah",        "NE", 16},    //69
	{"Numbers",         "NU", 4},     //70
	{"Obadiah",         "OB", 31},    //71
	{"Psalm 151",       "P1", 54},    //72
	{"Philemon",        "PHILE", 81}, //73
	{"Philippians",     "PHILI", 74}, //74
	{"Philemon",        "PHM", 81},   //75
	{"Philippians",     "PHP", 74},   //76
	{"Proverbs",        "PR", 20},    //77
	{"Psalms",          "PS", 19},    //78
	{"Revelation",      "RE", 90},    //79
	{"Romans",          "RM", 69},    //80
	{"Romans",          "RO", 69},    //81
	{"Ruth",            "RU", 8},     //82
	{"Sirach",          "SI", 44},    //83
	{"Song of Solomon", "SOL", 22},   //84
	{"Song of Solomon", "SON", 22},   //85
	{"Song of Solomon", "SS", 22},    //86
	{"Susanna",         "SU", 48},    //87
	{"Titus",           "TI", 80},    //88
	{"Tobit",           "TO", 40},    //89
	{"Wisdom",          "WI", 43},    //90
	{"Zechariah",       "ZEC", 38},   //91
	{"Zephaniah",       "ZEP", 36}    //92
	},

string BookFileName[91] = {
	"","Genesis","Exodus","Lev","Num","Deut","Joshua","Judges", // 0 - 7
	"Ruth","1Sam","2Sam","1Kings","2Kings","1Chron","2Chron",   // 8 - 14
	"Ezra","Nehemiah","Esther","Job","Psalms","Proverbs",       // 15-20
	"Eccl","Song","Isaiah","Jeremiah","Lament","Ezekiel",       // 21-26
	"Daniel","Hosea","Joel","Amos","Obadiah","Jonah","Micah",   // 27-33
	"Nahum","Habakkuk","Zeph","Haggai","Zech","Malachi",        // 34-39
	"Tobit","Judith","Esther","Wisdom","Sirach","Baruch",       // 40-45
	"Let","Azar","Susanna","Bel","1Mac","2Mac","1Esdras",       // 46-52
	"Man","P1","3Mac","2Esdras","4Mac","","","","","","",       // 53-63
	"Matthew","Mark","Luke","John","Acts","Romans","1Cor",      // 64-70
	"2Cor","Gal","Eph","Philip","Col","1Thes","2Thes","1Tim",   // 71-78
	"2Tim","Titus","Philemon","Hebrews","James","1Peter",       // 79-84
	"2Peter","1John","2John","3John","Jude","Rev"};             // 85-90

class TReadGBF {
private:
	FILE *fp;
	string FName, TokenLine;
	int TokenPos;
	bool fFileIsOpen, fParagraphEnd, fInTitle, fInPsalmBookTitle, fInHebrewTitle, fInSectionTitle;

public:
	string sBook, sChapter, sVerse, sMode;
	string sContext; // Last text type (header, body, or tail)
	string sTitle;   // Title of this book of the Bible
	string sPsalmBookTitle; // Title of this Psalm book
	string sHebrewTitle;    // Psalm Hebrew title
	string sSectionTitle;   // Section headings
	string sDate;
	string sFontName;
	int iTotalWords;
	char chJustification, chDirection;
	bool fIndent, fPoetry;
	int CharAttribs;
	char bBk, bChap, bVs, bWd;

	bool Init(const string sFileName);
	void Done();
	string GetToken(TToken &TokenKind);
    end;

class TWriteGBF {
	private:
	F: TextFile;
	FName, LineOut: string;
	fFileIsOpen: boolean;
	bBk, bChap, bVs, bWd: byte;

	public

	function Init(const sFileName: string): boolean;
	function Done: boolean;
	procedure Out(const s: string);
    end;

function isletter(const ch: char): boolean;
function isinword(const ch: char): boolean;
function IsDigit(const ch: char): Boolean;
function IsUpper(const ch: char): Boolean;
function ConformCase(const sPat, sSrc: string): string;
function BookNameToNumber(const sBookName: string): byte;

implementation

function isletter(const ch: char): boolean;
begin
    case ch of
	'A'..'Z': isletter := true;
	'a'..'z': isletter := true;
	else
	isletter := false;
    end;
end;

function isinword(const ch: char): boolean;
begin
    case ch of
	'-': isinword := true;
	'A'..'Z': isinword := true;
	'a'..'z': isinword := true;
	else
	isinword := false;
    end;
end;

function IsUpper(const ch: char): Boolean;
begin
    case ch of
	'A'..'Z': IsUpper := true;
	else
	    IsUpper := false;
    end;
end;

function IsDigit(const ch: char): Boolean;
begin
    case ch of
	'0'..'9': IsDigit := true;
	else
	    IsDigit := false;
    end;
end;


function MatchAbbrev(const sName, sAbbrev: string): boolean;
var i: integer;
begin
    if Length(sName) < Length(sAbbrev) then
	Result := false
    else
	Result := true;
    i := 1;
    while (i <= Length(sAbbrev)) and Result do
	begin
	if UpCase(sName[i]) <> sAbbrev[i] then
	    Result := false;
	inc(i);
	end;
end;

function BookNameToNumber(const sBookName: string): byte;
var i: integer;
begin
    Result := 0;
    try
    if IsDigit(sBookName[Length(sBookName)]) and IsDigit(sBookName[1]) then
	Result := StrToInt(sBookName);
    except
    Result := 0;
    end;
    i := 0;
    while (Result = 0) and (i <= 115) do  // Yuk! Linear search.
	begin
	if MatchAbbrev(sBookName,BookAbbr[i].Abbr) then
	    begin
	    Result := BookAbbr[i].Num;
	    end;
	inc(i);
	end;
end;

function BookNumberToName(const bBookNum: byte): string;
begin
    if bBookNum <= 115 then
	Result := BookAbbr[bBookNum].Name
    else
	Result := '';
end;

function ConformCase(const sPat, sSrc: string): string;
var i: integer;
begin
    Result := sSrc;
    if (Length(sPat) > 0) and (Length(sSrc) > 0) then
	begin
	Result := LowerCase(sSrc);
	if IsUpper(sPat[1]) then
	    Result[1] := UpCase(Result[1]);
	if (Length(sPat) > 1) and (Length(sSrc) > 1) then
	    begin
	    if IsUpper(sPat[2]) then
		begin
		for i := 2 to Length(Result) do
		    Result[i] := UpCase(Result[i]);
		end;
	    end;
	end;
end;

function TReadGBF.Init(const sFileName: string): boolean;
var s: string;
    tok: TToken;
begin
    try
    fParagraphEnd := false;
    bBk := 0;
    bChap := 0;
    bVs := 0;
    bWd := 0;
    iTotalWords := 0;
    FName := sFileName;
    Assign(F, FName);
    reset(F);
    readln(F, TokenLine);
    TokenPos := 1;
    fFileIsOpen := true;
    repeat
	s := GetToken(tok)
    until (tok = tokEOF) or ((tok = tokHeader) and (s[3] = '0'));
    Init := true;
    except
    Init := false;
    fFileIsOpen := false;
    end
end;

procedure TReadGBF.Done;
begin
    if fFileIsOpen then
	begin
	closefile(F);
	fFileIsOpen := false;
	end;
end;

function TReadGBF.GetToken(var TokenKind: TToken): string;
var m: integer;
begin
    Result := '';
    TokenKind := tokNull;
    if TokenPos = 0 then
	begin
	if (not fFileIsOpen) or EOF(F) then
	    TokenKind := tokEOF
	else
	    begin
	    ReadLn(F,TokenLine);
	    TokenPos := 1;
	    end;
	end;
    if TokenKind <> tokEOF then
	begin
	m := Length(TokenLine);
	if TokenPos > m then
	    begin
	    TokenKind := tokSpace;
	    if fParagraphEnd then
		fParagraphEnd := false
	    else
		Result := ' ';
	    TokenPos := 0;
	    end
	else
	    begin
	    if (TokenLine[TokenPos] = '<') then
		begin
		fParagraphEnd := false;
		repeat
		    Result := Result + TokenLine[TokenPos];
		    inc(TokenPos);
		until (TokenLine[TokenPos] = '>') or (TokenPos > m);
		Result := Result + '>';
		inc(TokenPos);
		case result[2] of
		    'B': begin // File body text type
			 TokenKind := tokContent;
			 sContext := Result;
			 end;
		    'C': begin // Special characters
			 TokenKind := tokControl;
			 if (Result[3] = 'M') or (Result[3] = 'L') then
			     fParagraphEnd := true;
			 end;
		    'D': begin // Direction
			 TokenKind := tokControl;
			 chDirection := Result[3];
			 end;
		    'H': begin
			 TokenKind := tokHeader;
			 sContext := Result;
			 end;
		    'F': begin // Font attributes
			 TokenKind := tokFont;
			 case Result[3] of
			     'B': CharAttribs := CharAttribs + [caBold];
			     'C': CharAttribs := CharAttribs + [caSmallCaps];
			     'I': CharAttribs := CharAttribs + [caItalic];
			     'N': sFontName := copy(Result,4,Length(Result)-4);
			     'O': CharAttribs := CharAttribs + [caOTQuote];
			     'R': CharAttribs := CharAttribs + [caRed];
			     'S': CharAttribs := CharAttribs + [caSuperscript];
			     'U': CharAttribs := CharAttribs + [caUnderline];
			     'V': CharAttribs := CharAttribs + [caSubscript];
			     'b': CharAttribs := CharAttribs - [caBold];
			     'c': CharAttribs := CharAttribs - [caSmallCaps];
			     'i': CharAttribs := CharAttribs - [caItalic];
			     'n': sFontName := '';
			     'o': CharAttribs := CharAttribs - [caOTQuote];
			     'r': CharAttribs := CharAttribs - [caRed];
			     's': CharAttribs := CharAttribs - [caSuperscript];
			     'u': CharAttribs := CharAttribs - [caUnderline];
			     'v': CharAttribs := CharAttribs - [caSubscript];

			 end;
			 end;
		    'J': begin // Justification
			 TokenKind := tokStyle;
			 chJustification := Result[3];
			 end;
		    'P': begin // Poetry/prose, indent
			 TokenKind := tokControl;
			 case Result[3] of
			     'I': fIndent := true;
			     'P': fPoetry := true;
			     'i': fIndent := false;
			     'p': fPoetry := false;
			 end;
			 end;
		    'R': begin // References and footnotes
			 TokenKind := tokControl;
			 end;
		    'S': begin // sync mark
			 TokenKind := TokSync;
			 case Result[3] of
			     'B': begin // Book
			          sBook := system.copy(Result, 4, length(Result)-4);
			          sPsalmBookTitle := '';
			          if sBook = '' then
			              begin
			              inc(bBk);
			              sBook := BookNumberToName(bBk);
			              end
			          else
			              bBk := BookNameToNumber(sBook);
			          sTitle := sBook;
			          end;
			     'C': begin //chapter
			          sChapter := system.copy(Result, 4, length(Result)-4);
			          if sChapter = '' then
			              begin
			              inc(bChap);
			              sChapter := IntToStr(bChap);
			              end
			          else
			              begin
			              try
			              bChap := StrToInt(sChapter);
			              except
			              showmessage('Non-numeric chapter: '+sBook+' '+sChapter);
			              end;
			              end;
			          sHebrewTitle := '';    
			          end;
			     'V': begin // Verse
			          bWd := 0;
			          sVerse := system.copy(Result, 4, length(Result)-4);
			          if sVerse = '' then
			              begin
			              inc(bVs);
			              sVerse := IntToStr(bVs);
			              end
			          else
			              begin
			              try
			              bVs := StrToInt(sVerse);
			              except
			              showmessage('Non-numeric verse: '+sBook+' '+sChapter+':'+sVerse);
			              end;
			              end;
			          end;
			     'D': begin // Date
			          sDate := system.copy(Result, 3, length(Result)-4);
			          end;
			 end;
			 end;
		    'T': begin // Titles
			 TokenKind := TokContent;
			 case Result[3] of
			     'B':
			         begin
			         sPsalmBookTitle := '';
			         fInPsalmBookTitle := true;
			         end;
			     'b': fInPsalmBookTitle := true;
			     'H':
			         begin
			         sHebrewTitle := '';
			         fInHebrewTitle := true;
			         end;
			     'h': fInHebrewTitle := false;
			     'S':
			         begin
			         sSectionTitle := '';
			         fInSectionTitle := true;
			         end;
			     's': fInSectionTitle := false;
			     'T':
			         begin
			         sTitle := '';
			         fInTitle := true;
			         end;
			     't': fInTitle := false;
			 end;
			 end;
		    'Z': begin // File tail
			 TokenKind := tokTail;
			 sContext := Result;
			 if Result[3] = 'Z' then
			     done;
			 end;
		    else
			 TokenKind := TokControl;

		end;
		end
	    else if isletter(TokenLine[TokenPos]) then
		begin {Word}
		fParagraphEnd := false;
		TokenKind := tokWord;
		repeat
		    Result := Result + TokenLine[TokenPos];
		    inc(TokenPos);
		until (TokenPos > m) or (not isinword(TokenLine[TokenPos]));
		inc(bWd);
		inc(iTotalWords);
		end
	    else if ((TokenLine[TokenPos] = ' ') or (TokenLine[TokenPos] = #9)) then
		begin
		fParagraphEnd := false;
		TokenKind := tokSpace;
		Result := Result + TokenLine[TokenPos];
		inc(TokenPos);
		end
	    else
		begin
		fParagraphEnd := false;
		TokenKind := tokChar;
		Result := Result + TokenLine[TokenPos];
		inc(TokenPos);
		end
	    end;
	end;
    if ((TokenKind = tokWord) or (TokenKind = tokSpace) or
       (TokenKind = tokChar)) then
	begin
	if fInTitle then
	    sTitle := sTitle + Result
	else if fInPsalmBookTitle then
	    sPsalmBookTitle := sPsalmBookTitle + Result
	else if fInHebrewTitle then
	    sHebrewTitle := sHebrewTitle + Result
	else if fInSectionTitle then
	    sSectionTitle := sSectionTitle + Result;
	end;
end;

function TWriteGBF.Init(const sFileName: string): boolean;
begin
    try
    bBk := 0;
    bChap := 0;
    bVs := 0;
    bWd := 0;
    LineOut := '';
    FName := sFileName;
    Assign(F, FName);
    filemode := 1;
    rewrite(F);
    fFileIsOpen := true;
    Init := true;
    except
    Init := false;
    fFileIsOpen := false;
    end
end;

function TWriteGBF.Done: boolean;
begin
    try
    if fFileIsOpen then
	begin
	if LineOut <> '' then
	    begin
	    WriteLn(F, LineOut);
	    LineOut := '';
	    end;
	CloseFile(F);
	end;
    Done := true;
    except
    Done := false;
    end;
end;

procedure TWriteGBF.Out(const s: string);
var sPrint, sSave, sBook, sChapter, sVerse: string;
    i: integer;
    b: byte;
begin
    if (Length(s) > 0) and IsLetter(s[1]) then
	begin
	inc(bWd);
	LineOut := LineOut + s;
	end
    else if Length(s) > 3 then
	begin
	if (s[1] = '<') and (s[2] = 'S') then
	    begin
	    case s[3] of
		'B': begin // Book
		     sBook := system.copy(s, 4, length(s)-4);
		     if sBook = '' then
			 begin
			 inc(bBk);
			 LineOut := LineOut + s;
			 end
		     else
			 begin
			 b := bBk;
			 bBk := BookNameToNumber(sBook);
			 if b <> bBk then
			     LineOut := LineOut + s;
			 end;
		     end;
		'C': begin //chapter
		     sChapter := system.copy(s, 4, length(s)-4);
		     if sChapter = '' then
			 begin
			 inc(bChap);
			 LineOut := LineOut + s;
			 end
		     else
			 begin
			 try
//			 b := bChap;
			 bChap := StrToInt(sChapter);
//			 if b <> bChap then
			     LineOut := LineOut + s;
			 except
			 showmessage('Non-numeric chapter: '+sBook+' '+sChapter);
			 end;
			 end;
		     end;
		'V': begin // Verse
		     bWd := 0;
		     sVerse := system.copy(s, 4, length(s)-4);
		     if sVerse = '' then
			 begin
			 inc(bVs);
			 LineOut := LineOut + s;
			 end
		     else
			 begin
			 try
//			 b := bVs;
			 bVs := StrToInt(sVerse);
//			 if b <> bVs then
			     LineOut := LineOut + s;
			 except
			 showmessage('Non-numeric verse: '+sBook+' '+sChapter+':'+sVerse);
			 end;
			 end;
		     end;
		else
		    LineOut := LineOut + s;
		end
	    end
	else
	    LineOut := LineOut + s; // Not a sync mark
	end
    else // other token, space, or punctuation
	LineOut := LineOut + s; // Length <= 3
    if ((s = '<CM>') or (s = '<CL>')) then
	begin
	if (Length(LineOut) > 78) then
	    begin
	    i := 78;
	    while (i > 0) and (LineOut[i] <> ' ') do
		dec(i);
	    if i < 1 then
		begin
		WriteLn(F,LineOut);
		LineOut := '';
		end
	    else
		begin
		sPrint := system.copy(LineOut,1,i-1);
		sSave := system.copy(LineOut,i+1,Length(LineOut)-i);
		WriteLn(F,sPrint);
		WriteLn(F, sSave);
		LineOut := '';
		end
	    end
	else
	    begin
	    WriteLn(F, LineOut);
	    LineOut := '';
	    end
	end
    else if (Length(LineOut) > 78) then
	begin
	i := 78;
	while (i > 0) and (LineOut[i] <> ' ') do
	    dec(i);
	if i < 1 then
	    begin
	    WriteLn(F,LineOut);
	    LineOut := '';
	    end
	else
	    begin
	    sPrint := system.copy(LineOut,1,i-1);
	    sSave := system.copy(LineOut,i+1,Length(LineOut)-i);
	    WriteLn(F,sPrint);
	    LineOut := sSave;
	    end
	end
end;

end.