/*************************************************************************/

/* bookloupe--check for assorted weirdnesses in a PG candidate text file */

/*                                                                       */

/* Copyright 2000-2005 Jim Tinsley <jtinsley@pobox.com>                  */

/* Copyright 2012- J. Ali Harlow <ali@juiblex.co.uk>                     */

/*                                                                       */

/* 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, see <http://www.gnu.org/licenses/>.  */

/*************************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#define MAXWORDLEN    80    /* max length of one word             */

#define LINEBUFSIZE 2048    /* buffer size for an input line      */

#define MAX_USER_TYPOS 1000

#define USERTYPO_FILE "gutcheck.typ"

#ifndef MAX_PATH

#define MAX_PATH 16384

#endif

char aline[LINEBUFSIZE];

char prevline[LINEBUFSIZE];

/* Common typos. */

char *typo[] = {

    "teh", "th", "og", "fi", "ro", "adn", "yuo", "ot", "fo", "thet", "ane",

    "nad", "te", "ig", "acn",  "ahve", "alot", "anbd", "andt", "awya", "aywa",

    "bakc", "om", "btu", "byt", "cna", "cxan", "coudl", "dont", "didnt",

    "couldnt", "wouldnt", "doesnt", "shouldnt", "doign", "ehr", "hmi", "hse",

    "esle", "eyt", "fitrs", "firts", "foudn", "frmo", "fromt", "fwe", "gaurd",

    "gerat", "goign", "gruop", "haev", "hda", "hearign", "seeign", "sayign",

    "herat", "hge", "hsa", "hsi", "hte", "htere", "htese", "htey", "htis",

    "hvae", "hwich", "idae", "ihs", "iits", "int", "iwll", "iwth", "jsut",

    "loev", "sefl", "myu", "nkow", "nver", "nwe", "nwo", "ocur", "ohter",

    "omre", "onyl", "otehr", "otu", "owrk", "owuld", "peice", "peices",

    "peolpe", "peopel", "perhasp", "perhpas", "pleasent", "poeple", "porblem",

    "porblems", "rwite", "saidt", "saidh", "saids", "seh", "smae", "smoe",

    "sohw", "stnad", "stopry", "stoyr", "stpo", "tahn", "taht", "tath",

    "tehy", "tghe", "tghis", "theri", "theyll", "thgat", "thge", "thier",

    "thna", "thne", "thnig", "thnigs", "thsi", "thsoe", "thta", "timne",

    "tirne", "tkae", "tthe", "tyhat", "tyhe", "veyr", "vou", "vour", "vrey",

    "waht", "wasnt", "awtn", "watn", "wehn", "whic", "whcih", "whihc", "whta",

    "wihch", "wief", "wiht", "witha", "wiull", "wnat", "wnated", "wnats",

    "woh", "wohle", "wokr", "woudl", "wriet", "wrod", "wroet", "wroking",

    "wtih", "wuould", "wya", "yera", "yeras", "yersa", "yoiu", "youve",

    "ytou", "yuor", "abead", "ahle", "ahout", "ahove", "altbough", "balf",

    "bardly", "bas", "bave", "baving", "bebind", "beld", "belp", "belped",

    "ber", "bere", "bim", "bis", "bome", "bouse", "bowever", "buge",

    "dehates", "deht", "han", "hecause", "hecome", "heen", "hefore", "hegan",

    "hegin", "heing", "helieve", "henefit", "hetter", "hetween", "heyond",

    "hig", "higber", "huild", "huy", "hy", "jobn", "joh", "meanwbile",

    "memher", "memhers", "numher", "numhers", "perbaps", "prohlem", "puhlic",

    "witbout", "arn", "hin", "hirn", "wrok", "wroked", "amd", "aud",

    "prornise", "prornised", "modem", "bo", "heside", "chapteb", "chaptee",

    "se", ""

};

char *usertypo[MAX_USER_TYPOS];

/* Common abbreviations and other OK words not to query as typos. */

char *okword[] = {

    "mr", "mrs", "mss", "mssrs", "ft", "pm", "st", "dr", "hmm", "h'm", "hmmm",

    "rd", "sh", "br", "pp", "hm", "cf", "jr", "sr", "vs", "lb", "lbs", "ltd",

    "pompeii","hawaii","hawaiian", "hotbed", "heartbeat", "heartbeats",

    "outbid", "outbids", "frostbite", "frostbitten", ""

};

/* Common abbreviations that cause otherwise unexplained periods. */

char *abbrev[] = {

    "cent", "cents", "viz", "vol", "vols", "vid", "ed", "al", "etc", "op",

    "cit", "deg", "min", "chap", "oz", "mme", "mlle", "mssrs", ""

};

/*

 * Two-Letter combinations that rarely if ever start words,

 * but are common scannos or otherwise common letter combinations.

 */

char *nostart[] = {

    "hr", "hl", "cb", "sb", "tb", "wb", "tl", "tn", "rn", "lt", "tj", ""

};

/*

 * Two-Letter combinations that rarely if ever end words,

 * but are common scannos or otherwise common letter combinations.

 */

char *noend[] = {

    "cb", "gb", "pb", "sb", "tb", "wh", "fr", "br", "qu", "tw", "gl", "fl",

    "sw", "gr", "sl", "cl", "iy", ""

};

char *markup[] = {

    "a", "b", "big", "blockquote", "body", "br", "center", "col", "div", "em",

    "font", "h1", "h2", "h3", "h4", "h5", "h6", "head", "hr", "html", "i",

    "img", "li", "meta", "ol", "p", "pre", "small", "span", "strong", "sub",

    "sup", "table", "td", "tfoot", "thead", "title", "tr", "tt", "u", "ul", ""

};

char *DPmarkup[] = {

    "<sc>", "</sc>", "/*", "*/", "/#", "#/", "/$", "$/", "<tb>", ""

};

char *nocomma[] = {

    "the", "it's", "their", "an", "mrs", "a", "our", "that's", "its", "whose",

    "every", "i'll", "your", "my", "mr", "mrs", "mss", "mssrs", "ft", "pm",

    "st", "dr", "rd", "pp", "cf", "jr", "sr", "vs", "lb", "lbs", "ltd", "i'm",

    "during", "let", "toward", "among", ""

};

char *noperiod[] = {

    "every", "i'm", "during", "that's", "their", "your", "our", "my", "or",

    "and", "but", "as", "if", "the", "its", "it's", "until", "than", "whether",

    "i'll", "whose", "who", "because", "when", "let", "till", "very", "an",

    "among", "those", "into", "whom", "having", "thence", ""

}; 

char vowels[] = "aeiouàáâãäæèéêëìíîïòóôõöùúûü";

struct {

    char *htmlent;

    char *htmlnum;

    char *textent;

} entities[] = {

    "&",	"&",     "&", 

    "&lt;",	"&#60;",     "<",

    ">",	">",     ">",

    "°",	"°",    " degrees",

    "£",	"£",    "L",

    """,	""",     "\"", /* quotation mark = APL quote */

    "Œ",	"Œ",    "OE", /* latin capital ligature OE */

    "œ",	"œ",    "oe", /* latin small ligature oe */

    "Š",	"Š",    "S", /* latin capital letter S with caron */

    "š",	"š",    "s", /* latin small letter s with caron */

    "Ÿ",	"Ÿ",    "Y", /* latin capital letter Y with diaeresis */

    "ˆ",	"ˆ",    "",  /* modifier letter circumflex accent */

    "˜",	"˜",    "~", /* small tilde, U+02DC ISOdia */

    " ",	" ",   " ", /* en space, U+2002 ISOpub */

    " ",	" ",   " ", /* em space, U+2003 ISOpub */

    " ",	" ",   " ", /* thin space, U+2009 ISOpub */

    "–",	"–",   "-", /* en dash, U+2013 ISOpub */

    "—",	"—",   "--", /* em dash, U+2014 ISOpub */

    "’",	"’",   "'", /* right single quotation mark */

    "‚",	"‚",   "'", /* single low-9 quotation mark */

    "“",	"“",   "\"", /* left double quotation mark */

    "”",	"”",   "\"", /* right double quotation mark */

    "„",	"„",   "\"", /* double low-9 quotation mark */

    "‹",	"‹",   "\"", /* single left-pointing angle quotation mark */

    "›",	"›",   "\"", /* single right-pointing angle quotation mark */

    " ",	" ",    " ", /* no-break space = non-breaking space, */

    "¡",	"¡",    "!", /* inverted exclamation mark */

    "¢",	"¢",    "c", /* cent sign */

    "£",	"£",    "L", /* pound sign */

    "¤",	"¤",    "$", /* currency sign */

    "¥",	"¥",    "Y", /* yen sign = yuan sign */

    "§",	"§",    "--", /* section sign */

    "¨",	"¨",    " ", /* diaeresis = spacing diaeresis */

    "©",	"©",    "(C) ", /* copyright sign */

    "ª",	"ª",    " ", /* feminine ordinal indicator */

    "«",	"«",    "\"", /* left-pointing double angle quotation mark */

    "­",	"­",    "-", /* soft hyphen = discretionary hyphen */

    "®",	"®",    "(R) ", /* registered sign = registered trade mark sign */

    "¯",	"¯",    " ", /* macron = spacing macron = overline */

    "°",	"°",    " degrees", /* degree sign */

    "±",	"±",    "+-", /* plus-minus sign = plus-or-minus sign */

    "²",	"²",    "2", /* superscript two = superscript digit two */

    "³",	"³",    "3", /* superscript three = superscript digit three */

    "´",	"´",    " ", /* acute accent = spacing acute */

    "µ",	"µ",    "m", /* micro sign */

    "¶",	"¶",    "--", /* pilcrow sign = paragraph sign */

    "¸",	"¸",    " ", /* cedilla = spacing cedilla */

    "¹",	"¹",    "1", /* superscript one = superscript digit one */

    "º",	"º",    " ", /* masculine ordinal indicator */

    "»",	"»",    "\"", /* right-pointing double angle quotation mark */

    "¼",	"¼",    "1/4", /* vulgar fraction one quarter */

    "½",	"½",    "1/2", /* vulgar fraction one half */

    "¾",	"¾",    "3/4", /* vulgar fraction three quarters */

    "¿",	"¿",    "?", /* inverted question mark */

    "À",	"À",    "A", /* latin capital letter A with grave */

    "Á",	"Á",    "A", /* latin capital letter A with acute */

    "Â",	"Â",    "A", /* latin capital letter A with circumflex */

    "Ã",	"Ã",    "A", /* latin capital letter A with tilde */

    "Ä",	"Ä",    "A", /* latin capital letter A with diaeresis */

    "Å",	"Å",    "A", /* latin capital letter A with ring above */

    "Æ",	"Æ",    "AE", /* latin capital letter AE */

    "Ç",	"Ç",    "C", /* latin capital letter C with cedilla */

    "È",	"È",    "E", /* latin capital letter E with grave */

    "É",	"É",    "E", /* latin capital letter E with acute */

    "Ê",	"Ê",    "E", /* latin capital letter E with circumflex */

    "Ë",	"Ë",    "E", /* latin capital letter E with diaeresis */

    "Ì",	"Ì",    "I", /* latin capital letter I with grave */

    "Í",	"Í",    "I", /* latin capital letter I with acute */

    "Î",	"Î",    "I", /* latin capital letter I with circumflex */

    "Ï",	"Ï",    "I", /* latin capital letter I with diaeresis */

    "Ð",	"Ð",    "E", /* latin capital letter ETH */

    "Ñ",	"Ñ",    "N", /* latin capital letter N with tilde */

    "Ò",	"Ò",    "O", /* latin capital letter O with grave */

    "Ó",	"Ó",    "O", /* latin capital letter O with acute */

    "Ô",	"Ô",    "O", /* latin capital letter O with circumflex */

    "Õ",	"Õ",    "O", /* latin capital letter O with tilde */

    "Ö",	"Ö",    "O", /* latin capital letter O with diaeresis */

    "×",	"×",    "*", /* multiplication sign */

    "Ø",	"Ø",    "O", /* latin capital letter O with stroke */

    "Ù",	"Ù",    "U", /* latin capital letter U with grave */

    "Ú",	"Ú",    "U", /* latin capital letter U with acute */

    "Û",	"Û",    "U", /* latin capital letter U with circumflex */

    "Ü",	"Ü",    "U", /* latin capital letter U with diaeresis */

    "Ý",	"Ý",    "Y", /* latin capital letter Y with acute */

    "Þ",	"Þ",    "TH", /* latin capital letter THORN */

    "ß",	"ß",    "sz", /* latin small letter sharp s = ess-zed */

    "à",	"à",    "a", /* latin small letter a with grave */

    "á",	"á",    "a", /* latin small letter a with acute */

    "â",	"â",    "a", /* latin small letter a with circumflex */

    "ã",	"ã",    "a", /* latin small letter a with tilde */

    "ä",	"ä",    "a", /* latin small letter a with diaeresis */

    "å",	"å",    "a", /* latin small letter a with ring above */

    "æ",	"æ",    "ae", /* latin small letter ae */

    "ç",	"ç",    "c", /* latin small letter c with cedilla */

    "è",	"è",    "e", /* latin small letter e with grave */

    "é",	"é",    "e", /* latin small letter e with acute */

    "ê",	"ê",    "e", /* latin small letter e with circumflex */

    "ë",	"ë",    "e", /* latin small letter e with diaeresis */

    "ì",	"ì",    "i", /* latin small letter i with grave */

    "í",	"í",    "i", /* latin small letter i with acute */

    "î",	"î",    "i", /* latin small letter i with circumflex */

    "ï",	"ï",    "i", /* latin small letter i with diaeresis */

    "ð",	"ð",    "eth", /* latin small letter eth */

    "ñ",	"ñ",    "n", /* latin small letter n with tilde */

    "ò",	"ò",    "o", /* latin small letter o with grave */

    "ó",	"ó",    "o", /* latin small letter o with acute */

    "ô",	"ô",    "o", /* latin small letter o with circumflex */

    "õ",	"õ",    "o", /* latin small letter o with tilde */

    "ö",	"ö",    "o", /* latin small letter o with diaeresis */

    "÷",	"÷",    "/", /* division sign */

    "ø",	"ø",    "o", /* latin small letter o with stroke */

    "ù",	"ù",    "u", /* latin small letter u with grave */

    "ú",	"ú",    "u", /* latin small letter u with acute */

    "û",	"û",    "u", /* latin small letter u with circumflex */

    "ü",	"ü",    "u", /* latin small letter u with diaeresis */

    "ý",	"ý",    "y", /* latin small letter y with acute */

    "þ",	"þ",    "th", /* latin small letter thorn */

    "ÿ",	"ÿ",    "y", /* latin small letter y with diaeresis */

    "", ""

};

/* special characters */

#define CHAR_SPACE        32

#define CHAR_TAB           9

#define CHAR_LF           10

#define CHAR_CR           13

#define CHAR_DQUOTE       34

#define CHAR_SQUOTE       39

#define CHAR_OPEN_SQUOTE  96

#define CHAR_TILDE       126

#define CHAR_ASTERISK     42

#define CHAR_FORESLASH    47

#define CHAR_CARAT        94

#define CHAR_UNDERSCORE    '_'

#define CHAR_OPEN_CBRACK   '{'

#define CHAR_CLOSE_CBRACK  '}'

#define CHAR_OPEN_RBRACK   '('

#define CHAR_CLOSE_RBRACK  ')'

#define CHAR_OPEN_SBRACK   '['

#define CHAR_CLOSE_SBRACK  ']'

/* longest and shortest normal PG line lengths */

#define LONGEST_PG_LINE   75

#define WAY_TOO_LONG      80

#define SHORTEST_PG_LINE  55

#define SWITCHES "ESTPXLOYHWVMUD" /* switches:-                            */

                                  /*     D - ignore DP-specific markup     */

                                  /*     E - echo queried line             */

                                  /*     S - check single quotes           */

                                  /*     T - check common typos            */

                                  /*     P - require closure of quotes on  */

                                  /*         every paragraph               */

                                  /*     X - "Trust no one" :-) Paranoid!  */

                                  /*         Queries everything            */

                                  /*     L - line end checking defaults on */

                                  /*         -L turns it off               */

                                  /*     O - overview. Just shows counts.  */

                                  /*     Y - puts errors to stdout         */

                                  /*         instead of stderr             */

                                  /*     H - Echoes header fields          */

                                  /*     M - Ignore markup in < >          */

                                  /*     U - Use file of User-defined Typos*/

                                  /*     W - Defaults for use on Web upload*/

                                  /*     V - Verbose - list EVERYTHING!    */

#define SWITNO 14                 /* max number of switch parms            */

                                  /*        - used for defining array-size */

#define MINARGS   1               /* minimum no of args excl switches      */

#define MAXARGS   1               /* maximum no of args excl switches      */

int pswit[SWITNO];                /* program switches set by SWITCHES      */

#define ECHO_SWITCH      0

#define SQUOTE_SWITCH    1

#define TYPO_SWITCH      2

#define QPARA_SWITCH     3

#define PARANOID_SWITCH  4

#define LINE_END_SWITCH  5

#define OVERVIEW_SWITCH  6

#define STDOUT_SWITCH    7

#define HEADER_SWITCH    8

#define WEB_SWITCH       9

#define VERBOSE_SWITCH   10

#define MARKUP_SWITCH    11

#define USERTYPO_SWITCH  12

#define DP_SWITCH        13

long cnt_dquot;       /* for overview mode, count of doublequote queries */

long cnt_squot;       /* for overview mode, count of singlequote queries */

long cnt_brack;       /* for overview mode, count of brackets queries */

long cnt_bin;         /* for overview mode, count of non-ASCII queries */

long cnt_odd;         /* for overview mode, count of odd character queries */

long cnt_long;        /* for overview mode, count of long line errors */

long cnt_short;       /* for overview mode, count of short line queries */

long cnt_punct;       /* for overview mode, count of punctuation and spacing queries */

long cnt_dash;        /* for overview mode, count of dash-related queries */

long cnt_word;        /* for overview mode, count of word queries */

long cnt_html;        /* for overview mode, count of html queries */

long cnt_lineend;     /* for overview mode, count of line-end queries */

long cnt_spacend;     /* count of lines with space at end */

long linecnt;         /* count of total lines in the file */

long checked_linecnt; /* count of lines actually checked */

void proghelp(void);

void procfile(char *);

#define LOW_THRESHOLD    0

#define HIGH_THRESHOLD   1

#define START 0

#define END 1

#define PREV 0

#define NEXT 1

#define FIRST_OF_PAIR 0

#define SECOND_OF_PAIR 1

#define MAX_WORDPAIR 1000

char running_from[MAX_PATH];

int mixdigit(char *);

const char *getaword(const char *,char *);

int matchword(char *,char *);

char *flgets(char *,int,FILE *,long);

void lowerit(char *);

int gcisalpha(unsigned char);

int gcisdigit(unsigned char);

int gcisletter(unsigned char);

char *gcstrchr(char *s,char c);

void postprocess_for_HTML(char *);

char *linehasmarkup(char *);

char *losemarkup(char *);

int tagcomp(char *,char *);

char *loseentities(char *);

int isroman(char *);

int usertypo_count;

void postprocess_for_DP(char *);

char wrk[LINEBUFSIZE];

#define MAX_QWORD 50

#define MAX_QWORD_LENGTH 40

char qword[MAX_QWORD][MAX_QWORD_LENGTH];

signed int dupcnt[MAX_QWORD];

int main(int argc,char **argv)

{

    char *argsw,*s;

    int i,switno,invarg;

    char usertypo_file[MAX_PATH];

    FILE *usertypofile;

    if (strlen(argv[0])<sizeof(running_from))

	/* save the path to the executable */

        strcpy(running_from,argv[0]);

    /* find out what directory we're running from */

    s=running_from+strlen(running_from);

    for (;*s!='/' && *s!='\\' && s>=running_from;s--)

        *s=0;

    switno=strlen(SWITCHES);

    for (i=switno;--i>0;)

        pswit[i]=0;           /* initialise switches */

    /*

     * Standard loop to extract switches.

     * When we come out of this loop, the arguments will be

     * in argv[0] upwards and the switches used will be

     * represented by their equivalent elements in pswit[]

     */

    while (--argc>0 && **++argv=='-')

        for (argsw=argv[0]+1;*argsw!='\0';argsw++)

            for (i=switno,invarg=1;(--i>=0) && invarg==1;)

                if ((toupper(*argsw))==SWITCHES[i])

		{

                    invarg=0;

                    pswit[i]=1;

		}

    /* Paranoid checking is turned OFF, not on, by its switch */

    pswit[PARANOID_SWITCH]^=1;

    if (pswit[PARANOID_SWITCH])

	/* if running in paranoid mode force typo checks as well   */

        pswit[TYPO_SWITCH]=pswit[TYPO_SWITCH]^1;

    /* Line-end checking is turned OFF, not on, by its switch */

    pswit[LINE_END_SWITCH]^=1;

    /* Echoing is turned OFF, not on, by its switch */

    pswit[ECHO_SWITCH]^=1;

    if (pswit[OVERVIEW_SWITCH])

	/* just print summary; don't echo */

        pswit[ECHO_SWITCH]=0;

    /*

     * Web uploads - for the moment, this is really just a placeholder

     * until we decide what processing we really want to do on web uploads

     */

    if (pswit[WEB_SWITCH])

    {

	/* specific override for web uploads */

        pswit[ECHO_SWITCH]=1;

        pswit[SQUOTE_SWITCH]=0;

        pswit[TYPO_SWITCH]=1;

        pswit[QPARA_SWITCH]=0;

        pswit[PARANOID_SWITCH]=1;

        pswit[LINE_END_SWITCH]=0;

        pswit[OVERVIEW_SWITCH]=0;

        pswit[STDOUT_SWITCH]=0;

        pswit[HEADER_SWITCH]=1;

        pswit[VERBOSE_SWITCH]=0;

        pswit[MARKUP_SWITCH]=0;

        pswit[USERTYPO_SWITCH]=0;

        pswit[DP_SWITCH]=0;

    }

    if (argc<MINARGS || argc>MAXARGS)

    {

	/* check number of args */

        proghelp();

        return 1;

    }

    /* read in the user-defined stealth scanno list */

    if (pswit[USERTYPO_SWITCH])

    {

	/* ... we were told we had one! */

        usertypofile=fopen(USERTYPO_FILE,"rb");

        if (!usertypofile)

	{

	    /* not in cwd. try excuteable directory. */

            strcpy(usertypo_file,running_from);

            strcat(usertypo_file,USERTYPO_FILE);

            usertypofile=fopen(usertypo_file,"rb");

            if (!usertypofile) {

		/* we ain't got no user typo file! */

                printf("   --> I couldn't find gutcheck.typ "

		  "-- proceeding without user typos.\n");

	    }

	}

        usertypo_count=0;

        if (usertypofile)

	{

	    /* we managed to open a User Typo File! */

            if (pswit[USERTYPO_SWITCH])

	    {

                while (flgets(aline,LINEBUFSIZE-1,usertypofile,

		  (long)usertypo_count))

		{

                    if (strlen(aline)>1)

		    {

                        if ((int)*aline>33)

			{

                            s=malloc(strlen(aline)+1);

                            if (!s)

			    {

                                fprintf(stderr,"bookloupe: cannot get enough "

				  "memory for user typo file!\n");

                                exit(1);

			    }

                            strcpy(s,aline);

                            usertypo[usertypo_count]=s;

                            usertypo_count++;

                            if (usertypo_count>=MAX_USER_TYPOS)

			    {

                                printf("   --> Only %d user-defined typos "

				  "allowed: ignoring the rest\n",

				  MAX_USER_TYPOS);

                                break;

			    }

			}

		    }

		}

	    }

            fclose(usertypofile);

	}

    }

    fprintf(stderr,"bookloupe: Check and report on an e-text\n");

    cnt_dquot=cnt_squot=cnt_brack=cnt_bin=cnt_odd=cnt_long=

    cnt_short=cnt_punct=cnt_dash=cnt_word=cnt_html=cnt_lineend=

    cnt_spacend=0;

    procfile(argv[0]);

    if (pswit[OVERVIEW_SWITCH])

    {

	printf("    Checked %ld lines of %ld (head+foot = %ld)\n\n",

	  checked_linecnt,linecnt,linecnt-checked_linecnt);

        printf("    --------------- Queries found --------------\n");

        if (cnt_long)

	    printf("    Long lines:                    %14ld\n",cnt_long);

        if (cnt_short)

	    printf("    Short lines:                   %14ld\n",cnt_short);

        if (cnt_lineend)

	    printf("    Line-end problems:             %14ld\n",cnt_lineend);

        if (cnt_word)

	    printf("    Common typos:                  %14ld\n",cnt_word);

        if (cnt_dquot)

	    printf("    Unmatched quotes:              %14ld\n",cnt_dquot);

        if (cnt_squot)

	    printf("    Unmatched SingleQuotes:        %14ld\n",cnt_squot);

        if (cnt_brack)

	    printf("    Unmatched brackets:            %14ld\n",cnt_brack);

        if (cnt_bin)

	    printf("    Non-ASCII characters:          %14ld\n",cnt_bin);

        if (cnt_odd)

	    printf("    Proofing characters:           %14ld\n",cnt_odd);

        if (cnt_punct)

	    printf("    Punctuation & spacing queries: %14ld\n",cnt_punct);

        if (cnt_dash)

	    printf("    Non-standard dashes:           %14ld\n",cnt_dash);

        if (cnt_html)

	    printf("    Possible HTML tags:            %14ld\n",cnt_html);

        printf("\n");

        printf("    TOTAL QUERIES                  %14ld\n",

          cnt_dquot+cnt_squot+cnt_brack+cnt_bin+cnt_odd+cnt_long+

          cnt_short+cnt_punct+cnt_dash+cnt_word+cnt_html+cnt_lineend);

    }

    return 0;

}

struct first_pass_results {

    long firstline,astline;

    long footerline,totlen,binlen,alphalen,endquote_count,shortline,dotcomma;

    long fslashline,hyphens,longline,verylongline,htmcount,standalone_digit;

    long spacedash,emdash,space_emdash,non_PG_space_emdash,PG_space_emdash;

    signed int Dutchcount,Frenchcount;

};

/*

 * first_pass:

 *

 * Run a first pass - verify that it's a valid PG

 * file, decide whether to report some things that

 * occur many times in the text like long or short

 * lines, non-standard dashes, etc.

 */

struct first_pass_results *first_pass(FILE *infile)

{

    char laststart=CHAR_SPACE;

    const char *s;

    signed int i,llen;

    unsigned int lastlen=0,lastblen=0;

    long spline=0,nspline=0;

    static struct first_pass_results results={0};

    char inword[MAXWORDLEN]="";

    while (fgets(aline,LINEBUFSIZE-1,infile))

    {

        while (aline[strlen(aline)-1]==10 || aline[strlen(aline)-1]==13)

	    aline[strlen(aline)-1]=0;

        linecnt++;

        if (strstr(aline,"*END") && strstr(aline,"SMALL PRINT") &&

	  (strstr(aline,"PUBLIC DOMAIN") || strstr(aline,"COPYRIGHT")))

	{

            if (spline)

                printf("   --> Duplicate header?\n");

            spline=linecnt+1;   /* first line of non-header text, that is */

	}

        if (!strncmp(aline,"*** START",9) && strstr(aline,"PROJECT GUTENBERG"))

	{

            if (nspline)

                printf("   --> Duplicate header?\n");

            nspline=linecnt+1;   /* first line of non-header text, that is */

	}

        if (spline || nspline)

	{

            lowerit(aline);

            if (strstr(aline,"end") && strstr(aline,"project gutenberg"))

	    {

                if (strstr(aline,"end")<strstr(aline,"project gutenberg"))

		{

                    if (results.footerline)

		    {

			/* it's an old-form header - we can detect duplicates */

                        if (!nspline)

                            printf("   --> Duplicate footer?\n");

		    }

                    else

                        results.footerline=linecnt;

		}

	    }

	}

        if (spline)

	    results.firstline=spline;

        if (nspline)

	    results.firstline=nspline;  /* override with new */

        if (results.footerline)

	    continue;    /* don't count the boilerplate in the footer */

        llen=strlen(aline);

        results.totlen+=llen;

        for (i=0;i<llen;i++)

	{

            if ((unsigned char)aline[i]>127)

		results.binlen++;

            if (gcisalpha(aline[i]))

		results.alphalen++;

            if (i>0 && aline[i]==CHAR_DQUOTE && isalpha(aline[i-1]))

		results.endquote_count++;

	}

        if (strlen(aline)>2 && lastlen>2 && lastlen<SHORTEST_PG_LINE &&

	  lastblen>2 && lastblen>SHORTEST_PG_LINE && laststart!=CHAR_SPACE)

	    results.shortline++;

        if (*aline && (unsigned char)aline[strlen(aline)-1]<=CHAR_SPACE)

	    cnt_spacend++;

        if (strstr(aline,".,"))

	    results.dotcomma++;

        /* only count ast lines for ignoring purposes where there is */

        /* locase text on the line */

        if (strstr(aline,"*"))

	{

            for (s=aline;*s;s++)

                if (*s>='a' && *s<='z')

                    break;

             if (*s)

		results.astline++;

	}

        if (strstr(aline,"/"))

            results.fslashline++;

        for (i=llen-1;i>0 && (unsigned char)aline[i]<=CHAR_SPACE;i--)

	    ;

        if (aline[i]=='-' && aline[i-1]!='-')

	    results.hyphens++;

        if (llen>LONGEST_PG_LINE)

	    results.longline++;

        if (llen>WAY_TOO_LONG)

	    results.verylongline++;

        if (strstr(aline,"<") && strstr(aline,">"))

	{

            i=(signed int)(strstr(aline,">")-strstr(aline,"<")+1);

            if (i>0)

                results.htmcount++;

            if (strstr(aline,"<i>"))

		results.htmcount+=4; /* bonus marks! */

	}

        /* Check for spaced em-dashes */

        if (strstr(aline,"--"))

	{

            results.emdash++;

            if (*(strstr(aline,"--")-1)==CHAR_SPACE ||

               (*(strstr(aline,"--")+2)==CHAR_SPACE))

		results.space_emdash++;

            if (*(strstr(aline,"--")-1)==CHAR_SPACE &&

               (*(strstr(aline,"--")+2)==CHAR_SPACE))

		/* count of em-dashes with spaces both sides */

		results.non_PG_space_emdash++;

            if (*(strstr(aline,"--")-1)!=CHAR_SPACE &&

               (*(strstr(aline,"--")+2)!=CHAR_SPACE))

		/* count of PG-type em-dashes with no spaces */

		results.PG_space_emdash++;

	}

        for (s=aline;*s;)

	{

            s=getaword(s,inword);

            if (!strcmp(inword,"hij") || !strcmp(inword,"niet")) 

                results.Dutchcount++;

            if (!strcmp(inword,"dans") || !strcmp(inword,"avec")) 

                results.Frenchcount++;

            if (!strcmp(inword,"0") || !strcmp(inword,"1")) 

                results.standalone_digit++;

	}

        /* Check for spaced dashes */

        if (strstr(aline," -") && *(strstr(aline," -")+2)!='-')

	    results.spacedash++;

        lastblen=lastlen;

        lastlen=strlen(aline);

        laststart=aline[0];

    }

    return &results;

}

struct warnings {

    signed int shortline,longline,bin,dash,dotcomma,ast,fslash,digit,hyphen;

    signed int endquote,isDutch,isFrench;

};

/*

 * report_first_pass:

 *

 * Make some snap decisions based on the first pass results.

 */

struct warnings *report_first_pass(struct first_pass_results *results)

{

    static struct warnings warnings={0};

    if (cnt_spacend>0)

        printf("   --> %ld lines in this file have white space at end\n",

	  cnt_spacend);

    warnings.dotcomma=1;

    if (results->dotcomma>5)

    {

        warnings.dotcomma=0;

        printf("   --> %ld lines in this file contain '.,'. "

	  "Not reporting them.\n",results->dotcomma);

    }

    /*

     * If more than 50 lines, or one-tenth, are short,

     * don't bother reporting them.

     */

    warnings.shortline=1;

    if (results->shortline>50 || results->shortline*10>linecnt)

    {

        warnings.shortline=0;

        printf("   --> %ld lines in this file are short. "

	  "Not reporting short lines.\n",results->shortline);

    }

    /*

     * If more than 50 lines, or one-tenth, are long,

     * don't bother reporting them.

     */

    warnings.longline=1;

    if (results->longline>50 || results->longline*10>linecnt)

    {

        warnings.longline=0;

        printf("   --> %ld lines in this file are long. "

	  "Not reporting long lines.\n",results->longline);

    }

    /* If more than 10 lines contain asterisks, don't bother reporting them. */

    warnings.ast=1;

    if (results->astline>10)

    {

        warnings.ast=0;

        printf("   --> %ld lines in this file contain asterisks. "

	  "Not reporting them.\n",results->astline);

    }

    /*

     * If more than 10 lines contain forward slashes,

     * don't bother reporting them.

     */

    warnings.fslash=1;

    if (results->fslashline>10)

    {

        warnings.fslash=0;

        printf("   --> %ld lines in this file contain forward slashes. "

	  "Not reporting them.\n",results->fslashline);

    }

    /*

     * If more than 20 lines contain unpunctuated endquotes,

     * don't bother reporting them.

     */

    warnings.endquote=1;

    if (results->endquote_count>20)

    {

        warnings.endquote=0;

        printf("   --> %ld lines in this file contain unpunctuated endquotes. "

	  "Not reporting them.\n",results->endquote_count);

    }

    /*

     * If more than 15 lines contain standalone digits,

     * don't bother reporting them.

     */

    warnings.digit=1;

    if (results->standalone_digit>10)

    {

        warnings.digit=0;

        printf("   --> %ld lines in this file contain standalone 0s and 1s. "

	  "Not reporting them.\n",results->standalone_digit);

    }

    /*

     * If more than 20 lines contain hyphens at end,

     * don't bother reporting them.

     */

    warnings.hyphen=1;

    if (results->hyphens>20)

    {

        warnings.hyphen=0;

        printf("   --> %ld lines in this file have hyphens at end. "

	  "Not reporting them.\n",results->hyphens);

    }

    if (results->htmcount>20 && !pswit[MARKUP_SWITCH])

    {

        printf("   --> Looks like this is HTML. Switching HTML mode ON.\n");

        pswit[MARKUP_SWITCH]=1;

    }

    if (results->verylongline>0)

        printf("   --> %ld lines in this file are VERY long!\n",

	  results->verylongline);

    /*

     * If there are more non-PG spaced dashes than PG em-dashes,

     * assume it's deliberate.

     * Current PG guidelines say don't use them, but older texts do,

     * and some people insist on them whatever the guidelines say.

     */

    warnings.dash=1;

    if (results->spacedash+results->non_PG_space_emdash>

      results->PG_space_emdash)

    {

        warnings.dash=0;

        printf("   --> There are %ld spaced dashes and em-dashes. "

	  "Not reporting them.\n",

	  results->spacedash+results->non_PG_space_emdash);

    }

    /* If more than a quarter of characters are hi-bit, bug out. */

    warnings.bin=1;

    if (results->binlen*4>results->totlen)

    {

        printf("   --> This file does not appear to be ASCII. "

	  "Terminating. Best of luck with it!\n");

        exit(1);

    }

    if (results->alphalen*4<results->totlen)

    {

        printf("   --> This file does not appear to be text. "

	  "Terminating. Best of luck with it!\n");

        exit(1);

    }

    if (results->binlen*100>results->totlen || results->binlen>100)

    {

        printf("   --> There are a lot of foreign letters here. "

	  "Not reporting them.\n");

        warnings.bin=0;

    }

    warnings.isDutch=0;

    if (results->Dutchcount>50)

    {

        warnings.isDutch=1;

        printf("   --> This looks like Dutch - "

	  "switching off dashes and warnings for 's Middags case.\n");

    }

    warnings.isFrench=0;

    if (results->Frenchcount>50)

    {

        warnings.isFrench=1;

        printf("   --> This looks like French - "

	  "switching off some doublepunct.\n");

    }

    if (results->firstline && results->footerline)

        printf("    The PG header and footer appear to be already on.\n");

    else

    {

        if (results->firstline)

            printf("    The PG header is on - no footer.\n");

        if (results->footerline)

            printf("    The PG footer is on - no header.\n");

    }

    printf("\n");

    if (pswit[VERBOSE_SWITCH])

    {

        warnings.bin=1;

        warnings.shortline=1;

        warnings.dotcomma=1;

        warnings.longline=1;

        warnings.dash=1;

        warnings.digit=1;

        warnings.ast=1;

        warnings.fslash=1;

        warnings.hyphen=1;

        warnings.endquote=1;

        printf("   *** Verbose output is ON -- you asked for it! ***\n");

    }

    if (warnings.isDutch)

        warnings.dash=0;

    if (results->footerline>0 && results->firstline>0 &&

      results->footerline>results->firstline &&

      results->footerline-results->firstline<100)

    {

        printf("   --> I don't really know where this text starts. \n");

        printf("       There are no reference points.\n");

        printf("       I'm going to have to report the header and footer "

	  "as well.\n");

        results->firstline=0;

    }

    return &warnings;

}

struct counters {

    long quot;

    signed int c_unders,c_brack,s_brack,r_brack;

    signed int open_single_quote,close_single_quote;

};

/*

 * analyse_quotes:

 *

 * Look along the line, accumulate the count of quotes, and see

 * if this is an empty line - i.e. a line with nothing on it

 * but spaces.

 * If line has just spaces, period, * and/or - on it, don't

 * count it, since empty lines with asterisks or dashes to

 * separate sections are common.

 *

 * Returns: Non-zero if the line is empty.

 */

int analyse_quotes(const char *s,struct counters *counters)

{

    signed int guessquote=0;

    int isemptyline=1;    /* assume the line is empty until proven otherwise */

    while (*s)

    {

	if (*s==CHAR_DQUOTE)

	    counters->quot++;

	if (*s==CHAR_SQUOTE || *s==CHAR_OPEN_SQUOTE)

	{

	    if (s==aline)

	    {

		/*

		 * At start of line, it can only be an openquote.

		 * Hardcode a very common exception!

		 */

		if (strncmp(s+2,"tis",3) && strncmp(s+2,"Tis",3))

		    counters->open_single_quote++;

	    }

	    else if (gcisalpha(s[-1]) && gcisalpha(s[1]))

		/* Do nothing! it's definitely an apostrophe, not a quote */

		;

	    /* it's outside a word - let's check it out */

	    else if (*s==CHAR_OPEN_SQUOTE || gcisalpha(s[1]))

	    {

		/* it damwell better BE an openquote */

		if (strncmp(s+1,"tis",3) && strncmp(s+1,"Tis",3))

		    /* hardcode a very common exception! */

		    counters->open_single_quote++;

	    }

	    else

	    {

		/* now - is it a closequote? */

		guessquote=0;   /* accumulate clues */

		if (gcisalpha(s[-1]))

		{

		    /* it follows a letter - could be either */

		    guessquote++;

		    if (s[-1]=='s')

		    {

			/* looks like a plural apostrophe */

			guessquote-=3;

			if (s[1]==CHAR_SPACE)  /* bonus marks! */

			    guessquote-=2;

		    }

		}

		/* it doesn't have a letter either side */

		else if (strchr(".?!,;:",s[-1]) && strchr(".?!,;: ",s[1]))

		    guessquote+=8; /* looks like a closequote */

		else

		    guessquote++;

		if (counters->open_single_quote>counters->close_single_quote)

		    /*

		     * Give it the benefit of some doubt,

		     * if a squote is already open.

		     */

		    guessquote++;

		else

		    guessquote--;

		if (guessquote>=0)

		    counters->close_single_quote++;

	    }

	}

	if (*s!=CHAR_SPACE && *s!='-' && *s!='.' && *s!=CHAR_ASTERISK &&

	  *s!=13 && *s!=10)

	    isemptyline=0;  /* ignore lines like  *  *  *  as spacers */

	if (*s==CHAR_UNDERSCORE)

	    counters->c_unders++;

	if (*s==CHAR_OPEN_CBRACK)

	    counters->c_brack++;

	if (*s==CHAR_CLOSE_CBRACK)

	    counters->c_brack--;

	if (*s==CHAR_OPEN_RBRACK)

	    counters->r_brack++;

	if (*s==CHAR_CLOSE_RBRACK)

	    counters->r_brack--;

	if (*s==CHAR_OPEN_SBRACK)

	    counters->s_brack++;

	if (*s==CHAR_CLOSE_SBRACK)

	    counters->s_brack--;

	s++;

    }

    return isemptyline;

}

/*