Esempio n. 1
0
/*!
 * \param hashname name of the hash file (dictionary)
 *
 * \return
 */
int ISpellChecker::linit(char *hashname)
{
    FILE *fpHash;

    register int i;
    register struct dent *dp;
    struct flagent *entry;
    struct flagptr *ind;
    int nextchar, x;
    int viazero;
    register ichar_t *cp;

    if((fpHash = fopen(hashname, "rb")) == NULL)
    {
        return (-1);
    }

    m_hashsize = fread(reinterpret_cast< char * >(&m_hashheader), 1, sizeof m_hashheader, fpHash);
    if(m_hashsize < static_cast< int >(sizeof(m_hashheader)))
    {
        if(m_hashsize < 0)
            fprintf(stderr, LOOKUP_C_CANT_READ, hashname);
        else if(m_hashsize == 0)
            fprintf(stderr, LOOKUP_C_NULL_HASH, hashname);
        else
            fprintf(stderr, LOOKUP_C_SHORT_HASH(m_hashname, m_hashsize, static_cast< int >(sizeof m_hashheader)));
        return (-1);
    }
    else if(m_hashheader.magic != MAGIC)
    {
        fprintf(stderr, LOOKUP_C_BAD_MAGIC(hashname, static_cast< unsigned int >(MAGIC), static_cast< unsigned int >(m_hashheader.magic)));
        return (-1);
    }
    else if(m_hashheader.magic2 != MAGIC)
    {
        fprintf(stderr, LOOKUP_C_BAD_MAGIC2(hashname, static_cast< unsigned int >(MAGIC), static_cast< unsigned int >(m_hashheader.magic2)));
        return (-1);
    }
    /*  else if (hashheader.compileoptions != COMPILEOPTIONS*/
    else if(1 != 1 || m_hashheader.maxstringchars != MAXSTRINGCHARS || m_hashheader.maxstringcharlen != MAXSTRINGCHARLEN)
    {
        fprintf(stderr,
                LOOKUP_C_BAD_OPTIONS(static_cast< unsigned int >(m_hashheader.compileoptions), m_hashheader.maxstringchars,
                                     m_hashheader.maxstringcharlen, static_cast< unsigned int >(COMPILEOPTIONS), MAXSTRINGCHARS, MAXSTRINGCHARLEN));
        return (-1);
    }

    {
        m_hashtbl = (struct dent *)calloc(static_cast< unsigned >(m_hashheader.tblsize), sizeof(struct dent));
        m_hashsize = m_hashheader.tblsize;
        m_hashstrings = static_cast< char * >(malloc(static_cast< unsigned >(m_hashheader.stringsize)));
    }
    m_numsflags = m_hashheader.stblsize;
    m_numpflags = m_hashheader.ptblsize;
    m_sflaglist = (struct flagent *)malloc((m_numsflags + m_numpflags) * sizeof(struct flagent));
    if(m_hashtbl == NULL || m_hashstrings == NULL || m_sflaglist == NULL)
    {
        fprintf(stderr, LOOKUP_C_NO_HASH_SPACE);
        return (-1);
    }
    m_pflaglist = m_sflaglist + m_numsflags;

    {
        if(fread(m_hashstrings, 1, static_cast< unsigned >(m_hashheader.stringsize), fpHash) != static_cast< size_t >(m_hashheader.stringsize))
        {
            fprintf(stderr, LOOKUP_C_BAD_FORMAT);
            fprintf(stderr, "stringsize err\n");
            return (-1);
        }
        if(m_hashheader.compileoptions & 0x04)
        {
            if(fread(reinterpret_cast< char * >(m_hashtbl), 1, static_cast< unsigned >(m_hashheader.tblsize) * sizeof(struct dent), fpHash)
               != (static_cast< size_t >(m_hashheader.tblsize * sizeof(struct dent))))
            {
                fprintf(stderr, LOOKUP_C_BAD_FORMAT);
                return (-1);
            }
        }
        else
        {
            for(x = 0; x < m_hashheader.tblsize; x++)
            {
                if(fread(reinterpret_cast< char * >(m_hashtbl + x), sizeof(struct dent) - sizeof(MASKTYPE), 1, fpHash) != 1)
                {
                    fprintf(stderr, LOOKUP_C_BAD_FORMAT);
                    return (-1);
                }
            } /*for*/
        }     /*else*/
    }
    if(fread(reinterpret_cast< char * >(m_sflaglist), 1, static_cast< unsigned >(m_numsflags + m_numpflags) * sizeof(struct flagent), fpHash)
       != (m_numsflags + m_numpflags) * sizeof(struct flagent))
    {
        fprintf(stderr, LOOKUP_C_BAD_FORMAT);
        return (-1);
    }
    fclose(fpHash);

    {
        for(i = m_hashsize, dp = m_hashtbl; --i >= 0; dp++)
        {
            if(dp->word == (char *)-1)
                dp->word = NULL;
            else
                dp->word = &m_hashstrings[reinterpret_cast< size_t >(dp->word)];
            if(dp->next == (struct dent *)-1)
                dp->next = NULL;
            else
                dp->next = &m_hashtbl[reinterpret_cast< size_t >(dp->next)];
        }
    }

    for(i = m_numsflags + m_numpflags, entry = m_sflaglist; --i >= 0; entry++)
    {
        if(entry->stripl)
            entry->strip = reinterpret_cast< ichar_t * >(&m_hashstrings[reinterpret_cast< size_t >(entry->strip)]);
        else
            entry->strip = NULL;
        if(entry->affl)
            entry->affix = reinterpret_cast< ichar_t * >(&m_hashstrings[reinterpret_cast< size_t >(entry->affix)]);
        else
            entry->affix = NULL;
    }
    /*
    ** Warning - 'entry' and 'i' are reset in the body of the loop
    ** below.  Don't try to optimize it by (e.g.) moving the decrement
    ** of i into the loop condition.
    */
    for(i = m_numsflags, entry = m_sflaglist; i > 0; i--, entry++)
    {
        if(entry->affl == 0)
        {
            cp = NULL;
            ind = &m_sflagindex[0];
            viazero = 1;
        }
        else
        {
            cp = entry->affix + entry->affl - 1;
            ind = &m_sflagindex[*cp];
            viazero = 0;
            while(ind->numents == 0 && ind->pu.fp != NULL)
            {
                if(cp == entry->affix)
                {
                    ind = &ind->pu.fp[0];
                    viazero = 1;
                }
                else
                {
                    ind = &ind->pu.fp[*--cp];
                    viazero = 0;
                }
            }
        }
        if(ind->numents == 0)
            ind->pu.ent = entry;
        ind->numents++;
        /*
        ** If this index entry has more than MAXSEARCH flags in
        ** it, we will split it into subentries to reduce the
        ** searching.  However, the split doesn't make sense in
        ** two cases:  (a) if we are already at the end of the
        ** current affix, or (b) if all the entries in the list
        ** have identical affixes.  Since the list is sorted, (b)
        ** is true if the first and last affixes in the list
        ** are identical.
        */
        if(!viazero && ind->numents >= MAXSEARCH && icharcmp(entry->affix, ind->pu.ent->affix) != 0)
        {
            /* Sneaky trick:  back up and reprocess */
            entry = ind->pu.ent - 1; /* -1 is for entry++ in loop */
            i = m_numsflags - (entry - m_sflaglist);
            ind->pu.fp = (struct flagptr *)calloc(static_cast< unsigned >(SET_SIZE + m_hashheader.nstrchars), sizeof(struct flagptr));
            if(ind->pu.fp == NULL)
            {
                fprintf(stderr, LOOKUP_C_NO_LANG_SPACE);
                return (-1);
            }
            ind->numents = 0;
        }
    }
    /*
    ** Warning - 'entry' and 'i' are reset in the body of the loop
    ** below.  Don't try to optimize it by (e.g.) moving the decrement
    ** of i into the loop condition.
    */
    for(i = m_numpflags, entry = m_pflaglist; i > 0; i--, entry++)
    {
        if(entry->affl == 0)
        {
            cp = NULL;
            ind = &m_pflagindex[0];
            viazero = 1;
        }
        else
        {
            cp = entry->affix;
            ind = &m_pflagindex[*cp++];
            viazero = 0;
            while(ind->numents == 0 && ind->pu.fp != NULL)
            {
                if(*cp == 0)
                {
                    ind = &ind->pu.fp[0];
                    viazero = 1;
                }
                else
                {
                    ind = &ind->pu.fp[*cp++];
                    viazero = 0;
                }
            }
        }
        if(ind->numents == 0)
            ind->pu.ent = entry;
        ind->numents++;
        /*
        ** If this index entry has more than MAXSEARCH flags in
        ** it, we will split it into subentries to reduce the
        ** searching.  However, the split doesn't make sense in
        ** two cases:  (a) if we are already at the end of the
        ** current affix, or (b) if all the entries in the list
        ** have identical affixes.  Since the list is sorted, (b)
        ** is true if the first and last affixes in the list
        ** are identical.
        */
        if(!viazero && ind->numents >= MAXSEARCH && icharcmp(entry->affix, ind->pu.ent->affix) != 0)
        {
            /* Sneaky trick:  back up and reprocess */
            entry = ind->pu.ent - 1; /* -1 is for entry++ in loop */
            i = m_numpflags - (entry - m_pflaglist);
            ind->pu.fp = static_cast< struct flagptr * >(calloc(SET_SIZE + m_hashheader.nstrchars, sizeof(struct flagptr)));
            if(ind->pu.fp == NULL)
            {
                fprintf(stderr, LOOKUP_C_NO_LANG_SPACE);
                return (-1);
            }
            ind->numents = 0;
        }
    }
#ifdef INDEXDUMP
    fprintf(stderr, "Prefix index table:\n");
    dumpindex(m_pflagindex, 0);
    fprintf(stderr, "Suffix index table:\n");
    dumpindex(m_sflagindex, 0);
#endif
    if(m_hashheader.nstrchartype == 0)
        m_chartypes = NULL;
    else
    {
        m_chartypes = (struct strchartype *)malloc(m_hashheader.nstrchartype * sizeof(struct strchartype));
        if(m_chartypes == NULL)
        {
            fprintf(stderr, LOOKUP_C_NO_LANG_SPACE);
            return (-1);
        }
        for(i = 0, nextchar = m_hashheader.strtypestart; i < m_hashheader.nstrchartype; i++)
        {
            m_chartypes[i].name = &m_hashstrings[nextchar];
            nextchar += strlen(m_chartypes[i].name) + 1;
            m_chartypes[i].deformatter = &m_hashstrings[nextchar];
            nextchar += strlen(m_chartypes[i].deformatter) + 1;
            m_chartypes[i].suffixes = &m_hashstrings[nextchar];
            while(m_hashstrings[nextchar] != '\0')
                nextchar += strlen(&m_hashstrings[nextchar]) + 1;
            nextchar++;
        }
    }

    initckch(NULL);

    return (0);
}
Esempio n. 2
0
/**
 * @brief ...
 * @param argc
 * @param argv
 * @param lib
 */
int my_main(int argc, char *argv[], char lib)
{
    char *wchars = NULL;
    char *preftype = NULL;
    static char outbuf[BUFSIZ];
    int arglen, old_argc;
    char *cpd = NULL;
    char *Cmd = *argv;
    /* Pointer to name of $(LIBDIR)/dict */
    char *LibDict = NULL; 

    islib = lib;
    old_argc = argc;
    Trynum = 0;
    sprintf(hashname, "%s/%s", LIBDIR, DEFHASH);
    strcpy(signs, DEFAULT_SIGNS);

    argv++;
    argc--;
    while (argc && **argv == '-') {
		/*
		 * Trying to add a new flag?  Can't remember what's been used?
		 * Here's a handy guide:
		 *
		 * Used:
		 *        ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789
		 *        ^^^^       ^^^ ^  ^^ ^^
		 *        abcdefghijklmnopqrstuvwxyz
		 *        ^^^^^^*    ^^^*^  ^^*^^^*
		 */
		arglen = strlen(*argv);
		add_inc = 0;
	
		switch ((*argv)[1]) {
		case 'v':
		    option_v(Cmd, argc, argv, arglen);
		    break;
		case 'n':
		    preftype = option_n(Cmd, preftype, arglen);
		    break;
		case 't': /* TeX mode */
		    preftype = option_t(Cmd, preftype, arglen);
		    break;
		case 'T': /* Set preferred file type */
		    preftype = option_T(Cmd, argc, argv);
		    break;
		case 'A':
		    option_A(Cmd, arglen);
		    break;
		case 'a':
		    option_a(Cmd, arglen);
		    break;
		case 'D':
		    option_D(Cmd, arglen);
		    break;
		case 'J':
		    option_J(Cmd, arglen);
		    break;
		case 'e':
		    option_e(Cmd, arglen, argv);
		    break;
		case 'c':
		    option_c(Cmd, arglen, argv);
		    break;
		case 'b':
		    option_b(Cmd, arglen);
		    break;
		case 'x':
		    option_x(Cmd, arglen);
		    break;
		case 'f':
		    option_f(Cmd, argc, argv); 
		    break;
		case 'L':
		    option_L(Cmd, argc, argv);
		    break;
		case 'l':
		    option_l(Cmd, arglen);
		    break;
		case 'S':
		    option_S(Cmd, arglen);
		    break;
		case 'B':   /* -B: report missing blanks */
		    option_B(Cmd, arglen);
		    break;
		case 'C':   /* -C: compound words are acceptable */
		    option_C(Cmd, arglen);
		    break;
		case 'P':   /* -P: don't gen non-dict poss's */
		    option_P(Cmd, arglen);
		    break;
		case 'm':   /* -m: make all poss affix combos*/
		    option_m(Cmd, arglen);
		    break;
		case 'N':   /* -N:  suppress minimenu */
		    option_N(Cmd, arglen);
		    break;
		case 'M':
		    option_M(Cmd, arglen);
		    break;   /* -M:  force minimenu */
		case 'p':
		    option_p(LibDict, &cpd, Cmd, argc, argv);
		    break;
		case 'd':
		    option_d(LibDict, cpd, Cmd, argc, argv);
		    break;
		case 'V':    /* Display 8-bit characters as M-xxx */
		    option_V(Cmd, arglen);
		    break;
		case 'w':
		    wchars = (*argv)+2;
		    if (*wchars == '\0') {
				argv++; argc--;
				if (argc == 0)
				    usage(Cmd);
				wchars = *argv;
		    }
		    break;
		case 'W':
		    option_W(Cmd, argc, argv);
		    break;
		case 'o':
		    option_o(Cmd, argc, argv); 
		    break;
		case 'g':
		    option_g(Cmd, arglen);
		    break;
		case 'u':
		    option_u(Cmd, arglen);
		    break;
		case 'y':
		    option_y(Cmd, arglen);
		    break;
		case 'z':
		    option_z(Cmd, arglen);
		    break;
		default:
		    usage(Cmd);
		}  /* end switch */
	
		if (add_inc) {
		    argv++; argc--;
		}
		argv++; argc--;
    }

    if (!argc  &&  !lflag  &&  !aflag   &&  !eflag  &&  !dumpflag)
		usage(Cmd);

    verify_files(argc, argv);

    if (!oflag) strcpy(o_form, DEF_OUT);
	if (linit() < 0) exit(1); /* Force an error */

    det_prefstringchar(preftype);

    if (prefstringchar < 0)
		defdupchar = 0;
    else
		defdupchar = prefstringchar;

    if (missingspaceflag < 0)
		missingspaceflag = hashheader.defspaceflag;
    if (tryhardflag < 0)
		tryhardflag = hashheader.defhardflag;

    initckch(wchars);

    process_LibDict(LibDict, cpd);

    if (process_a_e_and_d_flags() == 0)
		return 0;

    if (!islib)
		setbuf(stdout, outbuf);

    /* process lflag (also used with the -c option) */
    if (lflag) {
		infile = stdin;
		outfile = stdout;
		if (!islib)
	    	checkfile();
		return 0;
    }

    /* n. of parameters advanced */
    return old_argc - argc; 
}