summaryrefslogtreecommitdiff
path: root/macros/latex/contrib/bibarts/bibsort.c
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
committerNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
commite0c6872cf40896c7be36b11dcc744620f10adf1d (patch)
tree60335e10d2f4354b0674ec22d7b53f0f8abee672 /macros/latex/contrib/bibarts/bibsort.c
Initial commit
Diffstat (limited to 'macros/latex/contrib/bibarts/bibsort.c')
-rw-r--r--macros/latex/contrib/bibarts/bibsort.c7173
1 files changed, 7173 insertions, 0 deletions
diff --git a/macros/latex/contrib/bibarts/bibsort.c b/macros/latex/contrib/bibarts/bibsort.c
new file mode 100644
index 0000000000..9df9a577cb
--- /dev/null
+++ b/macros/latex/contrib/bibarts/bibsort.c
@@ -0,0 +1,7173 @@
+/* BibArts 2.2 assists you to write LaTeX texts in arts and humanities. */
+/* Copyright (C) 2019 Timo Baumann bibarts[at]gmx.de (2019/03/03) */
+
+/* This program is free software; you can redistribute it and/or modify */
+/* it under the terms of the GNU General Public License as published by */
+/* the Free Software Foundation; either version 2 of the License, or */
+/* (at your option) any later version. */
+
+/* This program is distributed in the hope that it will be useful, */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
+/* GNU General Public License for more details. */
+
+/* You should have received a copy of the GNU General Public License */
+/* along with this program; if not, write to the Free Software */
+/* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+
+
+/*
+ FILES OF THE PACKAGE AND DOCUMENTATION
+ CTAN mirrors > BibArts > bibarts.zip
+ bibarts.sty LaTeX style file
+ ba-short.pdf Short documentation (English)
+ ba-short.tex Source of ba-short.pdf
+ bibarts.pdf Full documentation (German)
+ bibarts.tex Source of bibarts.pdf
+ bibsort.exe Binary to create the lists
+ bibsort.c This file; source of bibsort.exe
+ COPYING The license of the package
+ */
+
+
+
+/*
+ COMPATIBILITY
+ I have tested bibsort.c with several C compilers. I had problems with
+ the devcpp.exe EDITOR (Dev-Cpp_5.4.0_TDM-GCC_x64_4.7.1). Sucessful was:
+ "C:\Program Files (x86)\Dev-Cpp\MinGW64\bin\gcc.exe" -O2 -c bibsort.c -o bibsort.o
+ "C:\Program Files (x86)\Dev-Cpp\MinGW64\bin\gcc.exe" bibsort.o -o bibsort.exe
+
+ Do NOT change this file when you do not have a qualified text
+ editor - it contains control chars: '', '', '', '', | Are the
+ '', '', '', ' ', ' ', '', '', '', '', '', '', | |'s in
+ '', '', '', '', '', '', '', '', '', and ''. | a line?
+
+ The C-compiled binary of this file is reading LaTeX .aux files.
+ It can NOT read the .bar files, which BibArts did use before 2.0.
+ BibArts 2.2 ONLY has an EMULATION for 1.3 texts: Keep copies of 1.x?
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <time.h>
+
+
+
+
+#define MAXLINES 65536
+#define MAXLEN 4096
+#define MAXFILES 128
+#define MAXFILENAMLEN 1024
+
+#define AUX_SUFFIX ".aux"
+#define VLI_SUFFIX ".vli"
+#define VQU_SUFFIX ".vqu"
+#define VKC_SUFFIX ".vkc"
+#define ABK_SUFFIX ".abk"
+#define PER_SUFFIX ".per"
+#define ARQ_SUFFIX ".arq"
+#define GRR_SUFFIX ".grr"
+#define PRR_SUFFIX ".prr"
+#define SRR_SUFFIX ".srr"
+
+#define IKILLNAME "\\Ikillname{}" /* -K: Damit wird ARG1 und ARG2 einer */
+ /* Zeile ersetzt, falls diese in der */
+ /* vorausgehenden Zeile gleich sind; */
+#define NKILLNAME "\\killname{}" /* ... und weitere gleiche Namen. */
+#define PLURALCHAR 'P' /* "\\Pkillname{}" */
+#define MALE "\\male"
+#define FEMALE "\\female"
+#define NOTDOT "\\banotdot"
+#define HASDOT "\\bahasdot"
+#define RELAX "\\relax" /* Auch um folgende spaces zu ignorieren */
+#define TeXITEM "\\item"
+#define TYPEOUT "\\typeout@ba"
+#define IeC "\\IeC\t"
+#define PREPARESPACE "\\bibsortpreparespace"
+#define PREPAREXSPACE "\\bibsortpreparexspace"
+#define PREPAREHEAD "\\bibsortpreparehead"
+
+#define ABKDEF "\\abkdef"
+
+#define BAFALSE "{false}"
+
+
+#define NOKILLAUTHORS 0
+#define DOKILLAUTHORS 1
+#define DOKILLABBREVS 2
+#define DOKILLREGISTS 3
+#define DOKILLK 4
+
+#define OPENB "\'{\'"
+#define NUMLEN 16
+
+int ignorespaces = 0;
+int hy_as_space = 0;
+ int kill = NOKILLAUTHORS;
+int registpoints = 0;
+char *lineptr[MAXLINES];
+
+int FntIndexOverPages = 1; /* new in 2.2 */
+
+#define PCOLS 2
+#define PCOLSSORT 1
+#define ACOLS 2
+#define ACOLSSORT 1
+#define KCOLS 4
+#define VCOLS 4
+#define IS_Q 2
+#define IS_V 1
+#define NO_V 0
+#define MAXBACOLS 4
+char *subAptr[MAXBACOLS][MAXLINES];
+char *subBptr[MAXBACOLS][MAXLINES];
+char *subCptr[MAXBACOLS][MAXLINES];
+
+#define PROTECT "\\protect"
+#define KTIT "\\ktit"
+#define KTITCMD "\\ktit\t"
+#define ANNOUNCEKTIT "\\announcektit"
+#define KURZ "\\kurz"
+#define KURZCMD "\\outkurz\t"
+#define KTITINTRO "\t"
+#define KTITINTROCH '\t'
+#define KTITERRORCH '\?' /* Insert ?? for bad inner \ktit */
+#define KTITSHA "\t<"
+#define KTITMISS "\t|"
+#define KTITEMPTY "\t>"
+#define KTITBEG "{"
+#define KTITEND "}"
+#define KTITOP '{'
+#define KTITCL '}'
+int otherktiterr = -1;
+
+#define ACCEPTLINE 0
+#define REJECTLINE 1
+#define DOUBLELINE 2 /* \ */
+#define DIFFERLINE 3 /* Erst ***nach*** */
+#define UNDEFILINE 4 /* QQsort vergeben */
+#define ABBREVLINE 5 /* / */
+#define REDEF1LINE 6
+#define REDEF2LINE 7
+int leval[MAXLINES];
+
+#define BARESTCOLS 5
+#define PAGEFNTCOL 1
+#define PAGECOL BARESTCOLS
+#define FNTCOL (BARESTCOLS+1)
+#define BAALLRCOLS (BARESTCOLS+2)
+char *subRptr[BAALLRCOLS][MAXLINES];
+int pagewgt[MAXLINES];
+int fntwgt[MAXLINES];
+
+#define STUFFRCOL 0
+#define KENTRY 0
+#define VENTRY 1
+#define ERRENTRY 2
+#define VENTRYCH 'v'
+#define KENTRYCH 'k'
+
+#define ERRINPUTLINENO "line \?\?"
+#define ERRINPUTLINENOLEN 7
+
+#define OVERFLOWTXT "Counter too large"
+ /* vgl. -> "\\errmessage\t" */
+#define MISSINGSYMB "\\erri@ba"
+#define MISSINGERMS "??"
+#define OVERFLOWSYMB "()"
+#define EMPTYSYMB "[]"
+char *TEXTSYMBOPEN[] = { "\\{{", "{", NULL };
+char *TEXTSYMBCLOSE[] = { "\\/}\\}", "\\/}", NULL };
+int notext = 0;
+
+int dqsort[MAXLINES];
+#define MINCATCODE 0
+#define MAXCATCODE 15
+#define ERRCATCODE MINCATCODE-1
+const char bareststr[] = "{}{}[][]()";
+#define DQCOL 2
+#define TeXACTIVE 13
+#define TeXPASSIVE 12
+#define LANCOL 3
+#define GERMANTEX "\\bagermanTeX" /* err-def ist \bagermanTeX#1{} */
+#define ORIGINALTEX "\\baoriginalTeX" /* err-def ist \baoriginalTeX#1{} */
+#define HYPHENATION "\\language="
+#define LINECOL 4
+#define OLDBIGROMAN "\\uppercase"
+#define NEWFNSYMBOL "\\ensuremath"
+#define TOMFNSYMBOL "\\TextOrMath"
+#define TEXFILELINE "\\line@ba"
+
+#define BS_SPACE "\\ "
+#define BANCOMMA ", "
+#define BAINDEXFIRS " \\first@baidx{"
+#define BAINDEXFOLL " \\follo@baidx{"
+#define BAINDEXEND "}\n"
+#define CLOOPASTART -1
+#define CLOOPBSTART 0
+#define BAINDEXLEN 45
+
+
+#define BADNUM 0
+#define GOODNUM 1
+#define CHECKNUM 0
+#define ANALYZENUM 1
+#define HASOFLOW 0
+#define HASNOOFLOW 1
+
+#define MAXMESSN 10
+#define MAXINFO 10
+
+FILE *infile, *outfile;
+char *filelist[MAXFILES];
+
+int upperascii = 0;
+int german = 0;
+int nogsty = 0;
+int encode = 0;
+int EinlROEMseiten = 0;
+#define BA_FALSE 0
+#define BA_TRUE 1
+ int get_R_pg = BA_FALSE;
+ int get_A_pg = BA_FALSE;
+ int get_r_pg = BA_FALSE;
+ int get_a_pg = BA_FALSE;
+int ALPHmpfootnotes = 0;
+ int get_R_fn = BA_FALSE;
+ int get_A_fn = BA_FALSE;
+ int get_r_fn = BA_FALSE;
+ int get_a_fn = BA_FALSE;
+int igleichj = 0;
+
+#define METALINEHEAD "%%%%META%%%%"
+
+
+int bago = 0; /* new in 2.2 */
+#define BAGOCMD "\\bago"
+
+char *soptarg = NULL;
+char *foptarg = NULL;
+
+void print_two(int line, int left, int right);
+int isLaTeXcmdletter(char a);
+int entkerne_IeC(char buf[], const char *s);
+
+char *mydefault = "";
+char *nofnt = "(nofnt)"; /* nur "" wuerde Fehler machen */
+char *unused = "(unused)";
+void myfree(char *p) { if (p != mydefault && p != nofnt && p != unused && p != NULL) free(p); }
+
+
+void openfailed(const char *s)
+{
+ fprintf(stderr, "%%%% == Failed to open \"%s\". ==\n", s);
+}
+
+
+void intern_err(int n)
+{
+ printf("%%%%\n%%%%> INTERNAL ERROR %d\n", n);
+}
+
+
+void announceexit(const char *s)
+{
+ fprintf(stderr, "%%%%> I give up my job, because I %s.\n", s);
+}
+
+
+int mystrncpy(char *p, const char *s, int len)
+{
+ int l = 0, ll;
+
+ while(*s != '\0' && l < len)
+ {
+ *p++ = *s++;
+ ++l;
+ }
+
+ *p = '\0'; /* handle error: len < 0 */
+
+ ll = l;
+ while (ll <= len)
+ {
+ *p++ = '\0';
+ ++ll;
+ }
+
+ return l;
+}
+
+
+char *strnmalloc(const char *q, int len)
+{ char *p = mydefault;
+ int l = 0;
+ if (len < 1) { intern_err(0); len = 1; } /* mallocError len */
+ p = (char *) malloc(len);
+ if (p == NULL)
+ {
+ printf("%%%%\n%%%%> Error: Not enough memory.\n");
+ announceexit("could not alloc enough memory");
+ exit(1);
+ }
+ else l = mystrncpy(p, q, len-1);
+ if (l != len-1) intern_err(1); /* alloc len l != len-1 */
+ return p;
+}
+#define HASFNTCH '@'
+#define HASUNUCH '-'
+
+
+/*--------------------------------------------------------------------------*/
+
+
+char *getmyname(char *p, int max)
+{
+ char *m = p;
+ int pos = strlen(p);
+
+ if (pos > max)
+ while(*p != '\0')
+ {
+ if (*p == '/' || *p == '\\')
+ {
+ m = p+1;
+ if (pos <= max) break;
+ }
+ ++p; --pos;
+ }
+ return m;
+}
+
+
+void licenseinfo(void)
+{
+ printf("%%%% I guess that I am a bin-compilation of bibsort.c. My job is to read\n");
+ printf("%%%% entries in LaTeX %s files which are made by bibarts.sty. Use e.g.\n", AUX_SUFFIX);
+ printf("%%%% \\vli{FirstName}{FamilyName}{BookTitle, Year} and \\printvli in your\n");
+ printf("%%%% .tex file. For usage, see ba-short.pdf (engl) or bibarts.pdf (ger).\n");
+ printf("%%%%\n");
+ printf("%%%% This program is free software; you can redistribute it and/or modify\n");
+ printf("%%%% it under the terms of the GNU General Public License as published by\n");
+ printf("%%%% the Free Software Foundation; either version 2 of the License, or\n");
+ printf("%%%% (at your option) any later version.\n");
+ printf("%%%%\n");
+ printf("%%%% This program is distributed in the hope that it will be useful,\n");
+ printf("%%%% but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
+ printf("%%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n");
+ printf("%%%% GNU General Public License for more details.\n");
+ printf("%%%%\n");
+ printf("%%%% You should have received a copy of the GNU General Public License\n");
+ printf("%%%% along with this program; if not, write to the Free Software\n");
+ printf("%%%% Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n");
+ printf("%%%%\n");
+}
+
+
+void moreinfo(void)
+{
+ printf("%%%% -t1 You use [T1]{fontenc} and NO [...]{inputenc}: I sort ASCIIs > 127.\n");
+ printf("%%%% -m Write into files the meta arguments which I use to sort lines.\n");
+ printf("%%%% -b If %s is in an arg, only text behind will have a sorting weight.\n", BAGOCMD);
+ printf("%%%% -n1 You reset fnt counters (no fnt-block-indexing over several pages).\n");
+ printf("%%%% INDEX TO PAGE AND FOOTNOTE NUMBERS (num-lists like \\printnumvkc):\n");
+ printf("%%%% (1) DEFAULT SORTING ORDER of page and footnote numbers:\n");
+ printf("%%%% fnsymbol r/Roman arabic a/Alph (z=26, aa=27, ab=28)\n");
+ printf("%%%% You may change the EVALUATION ORDER (r/Roman versus a/Alph):\n");
+ printf("%%%% / introduction = *lower roman page numbers*\n");
+ printf("%%%% DEFAULT < appendix = *capital Alph page numbers*\n");
+ printf("%%%% \\ minipages = *lower alph footnote numbers*\n");
+ printf("%%%% -s1 EVALUATE \'I\' as 1 in pages (intro Roman, appendix alph).\n");
+ printf("%%%% -f1 EVALUATE \'i\' as 1 in fnts (evaluate on roman before alph).\n");
+ printf("%%%% (2) NON-DEFAULT SORTING ORDER with an EVALUATION affixed to that order:\n");
+ printf("%%%% -s2 <xxxx> Page number style: -f2 <xxxx> Footnote mark style:\n");
+ printf("%%%% with a permutation of 4 letters out of nRrAas in free order\n");
+ printf("%%%% (a=alph, A=Alph, n=arabic, R=Roman, r=roman, s=fnsymbol);\n");
+ printf("%%%% but in <xxxx>, there must be n, s, and R *or* A, and r *or* a.\n");
+ printf("%%%%\n");
+}
+
+
+void maininfo(char *myname)
+{
+ printf("%%%% I read a LaTeX %s file (follow \\@input), and I write my output in files\n", AUX_SUFFIX);
+ printf("%%%% %s Literature %s Published sources %s Geographic index\n", VLI_SUFFIX, VQU_SUFFIX, GRR_SUFFIX);
+ printf("%%%% %s Short titles %s Unpublished sources %s Person index\n", VKC_SUFFIX, ARQ_SUFFIX, PRR_SUFFIX);
+ printf("%%%% %s Periodicals %s Abbreviations %s Subject index\n", PER_SUFFIX, ABK_SUFFIX, SRR_SUFFIX);
+ printf("%%%%\n");
+ printf("%%%% %s <LaTeXFile> [-o <OutFile>] [-g1 [OR] -g2] [<OtherOptions>]\n", getmyname(myname, 13));
+ printf("%%%%\n");
+ printf("%%%% DefaultSort: 0, .., 9, (A a), (B b), .., (s \\ss S), .., (Z z) and\n"); /* udtable */
+ printf("%%%% (a [\\.\\'\\`\\^\\\"\\=\\~]a \\aa=\\r{a} [\\b\\c\\k\\d\\H\\t\\u\\v]{a} \\ae), b, ..\n");
+ printf("%%%% -g<n> GermanSort: (a A), .., (z Z), 0, .., 9; and (\\\" or active \"):\n");
+ printf("%%%% -g1 GermanTelefonebookStyle: \"a = \\\"a = ae, ..., \"s = \\ss = ss;\n"); /* gweight */
+ printf("%%%% -g2 ModernGermanDictionary: \"a = \\\"a = a, ..., \"s = \\ss = ss.\n"); /* mweight */
+ printf("%%%% -x DoNotExpect german.sty: Active \"-characters do NOT produce umlauts.\n");
+ printf("%%%% -k Idemize ~ multiple used authors in the %s and %s lists (kill).\n", VLI_SUFFIX, VQU_SUFFIX);
+ printf("%%%% -d \\include{ / is \\ } (dos). -h Sort a hyphen as a space.\n");
+ printf("%%%% -i=j Sort \'i\' as \'j\'. -p Sort \"P.S.\" before \"Peter\" (point).\n");
+ printf("%%%% -l Ignore spaces (leer). -c Don\'t set bad page/fnt nums in {}.\n"); /* TEXTSYMBOPEN[0], TEXTSYMBCLOSE[0] */
+ printf("%%%% -r Typeout license (read). -\?\? Further options.\n");
+ printf("%%%%\n");
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+int isexactlcmd(const char *p, const char *s)
+{
+ while(*p == *s && *s != '\t' && *s != '\0' ) { ++p; ++s; }
+ if (*s == '\t' && isLaTeXcmdletter(*p) == 0) return 0;
+ return 1;
+}
+
+
+int num_of_cmds_in_str(const char *p, const char *s)
+{
+ int r = 0;
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\') ++p;
+ else
+ if (isexactlcmd(p, s) == 0) ++r;
+ }
+ ++p;
+ }
+
+ return r;
+}
+
+
+int nextbracket(const char *p, const char opench, const char closech)
+{
+ int c = 0, r = 0;
+
+ while (*p != '\0')
+ {
+ if (*p == '\\' && *(p+1) != '\0') { ++p; ++r; }
+ else if (*p == opench) ++c;
+ else if (*p == closech) --c;
+ ++p; ++r;
+ if (c == 0) break;
+ }
+
+ if (c != 0) r = -r;
+
+ return r;
+}
+
+
+int unshielded_cmds_in_str(const char *p, const char *s)
+{
+ int r = 0;
+
+ while (*p != '\0')
+ {
+ if (*p == '{') p += nextbracket(p, '{', '}') - 1;
+ else
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\') ++p;
+ else
+ if (*(p+1) == '{') ++p;
+ else
+ if (isexactlcmd(p, s) == 0) ++r;
+ }
+ ++p;
+ }
+
+ return r;
+}
+
+
+int artithmetic_overflow(const char *p, const char *cc)
+{
+ printf("%%%%\n%%%%> Warning: Arithmetic overflow %s-eval \"%s\".\n", p, cc);
+
+ return INT_MAX;
+}
+
+
+int getarabicnum(const char *p)
+{
+ int num = 0, vor = 1;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if (*p == '-') { vor = -1; ++p; }
+
+ while (*p >= '0' && *p <= '9' && num >= 0)
+ num = (10 * num) + (*p++ - '0');
+
+ if (num < 0) num = artithmetic_overflow("arabic", mem);
+
+ return num * vor;
+}
+
+
+int firstoverlettergan(const char *p)
+{
+ while (*p == ' ' || isalpha(*p) != 0) ++p;
+
+ return getarabicnum(p);
+}
+
+
+int secondoverlettergan(const char *p)
+{
+ while (*p == ' ' || isalpha(*p) != 0) ++p;
+ while (*p >= '0' && *p <= '9') ++p;
+ while (*p == ' ' || isalpha(*p) != 0) ++p;
+
+ return getarabicnum(p);
+}
+
+
+int getLetterletternum(const char *p)
+{
+ int num = 0, vor = 1;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if (*p == '-') { vor = -1; ++p; }
+
+ while (num >= 0)
+ {
+ if (*p >= 'A' && *p <= 'Z') num = (26 * num) + (*p++ - 'A' + 1);
+ else if (*p >= 'a' && *p <= 'z') num = (26 * num) + (*p++ - 'a' + 1);
+ else break;
+ }
+
+ if (num < 0) num = artithmetic_overflow("a/Alph", mem);
+
+ return num * vor;
+}
+
+
+int getRomanromannum(const char *p)
+{
+ int val = 0, nextval, num = 0, vor = 1;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if (*p == '-') { vor = -1; ++p; }
+
+ while (*p != '\0' && num >= 0)
+ {
+ if (*p == 'i' || *p == 'I') val = 1;
+ else if (*p == 'v' || *p == 'V') val = 5;
+ else if (*p == 'x' || *p == 'X') val = 10;
+ else if (*p == 'l' || *p == 'L') val = 50;
+ else if (*p == 'c' || *p == 'C') val = 100;
+ else if (*p == 'd' || *p == 'D') val = 500;
+ else if (*p == 'm' || *p == 'M') val = 1000;
+ else break;
+
+ if (*(p+1) == '\0') nextval = 0;
+ else if (*(p+1) == 'i' || *(p+1) == 'I') nextval = 1;
+ else if (*(p+1) == 'v' || *(p+1) == 'V') nextval = 5;
+ else if (*(p+1) == 'x' || *(p+1) == 'X') nextval = 10;
+ else if (*(p+1) == 'l' || *(p+1) == 'L') nextval = 50;
+ else if (*(p+1) == 'c' || *(p+1) == 'C') nextval = 100;
+ else if (*(p+1) == 'd' || *(p+1) == 'D') nextval = 500;
+ else if (*(p+1) == 'm' || *(p+1) == 'M') nextval = 1000;
+ else nextval = 0;
+
+ if (nextval > val) { num = num - val + nextval; ++p; }
+ else num = num + val;
+
+ ++p;
+ }
+
+ if (num < 0) num = artithmetic_overflow("r/Roman", mem);
+
+ return num * vor;
+}
+
+/*--------------------------------------------------------------------------*/
+
+
+int has_o_flow(const char *p)
+{
+ int r = HASNOOFLOW;
+
+ if (isinstr(p, OVERFLOWTXT) == 1) r = HASOFLOW;
+
+ return r;
+}
+
+
+int endnumberline(const char *p, int r)
+{
+ int len = strlen(RELAX);
+
+ while (*p == ' ') ++p;
+ if (*p == '}') ++p;
+ while (strncmp(p, RELAX, len) == 0) p+=len;
+ while (*p == ' ') ++p;
+
+ if (*p != '\0') r = BADNUM;
+
+ return r;
+}
+
+
+/* ALT */
+/* "*\relax " */ /* 1 */
+/* "\dagger \relax " */ /* 2 */
+/* "\ddagger \relax " */ /* 3 */
+/* "\mathchar "278\relax " */ /* 4 */
+/* "\mathchar "27B\relax " */ /* 5 */
+/* "\delimiter "26B30D \relax " */ /* 6 */
+/* "**\relax " */ /* 7 */
+/* "\dagger \dagger \relax " */ /* 8 */
+/* "\ddagger \ddagger \relax " */ /* 9 */
+
+/* NEU */
+/* "*" */ /* 1 */
+/* "\dagger " */ /* 2 */
+/* "\ddagger " */ /* 3 */
+/* "\mathchar "278" */ /* 4 */
+/* "\mathchar "27B" */ /* 5 */
+/* "\delimiter "026B30D " */ /* 6 */
+/* "**" */ /* 7 */
+/* "\dagger \dagger " */ /* 8 */
+/* "\ddagger \ddagger " */ /* 9 */
+
+/* GANZ NEU */
+/* "\ensuremath {*}" */ /* 1 */
+/* "\ensuremath {\dagger }" */ /* 2 */
+/* "\ensuremath {\ddagger }" */ /* 3 */
+/* "\ensuremath {\mathsection }" */ /* 4 */
+/* "\ensuremath {\mathparagraph }" */ /* 5 */
+/* "\ensuremath {\delimiter "026B30D }" */ /* 6 */
+/* "\ensuremath {**}" */ /* 7 */
+/* "\ensuremath {\dagger \dagger }" */ /* 8 */
+/* "\ensuremath {\ddagger \ddagger }" */ /* 9 */
+
+/* NOCH NEUER */
+/* \TextOrMath {\textasteriskcentered }{*} */ /* 1 */
+/* \TextOrMath {\textdagger }{\dagger } */ /* 2 */
+/* \TextOrMath {\textdaggerdbl }{\ddagger } */ /* 3 */
+/* \TextOrMath {\textsection }{\mathsection } */ /* 4 */
+/* \TextOrMath {\textparagraph }{\mathparagraph } */ /* 5 */
+/* \TextOrMath {\textbardbl }{\delimiter "026B30D } */ /* 6 */
+/* \TextOrMath {\textasteriskcentered \textasteriskcentered }{**} */ /* 7 */
+/* \TextOrMath {\textdagger \textdagger }{\dagger \dagger } */ /* 8 */
+/* \TextOrMath {\textdaggerdbl \textdaggerdbl }{\ddagger \ddagger } */ /* 9 */
+
+
+
+int nextsymbolnum(int oldnum, int beginnum)
+{
+ if (oldnum == 0) return beginnum;
+ else return oldnum + 6;
+}
+
+
+int len_tom(const char *p)
+{
+ int len, r = 0;
+
+ if (lcmdcmp(p, TOMFNSYMBOL) == 0)
+ {
+ p += (r=strlen(TOMFNSYMBOL));
+
+ while (*p == ' ') { ++p; ++r; }
+
+ if (*p == '{')
+ {
+ /* erstes Arg von NOCH NEUER */
+ len = nextbracket(p, '{', '}');
+ if (len > 1)
+ { r += len;
+ }
+ else r = 0;
+ }
+ else r = 0;
+ }
+
+ return r;
+}
+
+
+int evalsymbol(int pg, const char *p, const int job)
+{
+ int r = BADNUM, num = 0, len, cmdtyp = 0, cmd = 0, vor = 1;
+ const char *mem;
+
+ while (*p == ' ') ++p;
+
+ if (pg == 1)
+ {
+ if (lcmdcmp(p, NEWFNSYMBOL) == 0)
+ p += strlen(NEWFNSYMBOL);
+ else p += len_tom(p);
+ }
+
+ while (*p == ' ') ++p;
+ if (*p == '{') ++p;
+ mem = p;
+
+ if (*p == '-') { vor = -1; ++p; }
+
+ while (num >= 0)
+ {
+ if ((cmd == 0 || cmd == 6) && cmdtyp < 2 && strncmp(p, "\\delimiter", (len=strlen("\\delimiter"))) == 0)
+ {
+ r = BADNUM; /* folgen muessen \"26B30D oder \"026B30D */
+ cmdtyp = 2; /* cmd == 6 cmd == 6 */
+ }
+ else if ((cmd == 0 || cmd == 6) && cmdtyp == 2 && strncmp(p, "\"26B30D", (len=strlen("\"26B30D"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 6));
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 6) && cmdtyp == 2 && strncmp(p, "\"026B30D", (len=strlen("\"026B30D"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 6)); /* ebenfalls */
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 4 || cmd == 5) && cmdtyp < 2 && strncmp(p, "\\mathchar", (len=strlen("\\mathchar"))) == 0)
+ {
+ r = BADNUM; /* folgen muessen \"27B oder \"278 */
+ cmdtyp = 3; /* cmd == 5 cmd == 4 */
+ }
+ else if ((cmd == 0 || cmd == 5) && cmdtyp == 3 && strncmp(p, "\"27B", (len=strlen("\"27B"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 5));
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 5) && cmdtyp < 2 && strncmp(p, "\\mathparagraph", (len=strlen("\\mathparagraph"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 5));
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 4) && cmdtyp == 3 && strncmp(p, "\"278", (len=strlen("\"278"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 4));
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 4) && cmdtyp < 2 && strncmp(p, "\\mathsection", (len=strlen("\\mathsection"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 4));
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 3) && cmdtyp < 2 && strncmp(p, "\\ddagger", (len=strlen("\\ddagger"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 3));
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 2) && cmdtyp < 2 && strncmp(p, "\\dagger", (len=strlen("\\dagger"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 2));
+ cmdtyp = 1;
+ }
+ else if ((cmd == 0 || cmd == 1) && cmdtyp < 2 && strncmp(p, "*", (len=strlen("*"))) == 0)
+ {
+ r = GOODNUM;
+ num = nextsymbolnum(num, (cmd = 1));
+ cmdtyp = 0;
+ }
+ else if (cmdtyp > 0 && *p == ' ') len=1;
+ else break;
+
+ p += len;
+ }
+
+ if (num < 0) num = artithmetic_overflow("fnsymbol", mem);
+
+ r = endnumberline(p, r);
+
+ if (job == CHECKNUM) return r;
+ else return num * vor;
+}
+
+
+int evalroman(const char *p, const int job)
+{
+ int r = BADNUM, num = 0;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if (*p == '-') ++p;
+
+ while (*p != '\0')
+ {
+ if ( *p == 'i'
+ || *p == 'v'
+ || *p == 'x'
+ || *p == 'l'
+ || *p == 'c'
+ || *p == 'd'
+ || *p == 'm'
+ )
+ { ++p;
+ r = GOODNUM;
+ }
+ else break;
+ }
+
+ r = endnumberline(p, r);
+
+ if (job != CHECKNUM && r == GOODNUM) num = getRomanromannum(mem);
+
+ if (job == CHECKNUM) return r;
+ else return num;
+}
+
+
+int evalRoman(const char *p, const int job)
+{
+ int r = BADNUM, num = 0, len = strlen(OLDBIGROMAN), vor = 1;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if ( strncmp(p, OLDBIGROMAN, len) == 0
+ || (*p == '-' && strncmp((p+1), OLDBIGROMAN, len) == 0)
+ )
+ {
+ if (*p == '-') { vor = -1; ++p; }
+ p += len;
+ while (*p == ' ') ++p;
+ if (*p == '{')
+ { ++p; /* kleine roem. Zahl, die gross gedruckt wird */
+ if (*p == '}') r = GOODNUM; /* OLDBIGROMAN + " {}" */
+ else
+ r = evalroman(p, CHECKNUM); /* Der job ist in jedem Fall checken */
+ if (vor < 0 && (*p == ' ' || *p == '-')) r = BADNUM;
+ mem = p;
+ }
+ else r = BADNUM;
+ }
+ else
+ {
+ if (*p == '-') ++p;
+
+ while (*p != '\0')
+ {
+ if ( *p == 'I'
+ || *p == 'V'
+ || *p == 'X'
+ || *p == 'L'
+ || *p == 'C'
+ || *p == 'D'
+ || *p == 'M'
+ )
+ { ++p;
+ r = GOODNUM;
+ }
+ else break;
+ }
+
+ r = endnumberline(p, r);
+ }
+
+ if (job != CHECKNUM && r == GOODNUM)
+ { num = getRomanromannum(mem);
+ if (num < 0 && vor < 0) r = BADNUM;
+ }
+
+ if (job == CHECKNUM) return r;
+ else return num * vor; /* vor == -1 von OLDBIGROMAN */
+}
+
+
+int evalarabic(const char *p, const int job)
+{
+ int r = BADNUM, num = 0;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if (*p == '-') ++p;
+
+ while (*p != '\0')
+ {
+ if ( *p >= '0'
+ && *p <= '9'
+ )
+ { ++p;
+ r = GOODNUM;
+ }
+ else break;
+ }
+
+ r = endnumberline(p, r);
+
+ if (job != CHECKNUM && r == GOODNUM) num = getarabicnum(mem);
+
+ if (job == CHECKNUM) return r;
+ else return num;
+}
+
+
+int evalletter(const char *p, const int job)
+{
+ int r = BADNUM, num = 0;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if (*p == '-') ++p;
+
+ while (*p != '\0')
+ {
+ if ( *p >= 'a'
+ && *p <= 'z'
+ )
+ { ++p;
+ r = GOODNUM;
+ }
+ else break;
+ }
+
+ r = endnumberline(p, r);
+
+ if (job != CHECKNUM && r == GOODNUM) num = getLetterletternum(mem);
+
+ if (job == CHECKNUM) return r;
+ else return num;
+}
+
+
+int evalLetter(const char *p, const int job)
+{
+ int r = BADNUM, num = 0;
+ const char *mem;
+
+ while (*p == ' ') ++p; mem = p;
+
+ if (*p == '-') ++p;
+
+ while (*p != '\0')
+ {
+ if ( *p >= 'A'
+ && *p <= 'Z'
+ )
+ { ++p;
+ r = GOODNUM;
+ }
+ else break;
+ }
+
+ r = endnumberline(p, r);
+
+ if (job != CHECKNUM && r == GOODNUM) num = getLetterletternum(mem);
+
+ if (job == CHECKNUM) return r;
+ else return num;
+}
+
+
+int isinstr(const char *p, const char *s)
+{
+ const char *pp, *ss;
+
+ while (*p != '\0')
+ {
+ pp = p; ss = s;
+ while (*pp == *ss && *pp != '\0') { ++pp; ++ss; }
+ if (*ss == '\0') return 1;
+ ++p;
+ }
+
+ return 0;
+}
+
+
+ /* Typen-Gewichtung nicht mit Abpruef-Reihenfolge verwechseln! */
+ /* Zahl fuer Typen-Gewichtung ist gleichzeitig Typen-Identifizierer. */
+ /* Abpruef-Reihenfolge legen pgnumberweight + fntnumberweight fest, */
+ /* die auch entscheiden, ob etwa DC=600 oder DC=4*3=12 gesehen wird. */
+ /* !! \uppercase{xx} = OLDBIGROMAN gilt NIE als Buchstabenzaehler !! */
+#define INTERNALERR 0
+#define UNUSED 1 /* muss anfuehren (kleinster Wert)! */
+#define NOFOOTNOTE 2
+#define EMPTYNUM 3 /* Alph, alph, Roman, roman, symbol < 1 */
+#define BEGINWEIGHT 4
+int pg_symbol = 4, fn_symbol = 4;
+int pg_smallroman = 5, fn_smallroman = 5;
+int pg_bigroman = 6, fn_bigroman = 6;
+int pg_arabic = 7, fn_arabic = 7;
+int pg_smallletter = 8, fn_smallletter = 8;
+int pg_bigletter = 9, fn_bigletter = 9;
+#define ENDWEIGHT 10
+#define TEXT 10
+#define MISSNUM 11 /* Beschaedigte Zeile */
+#define OVERFLOW 12
+
+int pgnumberweight(const char *p)
+{
+ int r = INTERNALERR; /* primaer i, ii, ..., 1, 2, ..., A, B, *C*, ... */
+
+
+ if ( get_R_pg == BA_TRUE
+ || get_A_pg == BA_TRUE
+ || get_a_pg == BA_TRUE
+ || get_r_pg == BA_TRUE
+ )
+ {
+ if (p == unused) r = UNUSED;
+ else if (p == mydefault) r = MISSNUM;
+ else if (p == nofnt) r = INTERNALERR;
+ else if (*p == '\0') r = EMPTYNUM;
+ else if (has_o_flow(p) == HASOFLOW) r = OVERFLOW;
+ else if (evalarabic(p, CHECKNUM) == GOODNUM) r = pg_arabic;
+ else if (get_R_pg == BA_TRUE && evalRoman (p, CHECKNUM) == GOODNUM) r = pg_bigroman;
+ else if (get_A_pg == BA_TRUE && evalLetter(p, CHECKNUM) == GOODNUM) r = pg_bigletter;
+ else if (get_a_pg == BA_TRUE && evalletter(p, CHECKNUM) == GOODNUM) r = pg_smallletter;
+ else if (get_r_pg == BA_TRUE && evalroman (p, CHECKNUM) == GOODNUM) r = pg_smallroman;
+ else if (evalsymbol(1, p, CHECKNUM) == GOODNUM) r = pg_symbol;
+ else r = TEXT;
+ }
+ else
+ if (EinlROEMseiten == 1)
+ {
+ if (p == unused) r = UNUSED;
+ else if (p == mydefault) r = MISSNUM;
+ else if (p == nofnt) r = INTERNALERR;
+ else if (*p == '\0') r = EMPTYNUM;
+ else if (has_o_flow(p) == HASOFLOW) r = OVERFLOW;
+ else if (evalarabic(p, CHECKNUM) == GOODNUM) r = pg_arabic;
+ else if (evalRoman (p, CHECKNUM) == GOODNUM) r = pg_bigroman;
+ else if (evalLetter(p, CHECKNUM) == GOODNUM) r = pg_bigletter;
+ else if (evalletter(p, CHECKNUM) == GOODNUM) r = pg_smallletter;
+ else if (evalroman (p, CHECKNUM) == GOODNUM) r = pg_smallroman;
+ else if (evalsymbol(1, p, CHECKNUM) == GOODNUM) r = pg_symbol;
+ else r = TEXT;
+ }
+ else
+ {
+ if (p == unused) r = UNUSED;
+ else if (p == mydefault) r = MISSNUM;
+ else if (p == nofnt) r = INTERNALERR;
+ else if (*p == '\0') r = EMPTYNUM;
+ else if (has_o_flow(p) == HASOFLOW) r = OVERFLOW;
+ else if (evalarabic(p, CHECKNUM) == GOODNUM) r = pg_arabic;
+ else if (evalroman (p, CHECKNUM) == GOODNUM) r = pg_smallroman;
+ else if (evalletter(p, CHECKNUM) == GOODNUM) r = pg_smallletter;
+ else if (evalLetter(p, CHECKNUM) == GOODNUM) r = pg_bigletter;
+ else if (evalRoman (p, CHECKNUM) == GOODNUM) r = pg_bigroman;
+ else if (evalsymbol(1, p, CHECKNUM) == GOODNUM) r = pg_symbol;
+ else r = TEXT;
+ }
+
+ /* OLDBIGROMAN + " {}" */
+ if (r == pg_bigroman && evalRoman (p, ANALYZENUM) == 0) r = EMPTYNUM;
+
+ return r;
+}
+
+
+int fntnumberweight(const char *p)
+{
+ int r = INTERNALERR; /* primaer I, II, ..., 1, 2, ..., a, b, *c*, ... */
+
+
+ if ( get_R_fn == BA_TRUE
+ || get_A_fn == BA_TRUE
+ || get_a_fn == BA_TRUE
+ || get_r_fn == BA_TRUE
+ )
+ {
+ if (p == mydefault) r = MISSNUM;
+ else if (p == nofnt) r = NOFOOTNOTE;
+ else if (p == unused) r = INTERNALERR;
+ else if (*p == '\0') r = EMPTYNUM;
+ else if (has_o_flow(p) == HASOFLOW) r = OVERFLOW;
+ else if (evalarabic(p, CHECKNUM) == GOODNUM) r = fn_arabic;
+ else if (get_r_fn == BA_TRUE && evalroman (p, CHECKNUM) == GOODNUM) r = fn_smallroman;
+ else if (get_a_fn == BA_TRUE && evalletter(p, CHECKNUM) == GOODNUM) r = fn_smallletter;
+ else if (get_A_fn == BA_TRUE && evalLetter(p, CHECKNUM) == GOODNUM) r = fn_bigletter;
+ else if (get_R_fn == BA_TRUE && evalRoman (p, CHECKNUM) == GOODNUM) r = fn_bigroman;
+ else if (evalsymbol(0, p, CHECKNUM) == GOODNUM) r = fn_symbol;
+ else r = TEXT;
+ }
+ else
+ if (ALPHmpfootnotes == 1)
+ {
+ if (p == mydefault) r = MISSNUM;
+ else if (p == nofnt) r = NOFOOTNOTE;
+ else if (p == unused) r = INTERNALERR;
+ else if (*p == '\0') r = EMPTYNUM;
+ else if (has_o_flow(p) == HASOFLOW) r = OVERFLOW;
+ else if (evalarabic(p, CHECKNUM) == GOODNUM) r = fn_arabic;
+ else if (evalroman (p, CHECKNUM) == GOODNUM) r = fn_smallroman;
+ else if (evalletter(p, CHECKNUM) == GOODNUM) r = fn_smallletter;
+ else if (evalLetter(p, CHECKNUM) == GOODNUM) r = fn_bigletter;
+ else if (evalRoman (p, CHECKNUM) == GOODNUM) r = fn_bigroman;
+ else if (evalsymbol(0, p, CHECKNUM) == GOODNUM) r = fn_symbol;
+ else r = TEXT;
+ }
+ else
+ {
+ if (p == mydefault) r = MISSNUM;
+ else if (p == nofnt) r = NOFOOTNOTE;
+ else if (p == unused) r = INTERNALERR;
+ else if (*p == '\0') r = EMPTYNUM;
+ else if (has_o_flow(p) == HASOFLOW) r = OVERFLOW;
+ else if (evalarabic(p, CHECKNUM) == GOODNUM) r = fn_arabic;
+ else if (evalRoman (p, CHECKNUM) == GOODNUM) r = fn_bigroman;
+ else if (evalLetter(p, CHECKNUM) == GOODNUM) r = fn_bigletter;
+ else if (evalletter(p, CHECKNUM) == GOODNUM) r = fn_smallletter;
+ else if (evalroman (p, CHECKNUM) == GOODNUM) r = fn_smallroman;
+ else if (evalsymbol(0, p, CHECKNUM) == GOODNUM) r = fn_symbol;
+ else r = TEXT;
+ }
+
+ /* OLDBIGROMAN + " {}" */
+ if (r == fn_bigroman && evalRoman (p, ANALYZENUM) == 0) r = EMPTYNUM;
+
+ return r;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+int issonder(const char p)
+{
+ if (p > '\0' && p < ' ') return 1;
+ return 0;
+}
+
+
+ /* Neugewichtung der Ascii-Zeichen 33 und 48 bis 126. */
+
+ /* Im Deutschen werden Zeichen vor Buchstaben und */
+ /* Buchstaben vor Zahlen einsortiert. */
+ /* Im Konfliktfall stehen Kleinbuchstaben vor grossen. */
+
+int bewerten(char zz)
+{
+ switch(zz)
+ {
+ case '\0': return 0;
+
+ case ' ': return 32; /* ASCII 32 \ / normales Leerzeichen */
+ case '~': return 33; /* ASCII 126 / \ geschuetztes Leereichen */
+
+ case '!': return 48; /* ASCII 33 \ */
+ case ':': return 49; /* ASCII 58 | */
+ case ';': return 50; /* ASCII 59 | */
+ case '<': return 51; /* ASCII 60 | */
+ case '=': return 52; /* ASCII 61 | */
+ case '>': return 53; /* ASCII 62 | */
+ case '\?':return 54; /* ASCII 63 | */
+ case '@': return 55; /* ASCII 64 | */
+ case '[': return 56; /* ASCII 91 \ */
+ case ']': return 57; /* ASCII 93 > Zeichen vor Buchstaben */
+ /* / */
+ case '^': return 58; /* ASCII 94 | */
+ case '_': return 59; /* ASCII 95 | */
+ case '`': return 60; /* ASCII 96 | */
+ /* | */
+ case '{': return 61; /* ASCII 123 | */
+ case '|': return 62; /* ASCII 124 | */
+ case '}': return 63; /* ASCII 125 / */
+
+ case 'a': return 64; /* ASCII 97 \ */
+ case 'A': return 65; /* ASCII 65 | */
+ case 'b': return 66; /* ASCII 98 | */
+ case 'B': return 67; /* ASCII 66 | */
+ case 'c': return 68; /* ASCII 99 | */
+ case 'C': return 69; /* ASCII 67 | */
+ case 'd': return 70; /* ASCII 100 | */
+ case 'D': return 71; /* ASCII 68 | */
+ case 'e': return 72; /* ASCII 101 | */
+ case 'E': return 73; /* ASCII 69 | */
+ case 'f': return 74; /* ASCII 102 | */
+ case 'F': return 75; /* ASCII 70 | */
+ case 'g': return 76; /* ASCII 103 | */
+ case 'G': return 77; /* ASCII 71 | */
+ case 'h': return 78; /* ASCII 104 | */
+ case 'H': return 79; /* ASCII 72 | */
+ case 'i': return 80; /* ASCII 105 | */
+ case 'I': return 81; /* ASCII 73 | */
+ case 'j': return 82; /* ASCII 106 | */
+ case 'J': return 83; /* ASCII 74 | */
+ case 'k': return 84; /* ASCII 107 | */
+ case 'K': return 85; /* ASCII 75 | */
+ case 'l': return 86; /* ASCII 108 | */
+ case 'L': return 87; /* ASCII 76 | */
+ case 'm': return 88; /* ASCII 109 | */
+ case 'M': return 89; /* ASCII 77 | */
+ case 'n': return 90; /* ASCII 110 | */
+ case 'N': return 91; /* ASCII 78 | */
+ case 'o': return 92; /* ASCII 111 | */
+ case 'O': return 93; /* ASCII 79 | */
+ case 'p': return 94; /* ASCII 112 \ */
+ case 'P': return 95; /* ASCII 80 > Buchstaben: a, A, ... */
+ case 'q': return 96; /* ASCII 113 / */
+ case 'Q': return 97; /* ASCII 81 | */
+ case 'r': return 98; /* ASCII 114 | */
+ case 'R': return 99; /* ASCII 82 | */
+ case 's': return 100; /* ASCII 115 | */
+ case 'S': return 101; /* ASCII 83 | */
+ case 't': return 102; /* ASCII 116 | */
+ case 'T': return 103; /* ASCII 84 | */
+ case 'u': return 104; /* ASCII 117 | */
+ case 'U': return 105; /* ASCII 85 | */
+ case 'v': return 106; /* ASCII 118 | */
+ case 'V': return 107; /* ASCII 86 | */
+ case 'w': return 108; /* ASCII 119 | */
+ case 'W': return 109; /* ASCII 87 | */
+ case 'x': return 110; /* ASCII 120 | */
+ case 'X': return 111; /* ASCII 88 | */
+ case 'y': return 112; /* ASCII 121 | */
+ case 'Y': return 113; /* ASCII 89 | */
+ case 'z': return 114; /* ASCII 122 | */
+ case 'Z': return 115; /* ASCII 90 / */
+
+ case '0': return 116; /* ASCII 48 \ */
+ case '1': return 117; /* ASCII 49 | */
+ case '2': return 118; /* ASCII 50 | */
+ case '3': return 119; /* ASCII 51 | */
+ case '4': return 120; /* ASCII 52 \ */
+ case '5': return 121; /* ASCII 53 > Zahlen */
+ case '6': return 122; /* ASCII 54 / */
+ case '7': return 123; /* ASCII 55 | */
+ case '8': return 124; /* ASCII 56 | */
+ case '9': return 125; /* ASCII 57 / */
+
+ case '\\':return 126; /* ASCII 92 > Unbekannter Akzent? */
+
+ default : if (issonder(zz) == 1) return zz + 256;
+ return zz;
+ }
+}
+
+
+
+ /* Im Defaultfall werden Zeichen vor Zahlen und */
+ /* Zahlen vor Buchstaben einsortiert. */
+ /* Im Konfliktfall stehen Grossbuchstaben vor kleinen. */
+
+int dcompare(char zz)
+{
+ switch(zz)
+ {
+ case '\0': return 0;
+
+ case ' ': return 32; /* ASCII 32 \ / normales Leerzeichen */
+ case '~': return 33; /* ASCII 126 / \ geschuetztes Leereichen */
+
+ case '!': return 48; /* ASCII 33 \ */
+ case ':': return 49; /* ASCII 58 | */
+ case ';': return 50; /* ASCII 59 | */
+ case '<': return 51; /* ASCII 60 | */
+ case '=': return 52; /* ASCII 61 | */
+ case '>': return 53; /* ASCII 62 | */
+ case '\?':return 54; /* ASCII 63 | */
+ case '@': return 55; /* ASCII 64 | */
+ case '[': return 56; /* ASCII 91 \ */
+ case ']': return 57; /* ASCII 93 > Zeichen vor Zahlen */
+ /* / */
+ case '^': return 58; /* ASCII 94 | */
+ case '_': return 59; /* ASCII 95 | */
+ case '`': return 60; /* ASCII 96 | */
+ /* | */
+ case '{': return 61; /* ASCII 123 | */
+ case '|': return 62; /* ASCII 124 | */
+ case '}': return 63; /* ASCII 125 / */
+
+ case '0': return 64; /* ASCII 48 \ */
+ case '1': return 65; /* ASCII 49 | */
+ case '2': return 66; /* ASCII 50 | */
+ case '3': return 67; /* ASCII 51 | */
+ case '4': return 68; /* ASCII 52 \ */
+ case '5': return 69; /* ASCII 53 > Zahlen vor Buchstaben */
+ case '6': return 70; /* ASCII 54 / */
+ case '7': return 71; /* ASCII 55 | */
+ case '8': return 72; /* ASCII 56 | */
+ case '9': return 73; /* ASCII 57 / */
+
+ case 'A': return 74; /* ASCII 65 \ */
+ case 'a': return 75; /* ASCII 97 | */
+ case 'B': return 76; /* ASCII 66 | */
+ case 'b': return 77; /* ASCII 98 | */
+ case 'C': return 78; /* ASCII 67 | */
+ case 'c': return 79; /* ASCII 99 | */
+ case 'D': return 80; /* ASCII 68 | */
+ case 'd': return 81; /* ASCII 100 | */
+ case 'E': return 82; /* ASCII 69 | */
+ case 'e': return 83; /* ASCII 101 | */
+ case 'F': return 84; /* ASCII 70 | */
+ case 'f': return 85; /* ASCII 102 | */
+ case 'G': return 86; /* ASCII 71 | */
+ case 'g': return 87; /* ASCII 103 | */
+ case 'H': return 88; /* ASCII 72 | */
+ case 'h': return 89; /* ASCII 104 | */
+ case 'I': return 90; /* ASCII 73 | */
+ case 'i': return 91; /* ASCII 105 | */
+ case 'J': return 92; /* ASCII 74 | */
+ case 'j': return 93; /* ASCII 106 | */
+ case 'K': return 94; /* ASCII 75 | */
+ case 'k': return 95; /* ASCII 107 | */
+ case 'L': return 96; /* ASCII 76 | */
+ case 'l': return 97; /* ASCII 108 | */
+ case 'M': return 98; /* ASCII 77 | */
+ case 'm': return 99; /* ASCII 109 | */
+ case 'N': return 100; /* ASCII 78 | */
+ case 'n': return 101; /* ASCII 110 | */
+ case 'O': return 102; /* ASCII 79 | */
+ case 'o': return 103; /* ASCII 111 \ */
+ case 'P': return 104; /* ASCII 80 > Buchstaben: A, a, ... */
+ case 'p': return 105; /* ASCII 112 / */
+ case 'Q': return 106; /* ASCII 81 | */
+ case 'q': return 107; /* ASCII 113 | */
+ case 'R': return 108; /* ASCII 82 | */
+ case 'r': return 109; /* ASCII 114 | */
+ case 'S': return 110; /* ASCII 83 | */
+ case 's': return 111; /* ASCII 115 | */
+ case 'T': return 112; /* ASCII 84 | */
+ case 't': return 113; /* ASCII 116 | */
+ case 'U': return 114; /* ASCII 85 | */
+ case 'u': return 115; /* ASCII 117 | */
+ case 'V': return 116; /* ASCII 86 | */
+ case 'v': return 117; /* ASCII 118 | */
+ case 'W': return 118; /* ASCII 87 | */
+ case 'w': return 119; /* ASCII 119 | */
+ case 'X': return 120; /* ASCII 88 | */
+ case 'x': return 121; /* ASCII 120 | */
+ case 'Y': return 122; /* ASCII 89 | */
+ case 'y': return 123; /* ASCII 121 | */
+ case 'Z': return 124; /* ASCII 90 | */
+ case 'z': return 125; /* ASCII 122 / */
+
+ case '\\':return 126; /* ASCII 92 > Unbekannter Akzent? */
+
+ default : if (issonder(zz) == 1) return zz + 256;
+ return zz;
+ }
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+int igspstrcmp(const char *p, const char *q)
+{
+ while (1)
+ {
+ while (*p == ' ') ++p;
+ while (*q == ' ') ++q;
+ if (*p == *q && *p != '\0') { ++p; ++q; } else break;
+ }
+
+ return bewerten(*p) - bewerten(*q);
+}
+
+
+int numcmp(const int pg, const int w, const char *p, const char *q)
+{
+ int j = 0;
+
+ if (w == EMPTYNUM) j = 0;
+ else if (w == NOFOOTNOTE) j = 0;
+ else if (w == UNUSED) j = 0;
+ else if (pg == 1 && w == pg_smallroman) j = evalroman (p, ANALYZENUM) - evalroman (q, ANALYZENUM);
+ else if (pg == 0 && w == fn_smallroman) j = evalroman (p, ANALYZENUM) - evalroman (q, ANALYZENUM);
+ else if (pg == 1 && w == pg_bigroman) j = evalRoman (p, ANALYZENUM) - evalRoman (q, ANALYZENUM);
+ else if (pg == 0 && w == fn_bigroman) j = evalRoman (p, ANALYZENUM) - evalRoman (q, ANALYZENUM);
+ else if (pg == 1 && w == pg_arabic) j = evalarabic(p, ANALYZENUM) - evalarabic(q, ANALYZENUM);
+ else if (pg == 0 && w == fn_arabic) j = evalarabic(p, ANALYZENUM) - evalarabic(q, ANALYZENUM);
+ else if (pg == 1 && w == pg_smallletter) j = evalletter(p, ANALYZENUM) - evalletter(q, ANALYZENUM);
+ else if (pg == 0 && w == fn_smallletter) j = evalletter(p, ANALYZENUM) - evalletter(q, ANALYZENUM);
+ else if (pg == 1 && w == pg_bigletter) j = evalLetter(p, ANALYZENUM) - evalLetter(q, ANALYZENUM);
+ else if (pg == 0 && w == fn_bigletter) j = evalLetter(p, ANALYZENUM) - evalLetter(q, ANALYZENUM);
+ else if (pg == 1 && w == pg_symbol) j = evalsymbol(1, p, ANALYZENUM) - evalsymbol(1, q, ANALYZENUM);
+ else if (pg == 0 && w == fn_symbol) j = evalsymbol(0, p, ANALYZENUM) - evalsymbol(0, q, ANALYZENUM);
+ else if (w == TEXT) j = igspstrcmp(p, q);
+ else if (w == MISSNUM) j = 0;
+ else if (w == OVERFLOW) j = 0;
+ else intern_err(2); /* UNKNOWN PAGE-WEIGHT NUMBER */
+
+
+ return j;
+}
+
+
+void QQsort(int left, int right, const int deep, const int deepsort)
+{
+ int i, last, j, l;
+
+ void swap (int, int);
+ if (left >= right) return;
+ swap(left, (left + right)/2);
+ last = left;
+
+ for (i = left + 1; i <= right; i++)
+ {
+ j = 0; l = 0;
+ while (l < deepsort)
+ {
+ if ((j=vergleich(subCptr[l][i], subCptr[l][left])) != 0) break;
+ if ((j=Vergleich(subBptr[l][i], subBptr[l][left])) != 0) break;
+ if ((j=vergleich(subBptr[l][i], subBptr[l][left])) != 0) break;
+ ++l;
+ }
+
+ l = 0;
+ if (j == 0)
+ while (l < deepsort && (j=vergleich(subAptr[l][i], subAptr[l][left])) == 0) ++l;
+
+
+ if (j == 0)
+ j = leval[i] - leval[left];
+
+ if (j == 0)
+ j = pagewgt[i] - pagewgt[left];
+
+ if (j == 0) /* pagewgt[i] == pagewgt[left] */
+ j = numcmp(1, pagewgt[i], subRptr[PAGECOL][i], subRptr[PAGECOL][left]);
+
+ if (j == 0)
+ j = fntwgt[i] - fntwgt[left];
+
+ if (j == 0) /* fntwgt[i] == fntwgt[left] */
+ j = numcmp(0, fntwgt[i], subRptr[FNTCOL][i], subRptr[FNTCOL][left]);
+
+ if (j == 0)
+ j = firstoverlettergan(subRptr[LINECOL][i]) - firstoverlettergan(subRptr[LINECOL][left]);
+
+ if (j == 0)
+ j = secondoverlettergan(subRptr[LINECOL][i]) - secondoverlettergan(subRptr[LINECOL][left]);
+
+ l = deepsort;
+ if (j == 0)
+ while (l < deep && (j=vergleich(subAptr[l][i], subAptr[l][left])) == 0) ++l;
+
+
+ if (j < 0) swap(++last, i);
+ }
+
+
+ swap(left, last);
+ QQsort(left, last - 1, deep, deepsort);
+ QQsort(last + 1, right, deep, deepsort);
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+void swap(int i, int j)
+{
+ char *temp;
+ int l, temi;
+
+ temp = lineptr[i];
+ lineptr[i] = lineptr[j];
+ lineptr[j] = temp;
+
+ temi = pagewgt[i];
+ pagewgt[i] = pagewgt[j];
+ pagewgt[j] = temi;
+
+ temi = fntwgt[i];
+ fntwgt[i] = fntwgt[j];
+ fntwgt[j] = temi;
+
+ temi = dqsort[i];
+ dqsort[i] = dqsort[j];
+ dqsort[j] = temi;
+
+ temi = leval[i];
+ leval[i] = leval[j];
+ leval[j] = temi;
+
+ l = 0;
+ while (l < MAXBACOLS)
+ {
+ temp = subAptr[l][i];
+ subAptr[l][i] = subAptr[l][j];
+ subAptr[l][j] = temp;
+ ++l;
+ }
+
+ l = 0;
+ while (l < MAXBACOLS)
+ {
+ temp = subBptr[l][i];
+ subBptr[l][i] = subBptr[l][j];
+ subBptr[l][j] = temp;
+ ++l;
+ }
+
+ l = 0;
+ while (l < MAXBACOLS)
+ {
+ temp = subCptr[l][i];
+ subCptr[l][i] = subCptr[l][j];
+ subCptr[l][j] = temp;
+ ++l;
+ }
+
+ l = 0;
+ while (l < BAALLRCOLS)
+ {
+ temp = subRptr[l][i];
+ subRptr[l][i] = subRptr[l][j];
+ subRptr[l][j] = temp;
+ ++l;
+ }
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+int vergleich(const char *a, const char *b)
+{
+ while (*a != '\0' && *a == *b) { ++a; ++b; }
+
+ if (german > 0) return bewerten(*a) - bewerten(*b);
+ else return dcompare(*a) - dcompare(*b);
+}
+
+
+int Vergleich(const char *a, const char *b)
+{
+ while (1)
+ {
+ while (issonder(*a) == 1) ++a;
+ while (issonder(*b) == 1) ++b;
+ if (*a == '\0' || *a != *b) break;
+ ++a; ++b;
+ }
+
+ if (german > 0) return bewerten(*a) - bewerten(*b);
+ else return dcompare(*a) - dcompare(*b);
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+int myfgetc(void)
+{
+ int c = fgetc(infile);
+
+ if (c == '\t') c = ' ';
+
+ return c;
+}
+
+
+int ignFRONTSPACESgetline(char s[], int lim)
+{
+ int c,i;
+ i=0;
+ while( (c=myfgetc()) == ' ');
+ if (--lim > 0 && c != EOF && c != '\n')
+ s[i++] = c;
+ while(--lim > 0 && (c=myfgetc()) != EOF && c != '\n')
+ s[i++] = c;
+ if (c == '\n') s[i++] = c;
+ s[i] = '\0';
+ return i;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+int LaTeXcmp_endlen(const char *p, const char *s)
+{
+ int len = 0;
+
+ while (*s != '\0' && *s != '\t' && *s == *p)
+ {
+ ++s; ++p; ++len;
+ }
+
+ if (*s == '\t' && isLaTeXcmdletter(*p) == 0)
+ {
+ while (*p == ' ') { ++p; ++len; }
+ }
+ else len = 0;
+
+ return len;
+}
+
+
+int loesche_arg(char s[], const char *p, const char *com, const char op, const char cl)
+{
+ int len, r = 0, reallen;
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\')
+ {
+ s[r++] = *p++;
+ s[r++] = *p++;
+ }
+ else
+ if ((reallen = LaTeXcmp_endlen(p, com)) > 0)
+ {
+ p += reallen;
+
+ if (*p == '\0') break;
+
+ if (*p == op && (len = nextbracket(p, op, cl)) > 1)
+ {
+ p += len;
+ }
+ else
+ {
+ if (*p == '\\')
+ {
+ ++p;
+ if (isLaTeXcmdletter(*p) != 0)
+ {
+ while (isLaTeXcmdletter(*p) != 0) ++p;
+ while (*p == ' ') ++p;
+ }
+ else if (*p != '\0') ++p;
+ }
+ else
+ {
+ ++p; /* ungeklammerten Einzelbuchstaben loeschen */
+ }
+ }
+ }
+ else
+ {
+ s[r++] = *p++;
+ }
+ }
+ else
+ {
+ s[r++] = *p++;
+ }
+ }
+
+ s[r] = '\0';
+
+ return r;
+}
+
+
+int entkerne_arg(char s[], const char *p, const char *com, const char op, const char cl)
+{
+ int l, r = 0, reallen;
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\')
+ {
+ s[r++] = *p++;
+ s[r++] = *p++;
+ }
+ else
+ if ((reallen = LaTeXcmp_endlen(p, com)) > 0)
+ {
+ p += reallen;
+
+ if (*p == '\0') break;
+
+ if (*p == op && (l = nextbracket(p, op, cl)) > 1)
+ {
+ ++p;
+ if (*p == ' ')
+ {
+ if (r > 1 && s[r-1] == ' ' && s[r-2] == ' ') --r;
+ s[r++] = '\\';
+ }
+ while (--l > 1) { s[r++] = *p++; }
+ ++p;
+ }
+ else
+ {
+ s[r++] = *p++;
+ }
+ }
+ else
+ {
+ s[r++] = *p++;
+ }
+ }
+ else
+ {
+ s[r++] = *p++;
+ }
+ }
+
+ s[r] = '\0';
+
+ return r;
+}
+
+
+void print_not_tightly_err(const char *p, const char c)
+{
+ int len = strlen(p), sw = 0;
+
+ printf("%%%%\n%%%%> Warning: \'%c\' does not fit tightly after \"", c);
+
+ if (len > 2 && *(p+(len-1)) == c)
+ {
+ ++p; len -= 2;
+ }
+
+ while (len > 30) { --len; ++p; ++sw; }
+
+ if (sw > 0) printf("...");
+ printf("%.*s\".\n", len, p);
+}
+
+
+char *fillsubAptr(const char *p, int len, const char c)
+{
+ char buf[MAXLEN];
+ int i;
+
+ ++p; len -= 2;
+ while (*p == ' ') { ++p; --len; }
+ strcpy(buf, p);
+
+ buf[len] = '\0';
+ if (len > 0 && buf[len-1] == ' ')
+ { i = 2;
+ while (len-i >= 0 && buf[len-i] == ' ') ++i;
+ while (len-i >= 0 && isLaTeXcmdletter(buf[len-i]) != 0) ++i;
+ if (len-i < 0 || buf[len-i] != '\\') print_not_tightly_err(buf, c);
+ }
+ while (len > 0 && buf[len-1] == ' ') --len;
+
+ return strnmalloc(buf, len+1);
+}
+
+
+int form_only(char buf[], char forml, const char *onlycmdp, const char *p)
+{
+ int len;
+
+ if (forml == 'l')
+ {
+ len = loesche_arg(buf, p, onlycmdp, '{', '}');
+ }
+ else
+ if (forml == 'e')
+ {
+ len = entkerne_arg(buf, p, onlycmdp, '{', '}');
+ }
+ else
+ {
+ strcpy(buf, p);
+ len = strlen(buf);
+ if (forml != 'X') intern_err(3); /* unexpected forml in khvo */
+ }
+
+ return len;
+}
+
+
+int innerentry(const char *p, const char *icmdlist[][2], const int num)
+{
+ int l = 0;
+
+ while (l < num)
+ {
+ if (LaTeXcmp_endlen(p, icmdlist[l][0]) > 0) break;
+ ++l;
+ }
+
+ if (l >= num) l = -1;
+ return l;
+}
+
+#define DELSTARARG '='
+#define DELNORMARG '_'
+
+int endofbracks(const char *p, const char fmt[])
+{
+ int l = 0, len = 0, pos;
+
+ while (1)
+ {
+ if (fmt[l] == '\0' || fmt[l+1] == '\0' || fmt[l+2] == '\0') break;
+
+ while (*p == ' ') { ++p; ++len; }
+ if (fmt[l] == '*' && *p != '*') { l += 3; continue; }
+ if (fmt[l] == '*' && *p == '*') { ++p; ++len; }
+ if (fmt[l] == DELSTARARG && *p != '*') { l += 3; continue; }
+ if (fmt[l] == DELSTARARG && *p == '*') { ++p; ++len; }
+ while (*p == ' ') { ++p; ++len; }
+
+ if ((pos=nextbracket(p, fmt[l+1], fmt[l+2])) > 1)
+ {
+ p += pos;
+ len += pos;
+ }
+
+ l += 3;
+ }
+
+ return len;
+}
+
+
+void maxprint(int len, const char *s)
+{
+ char buf[MAXLEN];
+ int buflen = entkerne_IeC(buf, s);
+
+ if (len > 4 && buflen > len) printf("%.*s....", len-4, buf);
+ else printf("%s", buf);
+}
+
+
+void printktiterr(const char *s)
+{
+ printf("%%%% ");
+ maxprint(72, s);
+ printf("\n");
+}
+
+
+ const char *innerVcmd[][2] = {
+ { "\\printonlyvli\t", "+[]_{}:{}*{}!{}" },
+ { "\\printonlyvqu\t", "+[]_{}:{}*{}!{}" },
+ { "\\xprintonlyvli\t", "+[]_{}:{}*{}!{}" },
+ { "\\xprintonlyvqu\t", "+[]_{}:{}*{}!{}" },
+ { "\\vli\t", "+[]_{}:{}*{}!{}" }, /* wegen der */
+ { "\\vqu\t", "+[]_{}:{}*{}!{}" }, /* Fehler- */
+ { "\\xvli\t", "+[]_{}:{}*{}!{}" }, /* behandlung */
+ { "\\xvqu\t", "+[]_{}:{}*{}!{}" }, /* von KTIT */
+ { "\\shadowv\t", "_[]_{}_{}={}_{}" },
+ { "\\addtovli\t", "_[]_{}_{}={}_{}" },
+ { "\\addtovqu\t", "_[]_{}_{}={}_{}" },
+ { "\\xaddtovli\t", "_[]_{}_{}={}_{}" },
+ { "\\xaddtovqu\t", "_[]_{}_{}={}_{}" },
+ { NULL, NULL }};
+ const char *exkv[] = {
+ "\\printonlykli",
+ "\\printonlykqu",
+ "\\xprintonlykli",
+ "\\xprintonlykqu",
+ "\\printonlykli",
+ "\\printonlykqu",
+ "\\xprintonlykli",
+ "\\xprintonlykqu",
+ "\\@shadowba{}",
+ "\\@shadowba{}",
+ "\\@shadowba{}",
+ "\\@shadowba{}",
+ "\\@shadowba{}",
+ NULL };
+#define XVNUM 8
+#define AVNUM 13
+
+
+void get_ktit(char s[], const char *p, const char *com, const char op, const char cl, const int line)
+{
+ int l, reallen, found = 0, r = 0, ll, llen, b = 0, shielded = 0;
+ char buf[MAXLEN], fub[MAXLEN];
+
+ while (*p != '\0')
+ {
+ if (*p == '{' && b > 0)
+ {
+ l = nextbracket(p, '{', '}');
+ ll = 0;
+ while (l-- > 0)
+ {
+ fub[ll++] = *p;
+ buf[b++] = *p++;
+ }
+ fub[ll] = '\0';
+ shielded += num_of_cmds_in_str(fub, com);
+ }
+ else
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\' || *(p+1) == '{')
+ {
+ buf[b++] = *p++; buf[b++] = *p++;
+ }
+ else
+ if ((ll=innerentry(p, innerVcmd, AVNUM)) > -1)
+ {
+ /* inneres v-cmd ueberspringen: dort darf weiteres \\ktit stehen */
+ llen = LaTeXcmp_endlen(p, innerVcmd[ll][0]);
+ p += llen;
+ llen = endofbracks(p, innerVcmd[ll][1]);
+ p += llen;
+ buf[b++] = '<'; buf[b++] = '#'; buf[b++] = '>';
+ }
+ else
+ if ((reallen = LaTeXcmp_endlen(p, com)) > 0)
+ {
+ while (reallen-- > 0) buf[b++] = *p++;
+ ++found;
+
+ if (*p == '\0') break;
+
+ if ((l = nextbracket(p, op, cl)) > 0)
+ {
+ r = 0; /* <= Copy only arg of last \\ktit */
+ if (l == 1)
+ {
+ s[r++] = op;
+ s[r++] = *p; buf[b++] = *p++;
+ s[r++] = cl;
+ }
+ else
+ if (l == 2 && *p == '\\' && *(p+1) != '\0')
+ {
+ if (isLaTeXcmdletter(*(p+1)) == 0);
+ else
+ while (isLaTeXcmdletter(*(p+l)) != 0) ++l;
+ s[r++] = op;
+ while (l-- > 0) { s[r++] = *p; buf[b++] = *p++; }
+ s[r++] = cl;
+ }
+ else
+ {
+ while (l-- > 0)
+ {
+ s[r++] = *p; buf[b++] = *p++;
+ }
+ }
+ }
+ }
+ else buf[b++] = *p++;
+ }
+ else buf[b++] = *p++;
+ }
+
+ s[r] = '\0';
+ buf[b] = '\0';
+
+
+ if (r == 0 || (s[0] == op && s[1] == cl) || (s[0] == op && s[1] == ' ' && s[2] == cl))
+ {
+ if ( strlen(KTITBEG)
+ + strlen(KTITSHA)
+ + strlen(KTITMISS)
+ + strlen(KTITEMPTY)
+ + strlen(KTITEND)
+ > MAXLEN-2
+ )
+ {
+ intern_err(29);
+ }
+ else
+ {
+ strcpy(s, KTITBEG);
+ printf("%%%%\n%%%%> ");
+
+ if (shielded > 0)
+ {
+ printf("Error: %d shadowed { %s } cmd(s), and ...\n%%%% ", shielded, KTIT);
+ strcat(s, KTITSHA);
+ }
+
+ if (found == 0)
+ {
+ printf("Error: Missing");
+ strcat(s, KTITMISS);
+ }
+ else
+ {
+ printf("Warning: Empty");
+ strcat(s, KTITEMPTY);
+ }
+
+ printf(" %s in last arg of *inner v-cmd* (%s-entry %d):\n", KTIT, AUX_SUFFIX, line);
+ printktiterr(buf);
+ strcat(s, KTITEND);
+ }
+ }
+
+ if (found > 1)
+ {
+ printf("%%%%\n%%%%> Warning: %s used %d times in *inner v-cmd* (%s-entry %d):\n", KTIT, found, AUX_SUFFIX, line);
+ printktiterr(buf);
+ }
+
+ if (r > 2 && s[r-1] == cl && s[r-2] == ' ')
+ {
+ l = 3;
+ while (r-l > 1 && s[r-l] == ' ') ++l;
+ while (r-l > 1 && isLaTeXcmdletter(s[r-l]) != 0) ++l;
+ if (s[r-l] != '\\') print_not_tightly_err(s, cl);
+ }
+}
+
+
+int get_add_ktit(const char *p, const int maxktit, const int argno, const int line, const int screen)
+{
+ int reallen, found = 0, ll, llen, b = 0;
+ char buf[MAXLEN];
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\')
+ {
+ buf[b++] = *p++; buf[b++] = *p++;
+ }
+ else
+ if ((ll=innerentry(p, innerVcmd, AVNUM)) > -1)
+ {
+ /* inneres v-cmd ueberspringen: dort darf weiteres \\ktit stehen */
+ llen = LaTeXcmp_endlen(p, innerVcmd[ll][0]);
+ p += llen;
+ llen = endofbracks(p, innerVcmd[ll][1]);
+ p += llen;
+ buf[b++] = '<'; buf[b++] = '#'; buf[b++] = '>';
+ }
+ else
+ if ((reallen = LaTeXcmp_endlen(p, KTITCMD)) > 0)
+ {
+ while (reallen-- > 0) buf[b++] = *p++;
+ ++found;
+ }
+ else buf[b++] = *p++;
+ }
+ else buf[b++] = *p++;
+ }
+
+ buf[b] = '\0';
+
+ if (screen == 1 && found > maxktit)
+ {
+ printf("%%%%\n%%%%> Warning: ");
+ if (maxktit == 1)
+ printf("%d %s too much", found-1, KTIT);
+ else printf("%d misplaced %s", found, KTIT);
+ printf(" in %s-file (entry %d, arg %d):\n", AUX_SUFFIX, line, argno);
+ printktiterr(buf);
+ }
+
+ return found;
+}
+
+
+void do_innerVstarArg(char ret[], const char *p)
+{
+ const char *starlist[][2] =
+ {
+ { "\\vauthor\t", ":{}:{}" },
+ { "\\midvauthor\t", ":{}:{}" },
+ { NULL, NULL }};
+ const char *exlist[] =
+ {
+ "\\kauthor",
+ "\\midkauthor",
+ NULL
+ };
+ #define VKNUM 2
+
+ int r = 0, l, len, end;
+
+
+ strcpy(ret, p);
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\')
+ {
+ p += 2; r += 2;
+ }
+ else
+ if ((l=innerentry(p, starlist, VKNUM)) > -1)
+ {
+ len = LaTeXcmp_endlen(p, starlist[l][0]);
+ p += len;
+ end = nextbracket(p, *(starlist[l][1]+1), *(starlist[l][1]+2));
+ if (end == 2 && *p == '\\' && *(p+1) != '\0')
+ {
+ if (isLaTeXcmdletter(*(p+1)) == 0);
+ else
+ while (isLaTeXcmdletter(*(p+end)) != 0) ++end;
+ }
+ p += end;
+ ret[r] = '\0';
+ strcat(ret, exlist[l]);
+ end = llstrlen(exlist[l]);
+ r += end;
+
+ while (*p == ' ') ++p;
+ end = nextbracket(p, *(starlist[l][1]+4), *(starlist[l][1]+5));
+ if (end == 1)
+ {
+ ret[r++] = *(starlist[l][1]+4);
+ ret[r++] = *p++;
+ ret[r++] = *(starlist[l][1]+5);
+ }
+ else
+ if (end == 2 && *p == '\\' && *(p+1) != '\0')
+ {
+ if (isLaTeXcmdletter(*(p+1)) == 0);
+ else
+ while (isLaTeXcmdletter(*(p+end)) != 0) ++end;
+ ret[r++] = *(starlist[l][1]+4);
+ while (end-- > 0) { ret[r++] = *p++; }
+ ret[r++] = *(starlist[l][1]+5);
+ while (*p == ' ') ++p;
+ }
+ else
+ {
+ while (end-- > 0)
+ {
+ ret[r++] = *p++;
+ }
+ }
+ ret[r] = '\0';
+ strcat(ret, p);
+ }
+ else
+ {
+ ++p; ++r;
+ }
+ }
+ else
+ {
+ ++p; ++r;
+ }
+ }
+}
+
+
+int dobracks(char buf[], const char *p, const char fmt[], const int line)
+{
+ int l = 0, len = 0, pos;
+ char ibuf[MAXLEN], obuf[MAXLEN];
+
+ buf[0] = '\0';
+
+ while (1)
+ {
+ if (fmt[l] == '\0' || fmt[l+1] == '\0' || fmt[l+2] == '\0') break;
+
+ while (*p == ' ') { ++p; ++len; }
+ if (fmt[l] == '*' && *p != '*') { l += 3; continue; }
+ if (fmt[l] == '*' && *p == '*') { ++p; ++len; }
+ if (fmt[l] == DELSTARARG && *p != '*') { l += 3; continue; }
+ if (fmt[l] == DELSTARARG && *p == '*') { ++p; ++len; }
+ while (*p == ' ') { ++p; ++len; }
+
+ if ((pos=nextbracket(p, fmt[l+1], fmt[l+2])) > 1)
+ {
+ if (fmt[l] == '!')
+ {
+ mystrncpy(ibuf, p, pos);
+ get_ktit(obuf, ibuf, KTITCMD, KTITOP, KTITCL, line);
+ strcat(buf, obuf);
+ }
+ else
+ if (fmt[l] == '*' || fmt[l] == '+') /* +: \\vautkor => \\kauthor */
+ {
+ mystrncpy(ibuf, p, pos);
+ do_innerVstarArg(obuf, ibuf);
+ if (fmt[l] == '*')
+ strcat(buf, "*"); /* keep fmt[l] */
+ strcat(buf, obuf);
+ }
+ else
+ if (fmt[l] == DELNORMARG || fmt[l] == DELSTARARG)
+ ;
+ else
+ strncat(buf, p, pos);
+
+ p += pos;
+ len += pos;
+ }
+
+ l += 3;
+ }
+
+ return len;
+}
+
+
+int do_innercmd(char ret[], const char *p, const char *icmdlist[][2], const int num, const char *form)
+{
+ char buf[MAXLEN], cbuf[MAXLEN];
+ int r = 0, l, len, end;
+
+ strcpy(ret, p);
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\')
+ {
+ p += 2; r += 2;
+ }
+ else
+ if ((l=innerentry(p, icmdlist, num)) > -1)
+ {
+ len = LaTeXcmp_endlen(p, icmdlist[l][0]);
+ p += len; r += len;
+ end = endofbracks(p, icmdlist[l][1]);
+ mystrncpy(buf, p, end);
+ p += end;
+ end = do_only(cbuf, form, buf);
+ ret[r] = '\0';
+ strncat(ret, cbuf, end);
+ strcat(ret, p);
+ r += end;
+ }
+ else
+ {
+ ++p; ++r;
+ }
+ }
+ else
+ {
+ ++p; ++r;
+ }
+ }
+
+ return r;
+}
+
+
+int do_innerVcmd(char ret[], const char *p, const char *icmdlist[][2], const int num, const int line)
+{
+ char buf[MAXLEN], cbuf[MAXLEN];
+ const char *err = p;
+ int l, len, end, pos = 0;
+
+ strcpy(ret, p);
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\')
+ {
+ p += 2; pos += 2;
+ }
+ else
+ if ((l=innerentry(p, icmdlist, num)) > -1)
+ {
+ len = LaTeXcmp_endlen(p, icmdlist[l][0]);
+ p += len;
+ ret[pos] = '\0';
+ if (strlen(ret) + strlen(exkv[l]) < MAXLEN)
+ strcat(ret, exkv[l]); /* Exchange v-cmd => k-cmd; */
+ else { intern_err(4); break; }
+ pos += strlen(exkv[l]);
+ end = dobracks(buf, p, icmdlist[l][1], line);
+ p += end;
+ if (strlen(ret) + strlen(buf) < MAXLEN)
+ strcat(ret, buf);
+ else { intern_err(5); break; }
+ pos += strlen(buf);
+ if (strlen(ret) + strlen(p) < MAXLEN)
+ strcat(ret, p);
+ else { intern_err(6); break; }
+ }
+ else
+ {
+ ++p; ++pos;
+ }
+ }
+ else
+ {
+ ++p; ++pos;
+ }
+ }
+
+ return pos;
+}
+
+
+int do_only(char ret[], const char form[], const char in[])
+{
+ int l = 0, len = 0;
+ char buf[MAXLEN];
+ const char *onlycmd[] = { "\\onlykurz\t",
+ "\\onlyhere\t",
+ "\\onlyvoll\t",
+ "\\onlyout\t",
+ NULL
+ };
+#define KHVONUM 4
+
+
+ if (form[0] == '\0' || strlen(form) != KHVONUM)
+ {
+ intern_err(7); /* len of khvo */
+ strcpy(ret, in);
+ len = strlen(ret);
+ }
+ else
+ {
+ len = form_only(buf, form[l], onlycmd[l], in);
+ ++l;
+ if (l == KHVONUM) strcpy(ret, buf);
+
+ while (l < KHVONUM)
+ {
+ len = form_only(ret, form[l], onlycmd[l], buf);
+ ++l;
+ if (l == KHVONUM) break;
+
+ len = form_only(buf, form[l], onlycmd[l], ret);
+ ++l;
+ if (l == KHVONUM) strcpy(ret, buf);
+ }
+ }
+
+ return len;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+char *standardnum(char a[], char *p)
+{
+ int j, beforenum = 0;
+ char *top = p;
+
+ j = 0; while (j < NUMLEN-1) a[j++] = '0'; a[j] = '\0';
+
+ while (beforenum < NUMLEN-1 && isdigit(*p) != 0)
+ {
+ j = 1; while (j < NUMLEN-1) { a[j-1] = a[j]; ++j; }
+ a[NUMLEN-2] = *p;
+ ++beforenum;
+ ++p;
+
+ if (german == 0)
+ {
+ if ((*p == ',' || *p == ' ') && isdigit(*(p+1)) != 0 && isdigit(*(p+2)) != 0 && isdigit(*(p+3)) != 0 && isdigit(*(p+4)) == 0) ++p;
+ }
+ else
+ {
+ if ((*p == '.' || *p == ' ') && isdigit(*(p+1)) != 0 && isdigit(*(p+2)) != 0 && isdigit(*(p+3)) != 0 && isdigit(*(p+4)) == 0) ++p;
+ }
+ }
+
+ if (german == 0)
+ {
+ if (*p == '.' && isdigit(*(p+1)) != 0)
+ {
+ j = NUMLEN-1; while (j < 2*NUMLEN-1 && isdigit(*(p+1)) != 0) { ++p; a[j++] = *p; }
+ ++p; a[j] = '\0';
+ }
+ }
+ else
+ {
+ if (*p == ',' && isdigit(*(p+1)) != 0)
+ {
+ j = NUMLEN-1; while (j < 2*NUMLEN-1 && isdigit(*(p+1)) != 0) { ++p; a[j++] = *p; }
+ ++p; a[j] = '\0';
+ }
+ }
+
+ if (isdigit(*p) != 0)
+ {
+ printf("%%%%\n%%%%> Warning: Can\'t sort too long number \"%.*s...\".\n", 30, top);
+ while (isdigit(*p) != 0) ++p;
+ }
+
+ return p;
+}
+
+
+int isLaTeXcmdletter(char a)
+{
+ if (isalpha(a) != 0 || a == '@')
+ return 1;
+ return 0;
+}
+
+
+char *setptrtofirstbracket(char *p)
+{
+ while (*p != '\0')
+ {
+ if (*p == '\\' && *(p+1) != '\0') ++p;
+ ++p;
+ if (*p == '{') break;
+ }
+ return p;
+}
+
+
+void ignoreadditionaltext(const char *p, const char *i, const char *f)
+{
+ int ll;
+
+ while(*p == ' ') ++p;
+ if (*p != '\0' && *p != '%')
+ {
+ if (strlen(i) > 58)
+ ll = 0;
+ else ll = 58 - strlen(i);
+ printf("%%%%\n%%%%> Warning: Ignore additional text \"%.*s\"\n", 40, p);
+ printf("%%%% after \"%s\" -> \"%.*s\".\n", i, ll, f);
+ if (*p == '\\')
+ printf("%%%% ** I grap only one \\cmd per line! Fix that, and start me again! **\n");
+ }
+}
+
+
+void telldefault(int rest)
+{
+ printf("%%%% ** Missing %d argument(s). The \'%%\' remains in my output.\n", rest);
+}
+
+
+ const char *innerK_PER_ARQ_cmd[][2] = {
+ { "\\printonlykli\t", ":[]:{}*{}:{}" },
+ { "\\printonlykqu\t", ":[]:{}*{}:{}" },
+ { "\\xprintonlykli\t", ":[]:{}*{}:{}" },
+ { "\\xprintonlykqu\t", ":[]:{}*{}:{}" },
+ { "\\printonlyper\t", ":{}" },
+ { "\\printonlyarq\t", ":[]:{}:{}" },
+ { "\\printonlydefabk\t", ":{}:{}" },
+ { "\\printonlyabkdef\t", ":{}:{}" },
+ { "\\printonlyabk\t", ":{}" },
+ { NULL, NULL }};
+#define INNERTITLES 6
+#define XKPANUM 9
+
+
+int do_inneronly(char ret[], const char in[], const char *vf, const char *kpf)
+{
+ char buf[MAXLEN];
+ int len;
+
+ len = do_innercmd(buf, in, innerVcmd, XVNUM, vf); /* AVNUM unnecessary */
+ len = do_innercmd(ret, buf, innerK_PER_ARQ_cmd, XKPANUM, kpf);
+
+ return len;
+}
+
+
+char *makeAR(char *p, int cols, int rest, char bb, char eb, const char *ident, int linec, int i, char schalt, const char *formO, int ventry)
+{
+ int len, alen;
+ char ibuf[MAXLEN], cbuf[MAXLEN];
+
+ while (*p == ' ') ++p;
+
+ if (*p != bb)
+ { printf("%%%%\n%%%%> %s error in arg %d: Missing \'%c\'.\n", ident, i+cols, bb);
+ telldefault(rest-i);
+ return NULL;
+ }
+ else
+ {
+ if ((len = nextbracket(p, bb, eb)) < 0)
+ { printf("%%%%\n%%%%> %s error in arg %d: Missing \'%c\' after \"%.*s\".\n", ident, i+cols, eb, -len, p);
+ telldefault(rest-i);
+ return NULL;
+ }
+
+ if (schalt == 'A')
+ {
+ /* new in 2.2: Evaluate inner v-cmds in rest of v-cmds as k-cmds! */
+ if (ventry != IS_V && i == VCOLS-1)
+ {
+ /* alloc {li} or {qu} as 4th arg of k-cmds: */
+ alen = mystrncpy(cbuf, p, len);
+ }
+ else
+ {
+ mystrncpy(cbuf, p, len);
+ alen = do_inneronly(ibuf, cbuf, "eell", "leel");
+ alen = do_only(cbuf, formO, ibuf);
+
+ if (ventry == IS_V && i == VCOLS-1)
+ {
+ alen = do_innerVcmd(ibuf, cbuf, innerVcmd, AVNUM, linec+1);
+ strcpy(cbuf, ibuf);
+ get_add_ktit(cbuf, 1, i+cols, linec+1, 1); /* Rest v-cmd: Ein \\ktit erlaubt */
+ }
+ else
+ {
+ if(get_add_ktit(cbuf, 0, i+cols, linec+1, 1) > 0) /* sonst (auch andere Args v-cmd) */
+ { /* get_add_ktit schreibt Fehler!! */
+ if (otherktiterr < i+1) otherktiterr = i+1;
+ }
+ }
+ }
+
+ subAptr[i][linec] = fillsubAptr(cbuf, alen, eb);
+ }
+ else
+ if (schalt == 'R') subRptr[i][linec] = strnmalloc(p+1, len-1);
+ else intern_err(8); /* INTERNAL ERROR (A, R) */
+
+ p += len;
+ }
+
+ return p;
+}
+
+
+void dodqdeepsort(int linec, int alllines, int deepsort)
+{
+ int num;
+
+ while(linec < alllines)
+ {
+ if ( nogsty == 0
+ && userusesdq(deepsort, linec) == 1
+ && (num = getarabicnum(subRptr[DQCOL][linec])) >= MINCATCODE
+ && num <= MAXCATCODE
+ ) dqsort[linec] = num;
+ else dqsort[linec] = ERRCATCODE;
+ ++linec;
+ }
+}
+
+
+void dopgfntnumberweight(int linec, int alllines)
+{
+ while(linec < alllines)
+ {
+ pagewgt[linec] = pgnumberweight(subRptr[PAGECOL][linec]);
+ fntwgt[linec] = fntnumberweight(subRptr[FNTCOL][linec]);
+ ++linec;
+ }
+}
+
+
+int over_fonts(char *p, int start)
+{
+ int i, l, neu = 0;
+
+ const char *fonts[] =
+ {
+ NEWFNSYMBOL, /* start == 0 : footnote = $^{x}$ */
+ "\\rmfamily", /* start == 1 : else = text mode */
+ "\\sffamily",
+ "\\ttfamily",
+ "\\mdseries",
+ "\\bfseries",
+ "\\upshape",
+ "\\itshape",
+ "\\slshape",
+ "\\scshape",
+ "\\em",
+ "\\normalfont",
+ "\\textrm",
+ "\\rm",
+ "\\textsf",
+ "\\sf",
+ "\\texttt",
+ "\\tt",
+ "\\textmd",
+ "\\textbf",
+ "\\bf",
+ "\\textup",
+ "\\textit",
+ "\\it",
+ "\\textsl",
+ "\\sl",
+ "\\textsc",
+ "\\sc",
+ "\\emph",
+ "\\textnormal",
+ "\\bapageframe",
+ "\\pbapageframe",
+ "\\bafootnoteframe",
+ "\\pbafootnoteframe",
+ RELAX,
+ NULL,
+ };
+#define FONTC 35
+
+
+ while(*p == '{' && *(p+1) == '}')
+ {
+ p += 2; neu += 2;
+ while (*p == ' ') { ++p; ++neu; }
+ }
+
+
+ while(*p == '\\')
+ {
+ i = start;
+ l = 0;
+ while (i < FONTC && lcmdcmp(p, fonts[i]) != 0) ++i;
+ if( (i < FONTC && lcmdcmp(p, fonts[i]) == 0 && (l=strlen(fonts[i])) > 0)
+ || (start == 0 && (l=len_tom(p)) > 0)
+ )
+ {
+ p+=l;
+ neu+=l;
+ while (*p == ' ') { ++p; ++neu; }
+ }
+ else if (l == 0) break;
+ }
+
+ return neu;
+}
+
+
+
+void set_inner_number_on_subRptr(char *p, int len, int col, int line, int start)
+{
+ int neu;
+
+ /* start==0: in $^{x}$ kein \ensuremath oder \TextOrMath noetig! */
+ neu = over_fonts(p, start);
+ len -= neu;
+ p += neu;
+
+ while (*p == '{' && len > 2 && nextbracket(p, '{', '}') == len-1)
+ {
+ ++p; len -= 2;
+
+ while (*p == ' ') { ++p; --len; }
+
+ neu = over_fonts(p, start);
+ len -= neu;
+ p += neu;
+ }
+
+ subRptr[col][line] = strnmalloc(p, len);
+}
+
+
+void getbrackets(int linec, int alllines, const char *ident, int deep, int filenum, const char *formO, int ventry)
+{
+ char *p, buf[MAXLEN];
+ int len, i;
+
+ while(linec < alllines)
+ {
+ i = 0; while (i < MAXBACOLS) subAptr[i++][linec] = mydefault;
+ i = 0; while (i < BAALLRCOLS) subRptr[i++][linec] = mydefault;
+ leval[linec] = ACCEPTLINE;
+
+
+ p = lineptr[linec];
+ p = setptrtofirstbracket(p);
+
+ i = 0;
+ while (i < deep)
+ {
+ if ((p = makeAR(p, 1, deep+BARESTCOLS, '{', '}', ident, linec, i, 'A', formO, ventry)) == NULL)
+ {
+ leval[linec] = REJECTLINE;
+ break;
+ }
+ ++i;
+ }
+
+ if (i == deep)
+ {
+ i = 0;
+ while (i < BARESTCOLS)
+ {
+ if ((p = makeAR(p, BARESTCOLS, BARESTCOLS, bareststr[2*i], bareststr[2*i+1], ident, linec, i, 'R', "", ventry)) == NULL)
+ {
+ leval[linec] = REJECTLINE;
+ break;
+ }
+ ++i;
+ }
+ if (p != NULL) ignoreadditionaltext(p, ident, subAptr[0][linec]);
+
+ p = subRptr[PAGEFNTCOL][linec];
+ while (*p == ' ') ++p;
+ if (*p == '{' && (len = nextbracket(p, '{', '}')) > 1)
+ {
+ while (*(p+1) == ' ') { ++p; --len; }
+
+ set_inner_number_on_subRptr(p+1, len-1, PAGECOL, linec, 1);
+
+ p += len;
+ while (*p == ' ') ++p;
+ if (*p == '{' && (len = nextbracket(p, '{', '}')) > 1)
+ {
+ while (*(p+1) == ' ') { ++p; --len; }
+
+ set_inner_number_on_subRptr(p+1, len-1, FNTCOL, linec, 0);
+
+ p += len;
+ while (*p == ' ') ++p;
+ if (*p == '{' && (len = nextbracket(p, '{', '}')) > 1)
+ {
+ while (*(p+1) == ' ') { ++p; --len; }
+ if (*(p+1) == HASUNUCH)
+ {
+ myfree(subRptr[PAGECOL][linec]);
+ subRptr[PAGECOL][linec] = unused; /* UNUSED */
+ }
+ if (*(p+1) != HASFNTCH)
+ {
+ if (*subRptr[FNTCOL][linec] != '\0')
+ printf("%%%%\n%%%%> Warning: Ignore unexpected FNT-num \"%s\".\n", subRptr[FNTCOL][linec]);
+ myfree(subRptr[FNTCOL][linec]);
+ subRptr[FNTCOL][linec] = nofnt; /* NOFOOTNOTE */
+ }
+ if (*(p+1) != '}' && *(p+1) != HASFNTCH && *(p+1) != HASUNUCH)
+ { printf("%%%%\n%%%%> %s warning (part 3 of arg %d):\n", ident, deep+2);
+ printf("%%%% Get no {} or {%c} or {%c}!\n", HASFNTCH, HASUNUCH);
+ }
+ p += len;
+ while (*p == ' ') ++p;
+ if (*p != '\0')
+ { printf("%%%%\n%%%%> %s warning (parts of arg %d):\n", ident, deep+2);
+ printf("%%%% Unexpected text after {page}{footnote}{} number!\n");
+ }
+ }
+ else
+ { printf("%%%%\n%%%%> %s warning (part 3 of arg %d):\n", ident, deep+2);
+ printf("%%%% Get no {} or {%c}!\n", HASFNTCH);
+ }
+ }
+ else
+ { printf("%%%%\n%%%%> %s warning (part 2 of arg %d):\n", ident, deep+2);
+ printf("%%%% Get no {footnote} number!\n");
+ }
+ }
+ else
+ { printf("%%%%\n%%%%> %s warning (all 3 parts of arg %d):\n", ident, deep+2);
+ printf("%%%% Get no {page}{footnote}{} number!\n");
+ }
+ }
+
+ if (filenum > -1)
+ {
+ sprintf(buf, "file %d ", filenum);
+
+ if (firstoverlettergan(subRptr[LINECOL][linec]) > 0)
+ {
+ strncat(buf, subRptr[LINECOL][linec], MAXLEN-strlen(buf)-strlen(subRptr[LINECOL][linec])-1);
+ }
+ else
+ {
+ printf("%%%%\n%%%%> %s error in last arg: No line-number!\n", ident);
+ strncat(buf, ERRINPUTLINENO, MAXLEN-strlen(buf)-ERRINPUTLINENOLEN-1);
+ }
+
+ myfree(subRptr[LINECOL][linec]);
+ subRptr[LINECOL][linec] = strnmalloc(buf, strlen(buf)+1);
+ }
+
+ ++linec;
+ }
+}
+
+ /* ohne Aequivalent in MathMode sind \\b \\c \\k \\d \\H \\t */
+const char *weighttable[][2] = {
+ { "\\.", "" }, /* CTL+A */ /* MARK_POINT */
+ { "\\dot\t", "" },
+ { "\\\'", "" }, /* CTL+B */
+ { "\\acute\t", "" },
+ { "\\`", "" }, /* CTL+C */
+ { "\\grave\t", "" },
+ { "\\^", "" }, /* CTL+D */
+ { "\\hat\t", "" },
+ { "\\ddot\t", "" }, /* CTL+E umlaut */
+ { "\\ij\t", "i" }, /* Niederlaendische */
+ { "\\IJ\t", "I" }, /* Sondersortierung */
+ { "\\=", "" }, /* CTL+F */
+ { "\\bar\t", "" },
+ { "\\vec\t", "" }, /* Ctl+G */
+ { "\\~", " " }, /* CTL+K */ /* MARK_TILDE */
+ { "\\tilde\t", " " },
+ { "\\aa\t", " a" }, /* CTL+L */ /* \\r a \\r A */
+ { "\\AA\t", " A" },
+ { "\\r\t", " " }, /* \\AA \\aa */
+ { "\\mathring\t", " " },
+ { "\\b\t", "" }, /* CTL+N */
+ { "\\c\t", "" }, /* CTL+O */
+ { "\\k\t", "" }, /* CTL+P */ /* rechte Tilde */
+ { "\\d\t", "" }, /* CTL+Q */
+ { "\\H\t", "" }, /* CTL+R */
+ { "\\t\t", "" }, /* CTL+S */
+ { "\\u\t", "" }, /* CTL+T */
+ { "\\breve\t", "" },
+ { "\\v\t", "" }, /* CTL+U */
+ { "\\check\t", "" },
+ { "\\st\t", "" }, /* CTL+V */ /* NEW in 2.2 */
+ { "\\textst\t", "" }, /* NEW in 2.2 */
+ { "\\underline\t", "" }, /* CTL+W */ /* CHANGED in 2.2 */
+ { "\\underbar\t", "" },
+ { "\\ul\t", "" },
+ { "\\textul\t", "" }, /* NEW in 2.2 */
+ { "\\,", " " },
+ { "\\space\t", " " },
+ { "\\pteskip\t", " " }, /* 1\te 000 NEW in 2.2 */
+ { "\\te\t", ". " }, /* != 1000 NEW in 2.2 */
+ { "\\i\t", "i" },
+ { "\\imath\t", "i" },
+ { "\\j\t", "j" },
+ { "\\jmath\t", "j" },
+ { "\\ae\t", "ae" }, /* \ */ /* zweiteilig */
+ { "\\AE\t", "Ae" }, /* | */ /* <=> Oe */
+ { "\\BibArts\t", "BibArts"}, /* | */
+ { "\\pBibArts\t", "BibArts"}, /* | */
+ { "\\textcent\t", "c" }, /* | */
+ { "\\pcopyright\t", "c" }, /* | */
+ { "\\copyright\t", "c" }, /* | */
+ { "\\textcopyright\t", "c" }, /* | */
+ { "\\textcelsius\t", "C" }, /* | */
+ { "\\dh\t", "d" }, /* | */
+ { "\\dj\t", "d" }, /* | */
+ { "\\DH\t", "D" }, /* | */
+ { "\\DJ\t", "D" }, /* | */ /* =\\DH */
+ { "\\texteuro\t", "E" }, /* | */
+ { "\\textflorin\t", "f" }, /* | */
+ { "\\l\t", "l" }, /* | */
+ { "\\ell\t", "l" }, /* | */
+ { "\\Im\t", "I" }, /* | */
+ { "\\L\t", "L" }, /* | */
+ { "\\LaTeX\t", "LaTeX" }, /* | */
+ { "\\ng\t", "n" }, /* | */
+ { "\\NG\t", "N" }, /*CTL_X/Y*/
+ { "\\o\t", "o" }, /* | */
+ { "\\O\t", "O" }, /* | */
+ { "\\oe\t", "oe" }, /* | */
+ { "\\OE\t", "Oe" }, /* | */
+ { "\\textsterling\t", "P" }, /* | */
+ { "\\ppounds\t", "P" }, /* | */
+ { "\\pounds\t", "P" }, /* | */
+ { "\\Re\t", "R" }, /* | */
+ { "\\textregistered\t", "R" }, /* | */
+ { "\\th\t", "th" }, /* | */
+ { "\\TH\t", "Th" }, /* | */
+ { "\\TeX\t", "TeX" }, /* | */
+ { "\\textwon\t", "W" }, /* | */
+ { "\\textyen\t", "Y" }, /* / */
+ { "\\alpha\t", "a" }, /* 28 */
+ { "\\Alpha\t", "A" }, /* bibarts.sty; new in 2.1 */
+ { "\\beta\t", "b" },
+ { "\\Beta\t", "B" }, /* bibarts.sty; new in 2.1 */
+ { "\\chi\t", "ch" },
+ { "\\Chi\t", "Ch" }, /* bibarts.sty; new in 2.1 */
+ { "\\delta\t", "d" },
+ { "\\Delta\t", "D" },
+ { "\\epsilon\t", "e" },
+ { "\\Epsilon\t", "E" }, /* bibarts.sty; new in 2.1 */
+ { "\\varepsilon\t", "e" }, /* 29 */
+ { "\\eta\t", "e" }, /* 30 */
+ { "\\Eta\t", "E" }, /* bibarts.sty; new in 2.1 */
+ { "\\gamma\t", "g" },
+ { "\\Gamma\t", "G" },
+ { "\\iota\t", "i" },
+ { "\\Iota\t", "I" }, /* bibarts.sty; new in 2.1 */
+ { "\\kappa\t", "k" },
+ { "\\Kappa\t", "K" }, /* bibarts.sty; new in 2.1 */
+ { "\\varkappa\t", "k" },
+ { "\\lambda\t", "l" },
+ { "\\Lambda\t", "L" },
+ { "\\mu\t", "m" },
+ { "\\Mu\t", "M" }, /* bibarts.sty; new in 2.1 */
+ { "\\nu\t", "n" },
+ { "\\Nu\t", "N" }, /* bibarts.sty; new in 2.1 */
+ { "\\omicron\t", "o" }, /* bibarts.sty */
+ { "\\Omicron\t", "O" }, /* bibarts.sty; new in 2.1 */
+ { "\\omega\t", "o" },
+ { "\\Omega\t", "O" },
+ { "\\pi\t", "p" },
+ { "\\Pi\t", "P" },
+ { "\\varpi\t", "p" },
+ { "\\phi\t", "ph" },
+ { "\\Phi\t", "Ph" },
+ { "\\varphi\t", "ph" },
+ { "\\psi\t", "ps" },
+ { "\\Psi\t", "Ps" },
+ { "\\rho\t", "r" },
+ { "\\Rho\t", "R" }, /* bibarts.sty; new in 2.1 */
+ { "\\varrho\t", "r" },
+ { "\\sigma\t", "s" },
+ { "\\Sigma\t", "S" },
+ { "\\varsigma\t", "s" },
+ { "\\tau\t", "t" },
+ { "\\Tau\t", "T" }, /* bibarts.sty; new in 2.1 */
+ { "\\theta\t", "th" },
+ { "\\Theta\t", "Th" },
+ { "\\vartheta\t", "th" },
+ { "\\xi\t", "x" },
+ { "\\Xi\t", "X" },
+ { "\\upsilon\t", "y" },
+ { "\\Upsilon\t", "Y" },
+ { "\\zeta\t", "z" },
+ { "\\Zeta\t", "Z" }, /* bibarts.sty; new in 2.1 */
+ { NULL, NULL }};
+#define NLATEX 135
+
+
+const char *udtable[][2] = {
+ { "\\\"a", "a" }, /* \ \"a */
+ { "\\\"o", "o" }, /* | \"o */
+ { "\\\"u", "u" }, /* CTL+E \"u */
+ { "\\\"A", "A" }, /* | \"A */
+ { "\\\"O", "O" }, /* | \"O */
+ { "\\\"U", "U" }, /* | \"U */
+ { "\\ss\t", "s" }, /* \ss */
+ { "\\SS\t", "SS" }, /* \SS */
+ { "\\sz\t", "s" }, /* \sz */ /* new in 2.1 */
+ { "\\SZ\t", "S" }, /* \SZ */ /* new in 2.1 */
+ { "\\flqq\t", "" }, /* \flqq */ /* new in 2.2 */
+ { "\\frqq\t", "" }, /* \frqq */ /* new in 2.2 */
+ { "\\glqq\t", "" }, /* \glqq */ /* new in 2.2 */
+ { "\\grqq\t", "" }, /* \grqq */ /* new in 2.2 */
+ { "\\/", "" }, /* \/ */ /* new in 2.2 */
+ { "\\-", "" }, /* \- */ /* new in 2.2 */
+ { "\\oldhyc\t", "c" }, /* [c-] */ /* \ */
+ { "\\OLDHYC\t", "C" }, /* [C-] */ /* | */
+ { "\\oldhyl\t", "l" }, /* [l-] */ /* | */
+ { "\\OLDHYL\t", "L" }, /* [L-] */ /* | */
+ { "\\oldhym\t", "m" }, /* [m-] */ /* | */
+ { "\\OLDHYM\t", "M" }, /* [M-] */ /* | */
+ { "\\oldhyn\t", "n" }, /* [n-] */ /* | new */
+ { "\\OLDHYN\t", "N" }, /* [N-] */ /* | in */
+ { "\\oldhyp\t", "p" }, /* [p-] */ /* | 2.2 */
+ { "\\OLDHYP\t", "P" }, /* [P-] */ /* | */
+ { "\\oldhyr\t", "r" }, /* [r-] */ /* | */
+ { "\\OLDHYR\t", "R" }, /* [R-] */ /* | */
+ { "\\oldhyt\t", "t" }, /* [t-] */ /* | */
+ { "\\OLDHYT\t", "T" }, /* [T-] */ /* | */
+ { "\\oldhyf\t", "f" }, /* [f-] */ /* | */
+ { "\\OLDHYF\t", "F" }, /* [F-] */ /* / */
+ { "\\hy\t", "-" }, /* MINUS \hy */ /* new in 2.2 */
+ { "\\fhy\t", "-" }, /* MINUS \fhy*/ /* new in 2.2 */
+ { "\\\"", "" }, /* / \" */
+ { "\\3", "s" }, /* \3 */
+ { "\\ck\t", "ck" }, /* [c-k] */ /* new in 2.2 */
+ { "\\CK\t", "CK" }, /* [C-K] */ /* new in 2.2 */
+ { "\\oldhyss\t", "s" }, /* [s-s] */ /* \ */
+ { "\\OLDHYSS\t", "SS" }, /* [S-S] */ /* | new */
+ { "\\newhyss\t", "s" }, /* [-ss] */ /* | in */
+ { "\\NEWHYSS\t", "SS" }, /* [-SS] */ /* | 2.2 */
+ { "\\hyss\t", "s" }, /* [s-s/-ss] */ /* | */
+ { "\\HYSS\t", "SS" }, /* [S-S/-SS] */ /* / */
+ { NULL, NULL }};
+#define NUMTEX 44
+
+
+const char *gstylist[][2] = {
+ { "\"a", NULL }, /* \ "a */
+ { "\"o", NULL }, /* | "o */
+ { "\"u", NULL }, /* CTL+E "u */
+ { "\"A", NULL }, /* | "A */
+ { "\"O", NULL }, /* | "O */
+ { "\"U", NULL }, /* | "U */
+ { "\"s", NULL }, /* "s */
+ { "\"S", NULL }, /* "S */
+ { "\"z", NULL }, /* "z */ /* new in 2.1 */
+ { "\"Z", NULL }, /* "Z */ /* new in 2.1 */
+ { "\"<", NULL }, /* "` */ /* new in 2.2 */
+ { "\">", NULL }, /* "' */ /* new in 2.2 */
+ { "\"`", NULL }, /* "` */ /* new in 2.2 */
+ { "\"\'", NULL }, /* "' */ /* new in 2.2 */
+ { "\"|", NULL }, /* "| */ /* new in 2.2 */
+ { "\"-", NULL }, /* "- */ /* new in 2.2 */
+ { "\"c", NULL }, /* [c-] */ /* \ */
+ { "\"C", NULL }, /* [C-] */ /* | */
+ { "\"l", NULL }, /* [l-] */ /* | */
+ { "\"L", NULL }, /* [L-] */ /* | */
+ { "\"m", NULL }, /* [m-] */ /* | */
+ { "\"M", NULL }, /* [M-] */ /* | */
+ { "\"n", NULL }, /* [n-] */ /* | new */
+ { "\"N", NULL }, /* [N-] */ /* | in */
+ { "\"p", NULL }, /* [p-] */ /* | 2.2 */
+ { "\"P", NULL }, /* [P-] */ /* | */
+ { "\"r", NULL }, /* [r-] */ /* | */
+ { "\"R", NULL }, /* [R-] */ /* | */
+ { "\"t", NULL }, /* [t-] */ /* | */
+ { "\"T", NULL }, /* [T-] */ /* | */
+ { "\"f", NULL }, /* [f-] */ /* | */
+ { "\"F", NULL }, /* [F-] */ /* | */
+ { "\"=", NULL }, /* MINUS "= */ /* new in 2.2 */
+ { "\"~", NULL }, /* MINUS "~ */ /* new in 2.2 */
+ { "\"", NULL }, /* / " */
+ { NULL, NULL }};
+#define NUMGER 35
+
+
+const char *gweight[][2] = {
+ { NULL, "ae" }, /* \ \"a "a */
+ { NULL, "oe" }, /* | \"o "o */
+ { NULL, "ue" }, /* CTL+E \"u "u */
+ { NULL, "Ae" }, /* | \"A "A */
+ { NULL, "Oe" }, /* | \"O "O */
+ { NULL, "Ue" }, /* | \"U "U */
+ { NULL, "ss" }, /* \ss "s */
+ { NULL, "SS" }, /* \SS "S */
+ { NULL, "ss" }, /* \sz "z */ /* new in 2.1 */
+ { NULL, "SS" }, /* \SZ "Z */ /* new in 2.1 */
+ { NULL, "" }, /* \flqq "< */ /* new in 2.2 */
+ { NULL, "" }, /* \frqq "> */ /* new in 2.2 */
+ { NULL, "" }, /* \glqq "` */ /* new in 2.2 */
+ { NULL, "" }, /* \grqq "' */ /* new in 2.2 */
+ { NULL, "" }, /* \/ "| */ /* new in 2.2 */
+ { NULL, "" }, /* \- "- */ /* new in 2.2 */
+ { NULL, "c" }, /* [c-] "c */ /* \ */
+ { NULL, "C" }, /* [C-] "C */ /* | */
+ { NULL, "l" }, /* [l-] "l */ /* | */
+ { NULL, "L" }, /* [L-] "L */ /* | */
+ { NULL, "m" }, /* [m-] "m */ /* | */
+ { NULL, "M" }, /* [M-] "M */ /* | */
+ { NULL, "n" }, /* [n-] "n */ /* | new */
+ { NULL, "N" }, /* [N-] "N */ /* | in */
+ { NULL, "p" }, /* [p-] "p */ /* | 2.2 */
+ { NULL, "P" }, /* [P-] "P */ /* | */
+ { NULL, "r" }, /* [r-] "r */ /* | */
+ { NULL, "R" }, /* [R-] "R */ /* | */
+ { NULL, "t" }, /* [t-] "t */ /* | */
+ { NULL, "T" }, /* [T-] "T */ /* | */
+ { NULL, "f" }, /* [f-] "f */ /* | */
+ { NULL, "F" }, /* [F-] "F */ /* / */
+ { NULL, "-" }, /* MINUS \hy "= */ /* new in 2.2 */
+ { NULL, "-" }, /* MINUS \fhy "~ */ /* new in 2.2 */
+ { NULL, "" }, /* / \" " */
+ { NULL, "ss" }, /* \3 [] */
+ { NULL, "ck" }, /* \ck */ /* new in 2.2 */
+ { NULL, "CK" }, /* \CK */ /* new in 2.2 */
+ { NULL, "ss" }, /* [s-s] */ /* \ */
+ { NULL, "SS" }, /* [S-S] */ /* | new */
+ { NULL, "ss" }, /* [-ss] */ /* | in */
+ { NULL, "SS" }, /* [-SS] */ /* | 2.2 */
+ { NULL, "ss" }, /* [s-s/-ss] */ /* | */
+ { NULL, "SS" }, /* [S-S/-SS] */ /* / */
+ { NULL, NULL }};
+
+
+const char *mweight[][2] = {
+ { NULL, "a" }, /* \ \"a "a */
+ { NULL, "o" }, /* | \"o "o */
+ { NULL, "u" }, /* CTL+E \"u "u */
+ { NULL, "A" }, /* | \"A "A */
+ { NULL, "O" }, /* | \"O "O */
+ { NULL, "U" }, /* | \"U "U */
+ { NULL, "ss" }, /* \ss "s */
+ { NULL, "SS" }, /* \SS "S */
+ { NULL, "ss" }, /* \sz "z */ /* new in 2.1 */
+ { NULL, "SS" }, /* \SZ "Z */ /* new in 2.1 */
+ { NULL, "" }, /* \flqq "< */ /* new in 2.2 */
+ { NULL, "" }, /* \frqq "> */ /* new in 2.2 */
+ { NULL, "" }, /* \glqq "` */ /* new in 2.2 */
+ { NULL, "" }, /* \grqq "' */ /* new in 2.2 */
+ { NULL, "" }, /* \/ "| */ /* new in 2.2 */
+ { NULL, "" }, /* \- "- */ /* new in 2.2 */
+ { NULL, "c" }, /* [c-] "c */ /* \ */
+ { NULL, "C" }, /* [C-] "C */ /* | */
+ { NULL, "l" }, /* [l-] "l */ /* | */
+ { NULL, "L" }, /* [L-] "L */ /* | */
+ { NULL, "m" }, /* [m-] "m */ /* | */
+ { NULL, "M" }, /* [M-] "M */ /* | */
+ { NULL, "n" }, /* [n-] "n */ /* | new */
+ { NULL, "N" }, /* [N-] "N */ /* | in */
+ { NULL, "p" }, /* [p-] "p */ /* | 2.2 */
+ { NULL, "P" }, /* [P-] "P */ /* | */
+ { NULL, "r" }, /* [r-] "r */ /* | */
+ { NULL, "R" }, /* [R-] "R */ /* | */
+ { NULL, "t" }, /* [t-] "t */ /* | */
+ { NULL, "T" }, /* [T-] "T */ /* | */
+ { NULL, "f" }, /* [f-] "f */ /* | */
+ { NULL, "F" }, /* [F-] "F */ /* / */
+ { NULL, "-" }, /* \hy "= */ /* new in 2.2 */
+ { NULL, "-" }, /* \fhy "~ */ /* new in 2.2 */
+ { NULL, "" }, /* / \" " */
+ { NULL, "ss" }, /* \3 [] */
+ { NULL, "ck" }, /* \ck */ /* new in 2.2 */
+ { NULL, "CK" }, /* \CK */ /* new in 2.2 */
+ { NULL, "ss" }, /* [s-s] */ /* \ */
+ { NULL, "SS" }, /* [S-S] */ /* | new */
+ { NULL, "ss" }, /* [-ss] */ /* | in */
+ { NULL, "SS" }, /* [-SS] */ /* | 2.2 */
+ { NULL, "ss" }, /* [s-s/-ss] */ /* | */
+ { NULL, "SS" }, /* [S-S/-SS] */ /* / */
+ { NULL, NULL }};
+
+
+
+int texlistnum(const char *p, int n, const char *list[][2])
+{
+ const char *entry, *line;
+ int i = 0;
+
+ while (i < n)
+ {
+ entry = list[i][0];
+ line = p;
+ while (*line == *entry && *entry != '\0' && *entry != '\t')
+ { ++line; ++entry;
+ }
+ if (*entry == '\0' || (*entry == '\t' && isLaTeXcmdletter(*line) == 0)) break;
+ ++i;
+ }
+
+ if (i == n) return -1;
+ else return i;
+}
+
+
+int insposmaxstr(char s[], const char *p, int pos, int max)
+{
+ while(*p != '\0' && pos < max) s[pos++] = *p++;
+ s[pos] = '\0';
+ return pos;
+}
+
+
+int llstrlen(const char *s)
+{
+ int len = 0;
+
+ while (*s != '\0' && *s != '\t') { ++s; ++len; }
+
+ return len;
+}
+
+
+char *overspacesafterlettercmd(int len, const char *q, char *p)
+{
+ if (len > 0 && isLaTeXcmdletter(*(q+1)) != 0) while (*p == ' ') ++p;
+
+ return p;
+}
+
+
+int insertweight(char in[], int i, int pos, int max)
+{
+ if (german == 1) pos = insposmaxstr(in, gweight[i][1], pos, max);
+ else if (german == 2) pos = insposmaxstr(in, mweight[i][1], pos, max);
+ else pos = insposmaxstr(in, udtable[i][1], pos, max);
+
+ return pos;
+}
+
+
+int nichtvorziehen(char a)
+{
+ if (issonder(a) == 1 && a != '')
+ return 1; /* 31 */
+ return 0;
+}
+
+
+void nzvorziehen(char in[], char *p)
+{
+ int pos = 0, l;
+ char mem;
+
+ while (*p != '\0')
+ {
+ if (nichtvorziehen(*p) == 1)
+ {
+ l = pos;
+ while (nichtvorziehen(*p) == 1) in[l++] = *p++;
+ mem = in[l-1];
+ in[l-1] = in[pos];
+ in[pos] = mem;
+ pos = l;
+ }
+ else in[pos++] = *p++;
+ }
+ in[pos] = '\0';
+}
+
+
+char *austauschen(char in[], char *p, int dqcat)
+{
+ int pos = 0, i, len;
+
+ while (*p != '\0' && pos < MAXLEN-1)
+ {
+ if (*p == '\\') /* "\\\\" ist schon ' ' */
+ {
+ if ((i=texlistnum(p, NUMTEX, udtable)) > -1)
+ { p += (len=llstrlen( udtable[i][0]));
+ pos = insertweight(in, i, pos, MAXLEN-1);
+ p = overspacesafterlettercmd(len, udtable[i][0], p);
+ }
+ else if ((i=texlistnum(p, NLATEX, weighttable)) > -1)
+ { p += (len=llstrlen( weighttable[i][0]));
+ pos = insposmaxstr(in, weighttable[i][1], pos, MAXLEN-1);
+ p = overspacesafterlettercmd(len, weighttable[i][0], p);
+ }
+ else if (*(p+1) == '~') p += 2; /* falls \~ nicht in weighttable */
+ else if (isLaTeXcmdletter(*(p+1)) != 0)
+ { ++p; while (isLaTeXcmdletter(*p) != 0) ++p;
+ while (*p == ' ') ++p;
+ }
+ else
+ {
+ if (issonder(*p) == 0) in[pos++] = *p;
+ ++p;
+ }
+ }
+ else
+ if (*p == '\"' && dqcat == TeXACTIVE) /* nogsty == 0 */
+ {
+ if (*(p+1) == '\"') p += 2; /* "" ist nicht in gstylist */
+ else /* "~ muss in gstylist sein */
+ if ((i=texlistnum(p, NUMGER, gstylist)) > -1)
+ { p += llstrlen( gstylist[i][0]);
+ pos = insertweight(in, i, pos, MAXLEN-1);
+ }
+ else
+ {
+ if (issonder(*p) == 0) in[pos++] = *p;
+ ++p;
+ }
+ }
+ else if (*p == '~') /* MARK_TILDE */
+ {
+ in[pos++] = ' ';
+ ++p;
+ }
+ else
+ {
+ if (issonder(*p) == 0) in[pos++] = *p;
+ ++p;
+ }
+ }
+
+ in[pos] = '\0';
+
+ return in;
+}
+
+
+void kill_unnecessary_spaces(char *s, char *p)
+{
+
+ while (*p == ' ') ++p;
+
+ while (*p != '\0')
+ {
+ if (*p == ' ' && *(p+1) == ' ') ++p;
+ else if (*p == ' ' && *(p+1) == '\0') break;
+ else *s++ = *p++;
+ }
+
+ *s = '\0';
+}
+
+
+void swapBCstrs(const int linec)
+{
+ char *p;
+
+ p = subBptr[0][linec];
+ subBptr[0][linec] = subBptr[1][linec];
+ subBptr[1][linec] = p;
+
+ p = subCptr[0][linec];
+ subCptr[0][linec] = subCptr[1][linec];
+ subCptr[1][linec] = p;
+}
+
+
+static char *teinzerw[] = {
+ "\\u{A}", /* 128 */
+ "\\k{A}", /* 129 */
+ "\\\'C", /* 130 */
+ "\\v{C}", /* 131 */
+ "\\v{D}", /* 132 */
+ "\\v{E}", /* 133 */
+ "\\k{E}", /* 134 */
+ "\\u{G}", /* 135 */
+ "\\\'L", /* 136 */
+ "\\v{L}", /* 137 */
+ "\\L{}", /* 138 */
+ "\\\'N", /* 139 */
+ "\\v{N}", /* 140 */
+ "\\NG{}", /* 141 */
+ "\\H{O}", /* 142 */
+ "\\\'R", /* 143 */
+ "\\v{R}", /* 144 */
+ "\\\'S", /* 145 */
+ "\\v{S}", /* 146 */
+ "\\c{S}", /* 147 */
+ "\\v{T}", /* 148 */
+ "\\c{T}", /* 149 */
+ "\\H{U}", /* 150 */
+ "\\r{U}", /* 151 */
+ "\\\"Y", /* 152 */
+ "\\\'Z", /* 153 */
+ "\\v{Z}", /* 154 */
+ "\\.Z", /* 155 */
+ "\\IJ{}", /* 156 */
+ "\\.I", /* 157 */
+ "\\dj{}", /* 158 */
+ "\\S{}", /* 159 */ /* eigentl. "\\textsection{}" */
+ "\\u{a}", /* 160 */
+ "\\k{a}", /* 161 */
+ "\\\'c", /* 162 */
+ "\\v{c}", /* 163 */
+ "\\v{d}", /* 164 */
+ "\\v{e}", /* 165 */
+ "\\k{e}", /* 166 */
+ "\\u{g}", /* 167 */
+ "\\\'l", /* 168 */
+ "\\v{l}", /* 169 */
+ "\\l{}", /* 170 */
+ "\\\'n", /* 171 */
+ "\\v{n}", /* 172 */
+ "\\ng{}", /* 173 */
+ "\\H{o}", /* 174 */
+ "\\\'r", /* 175 */
+ "\\v{r}", /* 176 */
+ "\\\'s", /* 177 */
+ "\\v{s}", /* 178 */
+ "\\c{s}", /* 179 */
+ "\\v{t}", /* 180 */
+ "\\c{t}", /* 181 */
+ "\\H{u}", /* 182 */
+ "\\r{u}", /* 183 */
+ "\\\"y", /* 184 */
+ "\\\'z", /* 185 */
+ "\\v{z}", /* 186 */
+ "\\.z", /* 187 */
+ "\\ij{}", /* 188 */
+ "!`", /* 189 */ /* eigentl. "\\textexclamdown{}" */
+ "\?`", /* 190 */ /* eigentl. "\\textquestiondown{}" */
+ "\\pounds{}",/* 191 */ /* eigentl. "\\textsterling{}" */
+ "\\`A", /* 192 */
+ "\\\'A", /* 193 */
+ "\\^A", /* 194 */
+ "\\~A", /* 195 */
+ "\\\"A", /* 196 */
+ "\\r{A}", /* 197 */
+ "\\AE{}", /* 198 */
+ "\\c{C}", /* 199 */
+ "\\`E", /* 200 */
+ "\\\'E", /* 201 */
+ "\\^E", /* 202 */
+ "\\\"E", /* 203 */
+ "\\`I", /* 204 */
+ "\\\'I", /* 205 */
+ "\\^I", /* 206 */
+ "\\\"I", /* 207 */
+ "\\DH{}", /* 208 "\\DJ{}", 208 */
+ "\\~N", /* 209 */
+ "\\`O", /* 210 */
+ "\\\'O", /* 211 */
+ "\\^O", /* 212 */
+ "\\~O", /* 213 */
+ "\\\"O", /* 214 */
+ "\\OE{}", /* 215 */
+ "\\O{}", /* 216 */
+ "\\`U", /* 217 */
+ "\\\'U", /* 218 */
+ "\\^U", /* 219 */
+ "\\\"U", /* 220 */
+ "\\\'Y", /* 221 */
+ "\\TH{}", /* 222 */
+ "\\SS{}", /* 223 */
+ "\\`a", /* 224 */
+ "\\\'a", /* 225 */
+ "\\^a", /* 226 */
+ "\\~a", /* 227 */
+ "\\\"a", /* 228 */
+ "\\r{a}", /* 229 */
+ "\\ae{}", /* 230 */
+ "\\c{c}", /* 231 */
+ "\\`e", /* 232 */
+ "\\\'e", /* 233 */
+ "\\^e", /* 234 */
+ "\\\"e", /* 235 */
+ "\\`\\i{}", /* 236 */
+ "\\\'\\i{}", /* 237 */
+ "\\^\\i{}", /* 238 */
+ "\\\"\\i{}", /* 239 */
+ "\\dh{}", /* 240 */
+ "\\~n", /* 241 */
+ "\\`o", /* 242 */
+ "\\\'o", /* 243 */
+ "\\^o", /* 244 */
+ "\\~o", /* 245 */
+ "\\\"o", /* 246 */
+ "\\oe{}", /* 247 */
+ "\\o{}", /* 248 */
+ "\\`u", /* 249 */
+ "\\\'u", /* 250 */
+ "\\^u", /* 251 */
+ "\\\"u", /* 252 */
+ "\\\'y", /* 253 */
+ "\\th{}", /* 254 */
+ "\\ss{}"}; /* 255 */
+
+char *getTONEenc(unsigned char c)
+{
+ if (c >= 128 && c <= 255)
+ return teinzerw[c-128];
+ else return "";
+}
+
+
+void erweitert(char in[], const char *p)
+{
+ int pos = 0;
+
+ if (encode == 1)
+ {
+ while (*p != '\0' && pos < MAXLEN-1)
+ {
+ if (*p < 0) pos = insposmaxstr(in, getTONEenc(upperascii = *p), pos, MAXLEN-1);
+ else in[pos++] = *p;
+ ++p;
+ }
+ }
+ else
+ {
+ while (*p != '\0' && pos < MAXLEN-1)
+ {
+ if (*p > 0) in[pos++] = *p;
+ else upperascii = *p;
+ ++p;
+ }
+ }
+ in[pos] = '\0';
+}
+
+
+const char *transformtable[][2] = {
+ { "\\\\", "[]" },
+ { "\\vspace\t", "{}" },
+ { "\\hspace\t", "{}" },
+ { "\\nosort\t", "{}" },
+ { "\\index\t", "{}" },
+ { "\\glossary\t", "{}" },
+ { "\\label\t", "{}" },
+ { "\\pbalabel\t", "{}" },
+ { "\\balabel\t", "{}" },
+ { "\\pageref\t", "{}" },
+ { "\\pbaref\t", "[]{}" },
+ { "\\baref\t", "[]{}" },
+ { "\\ref\t", "{}" },
+ { "\\linebreak\t", "[]" },
+ { "\\nolinebreak\t", "[]" },
+ { "\\pagebreak\t", "[]" },
+ { "\\nopagebreak\t", "[]" },
+ { "\\footnote\t", "[]{}" },
+ { "\\footnotetext\t", "[]{}" },
+ { "\\footnotemark\t", "[]" },
+ { "\\framebox\t", "[][]" },
+ { "\\makebox\t", "[][]" },
+ { "\\parbox\t", "[]{}" },
+ { "\\raisebox\t", "{}[][]" },
+ { "\\rule\t", "[]{}{}" },
+ { "\\printonlyvqu\t", "[]{}{}*{}{}" }, /* innerVcmd */
+ { "\\vqu\t", "[]{}{}*{}{}" },
+ { "\\printonlyvli\t", "[]{}{}*{}{}" }, /* olny */
+ { "\\vli\t", "[]{}{}*{}{}" },
+ { "\\xprintonlyvqu\t", "[]{}{}*{}{}" }, /* changes */
+ { "\\xvqu\t", "[]{}{}*{}{}" },
+ { "\\xprintonlyvli\t", "[]{}{}*{}{}" }, /* IS_V */
+ { "\\xvli\t", "[]{}{}*{}{}" },
+ { "\\@shadowba\t", "{}" }, /* new. in 2.2 */
+ { "\\shadowv\t", "[]{}{}{}{}" },
+ { "\\addtovli\t", "[]{}{}{}{}" },
+ { "\\addtovqu\t", "[]{}{}{}{}" },
+ { "\\xaddtovli\t", "[]{}{}{}{}" },
+ { "\\xaddtovqu\t", "[]{}{}{}{}" },
+ { "\\printonlykqu\t", "[]{}*{}{}" },
+ { "\\printonlykli\t", "[]{}*{}{}" },
+ { "\\xprintonlykqu\t", "[]{}*{}{}" },
+ { "\\xprintonlykli\t", "[]{}*{}{}" },
+ { "\\shadowk\t", "[]{}{}{}" },
+ { "\\addtokli\t", "[]{}{}{}" },
+ { "\\addtokqu\t", "[]{}{}{}" },
+ { "\\xaddtokli\t", "[]{}{}{}" },
+ { "\\xaddtokqu\t", "[]{}{}{}" },
+ { "\\frac\t", "{}{}" },
+ { "\\vauthor\t", "{}{}" },
+ { "\\midvauthor\t", "{}{}" },
+ { "\\kauthor\t", "{}" },
+ { "\\midkauthor\t", "{}" },
+ { "\\ersch\t", "{}[]{}{}" },
+ { "\\persch\t", "{}[]{}{}" },
+ { "\\printonlyper\t", "{}" },
+ { "\\printonlyarq\t", "[]{}{}" }, /* new in 2.2 */
+ { "\\printonlydefabk\t", "{}{}" }, /* new in 2.2 */
+ { "\\printonlyabkdef\t", "{}{}" }, /* new in 2.2 */
+ { "\\shadowo\t", "{}" },
+ { "\\addtoper\t", "{}" },
+ { "\\shadowt\t", "{}{}" },
+ { "\\addtoarq\t", "{}{}" },
+ { "\\shadowone\t", "{}" },
+ { "\\addtoabk\t", "{}" },
+ { "\\addtogrr\t", "{}" },
+ { "\\addtoprr\t", "{}" },
+ { "\\addtosrr\t", "{}" },
+ { "\\shadowtwo\t", "{}{}" },
+ { "\\fillper\t", "{}{}" },
+ { "\\fillarq\t", "{}{}" },
+ { "\\fillgrr\t", "{}{}" },
+ { "\\fillprr\t", "{}{}" },
+ { "\\fillsrr\t", "{}{}" },
+ { "\\addtodefabk\t", "{}{}" },
+ { "\\addtoabkdef\t", "{}{}" },
+ { "\\errmessage\t", "{}" },
+ { "\\GenericError\t", "{}{}{}{}" },
+ { "\\message\t", "{}" },
+ { "\\typeout\t", "{}" },
+ { "\\mathhexbox\t", "{}{}{}" },
+ { "\\phantom\t", "{}" },
+ { "\\vphantom\t", "{}" },
+ { "\\hphantom\t", "{}" },
+ { "\\showhyphens\t", "{}" },
+ {"\\sethyphenation\t", "{}" },
+ {"\\selectlanguage\t", "{}" },
+ { "\\discretionary\t", "{}{}" },
+ { "\\pstressing\t", "{}" },
+ { "\\stressing\t", "{}" },
+ { "\\pxbibmark\t", "{}{}" }, /* Nur \\p... */
+ { "\\pxbibref\t", "{}" }, /* bearbeiten! */
+ { "\\pbibmark\t", "{}" },
+ { "\\bibmark\t", "{}" },
+ { KURZCMD, "{}" },
+ { "\\delkurz\t", "{}" },
+ { "\\begin\t", "{}" },
+ { "\\end\t", "{}" },
+ { "\\pfordinal\t", "{}" }, /* new in 2.2 */
+ { NULL, NULL }};
+#define NUMTRANSV 99
+
+
+/* Muessen im Bereich von issonder liegen: */
+#define WINGBR 25
+#define ANGUBR 24
+#define ROUNDBR 23
+#define OPTSTAR 22
+
+char *bracketsformward(char *q, char c)
+{
+ if (c == '}') *q = WINGBR;
+ else if (c == ']') *q = ANGUBR;
+ else if (c == ')') *q = ROUNDBR;
+ else intern_err(9); /* BRACKETS LOST */
+ return q;
+}
+
+
+void exchange_v(char *p, const char *bra, int num)
+{
+ int l = 0, la = 0, i = 0, lb = 0, j = 0, k;
+ char buf[MAXLEN], fub[MAXLEN], *lp = p, *anf = p;
+
+ while (*p == ' ') { ++p; ++la; }
+ if ((l=nextbracket(p, *(bra+(3*num+1)), *(bra+(3*num+2)))) > 0)
+ {
+ la += l; while (i < la) buf[i++] = *lp++;
+ p += l;
+ if (*(bra+(3*(num+1))) == '')
+ {
+ while (*p == ' ') { ++p; ++lb; }
+ if ((l=nextbracket(p, *(bra+(3*(num+1)+1)), *(bra+(3*(num+1)+2)))) > 0)
+ {
+ lb += l; while (j < lb) fub[j++] = *lp++;
+ k = 0; while (k < j) *anf++ = fub[k++];
+ k = 0; while (k < i) *anf++ = buf[k++];
+ }
+ }
+ else intern_err(10); /* No formatter Strg+Q after Strg+P */
+ }
+}
+
+
+char *handletransformarg(char *p, const char *bra)
+{
+ int l = 0, num = 0;
+ char *q = p;
+
+ while (*(bra+(3*num)) != '\0' && *q != '\0')
+ {
+ if ('' == *(bra+(3*num)) || '' == *(bra+(3*num)))
+ {
+ while (*q == ' ') ++q;
+ if ((l=nextbracket(q, *(bra+(3*num+1)), *(bra+(3*num+2)))) < 2) l = 0;
+ q += l;
+ if ('' == *(bra+(3*num)))
+ {
+ while (*q == ' ') ++q;
+ }
+ p = q;
+ }
+ else
+ if ('' == *(bra+(3*num)))
+ {
+ if (*(bra+(3*num+1)) == '' && *(bra+(3*num+2)) == '')
+ {
+ if ((l=nextbracket(q, '(', ')')) < 2 && (l=nextbracket(q, '[', ']')) < 2) l = 0;
+ }
+ else
+ if (*(bra+(3*num+1)) == '' && *(bra+(3*num+2)) == '')
+ {
+ if (*q == '_')
+ {
+ l = 1;
+ while (*(q+l) != '_' && *(q+l) != '\0') ++l;
+ if (*(q+l) == '_') ++l;
+ else if (*(q+l) == '\0') l = 0;
+ }
+ else
+ if (*q == '|')
+ {
+ l = 1;
+ while (*(q+l) != '|' && *(q+l) != '\0') ++l;
+ if (*(q+l) == '|') ++l;
+ else if (*(q+l) == '\0') l = 0;
+ }
+ else l = 0;
+ }
+ else l = 0;
+ q += l;
+ p = q;
+ }
+ else
+ if ('' == *(bra+(3*num)))
+ {
+ while (*q == ' ') ++q;
+ if (*q == '*')
+ {
+ ++q;
+ while (*q == ' ') ++q;
+ if ((l=nextbracket(q, *(bra+(3*num+1)), *(bra+(3*num+2)))) < 2) l = 0;
+ q += l;
+ p = q;
+ }
+ }
+ else
+ if ('' == *(bra+(3*num)))
+ {
+ while (*q == ' ') ++q;
+ if (*q == '*') ++q;
+ while (*q == ' ') ++q;
+ if (*q != *(bra+(3*num+1)) || (l=nextbracket(q, *(bra+(3*num+1)), *(bra+(3*num+2)))) < 2) l = 0;
+ q += l;
+ p = q;
+ }
+ else
+ if ('' == *(bra+(3*num)) || '' == *(bra+(3*num)) || '' == *(bra+(3*num)))
+ {
+ if ('' == *(bra+(3*num))) exchange_v(q, bra, num);
+ while (*q == ' ') ++q;
+ if ((l=nextbracket(q, *(bra+(3*num+1)), *(bra+(3*num+2)))) < 2) l = 0;
+ if (l > 0)
+ {
+ q += l-1;
+ q = bracketsformward(q, *(bra+(3*num+2)));
+ ++q;
+ }
+ }
+ else
+ if ('*' == *(bra+(3*num)))
+ {
+ while (*q == ' ') ++q;
+ if (*q == '*')
+ { *q = OPTSTAR;
+ ++q;
+ while (*q == ' ') ++q;
+ if ((l=nextbracket(q, *(bra+(3*num+1)), *(bra+(3*num+2)))) < 2) l = 0;
+ if (l > 0)
+ {
+ q += l-1;
+ q = bracketsformward(q, *(bra+(3*num+2)));
+ ++q;
+ }
+ }
+ }
+ ++num;
+ }
+
+ return p;
+}
+
+
+void transformline(char buf[], char *p)
+{
+ int pos = 0, i, l;
+
+ while (*p != '\0' && pos < MAXLEN-2)
+ {
+ if (*p == '\\')
+ {
+ if ((i=texlistnum(p, NUMTRANSV, transformtable)) > -1)
+ {
+ if (*(p+1) == '\\') buf[pos++] = ' ';
+ p += llstrlen(transformtable[i][0]);
+ p = handletransformarg(p, transformtable[i][1]);
+ }
+ else buf[pos++] = *p++;
+ }
+ else
+ if (issonder(*p) == 1)
+ {
+ if (*p == OPTSTAR);
+ else
+ {
+ if (*p == WINGBR) buf[pos++] = '}';
+ else if (*p == ANGUBR) buf[pos++] = ']';
+ else if (*p == ROUNDBR) buf[pos++] = ')';
+ else intern_err(11); /* unknown bracket symbol */
+ buf[pos++] = ' ';
+ }
+ ++p;
+ while (*p == ' ') ++p;
+ }
+ else buf[pos++] = *p++;
+ }
+
+ buf[pos] = '\0';
+}
+
+
+void nosondercpy(char *s, const char *p)
+{
+ while (*p != '\0')
+ { if (issonder(*p) == 0) *s++ = *p;
+ ++p;
+ }
+ *s = '\0';
+}
+
+
+const char *overbago(const char *s)
+{
+ const char *p = s;
+ int got = 0;
+
+ if (bago > 0)
+ {
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\')
+ {
+ ++p;
+ }
+ else
+ if (lcmdcmp(p, BAGOCMD) == 0)
+ {
+ p+=strlen(BAGOCMD);
+ while (*p == ' ') ++p;
+ got = 1;
+ break;
+ }
+ }
+ ++p;
+ }
+ }
+
+ if (got == 0) return s;
+ return p;
+}
+
+
+void vorbereiten(int linec, int alllines, int deepsort, int ventry)
+{
+ char *p, in[MAXLEN], out[MAXLEN], num[2*NUMLEN], last, buf[MAXLEN];
+ int pos, i, l;
+
+ /* dqsort geht bis zur Tiefe deepsort, nicht deep */
+
+ while (linec < alllines)
+ {
+ i = 0; while (i < MAXBACOLS) subBptr[i++][linec] = mydefault;
+ i = 0; while (i < MAXBACOLS) subCptr[i++][linec] = mydefault;
+
+
+ i = 0;
+ while (i < deepsort)
+ {
+ nosondercpy ( in, overbago(subAptr[i][linec]));
+ transformline(buf, in); /* veraendert zweites Arg! */
+ erweitert ( in, buf);
+ p = austauschen(buf, in, dqsort[linec]);
+
+
+ pos = 0; last = '\0';
+ while (*p != '\0' && pos < MAXLEN-1)
+ {
+ if ( isalpha (*p) != 0
+ || issonder(*p) == 1
+ || *p == ' '
+ || *p == '-'
+ || (*p == '.' && registpoints == 1) /* nur zusammen mit MARK_POINT */
+ )
+ {
+ if (*p == ' ' && ignorespaces == 1)
+ {
+ if (pos > 0 && out[pos-1] == '') --pos;
+ out[pos] = ''; /* 31 */
+ }
+ else
+ if (*p == '-') /* MINUS */
+ {
+ out[pos] = ''; /* 31 */
+ if (hy_as_space == 1 && pos < MAXLEN-2)
+ out[++pos] = ' ';
+ }
+ else out[pos] = *p;
+
+ ++pos;
+ }
+ else
+ if (isdigit(*p) != 0 && last != '\\')
+ {
+ p = standardnum(num, p);
+ out[pos] = '\0';
+ strncat(out, num, MAXLEN-strlen(out)-1);
+ pos = strlen(out);
+ --p;
+ }
+
+ last = *p;
+ ++p;
+ }
+
+ out[pos] = '\0';
+
+ kill_unnecessary_spaces(in, out);
+
+ nzvorziehen(out, in);
+
+ subBptr[i][linec] = strnmalloc(out, strlen(out)+1);
+
+ pos = 0;
+ l = 0;
+ while (out[pos] != '\0')
+ {
+ if (issonder(out[pos]) == 0)
+ {
+ in[l] = toupper(out[pos]);
+ if (igleichj == 1 && in[l] == 'I') in[l] = 'J';
+ ++l;
+ }
+ ++pos;
+ }
+ subCptr[i][linec] = strnmalloc(in, l+1);
+
+ ++i;
+ }
+
+ if (ventry == IS_V && *subAptr[0][linec] == '\0') swapBCstrs(linec);
+
+ ++linec;
+ }
+}
+
+
+int isvintroduced(int i)
+{
+ const char *p = subRptr[STUFFRCOL][i];
+
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ p += nextbracket(p, '{', '}');
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ p += nextbracket(p, '{', '}');
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ ++p;
+ while (*p == ' ') ++p;
+
+ if (*p == KENTRYCH)
+ {
+ ++p;
+ while (*p == ' ') ++p;
+
+ if (*p == '}') return KENTRY;
+ }
+
+ if (*p == VENTRYCH)
+ {
+ ++p;
+ while (*p == ' ') ++p;
+
+ if (*p == '}') return VENTRY;
+ }
+ }
+ }
+ }
+
+ return ERRENTRY;
+}
+
+
+int getthirdnum(int i)
+{
+ const char *p = subRptr[STUFFRCOL][i];
+
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ p += nextbracket(p, '{', '}');
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ p += nextbracket(p, '{', '}');
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ ++p;
+ while (*p == ' ') ++p;
+
+ return getarabicnum(p);
+ }
+ }
+ }
+
+ return 0;
+}
+
+
+int notfirstaccepted(int line)
+{
+ int r = 0, acceptbefore = 0;
+
+ while(r < line)
+ { if (leval[r] == ACCEPTLINE) { ++acceptbefore; break; }
+ ++r;
+ }
+
+ return acceptbefore;
+}
+
+
+void dofourtharg(int line)
+{
+ const char *p = subRptr[STUFFRCOL][line];
+ int l = 0;
+
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ p += nextbracket(p, '{', '}');
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ p += nextbracket(p, '{', '}');
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ p += nextbracket(p, '{', '}');
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ l = nextbracket(p, '{', '}');
+
+ if (l > 2)
+ {
+ ++p; l -= 2;
+ while (*p == ' ') { ++p; --l; };
+
+ if (l > 0)
+ {
+ fprintf(outfile, " %.*s\n %%%% <- Your extra-command(s)", l, p);
+ if (notfirstaccepted(line) == 0)
+ fprintf(outfile, " before the 1st item");
+ fprintf(outfile, ".\n");
+ }
+ }
+ }
+ }
+ }
+ }
+
+}
+
+
+void getfirsttwoargs(char *s, const char *p)
+{
+ int len;
+
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ if ((len=nextbracket(p, '{', '}')) < MAXLEN-1)
+ {
+ while(len-- > 0) *s++ = *p++;
+
+ while (*p == ' ') ++p;
+
+ if (*p == '{')
+ {
+ if (len + (len=nextbracket(p, '{', '}')) < MAXLEN-1)
+ {
+ while(len-- > 0) *s++ = *p++;
+ }
+ }
+ }
+ }
+ *s = '\0';
+}
+
+
+int baidxloop(int cloop, const char *p)
+{
+ cloop += fprintf(outfile, "%s", p);
+
+ if (cloop > BAINDEXLEN)
+ {
+ fprintf(outfile, "%s", BAINDEXEND);
+ fprintf(outfile, "%s", BAINDEXFOLL); /* neustart cloop */
+ cloop = CLOOPBSTART;
+ }
+
+ return cloop;
+}
+
+
+char *negnum(char *p)
+{
+ if (*p == '-') return "\\,";
+ return "";
+}
+
+
+int printipagefnt(const char *arraysep, int begin, int end, int lasti, int cloop)
+{
+ int fnc, pnc;
+
+ if ( lasti > -1
+ && pagewgt[begin] == pagewgt[lasti]
+ && numcmp(1, pagewgt[begin], subRptr[PAGECOL][lasti], subRptr[PAGECOL][begin]) == 0
+ )
+ {
+ cloop += fprintf(outfile, "$^{,}$");
+ cloop = baidxloop(cloop, BS_SPACE);
+ }
+ else
+ {
+ cloop = baidxloop(cloop, arraysep);
+ if (pagewgt[begin] == MISSNUM) cloop += fprintf(outfile, "{%s}", MISSINGSYMB);
+ else if (pagewgt[begin] == EMPTYNUM) cloop += fprintf(outfile, "%s", EMPTYSYMB);
+ else if (pagewgt[begin] == OVERFLOW) cloop += fprintf(outfile, "%s", OVERFLOWSYMB);
+ else if (pagewgt[begin] == INTERNALERR) intern_err(12); /* Bad pageno */
+ else if (pagewgt[begin] == UNUSED) intern_err(13); /* Unused pageno */
+ else if (pagewgt[begin] == TEXT) cloop += fprintf(outfile, "%s%s%s", TEXTSYMBOPEN[notext], subRptr[PAGECOL][begin], TEXTSYMBCLOSE[notext]);
+ else cloop += fprintf(outfile, "%s", subRptr[PAGECOL][begin]);
+ }
+
+ if (end > begin)
+ {
+ fnc = numcmp(0, fntwgt[begin], subRptr[FNTCOL][end], subRptr[FNTCOL][begin]);
+ pnc = numcmp(1, pagewgt[begin], subRptr[PAGECOL][end], subRptr[PAGECOL][begin]);
+
+ if (fnc == 1)
+ {
+ if (pnc > 0)
+ {
+ cloop += fprintf(outfile, "$^{%s}$", subRptr[FNTCOL][begin]);
+ cloop = baidxloop(cloop, BANCOMMA);
+ }
+ else
+ {
+ cloop += fprintf(outfile, "$^{%s}$$^{,}$", subRptr[FNTCOL][begin]);
+ cloop = baidxloop(cloop, BS_SPACE);
+ }
+
+ if (pnc > 0)
+ {
+ cloop += fprintf(outfile, "%s$^{", subRptr[PAGECOL][end]);
+ }
+ else
+ {
+ cloop += fprintf(outfile, "$^{");
+ }
+ }
+ else
+ if (fnc > 1)
+ {
+ if (pnc > 0)
+ {
+ cloop += fprintf(outfile, "$^{%s}$--%s%s$^{", subRptr[FNTCOL][begin], negnum(subRptr[PAGECOL][end]), subRptr[PAGECOL][end]);
+ }
+ else
+ {
+ cloop += fprintf(outfile, "$^{%s-", subRptr[FNTCOL][begin]);
+ }
+ }
+ else
+ if ( fntwgt[end] != INTERNALERR
+ && fntwgt[end] != NOFOOTNOTE
+ )
+ cloop += fprintf(outfile, "$^{");
+ }
+ else cloop += fprintf(outfile, "$^{");
+
+ if ( fntwgt[end] == MISSNUM) cloop += fprintf(outfile, "%s}$", MISSINGSYMB);
+ else if ( fntwgt[end] == EMPTYNUM) cloop += fprintf(outfile, "%s}$", EMPTYSYMB);
+ else if ( fntwgt[end] == OVERFLOW) cloop += fprintf(outfile, "%s}$", OVERFLOWSYMB);
+ else if ( fntwgt[end] == INTERNALERR) intern_err(14); /* Bad fntno */
+ else if ( fntwgt[end] == NOFOOTNOTE) intern_err(15); /* That is not a footnote */
+ else if ( fntwgt[end] == TEXT) cloop += fprintf(outfile, "%s%s%s}$", TEXTSYMBOPEN[notext], subRptr[FNTCOL][end], TEXTSYMBCLOSE[notext]);
+ else cloop += fprintf(outfile, "%s%s}$", negnum(subRptr[FNTCOL][end]), subRptr[FNTCOL][end]);
+
+ return cloop;
+}
+
+
+int printipage(const char *arraysep, int begin, int end, int cloop)
+{
+ int pnc;
+
+ cloop = baidxloop(cloop, arraysep);
+ if (pagewgt[begin] == MISSNUM) cloop += fprintf(outfile, "{%s}", MISSINGSYMB);
+ else if (pagewgt[begin] == EMPTYNUM) cloop += fprintf(outfile, "%s", EMPTYSYMB);
+ else if (pagewgt[begin] == OVERFLOW) cloop += fprintf(outfile, "%s", OVERFLOWSYMB);
+ else if (pagewgt[begin] == TEXT) cloop += fprintf(outfile, "%s%s%s", TEXTSYMBOPEN[notext], subRptr[PAGECOL][begin], TEXTSYMBCLOSE[notext]);
+ else cloop += fprintf(outfile, "%s", subRptr[PAGECOL][begin]);
+
+ if (end > begin)
+ {
+ pnc = numcmp(1, pagewgt[begin], subRptr[PAGECOL][end], subRptr[PAGECOL][begin]);
+ if (pnc == 1)
+ {
+ cloop = baidxloop(cloop, BANCOMMA);
+ cloop += fprintf(outfile, "%s", subRptr[PAGECOL][end]);
+ }
+ else if (pnc > 1)
+ {
+ cloop += fprintf(outfile, "--%s%s", negnum(subRptr[PAGECOL][end]), subRptr[PAGECOL][end]);
+ }
+ }
+
+ return cloop;
+}
+
+
+void makeipagefnt(int i, int line, int end)
+{
+ int begblock, lasti = -1, j, k, cloop = CLOOPASTART;
+ char *asfirst = "";
+ char *assecond = BANCOMMA;
+ char *arraysep = asfirst;
+
+
+ while (i <= end && pagewgt[i] == UNUSED) ++i;
+
+
+ if (i <= end)
+ {
+
+ while (i <= end)
+ {
+ if (cloop == CLOOPASTART)
+ {
+ fprintf(outfile, "%s", BAINDEXFIRS); /* Erststart cloop */
+ cloop = CLOOPBSTART;
+ }
+ else
+ if (cloop == CLOOPBSTART) intern_err(16);
+
+ begblock = i;
+
+ if (fntwgt[i] == NOFOOTNOTE) /* Seiten ohne FNTs */
+ {
+ while (i < end)
+ {
+ if ( fntwgt[i] == NOFOOTNOTE
+ && fntwgt[i+1] == NOFOOTNOTE
+ && pagewgt[i] != MISSNUM
+ && pagewgt[i] == pagewgt[i+1]
+ && ( (pagewgt[i] == TEXT && strcmp(subRptr[PAGECOL][i], subRptr[PAGECOL][i+1]) == 0)
+ || (pagewgt[i] != TEXT && ((j=numcmp(1, pagewgt[i], subRptr[PAGECOL][i+1], subRptr[PAGECOL][i])) == 0 || j == 1))
+ )
+ ) ++i;
+ else break;
+ }
+ cloop = printipage(arraysep, begblock, i, cloop);
+ lasti = -1;
+ }
+ else /* Seiten mit FNTs */
+ {
+ while (i < end)
+ {
+ k = -1;
+ if ( fntwgt[i] != NOFOOTNOTE
+ && pagewgt[i] != MISSNUM
+ && pagewgt[i] == pagewgt[i+1]
+ && ( (pagewgt[i] == TEXT && strcmp(subRptr[PAGECOL][i], subRptr[PAGECOL][i+1]) == 0)
+ || (pagewgt[i] != TEXT && ((k=numcmp(1, pagewgt[i], subRptr[PAGECOL][i+1], subRptr[PAGECOL][i])) == 0 || (k == 1 && FntIndexOverPages == 1)))
+ )
+ && fntwgt[i] != MISSNUM
+ && fntwgt[i] == fntwgt[i+1]
+ && ( ( fntwgt[i] == TEXT && (k == 0 || pagewgt[i] == TEXT)
+ && strcmp(subRptr[ FNTCOL][i], subRptr[ FNTCOL][i+1]) == 0)
+ || ( fntwgt[i] != TEXT && (((j=numcmp(0, fntwgt[i], subRptr[ FNTCOL][i+1], subRptr[ FNTCOL][i])) == 0 && k == 0) || j == 1))
+ )
+ ) ++i;
+ else break;
+ }
+ cloop = printipagefnt(arraysep, begblock, i, lasti, cloop);
+ lasti = i;
+ }
+
+ ++i;
+ arraysep = assecond;
+ }
+
+ fprintf(outfile, "%s", BAINDEXEND);
+ }
+}
+
+
+void makeindex(const int nlines, const int line, const int deepsort)
+{
+ int i, j, begin, end;
+
+ i = line;
+ while (i > 0 && leval[i-1] != REJECTLINE)
+ {
+ j = 0;
+ while (j < deepsort && texcmp(subAptr[j][i], subAptr[j][i-1], dqsort[i], dqsort[i-1]) == 0) ++j;
+ if (j < deepsort) break;
+ --i;
+ }
+ begin = i;
+
+ i = line;
+ while (i < nlines-1 && leval[i+1] != REJECTLINE)
+ {
+ j = 0;
+ while (j < deepsort && texcmp(subAptr[j][i], subAptr[j][i+1], dqsort[i], dqsort[i+1]) == 0) ++j;
+ if (j < deepsort) break;
+ ++i;
+ }
+ end = i;
+
+ makeipagefnt(begin, line, end);
+}
+
+
+void printsortline(int line, int deepsort)
+{
+ int l = 0;
+
+ if (deepsort > 0)
+ {
+ fprintf(outfile, " %s", METALINEHEAD);
+
+ while (l < deepsort)
+ {
+ fprintf(outfile, " (%s)", subBptr[l][line]);
+ ++l;
+ }
+
+ fprintf(outfile, "\n");
+ }
+}
+
+
+void del_ktitintro(char *s)
+{
+ while(*s != '\0')
+ {
+ if (*s == KTITINTROCH)
+ {
+ if (*(s+1) != '\0')
+ {
+ *s++ = KTITERRORCH; /* "????" is possible here, */
+ *s++ = KTITERRORCH; /* whereas BibArts prints "??" */
+ }
+ else
+ {
+ intern_err(30);
+ break;
+ }
+ }
+ else ++s;
+ }
+}
+
+
+int writetheline(char *p, const int nlines, const int line, const int deepsort, int filec, int printsort, int kandkused, int oktitused)
+{
+ int doprint = 0, pagenum = 0, fntnum = 0, uu = 0, tn = getthirdnum(line), j, ok, ie, sha, tha, uha, oerr;
+
+ if (*p != '%')
+ { if (leval[line] != ACCEPTLINE)
+ *p = '%';
+ intern_err(17); /* LINE WITHOUT \'%%\' */
+ }
+
+
+ if (leval[line] == ACCEPTLINE)
+ {
+ j = line-1;
+ while (j > 0 && leval[j] != ACCEPTLINE) --j;
+ if ( j < 0
+ || (leval[j] == ACCEPTLINE && *subCptr[0][j] != *subCptr[0][line])
+ || (leval[j] != ACCEPTLINE)
+ )
+ {
+ if (leval[j] != ACCEPTLINE && j != 0) intern_err(18); /* misplaced PREPARESPACE/PREPAREHEAD */
+
+ if (isalpha(*subCptr[0][line]) != 0)
+ {
+ fprintf(outfile, "\n\n");
+ if (line > 0 && leval[j] == ACCEPTLINE)
+ fprintf(outfile, "%s\n", PREPARESPACE);
+ fprintf(outfile, "%s{%c}\n\n", PREPAREHEAD, *subCptr[0][line]);
+ }
+ else if (line > 0 && isdigit(*subCptr[0][line]) != 0)
+ {
+ fprintf(outfile, "\n\n%s\n", PREPARESPACE);
+ fprintf(outfile, "%s\n\n", PREPAREXSPACE);
+ }
+ }
+ }
+
+
+ if (leval[line] == ACCEPTLINE) { doprint = 1; ++p; }
+ else if (leval[line] == REJECTLINE) { doprint = 2; }
+ else if (leval[line] == DOUBLELINE) { doprint = 0; /* *p = '!'; */ }
+ else if (leval[line] == DIFFERLINE) { doprint = 4; /* *p = ':'; */ }
+ else if (leval[line] == UNDEFILINE) { doprint = 5; /* *p = '*'; */ }
+ else if (leval[line] == REDEF1LINE) { doprint = 6; }
+ else if (leval[line] == REDEF2LINE) { doprint = 7; }
+ else if (leval[line] == ABBREVLINE) { doprint = 0; /* *p = '+'; */ }
+ else intern_err(19); /* UNKNOWN WRITELINES-leval */
+
+ if (pagewgt[line] == EMPTYNUM) pagenum = 1;
+ else if (pagewgt[line] == MISSNUM) pagenum = 2;
+ else if (pagewgt[line] == TEXT) pagenum = 3;
+ else if (pagewgt[line] == OVERFLOW) pagenum = 4;
+
+ if (pagewgt[line] == UNUSED) uu = 1;
+
+ if ( fntwgt[line] == EMPTYNUM) fntnum = 1;
+ else if ( fntwgt[line] == MISSNUM) fntnum = 2;
+ else if ( fntwgt[line] == TEXT) fntnum = 3;
+ else if ( fntwgt[line] == OVERFLOW) fntnum = 4;
+
+
+ if (tn > 0 && doprint == 1 && leval[line] == ACCEPTLINE) dofourtharg(line);
+
+ if (doprint == 2) fprintf(outfile, "%%%% *Reject entry* (syntax error or empty):\n");
+
+ if (doprint > 0 || pagenum > 0 || fntnum > 0 || uu > 0)
+ {
+ if (filec > 1) fprintf(outfile, "%%%% Entry from %s ...\n", subRptr[LINECOL][line]);
+ if (printsort == 1 && doprint == 1) printsortline(line, deepsort);
+ fprintf(outfile, "%s\n", p);
+
+ if (kandkused == 1 && num_of_cmds_in_str(p, KURZCMD) > 0)
+ fprintf(outfile, "%%%% <- Warning: You have used %s here, but %s elsewhere.\n", KURZ, KTIT);
+
+ if (otherktiterr > 0)
+ {
+ j = 0;
+ while (j < otherktiterr && subAptr[j][line] != mydefault)
+ {
+ if ((oerr = get_add_ktit(subAptr[j][line], 0, -1, -1, 0)) > 0)
+ fprintf(outfile, "%%%% <- Warning: %d misplaced %s in arg %d.\n", oerr, KTIT, j+1);
+ ++j;
+ }
+ }
+
+ if (oktitused > 0 && subAptr[VCOLS-1][line] != mydefault)
+ {
+ ok = num_of_cmds_in_str(subAptr[VCOLS-1][line], KTITCMD);
+ ie = hasinnerentry(subAptr[VCOLS-1][line], innerK_PER_ARQ_cmd, INNERTITLES);
+
+ if ( (oktitused == 3 || oktitused == 4)
+ && ok == 0
+ && ie > -1
+ )
+ fprintf(outfile, "%%%% <- Info: No outer %s used in **item with inner title**, but elsewhere you have %s in that case.\n", KTIT, KTIT);
+ else if (ok == 0 && oktitused < 5)
+ {
+ fprintf(outfile, "%%%% <- Info: No");
+ if (ie > -1) fprintf(outfile, " OUTER");
+ fprintf(outfile, " %s in arg %d (other entries have %s).\n", KTIT, VCOLS, KTIT);
+ }
+ else if (ok > 1)
+ {
+ fprintf(outfile, "%%%% <- Warning: %d", ok);
+ fprintf(outfile, " %s in last arg outside inner v-cmd found. Also check %s file.\n", KTIT, VKC_SUFFIX); /* VCOLS */
+ }
+
+ if (oktitused == 2 || oktitused == 4)
+ {
+ if (ok > (j=unshielded_cmds_in_str(subAptr[VCOLS-1][line], KTITCMD)))
+ {
+ fprintf(outfile, "%%%% <- Warning: %d", ok-j);
+ fprintf(outfile, " { %s } shadowed by brackets (in last arg outside inner v-cmd).\n", KTIT); /* VCOLS */
+ }
+ }
+
+ if ( isinstr(subAptr[VCOLS-1][line], KTITINTRO) == 1)
+ {
+ fprintf(outfile, "%%%% -> Info: An inner v-cmd should be printed as shortened reference (created by the arg of your %s cmd).\n", KTIT);
+ if ((sha=isinstr(subAptr[VCOLS-1][line], KTITSHA )) == 1)
+ fprintf(outfile, "%%%% <- Error: INNER { %s } is shadowed by brackets, and ...\n", KTIT);
+ if ((tha=isinstr(subAptr[VCOLS-1][line], KTITMISS )) == 1)
+ fprintf(outfile, "%%%% <- Error: INNER %s is missing.\n", KTIT);
+ if ((uha=isinstr(subAptr[VCOLS-1][line], KTITEMPTY)) == 1)
+ {
+ fprintf(outfile, "%%%% <- Warning: Arg of");
+ if (sha == 1) fprintf(outfile, " (last non-shadowed)");
+ fprintf(outfile, " INNER %s is empty.\n", KTIT);
+ }
+ if (sha != 1 && tha != 1 && uha != 1) intern_err(28); /* extra KTITINTRO found */
+
+ del_ktitintro(subAptr[VCOLS-1][line]); /* aus Prinzip: "\tX" => "??" */
+ }
+ }
+
+ }
+
+
+ if (doprint > 3) { fprintf(outfile, "%%%% <- TextArg-Warning");
+ if (uu == 0) fprintf(outfile, " (NUMBERS of entry are not necessarily rejected)");
+ fprintf(outfile, ":\n");
+ }
+ if (doprint == 4) fprintf(outfile, "%%%% HEAD is explained different now; that new explanation is ignored.\n");
+ if (doprint == 5) fprintf(outfile, "%%%% HEAD is not (yet\?) explained.\n");
+ if (doprint == 6) fprintf(outfile, "%%%% HEAD is explained again (short-title mismatch).\n");
+ if (doprint == 7) fprintf(outfile, "%%%% HEAD is explained again (risky when open/close seps are different).\n");
+
+
+ if (pagenum > 0 || fntnum > 0)
+ fprintf(outfile, "%%%% <- Counter-Warning (TEXT of entry is not necessarily rejected):\n");
+
+ if (pagenum > 0) fprintf(outfile, "%%%% * Page-num ");
+ if (pagenum == 1) fprintf(outfile, "empty.\n"); /* EMPTYNUM */
+ if (pagenum == 2) fprintf(outfile, "missing.\n"); /* MISSNUM */
+ if (pagenum == 3) fprintf(outfile, "not valid and SORTED as TEXT.\n");
+ if (pagenum == 4) fprintf(outfile, "contains \"%s\" (guess Alph/alph/fnsymbol overflow).\n", OVERFLOWTXT);
+
+ if (tn == 0 && uu == 1) fprintf(outfile, "%%%% <- Def is in an {unused}-environment or is a \\fill...-cmd.\n");
+ if (tn > 0 && uu == 1) fprintf(outfile, "%%%% <- List-internal heading (class %d).\n", tn);
+
+ if ( fntnum > 0) fprintf(outfile, "%%%% * Footnote-num ");
+ if ( fntnum == 1) fprintf(outfile, "empty.\n"); /* EMPTYNUM */
+ if ( fntnum == 2) fprintf(outfile, "missing.\n"); /* MISSNUM */
+ if ( fntnum == 3) fprintf(outfile, "not valid and SORTED as TEXT.\n");
+ if ( fntnum == 4) fprintf(outfile, "contains \"%s\" (guess Alph/alph/fnsymbol overflow).\n", OVERFLOWTXT);
+
+
+ if (doprint == 1 && nlines > 0) makeindex(nlines, line, deepsort);
+
+ if (doprint >= 2 || pagenum > 0 || fntnum > 0 || (doprint == 1 && nlines > 0) || uu > 0)
+ fprintf(outfile, "\n");
+
+
+ if (pagenum > 0 && fntnum > 0) return 2;
+ if (pagenum > 0 || fntnum > 0) return 1;
+ return 0;
+}
+
+
+void allerrorout(const char *s)
+{
+ fprintf(outfile, "%s %s\n", TeXITEM, s);
+ fprintf(outfile, "%s{BibArts warning: %s}%s\n", TYPEOUT, s, RELAX);
+ printf("%%%% -> %s\n", s);
+}
+
+
+static void timestamp (FILE *file)
+{
+ time_t t;
+ struct tm *tp;
+
+ if (time (&t) == -1) return;
+
+ tp = localtime(&t);
+ if (german == 0)
+ fprintf (file, "%%%%> Begin output (month-day-year) %.2d-%.2d-%.4d %.2d:%.2d:%.2d\n",
+ 1+tp->tm_mon, tp->tm_mday, 1900+tp->tm_year,
+ tp->tm_hour, tp->tm_min, tp->tm_sec);
+ else
+ fprintf (file, "%%%%> Begin output (day.month.year) %.2d.%.2d.%.4d %.2d:%.2d:%.2d\n",
+ tp->tm_mday, 1+tp->tm_mon, 1900+tp->tm_year,
+ tp->tm_hour, tp->tm_min, tp->tm_sec);
+}
+
+
+void outhline(void)
+{
+ printf("%%%% ======================================\n");
+}
+
+
+void printfilelist(FILE *file, int filec, int cc, const char *vor, const char *nach)
+{
+ int i = 0;
+
+ if (cc == 1)
+ fprintf(file, "\n%%%% BibArts 2.2 (C) Timo Baumann 2019 [%s]\n", __DATE__);
+
+ fprintf(file, "%%%%\n");
+ timestamp(file);
+ fprintf(file, "%%%% Sort arg(s):\n");
+ fprintf(file, "%s", vor);
+ if (german == 1) fprintf(file, " -g1");
+ if (german == 2) fprintf(file, " -g2");
+ if (nogsty == 1) fprintf(file, " -x");
+ if (ignorespaces == 1) fprintf(file, " -l");
+ if (hy_as_space == 1) fprintf(file, " -h");
+ if (registpoints == 1) fprintf(file, " -p");
+ if (encode == 1) fprintf(file, " -t1");
+ if (kill == DOKILLAUTHORS) fprintf(file, " -k");
+ if (EinlROEMseiten == 1) fprintf(file, " -s1");
+ if (ALPHmpfootnotes == 1) fprintf(file, " -f1");
+ if ( get_R_pg == BA_TRUE
+ || get_A_pg == BA_TRUE
+ || get_a_pg == BA_TRUE
+ || get_r_pg == BA_TRUE
+ ) fprintf(file, " -s2 %s", soptarg);
+ if ( get_R_fn == BA_TRUE
+ || get_A_fn == BA_TRUE
+ || get_a_fn == BA_TRUE
+ || get_r_fn == BA_TRUE
+ ) fprintf(file, " -f2 %s", foptarg);
+ if (igleichj == 1) fprintf(file, " -i=j");
+ if (bago == 1) fprintf(file, " -b");
+ if (FntIndexOverPages == 0) fprintf(file, " -n1");
+ if (notext == 1) fprintf(file, " -c");
+
+ if ( german == 0
+ && nogsty == 0
+ && ignorespaces == 0
+ && hy_as_space == 0
+ && registpoints == 0
+ && encode == 0
+ && kill != DOKILLAUTHORS
+ && EinlROEMseiten == 0
+ && ALPHmpfootnotes == 0
+ && (get_R_fn == BA_FALSE && get_A_fn == BA_FALSE && get_a_fn == BA_FALSE && get_r_fn == BA_FALSE)
+ && (get_R_pg == BA_FALSE && get_A_pg == BA_FALSE && get_a_pg == BA_FALSE && get_r_pg == BA_FALSE)
+ && igleichj == 0
+ && bago == 0
+ && FntIndexOverPages == 1
+ && notext == 0
+ ) fprintf(file, " Default");
+ fprintf(file, "%s\n", nach);
+
+ if (igleichj == 1 && cc == 1) fprintf(file, "%%%% \n%%%% Note, that you will not see i=j in %s lines here.\n", METALINEHEAD); /* "-m" + "-i=j" */
+
+ fprintf(file, "%%%%\n%%%%> Input file list:\n");
+
+ if (filec == 1)
+ fprintf(file, "%%%% only \"%s\".\n", filelist[i]);
+ else
+ while (i < filec)
+ {
+ fprintf(file, "%%%% %.3d \"%s\".\n", i+1, filelist[i]);
+ ++i;
+ }
+
+ if (cc == 1)
+ fprintf(file, "\n\n");
+ else
+ { printf("%%%%\n");
+ outhline();
+ }
+}
+
+
+int writelines(int nlines, const int dqcol, const int lancol, const int commentANDignlines, const int deepsort, int filec, int printsort, int kandkused, int oktitused)
+{
+ int i = 0, dqcat, lancat = 0, lancatbuf, extralines = 0, didsetorig, nerr = 0;
+
+ printfilelist(outfile, filec, 1, "\\gdef\\bibsortargs{", " }");
+
+ while (i < nlines && leval[i] != ACCEPTLINE)
+ {
+ nerr = nerr + writetheline(lineptr[i], 0, i, 0, filec, printsort, kandkused, oktitused);
+ ++i;
+ }
+
+ /* Wegen 2. Arg von abk ist hier dqsort ungeeignet! */
+
+ if (nlines-commentANDignlines > 0)
+ {
+ if ((dqcol > -1 && nogsty == 0) || lancol > -1) fprintf(outfile, "\n");
+
+ if (dqcol > -1 && nogsty == 0)
+ { dqcat = getarabicnum(subRptr[dqcol][i]);
+ if (dqcat == TeXACTIVE)
+ { fprintf(outfile, " \\ifnum\\catcode\\grave@ba\\\"=%d%s{\\message{ [bibsort] Begin list setting \\string%s. }}\\fi\n", TeXPASSIVE, GERMANTEX, GERMANTEX);
+ ++extralines;
+ }
+ else if (dqcat == TeXPASSIVE)
+ { fprintf(outfile, " \\ifnum\\catcode\\grave@ba\\\"=%d%s{\\message{ [bibsort] Begin list setting \\string%s. }}\\fi\n", TeXACTIVE, ORIGINALTEX, ORIGINALTEX);
+ ++extralines;
+ }
+ }
+
+ if (lancol > -1)
+ { lancat = getarabicnum(subRptr[lancol][i]);
+ fprintf(outfile, " \\ifnum\\language=%d\\else%s%d\\message{ [bibsort] Begin list setting hyphenation %d. }\\fi\n", lancat, HYPHENATION, lancat, lancat);
+ ++extralines;
+ }
+
+ if ((dqcol > -1 && nogsty == 0) || lancol > -1) fprintf(outfile, "\n");
+
+ nerr = nerr + writetheline(lineptr[i], nlines, i, deepsort, filec, printsort, kandkused, oktitused);
+
+ ++i;
+ }
+ else if (nlines > 0) allerrorout("bibsort did reject all your entries.");
+
+
+ while (i < nlines)
+ {
+ didsetorig = -1;
+ if (dqcol > -1 && nogsty == 0 && leval[i] == ACCEPTLINE)
+ {
+ if (dqcat == TeXACTIVE && (dqcat = getarabicnum(subRptr[dqcol][i])) == TeXPASSIVE)
+ { fprintf(outfile, " %s{\\message{ [bibsort] Set \\string%s \\space in line %s \\space of BibArts file. }}%s\n", ORIGINALTEX, ORIGINALTEX, TEXFILELINE, RELAX);
+ ++extralines;
+ didsetorig = 0;
+ }
+ else if (dqcat == TeXPASSIVE && (dqcat = getarabicnum(subRptr[dqcol][i])) == TeXACTIVE)
+ { fprintf(outfile, " %s{\\message{ [bibsort] Set \\string%s \\space in line %s \\space of BibArts file. }}%s\n", GERMANTEX, GERMANTEX, TEXFILELINE, RELAX);
+ ++extralines;
+ didsetorig = 1;
+ }
+ }
+
+ if (lancol > -1 && leval[i] == ACCEPTLINE)
+ { if ( lancat != (lancatbuf = getarabicnum(subRptr[lancol][i]))
+ || didsetorig != -1
+ )
+ { lancat = lancatbuf;
+ fprintf(outfile, " %s%d\\message{ [bibsort] Reproduce hyphenation %d in line %s \\space of BibArts file. }%s\n", HYPHENATION, lancat, lancat, TEXFILELINE, RELAX);
+ ++extralines;
+ }
+ }
+
+ nerr = nerr + writetheline(lineptr[i], nlines, i, deepsort, filec, printsort, kandkused, oktitused);
+
+ ++i;
+ }
+
+ if (nerr > 0)
+ {
+ printf("%%%% !!!\n");
+ printf("%%%% I\'ve marked %d page/footnote number(s)\n", nerr);
+ printf("%%%% as \"%s\", \"%s\", \"%s\", and \"%s...%s\" for\n", OVERFLOWSYMB, EMPTYSYMB, MISSINGERMS, TEXTSYMBOPEN[notext], TEXTSYMBCLOSE[notext]);
+ printf("%%%% counter overflow / empty / missing / invalid (TEXT).\n");
+ if (notext == 0 && (strcmp(TEXTSYMBOPEN[0], TEXTSYMBOPEN[1]) != 0 || strcmp(TEXTSYMBCLOSE[0], TEXTSYMBCLOSE[1]) != 0))
+ {
+ printf("%%%% Use opt -c to set invalids ");
+ if (*TEXTSYMBOPEN[1] != '\0' || *TEXTSYMBCLOSE[1] != '\0')
+ printf("as \"%s...%s\"", TEXTSYMBOPEN[1], TEXTSYMBCLOSE[1]);
+ else printf("naked");
+ printf(".\n");
+ }
+ printf("%%%% !!!\n");
+ }
+
+ return extralines;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+ /* Autoren, die mehrfach vorkommen, werden genannt */
+ /* und ab dann durch P|IKILLNAME/NKILLNAME ersetzt */
+
+
+int authorcmp(const char *s, const char *p, int dqcats, int dqcatp)
+{
+ int mlen = strlen(MALE), flen = strlen(FEMALE), cont = 1;
+ int hlen = strlen(HASDOT), nlen = strlen(NOTDOT);
+
+ while(1)
+ {
+ if (lcmdcmp(s, MALE) == 0) { s += mlen; while (*s == ' ') ++s; cont = 0; }
+ if (lcmdcmp(s, FEMALE) == 0) { s += flen; while (*s == ' ') ++s; cont = 0; }
+ if (lcmdcmp(s, HASDOT) == 0) { s += hlen; while (*s == ' ') ++s; cont = 0; }
+ if (lcmdcmp(s, NOTDOT) == 0) { s += nlen; while (*s == ' ') ++s; cont = 0; }
+ if (strncmp(s, "\\-", 2) == 0) { s += 2; cont = 0; }
+
+ if (lcmdcmp(p, MALE) == 0) { p += mlen; while (*p == ' ') ++p; cont = 0; }
+ if (lcmdcmp(p, FEMALE) == 0) { p += flen; while (*p == ' ') ++p; cont = 0; }
+ if (lcmdcmp(p, HASDOT) == 0) { p += hlen; while (*p == ' ') ++p; cont = 0; }
+ if (lcmdcmp(p, NOTDOT) == 0) { p += nlen; while (*p == ' ') ++p; cont = 0; }
+ if (strncmp(p, "\\-", 2) == 0) { p += 2; cont = 0; }
+
+ if (nogsty == 0)
+ {
+ if (dqcats == TeXACTIVE)
+ {
+ if (strncmp(s, "\"\"", 2) == 0) { s += 2; cont = 0; }
+ if (strncmp(s, "\"-", 2) == 0) { s += 2; cont = 0; }
+ }
+ if (dqcatp == TeXACTIVE)
+ {
+ if (strncmp(p, "\"\"", 2) == 0) { p += 2; cont = 0; }
+ if (strncmp(p, "\"-", 2) == 0) { p += 2; cont = 0; }
+ }
+ }
+
+ if (cont == 1)
+ {
+ if (*s != '\0' && *p == *s)
+ {
+ if (*s == '\\' && *(s+1) != '\0' && *(p+1) == *(s+1)) { ++p; ++s; }
+ else
+ if (*s == '\"' && dqcats != dqcatp) break;
+ ++p; ++s;
+ }
+ else break;
+ }
+ else if (*s == '\0' || *p == '\0') break;
+
+ cont = 1;
+ }
+
+ if (*p == '\0' && *s == '\0') return 0;
+ return 1;
+}
+
+
+int texcmp(const char *s, const char *p, int dqcats, int dqcatp)
+{
+ while(1)
+ {
+ if (*s != '\0' && *p == *s)
+ {
+ if (*s == '\\' && *(s+1) != '\0' && *(p+1) == *(s+1)) { ++p; ++s; }
+ else
+ if (*s == '\"' && dqcats != dqcatp) break;
+ ++p; ++s;
+ }
+ else break;
+ }
+
+ if (*p == '\0' && *s == '\0') return 0;
+ return 1;
+}
+
+
+int lcmdcmp(const char *s, const char *p)
+{
+ int r = 1;
+
+ while (*s != '\0')
+ {
+ if (*s == *p) { ++s; ++p; }
+ else break;
+
+ if (*p == '\0' && isLaTeXcmdletter(*s) == 0)
+ {
+ r = 0;
+ break;
+ }
+ }
+
+ return r;
+}
+
+
+int findFEmale(const char *s)
+{
+ int r = 0;
+
+ while(*s != '\0')
+ {
+ if (*s == '\\')
+ {
+ if (*(s+1) == '\\') ++s;
+ else
+ if ( lcmdcmp(s, MALE) == 0
+ || lcmdcmp(s, FEMALE) == 0
+ )
+ { r = 1;
+ break;
+ }
+ }
+ ++s;
+ }
+
+ return r;
+}
+
+
+void baaddx_error(void)
+{
+ printf("%%%% baaddx-error\n");
+}
+
+
+int insertfalse(const char *p, char a[], int i)
+{
+ int n;
+
+ while (*p == ' ') ++p;
+ n = nextbracket(p, '{', '}'); if (n < 2) baaddx_error();
+ while (n-- > 0 && i < MAXLEN) a[i++] = *p++;
+
+ while (*p == ' ') ++p;
+ if (*p == '{' && i < MAXLEN)
+ { a[i++] = *p++;
+
+ while (*p == ' ') ++p;
+ n = nextbracket(p, '{', '}'); if (n < 2) baaddx_error();
+ while (n-- > 0 && i < MAXLEN) a[i++] = *p++;
+
+ while (*p == ' ') ++p;
+ n = nextbracket(p, '{', '}'); if (n < 2) baaddx_error();
+ while (n-- > 0) p++;
+
+ if (i + strlen(BAFALSE) < MAXLEN)
+ {
+ a[i] = '\0'; strcat(a, BAFALSE); i += strlen(BAFALSE);
+ }
+ }
+ else baaddx_error();
+
+ while (*p != '\0' && i < MAXLEN) a[i++] = *p++;
+
+ return i;
+}
+
+
+int count_rejected(int nlines)
+{
+ int ret = 0, i = 0;
+
+ while (i < nlines)
+ {
+ if (leval[i] == REJECTLINE)
+ ++ret; /* parallel zu double_or_empty_abbreviation */
+ ++i;
+ }
+
+ return ret;
+}
+
+
+int checkifabbrisdefined(int nlines, int ret, char *Thead, const char *Thold, int Thint, int i)
+{
+ int found = 2, pwgt, fwgt;
+ char *pg, *fnt, *tline;
+
+ if ( leval[i] != REJECTLINE
+ && *subAptr[1][i] == '\0'
+ && ( *Thold == '\0'
+ || texcmp(subAptr[0][i], Thead, dqsort[i], Thint) != 0
+ )
+ )
+ {
+ leval[i] = UNDEFILINE;
+ ++ret;
+ found = 0;
+ }
+
+
+ Thead = subAptr[0][i];
+ Thint = dqsort[i];
+ pg = subRptr[PAGECOL][i];
+ fnt = subRptr[FNTCOL][i];
+ tline = subRptr[LINECOL][i];
+ pwgt = pagewgt[i];
+ fwgt = fntwgt[i];
+
+ if (found == 0)
+ {
+ while (++i < nlines && texcmp(subAptr[0][i], Thead, dqsort[i], Thint) == 0)
+ {
+ if ( leval[i] != REJECTLINE
+ && *subAptr[1][i] != '\0'
+ )
+ { found = 1;
+ break;
+ }
+ }
+ }
+
+ if (found == 0)
+ { printf("%%%%\n%%%%> Warning: Abbreviation \"%s\" is NEVER defined!\n", Thead);
+ printf("%%%% The entry (%s", tline);
+ if (Thint > -1) printf(", \":%d", Thint);
+ printf(") is rejected. Use %s\?\n", ABKDEF);
+ }
+
+ if (found == 1 &&
+ ( strcmp(tline, subRptr[LINECOL][i]) != 0
+ || strcmp( fnt, subRptr[FNTCOL][i] ) != 0
+ )
+ )
+ {
+ printf("%%%%\n%%%%> Warning: Abbreviation \"%s\" is used in\n", Thead);
+ printf("%%%% ");
+ if (fnt != nofnt)
+ { printf("A FNT ");
+ if (fwgt != fntwgt[i] && subRptr[FNTCOL][i] != nofnt && strcmp(pg, subRptr[PAGECOL][i]) == 0)
+ printf("T%d ", fwgt);
+ }
+ printf("%s and def in ", tline);
+ if (subRptr[FNTCOL][i] != nofnt)
+ {
+ printf("A FNT ");
+ if (fwgt != fntwgt[i] && fnt != nofnt && strcmp(pg, subRptr[PAGECOL][i]) == 0)
+ printf("T%d ", fntwgt[i]);
+ }
+ printf("%s!\n", subRptr[LINECOL][i]);
+ }
+
+ return ret;
+}
+
+
+int entkerne_IeC(char buf[], const char *s)
+{
+ int r = entkerne_arg(buf, s, IeC, '{', '}');
+ del_ktitintro(buf);
+ return r;
+}
+
+
+void printdline(int len, const char *s)
+{
+ printf("\"");
+ maxprint(len, s);
+ printf("\"");
+}
+
+
+void printD(const char *txt, const char *head, const char *Thold, const char *Trej, int i, int mem, int nmsg)
+{
+ int prnlen = 0;
+
+ if (nmsg == 0)
+ {
+ printf("%%%%\n%%%%> Warning: Different %s ", txt);
+ printdline(50 - strlen(txt), head);
+ printf(":\n");
+
+ printf("%%%% *Accept ");
+ if (mem > -1)
+ {
+ printf("%s ", subRptr[LINECOL][mem]);
+ prnlen = 60 - strlen(subRptr[LINECOL][mem]);
+ }
+ printdline(prnlen, Thold);
+ printf(";\n");
+ }
+
+ printf("%%%% *Reject %s ", subRptr[LINECOL][i]);
+
+ if (strcmp(Thold, Trej) == 0)
+ printf("(same string with other dq-catcode %d)", getarabicnum(subRptr[DQCOL][i]));
+ else printdline(60 - strlen(subRptr[LINECOL][i]), Trej);
+
+ printf(".\n");
+}
+
+
+int twoargsSTUFFcmp(const char *txt, int i, int mem, int messn)
+{
+ char a_buf[MAXLEN], b_buf[MAXLEN];
+
+ if (mem > -1)
+ {
+ getfirsttwoargs(a_buf, subRptr[STUFFRCOL][i]);
+ getfirsttwoargs(b_buf, subRptr[STUFFRCOL][mem]);
+
+ if (texcmp(a_buf, b_buf, getarabicnum(subRptr[DQCOL][i]), getarabicnum(subRptr[DQCOL][mem])) != 0)
+ {
+ if (messn < MAXMESSN)
+ {
+ printD(txt, subAptr[0][i], b_buf, a_buf, i, mem, messn);
+ }
+ ++messn;
+ }
+ }
+
+ return messn;
+}
+
+
+int xstrcmp(const char *a, const char *b, int mem, int i)
+{
+ if ( ( nogsty == 1
+ || (mem > -1 && getarabicnum(subRptr[DQCOL][i]) == getarabicnum(subRptr[DQCOL][mem]))
+ || userusesdq(PCOLS, i) == 0
+ )
+ && strcmp(a, b) == 0
+ ) return 0;
+ return 1;
+}
+
+
+void printT(int i)
+{
+ printf("%%%% ");
+ print_two(i, 0, 1);
+ printf("\n");
+}
+
+
+void warnFEmaleT(int nlines)
+{
+ int i = 0;
+
+ while (i < nlines)
+ {
+ if ( findFEmale(subAptr[0][i]) != 0
+ || findFEmale(subAptr[1][i]) != 0
+ )
+ {
+ printf("%%%%\n%%%%> Warning: %s or %s in entry %s:\n", FEMALE, MALE, subRptr[LINECOL][i]);
+ printT(i);
+ }
+ ++i;
+ }
+}
+
+
+void checkSTUFFblock(const char *msg, int i, const int nlines, const int deepsort, const int deep)
+{
+ const int mem = i;
+ const char *TheadA = subAptr[0][mem];
+ const char *TheadB = subAptr[1][mem];
+ const char *TheadC = subAptr[2][mem];
+ const char *TheadD = subAptr[3][mem];
+ const int Thint = dqsort[mem];
+ int messn = 0;
+
+
+ if ( deepsort != deep
+ && deepsort != deep-1
+ )
+ {
+ intern_err(20); /* deep/deepsort */
+ }
+ else
+ {
+ while (++i < nlines)
+ {
+ if (leval[i] == REJECTLINE);
+ else
+ if ( (deepsort > 0 && texcmp(subAptr[0][i], TheadA, dqsort[i], Thint) != 0)
+ || (deepsort > 1 && texcmp(subAptr[1][i], TheadB, dqsort[i], Thint) != 0)
+ || (deepsort > 2 && texcmp(subAptr[2][i], TheadC, dqsort[i], Thint) != 0)
+ || (deepsort > 3 && texcmp(subAptr[3][i], TheadD, dqsort[i], Thint) != 0)
+ )
+ {
+ break;
+ }
+ else if ( deepsort == deep
+ || (*subAptr[deep-1][i] != '\0' && texcmp(subAptr[deep-1][i], subAptr[deep-1][mem], getarabicnum(subRptr[DQCOL][i]), getarabicnum(subRptr[DQCOL][mem])) == 0)
+ )
+ {
+ messn = twoargsSTUFFcmp(msg, i, mem, messn);
+ }
+ }
+
+ if (messn > MAXMESSN) printf("%%%% *** Report the first %d different seps (of %d) for that entry. ***\n", MAXMESSN, messn);
+ }
+}
+
+
+int double_or_empty_abbreviation(int nlines, int deepsort, int deep)
+{
+ int i, ret = 0, Thint = -1, mem = -1;
+ char *Thead = "", *Thold = "", *Thart = NULL, *oldmsg = NULL, *oldstuffA = NULL, *oldstuffB = NULL;
+
+ /* dqsort geht bis zur Tiefe deepsort, nicht deep */
+
+
+ warnFEmaleT(nlines);
+
+
+ i = 0; while (i < nlines)
+ {
+ if (leval[i] == REJECTLINE)
+ {
+ ++ret; /* Anzahl bereits auskommentierter Zeilen */
+ }
+ else
+ if (*subAptr[0][i] == '\0')
+ {
+ leval[i] = REJECTLINE;
+ printf("%%%%\n%%%%> Reject empty abbreviation in %s!\n", subRptr[LINECOL][i]);
+ ++ret;
+ }
+ ++i;
+ }
+
+
+ ret = checkifabbrisdefined(nlines, ret, Thead, Thold, Thint, 0);
+
+ i = 1; while (i < nlines)
+ {
+ if ( leval[i-1] != REJECTLINE
+ && *subAptr[0][i-1] != '\0'
+ && *subAptr[1][i-1] != '\0'
+ )
+ {
+ if ( *Thold == '\0'
+ || texcmp(subAptr[0][i-1], Thead, dqsort[i-1], Thint) != 0
+ )
+ { Thold = subAptr[1][i-1];
+ mem = i-1;
+ Thart = subRptr[FNTCOL][i-1];
+ }
+ else
+ if (Thart != nofnt && subRptr[FNTCOL][i-1] == nofnt)
+ {
+ Thart = subRptr[FNTCOL][i-1];
+ }
+ Thead = subAptr[0][i-1];
+ Thint = dqsort[i-1];
+ }
+
+ if ( leval[i] != REJECTLINE
+ && *subAptr[0][i] != '\0'
+ && *subAptr[1][i] == '\0'
+ && Thart != NULL
+ && Thart != nofnt
+ && subRptr[FNTCOL][i] == nofnt
+ && texcmp(subAptr[0][i], Thead, dqsort[i], Thint) == 0
+ )
+ {
+ if (oldmsg == NULL || strcmp(oldmsg, subAptr[0][i]) != 0)
+ printf("%%%%\n%%%%> Warning: Abbreviation \"%s\" is used in\n", subAptr[0][i]);
+ printf("%%%% TEXT %s, whereas all foregoing defs were in FNTs!\n", subRptr[LINECOL][i]);
+ oldmsg = subAptr[0][i];
+ }
+
+ ret = checkifabbrisdefined(nlines, ret, Thead, Thold, Thint, i);
+
+ if ( leval[i] != REJECTLINE
+ && *subAptr[1][i] == '\0'
+ && *Thold != '\0'
+ && texcmp(subAptr[0][i], Thead, dqsort[i], Thint) == 0
+ )
+ {
+ leval[i] = ABBREVLINE;
+ ++ret;
+ }
+
+ if ( leval[i] != REJECTLINE
+ && *subAptr[1][i] != '\0'
+ && *Thead != '\0'
+ && texcmp(subAptr[0][i], Thead, dqsort[i], Thint) == 0
+ )
+ {
+ if (xstrcmp(Thold, subAptr[1][i], mem, i) != 0) /* leval[i] sagt nichts zu Arg2 */
+ {
+ printD("defs for abbreviation", subAptr[0][i], Thold, subAptr[1][i], i, mem, 0);
+ leval[i] = DIFFERLINE;
+ ++ret;
+ }
+ else
+ {
+ leval[i] = DOUBLELINE;
+ ++ret;
+ /* printf("%%%%\n%%%%> Reject repeated def for abbreviation \"%s\" -> \"%s\"!\n", subAptr[0][i], subAptr[1][i]);
+ */
+ if ( (oldstuffA == NULL && oldstuffB == NULL)
+ || strcmp(oldstuffA, subAptr[0][mem]) != 0
+ || strcmp(oldstuffB, subAptr[1][mem]) != 0
+ )
+ checkSTUFFblock("abkdef-open/-close seps after", mem, nlines, deepsort, deep);
+ oldstuffA = subAptr[0][mem];
+ oldstuffB = subAptr[1][mem];
+ }
+ }
+ ++i;
+ }
+
+ return ret;
+}
+
+
+void printcline(int len, const char *s)
+{
+ printf("(");
+ maxprint(len, s);
+ printf(") ");
+}
+
+
+
+#define LMAX 26
+#define RMAX 36
+
+void print_two(int i, int e, int z)
+{
+ char bufa[MAXLEN], bufb[MAXLEN];
+ int llen, rlen;
+
+ llen = entkerne_IeC(bufa, subAptr[e][i]);
+ rlen = entkerne_IeC(bufb, subAptr[z][i]);
+
+ if (llen > LMAX && rlen > RMAX)
+ {
+ rlen = RMAX;
+ llen = LMAX;
+ }
+ else
+ if (llen + rlen > LMAX + RMAX)
+ {
+ if (llen > LMAX) llen = LMAX+RMAX-rlen;
+ if (rlen > RMAX) rlen = LMAX+RMAX-llen;
+ }
+
+ printcline(llen, bufa);
+ printcline(rlen, bufb);
+}
+
+
+#define LEFTMAX 16
+#define MIDMAX 18
+#define RIGHTMAX 24
+
+void print_three(int i, int e, int z, int d)
+{
+ char bufa[MAXLEN], bufb[MAXLEN], bufc[MAXLEN];
+ int llen, mlen, rlen, vari;
+
+ llen = entkerne_IeC(bufa, subAptr[e][i]);
+ mlen = entkerne_IeC(bufb, subAptr[z][i]);
+ rlen = entkerne_IeC(bufc, subAptr[d][i]);
+
+ if (llen > LEFTMAX && mlen > MIDMAX && rlen > RIGHTMAX)
+ {
+ rlen = RIGHTMAX;
+ mlen = MIDMAX;
+ llen = LEFTMAX;
+ }
+ else
+ if (llen + mlen + rlen > LEFTMAX + MIDMAX + RIGHTMAX)
+ {
+ if (rlen <= RIGHTMAX && mlen <= MIDMAX)
+ {
+ llen = LEFTMAX + RIGHTMAX-rlen + MIDMAX-mlen;
+ }
+ else
+ if (mlen <= MIDMAX && llen <= LEFTMAX)
+ {
+ rlen = RIGHTMAX + MIDMAX-mlen + LEFTMAX-llen;
+ }
+ else
+ if (rlen <= RIGHTMAX && llen <= LEFTMAX)
+ {
+ mlen = MIDMAX + RIGHTMAX-rlen + LEFTMAX-llen;
+ }
+ else
+ if (rlen <= RIGHTMAX)
+ {
+ vari = RIGHTMAX-rlen;
+ if (llen > LEFTMAX + vari && mlen > MIDMAX)
+ {
+ llen = LEFTMAX + vari;
+ mlen = MIDMAX;
+ }
+ else
+ if (mlen + llen > MIDMAX + LEFTMAX + vari)
+ {
+ if (llen > LEFTMAX+vari) llen = MIDMAX+ LEFTMAX+vari-mlen;
+ if (mlen > MIDMAX) mlen = MIDMAX+ LEFTMAX+vari-llen;
+ }
+ }
+ else
+ if (llen <= LEFTMAX)
+ {
+ vari = LEFTMAX-llen;
+ if (mlen > MIDMAX + vari && rlen > RIGHTMAX)
+ {
+ mlen = MIDMAX + vari;
+ rlen = RIGHTMAX;
+ }
+ else
+ if (mlen + rlen > MIDMAX + RIGHTMAX + vari)
+ {
+ if (mlen > MIDMAX+vari) mlen = MIDMAX+RIGHTMAX+vari-rlen;
+ if (rlen > RIGHTMAX) rlen = MIDMAX+RIGHTMAX+vari-mlen;
+ }
+ }
+ else
+ if (mlen <= MIDMAX)
+ {
+ vari = MIDMAX-mlen;
+ if (llen > LEFTMAX + vari && rlen > RIGHTMAX)
+ {
+ llen = LEFTMAX + vari;
+ rlen = RIGHTMAX;
+ }
+ else
+ if (rlen + llen > RIGHTMAX + LEFTMAX + vari)
+ {
+ if (llen > LEFTMAX+vari) llen = RIGHTMAX+LEFTMAX+vari-rlen;
+ if (rlen > RIGHTMAX) rlen = RIGHTMAX+LEFTMAX+vari-llen;
+ }
+ }
+ }
+
+ if (llen + mlen + rlen > LEFTMAX + MIDMAX + RIGHTMAX)
+ intern_err(21); /* Bad screen print */
+
+ printcline(llen, bufa);
+ printcline(mlen, bufb);
+ printcline(rlen, bufc);
+}
+
+
+#define MAXA 12
+#define MAXB 8
+#define MAXC 16
+#define MAXD 18
+#define ALLMAX (MAXA+MAXB+MAXC+MAXD)
+
+void print_four(int i)
+{
+ char bufa[MAXLEN], bufb[MAXLEN], bufc[MAXLEN], bufd[MAXLEN];
+ int lena, lenb, lenc, lend;
+ int over, overa = 0, overb = 0, overc = 0, overd = 0;
+
+ lena = entkerne_IeC(bufa, subAptr[1][i]); /* (Vorname) */
+ lenb = entkerne_IeC(bufb, subAptr[0][i]);
+ lenc = entkerne_IeC(bufc, subAptr[2][i]);
+ lend = entkerne_IeC(bufd, subAptr[3][i]);
+
+ if (lena + lenb + lenc + lend > ALLMAX)
+ {
+ if (lena < MAXA) overa = MAXA - lena;
+ if (lenb < MAXB) overb = MAXB - lenb;
+ if (lenc < MAXC) overc = MAXC - lenc;
+ if (lend < MAXD) overd = MAXD - lend;
+
+ over = overa + overb + overc + overd;
+ overa = 0; overb = 0; overc = 0; overd = 0;
+
+ while (over > 0)
+ {
+ if (lena-overa > MAXA && over > 0) { ++overa; --over; }
+ if (lenb-overb > MAXB && over > 0) { ++overb; --over; }
+ if (lenc-overc > MAXC && over > 0) { ++overc; --over; }
+ if (lend-overd > MAXD && over > 0) { ++overd; --over; }
+ }
+
+ over = overa + overb + overc + overd;
+
+ while(lena + lenb + lenc + lend + over > ALLMAX)
+ {
+ if (lena + lenb + lenc + lend + over > ALLMAX && lena > MAXA) --lena;
+ if (lena + lenb + lenc + lend + over > ALLMAX && lenb > MAXB) --lenb;
+ if (lena + lenb + lenc + lend + over > ALLMAX && lenc > MAXC) --lenc;
+ if (lena + lenb + lenc + lend + over > ALLMAX && lend > MAXD) --lend;
+ }
+ }
+
+ printcline(lena+overa, bufa); /* (Vorname) */
+ printcline(lenb+overb, bufb);
+ printcline(lenc+overc, bufc);
+ printcline(lend+overd, bufd);
+}
+
+
+void fitssingleentry(int i, int nlines, int arq, const char *suffix)
+{
+ int l;
+
+ if ( leval[i] != REJECTLINE
+ && *subAptr[1][i] != '\0'
+ && (arq != IS_Q || getthirdnum(i) == 0)
+ )
+ {
+ l = i;
+ while (l > 0)
+ {
+ if (leval[l-1] == REJECTLINE);
+ else if (texcmp(subAptr[0][l-1], subAptr[0][i], dqsort[l-1], dqsort[i]) != 0) break;
+ else if (*subAptr[1][l-1] == '\0') { --l; break; }
+ --l;
+ }
+
+ if (leval[l] == REJECTLINE || *subAptr[1][l] != '\0')
+ {
+ while (l < nlines-1)
+ {
+ if (leval[l+1] == REJECTLINE);
+ else if (texcmp(subAptr[0][l+1], subAptr[0][i], dqsort[l+1], dqsort[i]) != 0) break;
+ else if (*subAptr[1][l+1] == '\0') { ++l; break; }
+ ++l;
+ }
+ }
+
+ if (leval[l] == REJECTLINE || *subAptr[1][l] != '\0')
+ {
+ printf("%%%%\n%%%%> Info: \\fill%s in %s fits NO single entry:\n", suffix, subRptr[LINECOL][i]);
+ printT(i);
+ }
+ }
+}
+
+
+void misplaced_heading(int heada, int line)
+{
+ printf("%%%%\n%%%%> Warning: Misplaced %d-heading (from %s):\n", heada, subRptr[LINECOL][line]);
+ printT(line);
+}
+
+
+int double_or_empty_arqperregisters(int nlines, int arq, const char *suffix, int deepsort, int deep)
+{
+ int i, ret = 0, ThintA = -1, mem = -1, lastmem = mem, len, heada, headb;
+ char *TheadA = "", *heredefault = "", *TheadB = heredefault, *oldstuffA = NULL, *oldstuffB = NULL;
+
+
+ warnFEmaleT(nlines);
+
+
+ i = 0; while (i < nlines)
+ {
+ if (leval[i] == REJECTLINE)
+ {
+ ++ret; /* Anzahl bereits auskommentierter Zeilen */
+ }
+ else
+ if (*subAptr[0][i] == '\0')
+ {
+ printf("%%%%\n%%%%> Warning: Empty entry in %s", subRptr[LINECOL][i]);
+ if (*subAptr[1][i] != '\0')
+ {
+ if (arq == IS_Q && (heada=getthirdnum(i)) > 0)
+ printf(" (%d-heading)", heada);
+ else printf(" (\\fill%s-cmd)", suffix);
+ }
+ printf(".\n");
+ leval[i] = REJECTLINE;
+ ++ret;
+ }
+ ++i;
+ }
+
+
+ fitssingleentry(0, nlines, arq, suffix);
+
+
+ i = 1; while (i < nlines)
+ {
+ if ( leval[i-1] != REJECTLINE
+ && *subAptr[0][i-1] != '\0'
+ && texcmp(subAptr[0][i-1], TheadA, dqsort[i-1], ThintA) != 0
+ )
+ {
+ TheadA = subAptr[0][i-1];
+ ThintA = dqsort[i-1];
+
+ if (pagewgt[i-1] == UNUSED)
+ {
+ mem = i-1;
+ TheadB = subAptr[1][i-1];
+ }
+ else
+ {
+ mem = -1;
+ TheadB = heredefault;
+ }
+ }
+
+ /* da deepsort < deep wird subAptr[1][i] von dqsort nicht erfasst */
+ if ( leval[i] != REJECTLINE
+ && *TheadA != '\0'
+ && texcmp(subAptr[0][i], TheadA, dqsort[i], ThintA) == 0
+ )
+ {
+ if (*subAptr[1][i] == '\0')
+ {
+ leval[i] = DOUBLELINE;
+ }
+ else
+ {
+ if (xstrcmp(TheadB, subAptr[1][i], mem, i) == 0) /* leval[i] sagt nichts zu Arg2 */
+ {
+ leval[i] = REDEF2LINE;
+ if ( (oldstuffA == NULL && oldstuffB == NULL)
+ || strcmp(oldstuffA, subAptr[0][mem]) != 0
+ || strcmp(oldstuffB, subAptr[1][mem]) != 0
+ )
+ checkSTUFFblock("open/close seps after", mem, nlines, deepsort, deep);
+ oldstuffA = subAptr[0][mem];
+ oldstuffB = subAptr[1][mem];
+ }
+ else
+ {
+ printD("fills for head", subAptr[0][i], TheadB, subAptr[1][i], i, mem, 0);
+ if (arq == IS_Q && getthirdnum(i) == 1)
+ printf("%%%% ... A list-internal heading is shadowed.\n");
+ leval[i] = DIFFERLINE;
+ }
+ }
+
+ ++ret;
+ }
+
+
+ if ( arq == IS_Q
+ && ( leval[i] == ACCEPTLINE
+ || leval[i] == REDEF2LINE
+ || leval[i] == DOUBLELINE
+ )
+ )
+ {
+ if ( mem > lastmem
+ && (heada=getthirdnum(mem)) > 0
+ )
+ {
+ len = strlen(TheadA);
+ headb = getthirdnum(i);
+ if ( strncmp(subAptr[0][i], TheadA, len) != 0
+ || len >= strlen(subAptr[0][i])
+ || (headb < heada && headb > 0)
+ )
+ {
+ misplaced_heading(heada, mem);
+ printf("%%%% ... That");
+ if (texcmp(subAptr[0][i], TheadA, dqsort[i], ThintA) == 0)
+ printf(" melts into ");
+ else
+ {
+ printf("\'s before ");
+ if (strcmp(subAptr[0][i], TheadA) == 0) printf("[\"!] ");
+ }
+ if (headb > 0)
+ {
+ printf("%d-heading", headb);
+ printf(" (from %s):\n", subRptr[LINECOL][i]);
+ printT(i);
+ }
+ else printf("list item (from %s).\n", subRptr[LINECOL][i]);
+ }
+ }
+ lastmem = mem;
+ }
+
+
+ fitssingleentry(i, nlines, arq, suffix);
+
+ ++i;
+ }
+
+
+ return ret;
+}
+
+
+void printV(int i)
+{
+ printf("%%%% ");
+ if (dqsort[i] == TeXACTIVE)
+ printf( "!\" ");
+ else
+ printf( " ");
+
+ if (*subAptr[2][i] == '\0')
+ {
+ print_three(i, 1, 0, 3); /* (Vorname) (Nachname) (Rest) */
+ }
+ else
+ {
+ print_four(i);
+ }
+ printf("\n");
+}
+
+
+void printK(int i)
+{
+ printf("%%%% ");
+ if (dqsort[i] == TeXACTIVE)
+ printf( "!\" ");
+ else
+ printf( " ");
+
+ if (*subAptr[1][i] == '\0')
+ {
+ print_two(i, 0, 2);
+ }
+ else
+ {
+ print_three(i, 0, 1, 2);
+ }
+ printf("\n");
+}
+
+
+int checkifisfullcited(int i, int nlines, int ret)
+{
+ char *TheadA = subAptr[0][i];
+ char *TheadB = subAptr[1][i];
+ char *TheadC = subAptr[2][i];
+ char *TheadD = subAptr[3][i];
+ int Thint = dqsort[i], mem = i, j = i, cnt = 0, rest = nlines;
+
+
+
+
+ if ( leval[i] != REJECTLINE
+ && isvintroduced(i) == KENTRY
+ )
+ {
+ printf("%%%%\n%%%%> Info: Short-%s-title %s is NOT yet introduced.\n", subAptr[3][i], subRptr[LINECOL][i]);
+ printK(i);
+
+
+ while (++i < nlines)
+ {
+ if (leval[i] == REJECTLINE);
+ else
+ if ( texcmp(subAptr[0][i], TheadA, dqsort[i], Thint) != 0
+ || texcmp(subAptr[1][i], TheadB, dqsort[i], Thint) != 0
+ || texcmp(subAptr[2][i], TheadC, dqsort[i], Thint) != 0
+ || texcmp(subAptr[3][i], TheadD, dqsort[i], Thint) != 0
+ )
+ break;
+ else
+ if (isvintroduced(i) == VENTRY)
+ {
+ if (subRptr[FNTCOL][j] != nofnt && subRptr[FNTCOL][i] != nofnt && fntwgt[j] != fntwgt[i] && strcmp(subRptr[PAGECOL][j], subRptr[PAGECOL][i]) == 0)
+ printf("%%%% Full titel %s and short title in FNTs T%d T%d.\n", subRptr[LINECOL][i], fntwgt[i], fntwgt[j]);
+ else
+ printf("%%%% ... Exchange it with the full-title in %s.\n", subRptr[LINECOL][i]);
+ mem = i;
+
+ leval[j] = DOUBLELINE;
+ ++ret;
+
+ break;
+ }
+ else
+ {
+ leval[i] = DOUBLELINE;
+ ++ret;
+ }
+ }
+ if (mem == j)
+ {
+ if (findFEmale(subAptr[0][mem]) != 0 || findFEmale(subAptr[1][mem]) != 0 || findFEmale(subAptr[2][mem]) != 0)
+ printf("%%%% ... Delete misplaced cmd %s or %s.\n", FEMALE, MALE);
+ else
+ printf("%%%% ... Change that short-title into missing full-title (%s)\?\n", KTIT);
+ }
+
+ rest = i;
+ }
+
+ i = mem;
+ if ( leval[i] != REJECTLINE
+ && isvintroduced(i) == VENTRY
+ )
+ {
+ while (++i < nlines)
+ {
+ if (leval[i] == REJECTLINE);
+ else
+ if ( texcmp(subAptr[0][i], TheadA, dqsort[i], Thint) != 0
+ || texcmp(subAptr[1][i], TheadB, dqsort[i], Thint) != 0
+ || texcmp(subAptr[2][i], TheadC, dqsort[i], Thint) != 0
+ || texcmp(subAptr[3][i], TheadD, dqsort[i], Thint) != 0
+ )
+ break;
+ else
+ if (isvintroduced(i) == VENTRY)
+ {
+ ++cnt;
+ if (cnt == 1)
+ printf("%%%%\n%%%%> Info: ");
+ else if (cnt < MAXINFO)
+ printf("%%%%> ");
+ if (cnt < MAXINFO)
+ {
+ printf("Re-introduction of "); /* intro cnt+1 */
+ if (cnt > 1) printf("that ");
+ printf("short-%s-title in %s.\n", subAptr[3][i], subRptr[LINECOL][i]);
+ }
+ if (cnt == 1)
+ {
+ printK(i);
+ printf("%%%% First introduction has been in %s (%s).\n", subRptr[LINECOL][mem], KTIT);
+ }
+
+ leval[i] = REDEF1LINE;
+ ++ret;
+ }
+ else
+ {
+ leval[i] = DOUBLELINE;
+ ++ret;
+ }
+ }
+
+ if (cnt+1 > MAXINFO)
+ printf("%%%%> This have been the first %d (of %d) intros of that short-title.\n", MAXINFO, cnt+1);
+
+ rest = i;
+ }
+
+ i = rest;
+ while (++i < nlines)
+ {
+ if (leval[i] == REJECTLINE);
+ else
+ if ( texcmp(subAptr[0][i], TheadA, dqsort[i], Thint) == 0
+ && texcmp(subAptr[1][i], TheadB, dqsort[i], Thint) == 0
+ && texcmp(subAptr[2][i], TheadC, dqsort[i], Thint) == 0
+ && texcmp(subAptr[3][i], TheadD, dqsort[i], Thint) == 0
+ )
+ {
+ leval[i] = DOUBLELINE;
+ ++ret;
+ }
+ else break;
+ }
+
+ return ret;
+}
+
+
+void checkmanipulationk(int i)
+{
+
+ if ( leval[i] != REJECTLINE
+ && isvintroduced(i) == ERRENTRY
+ )
+ {
+ printf("%%%%\n%%%%> Warning: Reference %s has unknown status.\n", subRptr[LINECOL][i]);
+ printK(i);
+ }
+}
+
+
+void checkshortmismatch(int i, const int nlines, const int mem)
+{
+ while (i < nlines)
+ {
+ if ( texcmp(subAptr[0][i], subAptr[0][mem], dqsort[i], dqsort[mem]) == 0
+ && texcmp(subAptr[1][i], subAptr[1][mem], dqsort[i], dqsort[mem]) == 0
+ && texcmp(subAptr[2][i], subAptr[2][mem], dqsort[i], dqsort[mem]) == 0
+ && texcmp(subAptr[3][i], subAptr[3][mem], dqsort[i], dqsort[mem]) != 0
+ )
+ {
+ printf("%%%%\n%%%%> Warning: SAME short-title used for ...li and ...qu:\n");
+ printK(i);
+ printf("%%%% See %s in %s and %s in %s.\n", subAptr[3][i], subRptr[LINECOL][i], subAptr[3][mem], subRptr[LINECOL][mem]);
+ }
+ else break;
+
+ ++i;
+ }
+}
+
+
+int double_k(int nlines, int deepsort)
+{
+ int i, ret = 0, mem = 0;
+ char *TheadA = subAptr[0][0];
+ char *TheadB = subAptr[1][0];
+ char *TheadC = subAptr[2][0];
+ char *TheadD = subAptr[3][0];
+ int Thint = dqsort[0];
+
+
+ i = 0; while (i < nlines)
+ {
+ if ( findFEmale(subAptr[0][i]) != 0
+ || findFEmale(subAptr[1][i]) != 0
+ || findFEmale(subAptr[2][i]) != 0
+ )
+ {
+ printf("%%%%\n%%%%> Warning: %s or %s in short-%s-title %s:\n", FEMALE, MALE, subAptr[3][i], subRptr[LINECOL][i]);
+ printK(i);
+ if (isvintroduced(i) == VENTRY)
+ printf("%%%% ... That k-entry was generated automatically from a v-entry.\n");
+ }
+ ++i;
+ }
+
+ i = 0; while (i < nlines)
+ {
+ if (leval[i] == REJECTLINE)
+ {
+ ++ret; /* Anzahl bereits auskommentierter Zeilen */
+ }
+ ++i;
+ }
+
+ ret = checkifisfullcited(0, nlines, ret);
+ checkmanipulationk(0);
+
+ i = 1; while (i < nlines)
+ {
+ if ( leval[i-1] != REJECTLINE
+ && (
+ texcmp(subAptr[0][i], TheadA, dqsort[i], Thint) != 0
+ || texcmp(subAptr[1][i], TheadB, dqsort[i], Thint) != 0
+ || texcmp(subAptr[2][i], TheadC, dqsort[i], Thint) != 0
+ || texcmp(subAptr[3][i], TheadD, dqsort[i], Thint) != 0
+ )
+ )
+ {
+ TheadA = subAptr[0][i];
+ TheadB = subAptr[1][i];
+ TheadC = subAptr[2][i];
+ TheadD = subAptr[3][i];
+ Thint = dqsort[i];
+ ret = checkifisfullcited(i, nlines, ret);
+ checkshortmismatch(i, nlines, mem);
+ mem = i;
+ checkSTUFFblock("vkc-seps after", i, nlines, deepsort, deepsort);
+ }
+
+ checkmanipulationk(i);
+
+ ++i;
+ }
+
+ return ret;
+}
+
+
+int doubleventries(int nlines, int deepsort)
+{
+ int ret = 0, i = 1, alast = -1, ainfos = 0, aget = 0, mem = -1, difftitle = 0, shown = 0;
+
+ /* geht davon aus, dass count_rejected nur REJECTLINE behandelt */
+ /* und doubleauthor commentANDignlines unveraendert laesst! */
+
+ while (i < nlines)
+ {
+ if ( texcmp(subAptr[0][i], subAptr[0][i-1], dqsort[i], dqsort[i-1]) == 0
+ && texcmp(subAptr[1][i], subAptr[1][i-1], dqsort[i], dqsort[i-1]) == 0
+ && texcmp(subAptr[2][i], subAptr[2][i-1], dqsort[i], dqsort[i-1]) == 0
+ && texcmp(subAptr[3][i], subAptr[3][i-1], dqsort[i], dqsort[i-1]) == 0
+ )
+ {
+ if (mem < 0) mem = i-1;
+
+ if (alast < i-1)
+ {
+ if (ainfos < MAXINFO)
+ {
+ printf("%%%%\n%%%%> Info: Identical full-titles %s, %s:\n", subRptr[LINECOL][i-1], subRptr[LINECOL][i]);
+ printV(i);
+ ainfos+=2;
+ ++shown;
+ }
+ else
+ ++difftitle;
+ aget +=2;
+ }
+ else
+ {
+ if (ainfos < MAXINFO)
+ {
+ printf("%%%%> ... and the same entry again from %s.\n", subRptr[LINECOL][i]);
+ ainfos+=1;
+ }
+ aget +=1;
+ }
+ alast = i;
+
+
+ if ( leval[i] != REJECTLINE
+ && leval[i-1] != REJECTLINE
+ )
+ {
+ leval[i] = DOUBLELINE;
+ ++ret;
+
+ if (mem == i-1) checkSTUFFblock("v-seps after", mem, nlines, deepsort, deepsort);
+ }
+ }
+ else mem = -1;
+
+ ++i;
+ }
+
+ if (ainfos > 1)
+ {
+ printf("%%%%\n%%%%> This have been the first %d (of %d) entries", ainfos, aget);
+ if (shown > 1)
+ printf(" (%d different titles)", shown);
+ printf("\n%%%% which are repeatingly cited");
+ if (aget > MAXINFO)
+ printf(" (further %d different titles)", difftitle);
+ printf(".\n%%%%\n");
+ }
+
+ return ret;
+}
+
+
+int doubleauthor(const char *entry, int nlines)
+{
+ int i, num = 0, len = strlen(entry), killpos, hint, Adq;
+ char a[MAXLEN], *p, xx[1], *AAp, *ABp, *ACp;
+
+ strcpy(a, entry);
+
+ i = 0; while (i < nlines)
+ {
+ if (findFEmale(subAptr[0][i]) != 0)
+ { printf("%%%%\n%%%%> Warning: %s or %s in lastname instead firstname %s:\n", FEMALE, MALE, subRptr[LINECOL][i]);
+ printV(i);
+ }
+ if (findFEmale(subAptr[2][i]) != 0)
+ { printf("%%%%\n%%%%> Warning: %s or %s in OptArg %s:\n", FEMALE, MALE, subRptr[LINECOL][i]);
+ printV(i);
+ }
+ ++i;
+ }
+
+ while(--nlines > 0)
+ {
+ if (*subAptr[0][nlines] == '\0' && *subAptr[1][nlines] == '\0') continue;
+ if (leval[nlines] == REJECTLINE) continue;
+
+ hint = nlines-1;
+ while(hint >= 0 && leval[hint] == REJECTLINE) --hint;
+ if (hint < 0) break;
+ AAp = subAptr[0][hint];
+ ABp = subAptr[1][hint];
+ Adq = dqsort[hint];
+ ACp = subAptr[2][hint];
+
+ if ( authorcmp(subAptr[0][nlines], AAp, dqsort[nlines], Adq) == 0
+ && authorcmp(subAptr[1][nlines], ABp, dqsort[nlines], Adq) == 0
+ )
+ {
+ i = len; p = lineptr[nlines] + len;
+
+ while (*p == ' ') { a[i++] = ' '; ++p; }
+ a[i++] = '{'; a[i] = '\0';
+ p += nextbracket(p, '{', '}');
+ killpos = i + 1;
+ strcat(a, IKILLNAME); i = i + strlen(IKILLNAME);
+ a[i++] = '}';
+
+ while (*p == ' ') { a[i++] = ' '; ++p; }
+ a[i++] = '{';
+ p += nextbracket(p, '{', '}');
+ a[i++] = '}';
+
+ while (*p == ' ') { a[i++] = ' '; ++p; }
+ a[i++] = '{';
+ p += nextbracket(p, '{', '}');
+
+ if (findFEmale(ABp) == 0 && findFEmale(subAptr[1][nlines]) == 1)
+ { printf("%%%%\n%%%%> Warning: No %s or %s in firstname %s:\n", FEMALE, MALE, subRptr[LINECOL][hint]);
+ printV(hint);
+ }
+
+ xx[0] = '0';
+ i = subdoubleauthors(0, 0, a, i, i, ACp, subAptr[2][nlines], hint, nlines, findFEmale(ABp), xx);
+ if (i < 0)
+ { i = -i; a[killpos] = PLURALCHAR;
+ a[i++] = '}';
+ if (xx[0] != '0') i = insertfalse(p, a, i);
+ else while (*p != '\0' && i < MAXLEN) a[i++] = *p++;
+ }
+ else
+ { a[i++] = '}';
+ while (*p != '\0' && i < MAXLEN) a[i++] = *p++;
+ }
+
+
+ if (i < MAXLEN)
+ { ++num;
+ myfree(lineptr[nlines]);
+ lineptr[nlines] = strnmalloc(a, i+1);
+ }
+ else printf("%%%%\n%%%%> Error: Can\'t replace {%s}{%s} by %s (too long)\n", subAptr[0][nlines], subAptr[1][nlines], IKILLNAME);
+ }
+ }
+ return num;
+}
+
+
+void pauthorbrackwarn(int nline, const char *head)
+{
+ printf("%%%%\n%%%%> Warning outfile entry %d (in arg 3): Missing brackets as %s{..}{..}\n", nline+1, head);
+}
+
+
+const char *authortable[][2] = {
+ { "\\vauthor\t", "\\vauthor" },
+ { "\\midvauthor\t", "\\midvauthor" },
+ {NULL, NULL}};
+#define NAUTHOR 2
+
+
+int findauthor(const char *s)
+{
+ int r = 0;
+
+ while(*s != '\0')
+ {
+ if (*s == '\\')
+ {
+ if (*(s+1) == '\\')
+ {
+ ++s; ++r;
+ }
+ else if (texlistnum(s, NAUTHOR, authortable) > -1) break;
+ }
+ ++s; ++r;
+ }
+
+ if (*s == '\0') r = -1;
+
+ return r;
+}
+
+
+int subdoubleauthors(int found, int addtxt, char a[], int remi, int i, const char *q, const char *p, int qline, int pline, int fe, char xx[])
+{
+ int ql = 0, pl, len, haveto, havedone = 0, ntxt = 0, nn, j;
+ char qbuf[MAXLEN] = "", pbuf[MAXLEN] = "";
+ const char *pmem, *qin = q, *pin = p;
+ const char *head;
+
+ while(*q != '\0')
+ {
+ haveto = 0;
+ if ((j=texlistnum(q, NAUTHOR, authortable)) > -1)
+ {
+ head = authortable[j][1];
+ haveto = 1;
+ }
+ else if (*q != ' ') ntxt = 1;
+
+ if (haveto == 1)
+ {
+ q += llstrlen(authortable[j][0]);
+ while(*q == ' ') ++q;
+ if (*q == '{' && (ql = nextbracket(q, '{', '}')) > 1)
+ {
+ ql = mystrncpy(qbuf, q, ql);
+ q += ql;
+ while(*q == ' ') ++q;
+ ql = ql + (len=nextbracket(q, '{', '}'));
+ if (len > 1)
+ {
+ strncat(qbuf, q, len);
+ q += len;
+ }
+ }
+ break;
+ }
+ else
+ if (*q == '\\' && *(q+1) == '\\')
+ {
+ ntxt = 1;
+ q++;
+ }
+
+ q++;
+ }
+
+
+ while(*p != '\0' && i < MAXLEN-1)
+ {
+ haveto = 0;
+ if ((j=texlistnum(p, NAUTHOR, authortable)) > -1)
+ {
+ head = authortable[j][1];
+ haveto = 1;
+ }
+ else if (*p != ' ') ntxt = 1;
+
+ if (haveto == 1)
+ {
+ pmem = p;
+ p += llstrlen(authortable[j][0]);
+ while(*p == ' ') ++p;
+ if (*p == '{' && (pl = nextbracket(p, '{', '}')) > 1)
+ {
+ pl = mystrncpy(pbuf, p, pl);
+ p += pl;
+ while(*p == ' ') ++p;
+ pl = pl + (len=nextbracket(p, '{', '}'));
+ if (len > 1)
+ { strncat(pbuf, p, len);
+ p += len;
+ if ( authorcmp(qbuf, pbuf, dqsort[qline], dqsort[pline]) == 0
+ && strcmp(qbuf, "{}{}") != 0
+ && strcmp(qbuf, "{ }{ }") != 0
+ && i + strlen(head) + 4 + strlen(NKILLNAME) + 1 < MAXLEN
+ )
+ {
+ a[i] = '\0';
+ strcat(a, head); i += strlen(head);
+ strcat(a, " {}{"); i += 4;
+ strcat(a, NKILLNAME); i += strlen(NKILLNAME);
+ strcat(a, "}"); i += 1;
+ havedone = 1;
+ }
+ else
+ { p = pmem;
+ }
+ }
+ else
+ { p = pmem; pauthorbrackwarn(pline, head);
+ }
+ break;
+ }
+ else
+ { p = pmem; pauthorbrackwarn(pline, head);
+ }
+ }
+ else
+ if (*p == '\\' && *(p+1) == '\\')
+ {
+ ntxt = 1;
+ a[i++] = *p++;
+ }
+
+ a[i++] = *p++;
+ }
+
+
+ if (havedone == 0)
+ {
+ if (found > 0 && addtxt == 0 && fe == 1 && findauthor(qin) == -1)
+ { nn = 1; i = remi;
+ p = pin;
+ while (*p == ' ') ++p;
+ if (ntxt == 1) xx[0] = '1';
+ } else nn = 0;
+
+ while (*p != '\0' && i < MAXLEN) a[i++] = *p++;
+ if (nn == 1) i = -i;
+ }
+ else
+ { if (ntxt > 0) addtxt = ntxt;
+ i = subdoubleauthors(++found, addtxt, a, remi, i, q, p, qline, pline, fe, xx);
+ }
+
+ return i;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+int readlines(int maxlines, int nlines, const char *head)
+{
+ int len, headlen = strlen(head);
+ char *p, linestr[MAXLEN];
+
+ while ((len = ignFRONTSPACESgetline(linestr, MAXLEN)) > 0)
+ {
+ if ( strncmp(linestr, head, headlen) == 0
+ && isLaTeXcmdletter(*(linestr+headlen)) == 0
+ )
+ {
+ if ( nlines >= maxlines
+ || (p = (char *) malloc(len)) == NULL
+ ) return -1;
+ else
+ { linestr[len-1] = '\0';
+ strcpy(p, linestr);
+ lineptr[nlines++] = p;
+ }
+ }
+ }
+ return nlines;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+ /* Kehrt mit -argc+1 zur"uck, wenn Option da ist. */
+
+int single_option(int argc, char *argv[], char a[], char b[])
+{
+
+ int l = 1, c;
+ int _found = 0;
+
+ while (l < argc)
+ {
+ if (strcmp(argv[l], a) == 0 || strcmp(argv[l], b) == 0)
+ { _found = 1;
+ /* myfree(argv[l]); */
+ --argc;
+ c = l;
+ while (c < argc)
+ { argv[c] = argv[c+1];
+ ++c;
+ }
+ --l;
+ }
+ ++l;
+ }
+ if (_found == 1) return -argc;
+ else return argc;
+}
+
+
+char *arg_option(int argc, char *argv[], char a[], char b[], char *info)
+{
+
+ int l = 1, c, found = 0;
+ char *p = NULL;
+
+ if (argc > 1 && (strcmp(argv[argc-1], a) == 0 || strcmp(argv[argc-1], b) == 0))
+ {
+ printf("%%%%\n%%%%> Error: %s is not followed by an argument %s.\n", b, info);
+ announceexit("get an arg option without arg");
+ exit(1);
+ }
+
+ while (l < argc-1)
+ {
+ if (strcmp(argv[l], a) == 0 || strcmp(argv[l], b) == 0)
+ {
+ /* myfree(argv[l]); */
+ p = argv[l+1];
+ ++found;
+ argc -= 2;
+ c = l;
+ while (c < argc)
+ {
+ argv[c] = argv[c+2];
+ ++c;
+ }
+ --l;
+ }
+ ++l;
+ }
+
+ if (found > 1)
+ {
+ printf("%%%%\n%%%%> Error: %s [arg] setted %d times.\n", a, found);
+ announceexit("do not accept multiple defined arg options");
+ exit(1);
+ }
+
+ return p;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+ /* Erkennt unbekannte Optionen. */
+
+int surp_option(int argc, char *argv[])
+{
+ int l = 1, c;
+
+ while (l < argc)
+ {
+ if (*argv[l] == '-')
+ { printf("%%%%\n%%%%> Error: Get unknown option \"%s\"!\n", argv[l]);
+ /* myfree(argv[l]); */
+ --argc;
+ c = l;
+ while (c < argc)
+ { argv[c] = argv[c+1];
+ ++c;
+ }
+ --l;
+ }
+ ++l;
+ }
+ return argc;
+}
+
+
+/*--------------------------------------------------------------------------*/
+
+
+char *makename(const char *prefix, const char *suffix)
+{
+ char fname[MAXFILENAMLEN];
+ int plen;
+
+ plen = mystrncpy(fname, prefix, MAXFILENAMLEN-1);
+ strncat(fname, suffix, MAXFILENAMLEN-plen-1);
+
+ if (plen + strlen(suffix) > MAXFILENAMLEN-1)
+ {
+ announceexit("get a too long path/file name");
+ printf("%%%%\n%%%% \"%s%s\"\n", prefix, suffix);
+ exit(1);
+ }
+
+ return strnmalloc(fname, strlen(fname)+1);
+}
+
+
+int dofile(int filenum, char *filenam, int nlines, const char *entry, const char *formO, int deep, int deepsort, int ventry)
+{
+ int alllines = nlines;
+
+ infile = fopen(filenam, "r");
+
+ if (infile != NULL)
+ {
+ printf("%%%%> Search *\"%s\"* in file \"%s\" ...\n", entry, filenam);
+
+ if ((alllines = readlines(MAXLINES, nlines, entry)) >= 0)
+ {
+ if (alllines-nlines > 0 && MAXLINES > 0)
+ {
+ printf("%%%% ^^^^^^^^^^^ ... get %d line(s)", alllines-nlines);
+ if (alllines*100/MAXLINES > 0)
+ printf(" [reach %d%% of capacity]", alllines*100/MAXLINES);
+ printf(".\n");
+ }
+ getbrackets(nlines, alllines, entry, deep, filenum, formO, ventry);
+ dopgfntnumberweight(nlines, alllines);
+ dodqdeepsort(nlines, alllines, deepsort);
+ vorbereiten(nlines, alllines, deepsort, ventry);
+ }
+ else printf("%%%%\n%%%%> Error: More than %d input entries.\n", MAXLINES); /* exit(1) bei dofile */
+ }
+ else
+ { printf("%%%%\n%%%%> Error: No file \"%s\".\n", filenam);
+ openfailed(filenam);
+ }
+
+ if (infile != NULL) fclose(infile);
+
+ return alllines;
+}
+
+
+char *switchtodospath(char s[])
+{
+ int i = 0;
+
+ while (s[i] != '\0')
+ {
+ if (s[i] == '/') s[i] = '\\';
+ ++i;
+ }
+
+ return s;
+}
+
+
+int getfilenames(int nlines, int usedospath)
+{
+ int i = 0, j = 0, len;
+ char *p;
+
+ while (i < nlines)
+ {
+ p = setptrtofirstbracket(lineptr[i]);
+ if (*p == '{' && (len=nextbracket(p, '{', '}')) > 2)
+ { filelist[j] = strnmalloc(p+1, len-1);
+ p += len;
+ if (usedospath == 1)
+ filelist[j] = switchtodospath(filelist[j]);
+ ignoreadditionaltext(p, "\\@input", filelist[j]);
+ ++j;
+ }
+ else printf("%%%%\n%%%%> Error after \\@input-cmd %d: Empty, or not matching brackets.\n", i+1);
+ myfree(lineptr[i]);
+ ++i;
+ }
+ if (i != j && i != 0) printf("%%%% %d input file(s) remain(s).\n", j);
+ return j;
+}
+
+
+int userusesdq(int deepsort, int linec)
+{
+ int i = 0;
+ char *p;
+
+ while (i < deepsort)
+ {
+ p = subAptr[i++][linec];
+ while (*p != '\0')
+ {
+ if (*p == '\"') return 1;
+ if (*p == '\\' && *(p+1) != '\0') ++p;
+ ++p;
+ }
+ }
+
+ return 0;
+}
+
+
+void freeall(int nlines, int deep, int deepsort)
+{
+ int linec = 0, i;
+
+ if (deepsort > deep) intern_err(22); /* deepsort > deep */
+
+ while(linec < nlines)
+ { myfree(lineptr[linec]);
+ i = 0; while (i < deep) myfree(subAptr[i++][linec]);
+ i = 0; while (i < deepsort) myfree(subBptr[i++][linec]);
+ while (i < deep ) if (subBptr[i++][linec] != mydefault) intern_err(23); /* FREEALL */
+ i = 0; while (i < deepsort) myfree(subCptr[i++][linec]);
+ while (i < deep ) if (subCptr[i++][linec] != mydefault) intern_err(24); /* FREEALL */
+ i = 0; while (i < BAALLRCOLS) myfree(subRptr[i++][linec]);
+ ++linec;
+ }
+}
+
+
+void testdrucken(int linec, int alllines, int deep, char *subptr[MAXBACOLS][MAXLINES])
+{
+ int i;
+
+ while (linec < alllines)
+ {
+ i = 0;
+ while (i < deep)
+ {
+ printf(" (%s)", subptr[i][linec]);
+ ++i;
+ }
+ printf(" [\"=%d, %d]", dqsort[linec], getarabicnum(subRptr[DQCOL][linec]));
+ printf("\n");
+ ++linec;
+ }
+}
+
+
+int check_kandk(int nlines)
+{
+ int i = 0;
+ int outkurz = 0;
+ int ktit = 0;
+
+ while (i < nlines)
+ {
+ outkurz += num_of_cmds_in_str(lineptr[i], KURZCMD);
+ ktit += num_of_cmds_in_str(lineptr[i], KTITCMD);
+ ++i;
+ }
+
+ if (outkurz > 0 && ktit > 0)
+ {
+ printf("%%%%\n%%%%> Warning: %d time(s) %s and %d time(s) %s found;\n", outkurz, KURZ, ktit, KTIT);
+ printf("%%%% see %s warnings in the output file.\n", KURZ);
+ }
+
+ if (outkurz > 0 && ktit > 0) return 1;
+ return 0;
+}
+
+
+int hasinnerentry(const char *p, const char *icmdlist[][2], const int num)
+{
+ int r = -1;
+
+ while (*p != '\0')
+ {
+ if (*p == '\\')
+ {
+ if (*(p+1) == '\\') ++p;
+ else
+ if ((r=innerentry(p, icmdlist, num)) > -1) break;
+ }
+ ++p;
+ }
+
+ return r;
+}
+
+
+int check_ktit(int nlines, int ventry)
+{
+ int i = 0, ohask = 0, ohasnok = 0, elsehask = 0, shadowedlines = 0, unshadnum = 0, l, ll, badlines = 0;
+ int ohk[MAXINFO];
+
+ if (ventry != IS_V) return 0;
+
+ while (i < nlines)
+ {
+ if (subAptr[VCOLS-1][i] == mydefault)
+ {
+ ++badlines;
+ }
+ else
+ {
+ l = num_of_cmds_in_str(subAptr[VCOLS-1][i], KTITCMD);
+ unshadnum += (ll=unshielded_cmds_in_str(subAptr[VCOLS-1][i], KTITCMD));
+
+ if (l > ll)
+ {
+ if (shadowedlines == 0)
+ printf("%%%%\n%%%%> Warning: { %s } is shadowed by brackets ...\n", KTIT);
+ printf("%%%% ... in entry from %s:\n", subRptr[LINECOL][i]);
+ printV(i);
+ ++shadowedlines;
+ }
+
+ if (hasinnerentry(subAptr[VCOLS-1][i], innerK_PER_ARQ_cmd, INNERTITLES) > -1)
+ {
+ if (l > 0)
+ {
+ ++ohask;
+ }
+ else
+ {
+ if (ohasnok < MAXINFO) ohk[ohasnok] = i;
+ ++ohasnok;
+ }
+ }
+ else
+ if (l > 0)
+ ++elsehask;
+ }
+ ++i;
+ }
+
+ if (shadowedlines > 0) printf("%%%%> A shadowed outer %s can not create %s in your text;\n%%%% a shadowed inner %s can not create a shortened reference in the list.\n%%%%\n", KTIT, ANNOUNCEKTIT, KTIT);
+
+ if (badlines > 0)
+ printf("%%%%> %s: Can\'t check all entries (%d are corrupt).\n", KTIT, badlines);
+
+
+ if (badlines < nlines)
+ {
+
+ if (ohask > 0 && ohasnok > 0)
+ {
+ printf("%%%%> Info: Items with inner title: %d with outer %s found, %d without.\n", ohask, KTIT, ohasnok);
+ }
+
+
+ if (ohasnok > 0)
+ {
+ printf("%%%%\n%%%%> Info: Entries with inner reference and no outer %s ...\n", KTIT);
+ i = 0;
+ while (i < MAXINFO && i < ohasnok)
+ {
+ l = ohk[i];
+ printf("%%%% ... from %s:\n", subRptr[LINECOL][l]);
+ printV(l);
+ ++i;
+ }
+ if (ohasnok > 0)
+ printf("%%%%> This have been the first %d (of %d) entries without outer %s.\n%%%%\n", i, ohasnok, KTIT);
+ }
+
+
+ if ( (shadowedlines == 0 && badlines == 0)
+ || (elsehask + ohask == 0 && badlines == 0)
+ )
+ printf("%%%%> Info: ");
+
+
+ if (shadowedlines == 0 && badlines == 0 && (ohask > 0 || elsehask > 0))
+ {
+ if (elsehask+ohask == nlines) printf("All");
+ else printf("NOT all");
+ printf(" v-entries have (outer) %s cmds in their last arg", KTIT); /* VCOLS */
+ if (elsehask+ohask == nlines) printf(".\n");
+ else printf(":\n%%%% In case of %s see messages in the output file.\n", ANNOUNCEKTIT);
+
+ if (nlines < unshadnum)
+ printf("%%%% I count %d unshadowed %s in %d entries (%d too much).\n", unshadnum, KTIT, nlines, unshadnum-nlines);
+ }
+ else if (elsehask + ohask == 0 && badlines == 0)
+ {
+ printf("You\'ve never used %s in last v-args:\n", KTIT);
+ printf("%%%% No info on outer %s in output file; no %s done.\n", KTIT, ANNOUNCEKTIT);
+ }
+ }
+
+
+ l = 1;
+ if (elsehask + ohask == 0) l += 4;
+ if (ohask > 0 && ohasnok > 0) l += 2;
+ if (shadowedlines > 0) ++l;
+ return l;
+}
+
+
+void prepareoutput(const char *entry, const char *suffix, int deep, int deepsort, int filec, char *arg_i, char *arg_o, int prep_kill, const char *formO, int ventry, int printsort)
+{
+ int nlines = 0, i = 0, extralines = 0, commentANDignlines = 0;
+ int filenum = -1, kandkused = 0, oktitused = 0;
+ char *outname = mydefault;
+
+ if (arg_o == NULL) outname = makename(arg_i, suffix);
+ else outname = makename(arg_o, suffix);
+
+ otherktiterr = 0;
+
+ while (i < filec)
+ {
+ if (filec > 0) filenum = i+1;
+ if ((nlines = dofile(filenum, filelist[i++], nlines, entry, formO, deep, deepsort, ventry)) < 0)
+ {
+ announceexit("get a too big list of entries");
+ exit(1);
+ }
+ }
+
+ if (MAXLINES > 0 && nlines*100/MAXLINES > 90)
+ printf("%%%% *** WARNING: Have capacity for only %d further entries! ***\n%%%%\n", MAXLINES-nlines);
+
+
+ /* printf("\nC: "); testdrucken(0, nlines, deep, subCptr); */
+ /* printf("\nB: "); testdrucken(0, nlines, deep, subBptr); */
+ /* printf("\nA: "); testdrucken(0, nlines, deep, subAptr); */
+ /* testdrucken(0, nlines, BAALLRCOLS, subRptr); */
+
+
+ if (nlines > 0)
+ {
+ if (nlines > 1) printf("%%%% Sort %d lines. Wait.\n", nlines);
+ QQsort(0, nlines-1, deep, deepsort);
+
+
+ if (prep_kill == DOKILLAUTHORS && nlines > 1)
+ { printf("%%%%> -k: Search multiply used authors ...\n");
+ printf("%%%%> -k: Authors in %d line(s) IDEMized [identical full-titles included].\n", doubleauthor(entry, nlines));
+ commentANDignlines = count_rejected(nlines);
+ }
+ else
+ if (prep_kill == DOKILLABBREVS && nlines > 0)
+ { printf("%%%% Search multiply used or empty abbreviations ...\n");
+ commentANDignlines = double_or_empty_abbreviation(nlines, deepsort, deep);
+ }
+ else
+ if (prep_kill == DOKILLREGISTS && nlines > 0)
+ { printf("%%%% Search multiply used or empty entries ...\n");
+ if (*suffix == '.')
+ commentANDignlines = double_or_empty_arqperregisters(nlines, ventry, suffix+1, deepsort, deep);
+ else intern_err(25); /* ERROR with \\fill... */
+ }
+ else
+ if (prep_kill == DOKILLK && nlines > 0)
+ { printf("%%%% Search multiply used short-titles ...\n");
+ commentANDignlines = double_k(nlines, deepsort);
+ }
+ else commentANDignlines = count_rejected(nlines);
+
+
+ if (prep_kill == DOKILLAUTHORS || prep_kill == NOKILLAUTHORS)
+ {
+ if (deep == VCOLS && ventry == IS_V)
+ commentANDignlines = commentANDignlines + doubleventries(nlines, deepsort);
+ else intern_err(26); /* ERROR with doubleventries */
+ }
+
+ kandkused = check_kandk(nlines);
+ oktitused = check_ktit(nlines, ventry);
+
+ if ((outfile = fopen(outname, "w")) == NULL)
+ {
+ printf("%%%%\n%%%%> Error: Can\'t write to file \"%s\".\n", outname);
+ openfailed(outname);
+ }
+ else
+ { printf("%%%%> Write %d item(s) to file \"%s\".\n", nlines-commentANDignlines, outname);
+ if ((extralines = writelines(nlines, DQCOL, LANCOL, commentANDignlines, deepsort, filec, printsort, kandkused, oktitused)) > 0)
+ printf("%%%% (Have added %d line(s) containing commands for LaTeX.)\n", extralines);
+ }
+
+ if (outfile != NULL) { fclose(outfile); fflush(outfile); }
+ freeall(nlines, deep, deepsort);
+ }
+ else
+ {
+ printf("%%%% No entries. ");
+ if ((outfile = fopen(outname, "r")) != NULL)
+ {
+ fclose(outfile); fflush(outfile);
+ if ((outfile = fopen(outname, "w")) != NULL)
+ {
+ fclose(outfile); fflush(outfile);
+ printf("*DELETE* old");
+ remove(outname);
+ }
+ else printf("CAN\'T delete");
+ }
+ else printf("Do NOT create");
+ printf(" file \"%s\".\n", outname);
+ }
+
+ outhline();
+
+ myfree(outname);
+}
+
+
+#define ALLWEIGHT ENDWEIGHT-2
+void setnewweight(const int pg, const char *p, const char *opt)
+{
+ int lauf = BEGINWEIGHT; /* 4 ... 7+2 */
+ int have_n = 0;
+ int have_R = 0, typed_R = 0;
+ int have_r = 0, typed_r = 0;
+ int have_A = 0, typed_A = 0;
+ int have_a = 0, typed_a = 0;
+ int have_s = 0;
+ int wrong_letter = 0;
+ const char *q = p;
+
+ while(*p != '\0' && lauf < ALLWEIGHT)
+ {
+ if (*p == 'n') { if (pg == 1) { pg_arabic = lauf; } else { fn_arabic = lauf; } ++have_n; }
+ else if (*p == 'R') { if (pg == 1) { pg_bigroman = lauf; get_R_pg = BA_TRUE; } else { fn_bigroman = lauf; get_R_fn = BA_TRUE; } ++have_R; ++have_A; ++typed_R; }
+ else if (*p == 'r') { if (pg == 1) { pg_smallroman = lauf; get_r_pg = BA_TRUE; } else { fn_smallroman = lauf; get_r_fn = BA_TRUE; } ++have_r; ++have_a; ++typed_r; }
+ else if (*p == 'A') { if (pg == 1) { pg_bigletter = lauf; get_A_pg = BA_TRUE; } else { fn_bigletter = lauf; get_A_fn = BA_TRUE; } ++have_A; ++have_R; ++typed_A; }
+ else if (*p == 'a') { if (pg == 1) { pg_smallletter = lauf; get_a_pg = BA_TRUE; } else { fn_smallletter = lauf; get_a_fn = BA_TRUE; } ++have_a; ++have_r; ++typed_a; }
+ else if (*p == 's') { if (pg == 1) { pg_symbol = lauf; } else { fn_symbol = lauf; } ++have_s; }
+ else { ++wrong_letter; break; }
+ ++lauf; ++p;
+ }
+
+
+ if ( *p != '\0'
+ || lauf != ALLWEIGHT
+ || have_n != 1
+ || have_R != 1
+ || have_r != 1
+ || have_A != 1
+ || have_a != 1
+ || have_s != 1
+ )
+ {
+ printf("%%%%\n%%%%> Error: Not the %d expected letters in \"%s %.29s\".\n", ALLWEIGHT-BEGINWEIGHT, opt, q);
+ if (strlen(q) <= ALLWEIGHT-BEGINWEIGHT)
+ {
+ printf("%%%% Missing:");
+ if ( have_n == 0) printf(" [n]");
+ if ( have_s == 0) printf(" [s]");
+ if (typed_R == 0 && typed_A == 0) printf(" [R *or* A]");
+ if (typed_r == 0 && typed_a == 0) printf(" [r *or* a]");
+ }
+ else
+ {
+ printf("%%%% Error: More than %d letters", ALLWEIGHT-BEGINWEIGHT);
+ }
+ printf(". E.g.: snRa, nArs, Rrns, naAs.\n");
+ if ( have_n > 1
+ || have_s > 1
+ || typed_R > 1
+ || typed_A > 1
+ || typed_r > 1
+ || typed_a > 1
+ )
+ {
+ printf("%%%% Error: You have setted");
+ if (typed_A > 1) printf(" [A]");
+ if (typed_a > 1) printf(" [a]");
+ if ( have_n > 1) printf(" [n]");
+ if (typed_R > 1) printf(" [R]");
+ if (typed_r > 1) printf(" [r]");
+ if ( have_s > 1) printf(" [s]");
+ printf(" more than once.\n");
+ }
+ if ( (typed_A > 0 && typed_R > 0)
+ || (typed_a > 0 && typed_r > 0)
+ )
+ {
+ printf("%%%% Error: You have setted");
+ if (typed_A > 0 && typed_R > 0) printf(" [R] *and* [A]");
+ if (typed_A > 0 && typed_R > 0 && typed_a > 0 && typed_r > 0)
+ printf(", and ");
+ if (typed_a > 0 && typed_r > 0) printf(" [r] *and* [a]");
+ printf(".\n");
+ if ( (typed_a > 0 && typed_r > 0)
+ || (typed_A > 0 && typed_R > 0)
+ )
+ {
+ printf("%%%% ** A number like 'i' could mean 9 (alph), and 1 (roman). In xxxx,\n");
+ printf("%%%% ** you can only choose R and a, or R and r, or A and a, or A and r.\n");
+ }
+ }
+ if (wrong_letter > 0) printf("%%%% Break: Unexpected character \'%c\'.\n", *p);
+ announceexit("did not get 4 out of nRrAas (R or A, r or a)");
+ exit(1);
+ }
+
+
+ if (pg == 1)
+ {
+ if (get_r_pg == BA_FALSE) pg_smallroman = ++lauf;
+ if (get_R_pg == BA_FALSE) pg_bigroman = ++lauf;
+ if (get_a_pg == BA_FALSE) pg_smallletter = ++lauf;
+ if (get_A_pg == BA_FALSE) pg_bigletter = ++lauf;
+ }
+ else
+ {
+ if (get_r_fn == BA_FALSE) fn_smallroman = ++lauf;
+ if (get_R_fn == BA_FALSE) fn_bigroman = ++lauf;
+ if (get_a_fn == BA_FALSE) fn_smallletter = ++lauf;
+ if (get_A_fn == BA_FALSE) fn_bigletter = ++lauf;
+ }
+
+ if ((pg == 0 || pg == 1) && lauf == ENDWEIGHT);
+ else intern_err(27); /* setnewweight */
+}
+
+
+void print_arg_list(char *argv[], int argc)
+{
+ int l = 1;
+ while (l < argc) printf("%%%% %d: \"%s\"\n", l, argv[l++]);
+}
+
+
+int main(int argc, char *argv[])
+{
+ int nlines = 0;
+ int usedospath = 0;
+ int filec = 0;
+ int get_g = 0;
+ int printsort = 0;
+ char *inname = mydefault, *arg_i = NULL, *arg_o = NULL;
+
+
+ printf("\n%%%%> This is bibsort 2.2 (for help: %s -\?)\n", getmyname(argv[0], 37));
+ fprintf(stderr, "%%%% bibsort 2.2 is part of BibArts 2.2 (C) Timo Baumann 2019.\n");
+
+
+ argc = single_option(argc, argv, "-B", "-b");
+ if (argc < 0)
+ {
+ bago = 1;
+ argc = -argc;
+ }
+
+ argc = single_option(argc, argv, "-N1", "-n1");
+ if (argc < 0)
+ {
+ FntIndexOverPages = 0;
+ argc = -argc;
+ }
+
+ argc = single_option(argc, argv, "-c", "-C");
+ if (argc < 0)
+ { argc = -argc;
+ notext = 1;
+ }
+
+ soptarg = arg_option(argc, argv, "-S2", "-s2", "[sorting key: 4 out of nRrAas]");
+ if (soptarg != NULL)
+ {
+ argc -= 2;
+ setnewweight(1, soptarg, "-s2");
+ }
+
+ argc = single_option(argc, argv, "-S1", "-s1");
+ if (argc < 0)
+ { argc = -argc;
+ if ( get_R_pg == BA_FALSE
+ && get_A_pg == BA_FALSE
+ && get_a_pg == BA_FALSE
+ && get_r_pg == BA_FALSE
+ )
+ {
+ EinlROEMseiten = 1;
+ }
+ else
+ {
+ announceexit("get opt -s1 *and* -s2");
+ exit(1);
+ }
+ }
+
+ foptarg = arg_option(argc, argv, "-F2", "-f2", "[sorting key: 4 out of nRrAas]");
+ if (foptarg != NULL)
+ {
+ argc -= 2;
+ setnewweight(0, foptarg, "-f2");
+ }
+
+ argc = single_option(argc, argv, "-F1", "-f1");
+ if (argc < 0)
+ { argc = -argc;
+ if ( get_R_fn == BA_FALSE
+ && get_A_fn == BA_FALSE
+ && get_a_fn == BA_FALSE
+ && get_r_fn == BA_FALSE
+ )
+ {
+ ALPHmpfootnotes = 1;
+ }
+ else
+ {
+ announceexit("get opt -f1 *and* -f2");
+ exit(1);
+ }
+ }
+
+ argc = single_option(argc, argv, "-i=j", "-I=J");
+ if (argc < 0)
+ { argc = -argc;
+ igleichj = 1;
+ }
+
+ argc = single_option(argc, argv, "-D", "-d");
+ if (argc < 0)
+ { argc = -argc;
+ usedospath = 1;
+ }
+
+ argc = single_option(argc, argv, "-K", "-k");
+ if (argc < 0)
+ { argc = -argc;
+ kill = DOKILLAUTHORS;
+ }
+
+ argc = single_option(argc, argv, "-L", "-l");
+ if (argc < 0)
+ { argc = -argc;
+ ignorespaces = 1;
+ }
+
+ argc = single_option(argc, argv, "-H", "-h");
+ if (argc < 0)
+ { argc = -argc;
+ hy_as_space = 1;
+ }
+
+ argc = single_option(argc, argv, "-P", "-p");
+ if (argc < 0)
+ { argc = -argc;
+ registpoints = 1;
+ }
+
+ argc = single_option(argc, argv, "-T1", "-t1");
+ if (argc < 0)
+ { argc = -argc;
+ encode = 1;
+ }
+
+ argc = single_option(argc, argv, "-X", "-x");
+ if (argc < 0)
+ { argc = -argc;
+ nogsty = 1;
+ }
+
+ argc = single_option(argc, argv, "-M", "-m");
+ if (argc < 0)
+ { argc = -argc;
+ printsort = 1;
+ }
+
+ argc = single_option(argc, argv, "-G1", "-g1");
+ if (argc < 0)
+ { argc = -argc;
+ ++get_g;
+ german = 1;
+ }
+
+ argc = single_option(argc, argv, "-G2", "-g2");
+ if (argc < 0)
+ { argc = -argc;
+ if (get_g == 0) german = 2;
+ ++get_g;
+ }
+
+ if (get_g > 1)
+ {
+ announceexit("get opt -g1 *and* -g2");
+ exit(1);
+ }
+
+ argc = single_option(argc, argv, "-\?", "-h1"); /* 2.2: -h => hyphen */
+ if (argc < 0)
+ {
+ argc = -argc;
+ maininfo(argv[0]);
+ announceexit("get your question for help");
+ exit(1);
+ }
+
+ argc = single_option(argc, argv, "-\?\?", "-h2"); /* 2.2: -hh => -h2 */
+ if (argc < 0)
+ {
+ argc = -argc;
+ moreinfo();
+ announceexit("get your question for more help");
+ exit(1);
+ }
+
+ argc = single_option(argc, argv, "-R", "-r");
+ if (argc < 0)
+ {
+ argc = -argc;
+ licenseinfo();
+ announceexit("get your question for license informations");
+ exit(1);
+ }
+
+ if (argc < 2)
+ { if (argc == 1) maininfo(argv[0]);
+ announceexit("get no <FileNamePrefix> of an auxiliary file");
+ exit(1);
+ }
+
+ arg_i = arg_option(argc, argv, "-I", "-i", "<InputFilenamePrefix>");
+ if (arg_i != NULL)
+ {
+ argc -= 2;
+ }
+
+ arg_o = arg_option(argc, argv, "-O", "-o", "<OutputFilenamesPrefix>");
+ if (arg_o != NULL)
+ {
+ argc -= 2;
+ }
+
+ if (argc != surp_option(argc, argv))
+ {
+ announceexit("get an unknown -[option]");
+ exit(1);
+ }
+
+
+ if ( (argc == 2 && arg_i == NULL)
+ || (argc == 1 && arg_i != NULL)
+ )
+ {
+ if (argc == 2) { arg_i = argv[1]; --argc; }
+ inname = makename(arg_i, AUX_SUFFIX);
+ infile = fopen(inname, "r");
+ }
+ else
+ { printf("%%%%\n%%%%> Error: Too many arguments:\n");
+ print_arg_list(argv, argc);
+ printf("%%%% Since vers 2.1, you have to use -o <OutputFileNamesPrefix>.\n");
+ announceexit("get more than one file name in command line");
+ exit(1);
+ }
+
+ if (infile == NULL)
+ {
+ printf("%%%%\n%%%%> Error: No file \"%s\".\n", inname);
+ openfailed(inname);
+ announceexit("did not get the name of an existing file");
+ exit(0); /* damit TeXnicCenter danach trotzdem LaTeX startet */
+ }
+
+ if ((nlines = readlines(MAXFILES, 0, "\\@input")) == 0)
+ {
+ printf("%%%%> No \\@input cmds in \"%s\":\n", inname);
+ filelist[0] = inname;
+ filec = 1;
+ }
+ else
+ if (nlines < 0)
+ {
+ printf("%%%%> Error: To many \\@input cmds in \"%s\".\n", inname);
+ announceexit("can not handle such a big list of files");
+ exit(1);
+ }
+ else
+ {
+ printf("%%%%> Try to work list of %d \\@input files in \"%s\":\n", nlines, inname);
+ nlines = getfilenames(nlines, usedospath);
+ if (nlines < 1)
+ {
+ announceexit("get a too big input file");
+ exit(1);
+ }
+ filec = nlines;
+ }
+
+ if (infile != NULL) fclose(infile);
+
+ printfilelist( stdout, filec, 0, "%% ", "");
+
+
+
+ /* changed in 2.2 => inner \\printonlyvli \\printonlyvqu */
+ /* l = loeschen */
+ /* e = entkernen */
+ /* X = weder loeschen noch entkernen */
+ /* "----" KHVONUM Positionen: \\onlykurz \\onlyhere \\onlyvoll \\onlyout */
+
+ prepareoutput("%\\literentry", VLI_SUFFIX, VCOLS, VCOLS, filec, arg_i, arg_o, kill, "llee", IS_V, printsort);
+ prepareoutput("%\\quellentry", VQU_SUFFIX, VCOLS, VCOLS, filec, arg_i, arg_o, kill, "llee", IS_V, printsort);
+ prepareoutput("%\\vkcitentry", VKC_SUFFIX, KCOLS, KCOLS, filec, arg_i, arg_o, DOKILLK, "elle", NO_V, printsort);
+
+ prepareoutput("%\\abkrzentry", ABK_SUFFIX, ACOLS, ACOLSSORT, filec, arg_i, arg_o, DOKILLABBREVS, "llee", NO_V, printsort);
+ prepareoutput("%\\perioentry", PER_SUFFIX, PCOLS, PCOLSSORT, filec, arg_i, arg_o, DOKILLREGISTS, "llee", NO_V, printsort);
+ prepareoutput("%\\archqentry", ARQ_SUFFIX, PCOLS, PCOLSSORT, filec, arg_i, arg_o, DOKILLREGISTS, "llee", IS_Q, printsort);
+
+ prepareoutput("%\\geogrentry", GRR_SUFFIX, PCOLS, PCOLSSORT, filec, arg_i, arg_o, DOKILLREGISTS, "llee", NO_V, printsort);
+ prepareoutput("%\\persrentry", PRR_SUFFIX, PCOLS, PCOLSSORT, filec, arg_i, arg_o, DOKILLREGISTS, "llee", NO_V, printsort);
+ prepareoutput("%\\subjrentry", SRR_SUFFIX, PCOLS, PCOLSSORT, filec, arg_i, arg_o, DOKILLREGISTS, "llee", NO_V, printsort);
+
+
+
+ if (upperascii < 0)
+ {
+ if (encode == 1)
+ {
+ printf("%%%%\n%%%%> -t1: Gave 8-bit character %d sorting weight \"%s\" ....\n", ((unsigned char)upperascii), getTONEenc(upperascii));
+ fprintf(stderr, "%%%% Did NOT ignore upper ascii characters ({T1} and no {inputenc} assumed).\n");
+ }
+ else
+ {
+ printf("%%%%\n%%%%> Info: Gave 8-bit character %d NO sorting weight. Use -t1\?\n", ((unsigned char)upperascii));
+ fprintf(stderr, "%%%% Did ignore all upper ascii characters ({OT1} and no {inputenc} assumed).\n");
+ }
+ }
+ else if (encode == 1)
+ printf("%%%%\n%%%%> -t1 is unnecessary: No upper ascii characters found.\n");
+
+ return 0;
+}
+
+
+/*--------------------------------------------------------------------------*/
+/*--------------------------------------------------------------------------*/