Category : C Source Code
Archive   : MSPELL1_.ZIP
Filename : MAIN.C

 
Output of file : MAIN.C contained in archive : MSPELL1_.ZIP
/* MAIN: Main module for MicroSPELL 1.0
Spell Checker and Corrector

(C)opyright May 1987 by Daniel Lawrence
All Rights Reserved

Revision History:

21-jul-87
[Released version 1.0 to the USENET]
*/

#define maindef 1

#include
#include "dopt.h"
#include "dstruct.h"
#include "ddef.h"

main(argc, argv)

int argc; /* command line argument count */
char **argv; /* argument vector */

{
WORD *tword;

/* check to see if they need help.... */
if (argc == 1) {
usage();
exit(EXBADOPT);
}

/* announce us */
printf("MicroSPELL %s Interactive Speller and Corrector\n", VERSION);

/* load the common word list */
loadcom();

/* parse the command line */
while (--argc) {
argv++; /* skip to next argument */
if (argv[0][0] == '-')
option(&argc, &argv);
else
sfile(argv[0]);
}

/* prepare to spell */
comsort();
if (swdebug && (numfiltr > numcom))
printf("[%u User words loaded and sorted]\n", numfiltr - numcom);

if (mopen() == FALSE)
exit(EXMDICT);
mclose();
if ((outfile = fopen("spell.lst", "w")) == NULL) {
printf("%%Can not open temp file\n");
exit(EXTEMP);
}

/* read the words in */
tword = getword();
while (tword) {
++totwords;
if (!iscom(tword->w_text)) {
++prowords;
insword(tword);
}
tword = getword();
}

/* if there are words left to spell check... go do it */
if (numwords > 0)
check();
if (swwords)
fprintf(outfile, "!end\n");
else
fprintf(outfile, "-2\n0\n");
fclose(outfile);

printf("[%u/%u words processed]\n", prowords, totwords);

if (swemacs) {
perform("emacs @scan.cmd");
#if ATARI & LATTICE
printf("%%Cannot execute EMACS from here...type\m");
printf(" emacs @scan.cmd\nto scan document\n");
#endif
}

exit(EXGOOD);
}

insword(cword) /* insert a word in the source word list */

WORD *cword;

{
register WORD *wp; /* temporary word pointer */

if (numwords == MAXWORDS)
check();

/* malloc room for the word */
wp = NULL;
while (wp == NULL && numwords >= 0) {
wp = (WORD *)malloc(sizeof(WORD) + strlen(cword->w_text) + 1);
if (wp == NULL)
check();
}

if (wp == NULL) {
printf("%%Out of Memory while scanning input file\n");
exit(EXNORAM);
}

/* copy the word in */
wp->w_file = cword->w_file;
wp->w_line = cword->w_line;
wp->w_col = cword->w_col;
strcpy(wp->w_text, cword->w_text);

/* and hook it in */
sword[numwords++] = wp;
}

option(argc, argv) /* process a command line option */

int *argc; /* ptr to cmd line argc */
char ***argv; /* paramters */

{
register char ochar; /* option character */

ochar = (*argv)[0][1];
switch (ochar) {
case 'd': /* debug switched on */
swdebug = TRUE;
break;

case 'e': /* emacs to be used to correct */
swemacs = TRUE;
break;

case 'u': /* specify user dictionary */
if ((*argv)[0][2])
uread(&(*argv)[0][2]);
else {
if (*argc > 0)
uread((*argv)[1]);
(*argv)++;
(*argc)--;
}
break;

case 'w': /* output a word lsit instead of locations */
swwords = TRUE;
break;

default: /* bad option */
printf("%%No such option '%s'\n", &(*argv)[0][1]);
exit(EXBADOPT);
}
}

sfile(fname) /* record and check the file to be spelled */

char *fname; /* file to spell */

{
if (swdebug)
printf("[Queueing '%s' to spell]\n", fname);

/* check to see if we have too many */
if (numspell >= MAXSPELL) {
printf("%%Too many input files... '%s' ignored\n", fname);
return(FALSE);
} else {
strcpy(splname[numspell++], fname);
return(TRUE);
}
}

usage() /* print the command line usage */

{
printf("MicroSPELL %s Interactive Speller and Corrector\n", VERSION);
puts("\nUsage\n");
puts(" spell {} {.....}\n");
puts("Options:\n");
puts(" -d Debugging mode");
puts(" -e Use MicroEMACS to scan errors");
puts(" -u Use user word list ");
puts(" -w Output a word list instead of location list");
}

#if RAMSIZE & LATTICE & MSDOS
/* These routines will allow me to track memory usage by placing
a layer on top of the standard system malloc() and free() calls.
with this code defined, the number of allocated bytes is displayed
in the upper right corner of the screen
*/

#undef malloc
#undef free

char *allocate(nbytes) /* allocate nbytes and track */

unsigned nbytes; /* # of bytes to allocate */

{
char *mp; /* ptr returned from malloc */
char *malloc();

mp = malloc(nbytes);
if (mp) {
envram += nbytes;
#if RAMSHOW
dspram();
#endif
}

return(mp);
}

release(mp) /* release malloced memory and track */

char *mp; /* chunk of RAM to release */

{
unsigned *lp; /* ptr to the long containing the block size */

if (mp) {
lp = ((unsigned *)mp) - 1;

/* update amount of ram currently malloced */
envram -= (long)*lp - 2;
free(mp);
#if RAMSHOW
dspram();
#endif
}
}

#if RAMSHOW
dspram() /* display the amount of RAM currently malloced */

{
char mbuf[20];
char *sp;

/* TTmove(term.t_nrow - 1, 70);*/
sprintf(mbuf, "[%lu]", envram);
sp = &mbuf[0];
puts(sp);
}
#endif
#endif

#if AZTEC & MSDOS
#undef fgetc
#undef fgets
/* a1gets: Get an ascii string from a file using a1getc */

char *a1gets(buffer, length, fp)

char *buffer; /* buffer to leave string in */
int length; /* maximum length of string */
FILE *fp; /* file to get string from */

{
register int c; /* current character read */
register char *bp; /* pointer into buffer */

bp = buffer;

while ((c = a1getc(fp)) != EOF) {
*bp++ = (char)c;
if (c == '\n')
break;
}

*bp = 0;
if (c == EOF)
return(NULL);
else
return(buffer);
}

/* a1getc: Get an ascii char from the file input stream
but DO NOT strip the high bit
*/

int a1getc(fp)

FILE *fp;

{
int c; /* translated character */

c = getc(fp); /* get the character */

/* if its a char, throw it out */
while (c == 10)
c = getc(fp);


/* if its a char, change it to a LF */
if (c == '\r')
c = '\n';

/* if its a ^Z, its an EOF */
if (c == 26)
c = EOF;

return(c);
}
#endif

perform(cmd) /* send out a DOS command and execute it */

char *cmd; /* command to execute */

{
if (swdebug) /* output command string with diagnostics */
puts(cmd);

#if LATTICE & ~ATARI & ~CMS
forkl(getenv("COMSPEC"),"command","-C",cmd,NULL);
return(wait());
#endif

#if AZTEC | CMS
system(cmd);
return(TRUE);
#endif
}

#if CMS
#undef fopen
/* The IBM 30xx likes to tell us when file opens
fail...it's too chatty....I like to handle these myself */

FILE *cmsopen(file, mode)

char *file; /* name of file to open */
char *mode; /* mode to open it in */

{
quiet(1);
return(fopen(file,mode));
}
#endif


  3 Responses to “Category : C Source Code
Archive   : MSPELL1_.ZIP
Filename : MAIN.C

  1. Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!

  2. This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.

  3. But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/