350 lines
8.6 KiB
C
350 lines
8.6 KiB
C
/* ecs - equivalence class routines */
|
|
|
|
/*-
|
|
* Copyright (c) 1990 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Vern Paxson.
|
|
*
|
|
* The United States Government has rights in this work pursuant
|
|
* to contract no. DE-AC03-76SF00098 between the United States
|
|
* Department of Energy and the University of California.
|
|
*
|
|
* Redistribution and use in source and binary forms are permitted provided
|
|
* that: (1) source distributions retain this entire copyright notice and
|
|
* comment, and (2) distributions including binaries display the following
|
|
* acknowledgement: ``This product includes software developed by the
|
|
* University of California, Berkeley and its contributors'' in the
|
|
* documentation or other materials provided with the distribution and in
|
|
* all advertising materials mentioning features or use of this software.
|
|
* Neither the name of the University nor the names of its contributors may
|
|
* be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char rcsid[] =
|
|
"@(#) $Header: /cvsroot/src/usr.bin/lex/Attic/ecs.c,v 1.2 1993/05/04 07:44:45 cgd Exp $ (LBL)";
|
|
#endif
|
|
|
|
#include "flexdef.h"
|
|
|
|
/* ccl2ecl - convert character classes to set of equivalence classes
|
|
*
|
|
* synopsis
|
|
* ccl2ecl();
|
|
*/
|
|
|
|
void ccl2ecl()
|
|
|
|
{
|
|
int i, ich, newlen, cclp, ccls, cclmec;
|
|
|
|
for ( i = 1; i <= lastccl; ++i )
|
|
{
|
|
/* we loop through each character class, and for each character
|
|
* in the class, add the character's equivalence class to the
|
|
* new "character" class we are creating. Thus when we are all
|
|
* done, character classes will really consist of collections
|
|
* of equivalence classes
|
|
*/
|
|
|
|
newlen = 0;
|
|
cclp = cclmap[i];
|
|
|
|
for ( ccls = 0; ccls < ccllen[i]; ++ccls )
|
|
{
|
|
ich = ccltbl[cclp + ccls];
|
|
cclmec = ecgroup[ich];
|
|
|
|
if ( xlation && cclmec < 0 )
|
|
{
|
|
/* special hack--if we're doing %t tables then it's
|
|
* possible that no representative of this character's
|
|
* equivalence class is in the ccl. So waiting till
|
|
* we see the representative would be disastrous. Instead,
|
|
* we add this character's equivalence class anyway, if it's
|
|
* not already present.
|
|
*/
|
|
int j;
|
|
|
|
/* this loop makes this whole process n^2; but we don't
|
|
* really care about %t performance anyway
|
|
*/
|
|
for ( j = 0; j < newlen; ++j )
|
|
if ( ccltbl[cclp + j] == -cclmec )
|
|
break;
|
|
|
|
if ( j >= newlen )
|
|
{ /* no representative yet, add this one in */
|
|
ccltbl[cclp + newlen] = -cclmec;
|
|
++newlen;
|
|
}
|
|
}
|
|
|
|
else if ( cclmec > 0 )
|
|
{
|
|
ccltbl[cclp + newlen] = cclmec;
|
|
++newlen;
|
|
}
|
|
}
|
|
|
|
ccllen[i] = newlen;
|
|
}
|
|
}
|
|
|
|
|
|
/* cre8ecs - associate equivalence class numbers with class members
|
|
*
|
|
* synopsis
|
|
* int cre8ecs();
|
|
* number of classes = cre8ecs( fwd, bck, num );
|
|
*
|
|
* fwd is the forward linked-list of equivalence class members. bck
|
|
* is the backward linked-list, and num is the number of class members.
|
|
*
|
|
* Returned is the number of classes.
|
|
*/
|
|
|
|
int cre8ecs( fwd, bck, num )
|
|
int fwd[], bck[], num;
|
|
|
|
{
|
|
int i, j, numcl;
|
|
|
|
numcl = 0;
|
|
|
|
/* create equivalence class numbers. From now on, abs( bck(x) )
|
|
* is the equivalence class number for object x. If bck(x)
|
|
* is positive, then x is the representative of its equivalence
|
|
* class.
|
|
*/
|
|
for ( i = 1; i <= num; ++i )
|
|
if ( bck[i] == NIL )
|
|
{
|
|
bck[i] = ++numcl;
|
|
for ( j = fwd[i]; j != NIL; j = fwd[j] )
|
|
bck[j] = -numcl;
|
|
}
|
|
|
|
return ( numcl );
|
|
}
|
|
|
|
|
|
/* ecs_from_xlation - associate equivalence class numbers using %t table
|
|
*
|
|
* synopsis
|
|
* numecs = ecs_from_xlation( ecmap );
|
|
*
|
|
* Upon return, ecmap will map each character code to its equivalence
|
|
* class. The mapping will be positive if the character is the representative
|
|
* of its class, negative otherwise.
|
|
*
|
|
* Returns the number of equivalence classes used.
|
|
*/
|
|
|
|
int ecs_from_xlation( ecmap )
|
|
int ecmap[];
|
|
|
|
{
|
|
int i;
|
|
int nul_is_alone = false;
|
|
int did_default_xlation_class = false;
|
|
|
|
if ( xlation[0] != 0 )
|
|
{
|
|
/* if NUL shares its translation with other characters, choose one
|
|
* of the other characters as the representative for the equivalence
|
|
* class. This allows a cheap test later to see whether we can
|
|
* do away with NUL's equivalence class.
|
|
*/
|
|
for ( i = 1; i < csize; ++i )
|
|
if ( xlation[i] == -xlation[0] )
|
|
{
|
|
xlation[i] = xlation[0];
|
|
ecmap[0] = -xlation[0];
|
|
break;
|
|
}
|
|
|
|
if ( i >= csize )
|
|
/* didn't find a companion character--remember this fact */
|
|
nul_is_alone = true;
|
|
}
|
|
|
|
for ( i = 1; i < csize; ++i )
|
|
if ( xlation[i] == 0 )
|
|
{
|
|
if ( did_default_xlation_class )
|
|
ecmap[i] = -num_xlations;
|
|
|
|
else
|
|
{
|
|
/* make an equivalence class for those characters not
|
|
* specified in the %t table
|
|
*/
|
|
++num_xlations;
|
|
ecmap[i] = num_xlations;
|
|
did_default_xlation_class = true;
|
|
}
|
|
}
|
|
|
|
else
|
|
ecmap[i] = xlation[i];
|
|
|
|
if ( nul_is_alone )
|
|
/* force NUL's equivalence class to be the last one */
|
|
{
|
|
++num_xlations;
|
|
ecmap[0] = num_xlations;
|
|
|
|
/* there's actually a bug here: if someone is fanatic enough to
|
|
* put every character in its own translation class, then right
|
|
* now we just promoted NUL's equivalence class to be csize + 1;
|
|
* we can handle NUL's class number being == csize (by instead
|
|
* putting it in its own table), but we can't handle some *other*
|
|
* character having to be put in its own table, too. So in
|
|
* this case we bail out.
|
|
*/
|
|
if ( num_xlations > csize )
|
|
flexfatal( "too many %t classes!" );
|
|
}
|
|
|
|
return num_xlations;
|
|
}
|
|
|
|
|
|
/* mkeccl - update equivalence classes based on character class xtions
|
|
*
|
|
* synopsis
|
|
* Char ccls[];
|
|
* int lenccl, fwd[llsiz], bck[llsiz], llsiz, NUL_mapping;
|
|
* mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping );
|
|
*
|
|
* where ccls contains the elements of the character class, lenccl is the
|
|
* number of elements in the ccl, fwd is the forward link-list of equivalent
|
|
* characters, bck is the backward link-list, and llsiz size of the link-list
|
|
*
|
|
* NUL_mapping is the value which NUL (0) should be mapped to.
|
|
*/
|
|
|
|
void mkeccl( ccls, lenccl, fwd, bck, llsiz, NUL_mapping )
|
|
Char ccls[];
|
|
int lenccl, fwd[], bck[], llsiz, NUL_mapping;
|
|
|
|
{
|
|
int cclp, oldec, newec;
|
|
int cclm, i, j;
|
|
static unsigned char cclflags[CSIZE]; /* initialized to all '\0' */
|
|
|
|
/* note that it doesn't matter whether or not the character class is
|
|
* negated. The same results will be obtained in either case.
|
|
*/
|
|
|
|
cclp = 0;
|
|
|
|
while ( cclp < lenccl )
|
|
{
|
|
cclm = ccls[cclp];
|
|
|
|
if ( NUL_mapping && cclm == 0 )
|
|
cclm = NUL_mapping;
|
|
|
|
oldec = bck[cclm];
|
|
newec = cclm;
|
|
|
|
j = cclp + 1;
|
|
|
|
for ( i = fwd[cclm]; i != NIL && i <= llsiz; i = fwd[i] )
|
|
{ /* look for the symbol in the character class */
|
|
for ( ; j < lenccl; ++j )
|
|
{
|
|
register int ccl_char;
|
|
|
|
if ( NUL_mapping && ccls[j] == 0 )
|
|
ccl_char = NUL_mapping;
|
|
else
|
|
ccl_char = ccls[j];
|
|
|
|
if ( ccl_char > i )
|
|
break;
|
|
|
|
if ( ccl_char == i && ! cclflags[j] )
|
|
{
|
|
/* we found an old companion of cclm in the ccl.
|
|
* link it into the new equivalence class and flag it as
|
|
* having been processed
|
|
*/
|
|
|
|
bck[i] = newec;
|
|
fwd[newec] = i;
|
|
newec = i;
|
|
cclflags[j] = 1; /* set flag so we don't reprocess */
|
|
|
|
/* get next equivalence class member */
|
|
/* continue 2 */
|
|
goto next_pt;
|
|
}
|
|
}
|
|
|
|
/* symbol isn't in character class. Put it in the old equivalence
|
|
* class
|
|
*/
|
|
|
|
bck[i] = oldec;
|
|
|
|
if ( oldec != NIL )
|
|
fwd[oldec] = i;
|
|
|
|
oldec = i;
|
|
next_pt:
|
|
;
|
|
}
|
|
|
|
if ( bck[cclm] != NIL || oldec != bck[cclm] )
|
|
{
|
|
bck[cclm] = NIL;
|
|
fwd[oldec] = NIL;
|
|
}
|
|
|
|
fwd[newec] = NIL;
|
|
|
|
/* find next ccl member to process */
|
|
|
|
for ( ++cclp; cclflags[cclp] && cclp < lenccl; ++cclp )
|
|
{
|
|
/* reset "doesn't need processing" flag */
|
|
cclflags[cclp] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* mkechar - create equivalence class for single character
|
|
*
|
|
* synopsis
|
|
* int tch, fwd[], bck[];
|
|
* mkechar( tch, fwd, bck );
|
|
*/
|
|
|
|
void mkechar( tch, fwd, bck )
|
|
int tch, fwd[], bck[];
|
|
|
|
{
|
|
/* if until now the character has been a proper subset of
|
|
* an equivalence class, break it away to create a new ec
|
|
*/
|
|
|
|
if ( fwd[tch] != NIL )
|
|
bck[fwd[tch]] = bck[tch];
|
|
|
|
if ( bck[tch] != NIL )
|
|
fwd[bck[tch]] = fwd[tch];
|
|
|
|
fwd[tch] = NIL;
|
|
bck[tch] = NIL;
|
|
}
|