🚀 go-pugleaf

Se llama algoritmo de  hipenaci�n y se usa en los processadores de texto
para la partici�n con guiones de los textos.

puedes provar este codigo, est� adaptado al idioma catal�n pero es valido
para el castellano.

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

/* Agost'90 */

/*    hypen.cpp*/

/* Funcions de hypenaci� */

/* */

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



#include <string.h>

#define LF 0x0A

#define SPACE 0x20

#define RET 0x0D

#define min(a, b) (((a) < (b)) ? (a) : (b))

#define max(a, b) (((a) > (b)) ? (a) : (b))

#define DSP 0 /* espai */

#define DNU 1 /* numero */

#define DLE 2 /* lletra */

#define DPU 3 /* punt decimal */

#define DPO 4 /* parentesi ( */

#define DPT 5 /* parentesi ) */

#define DIG 6 /* igual */

#define DMA 7 /* mayor */

#define DME 8 /* menor */

#define DDF 9 /* diferent */

#define DMI 10 /* mayor o igual */

#define DEI 11 /* menor o igual */

#define DOR 12 /* or | */

#define DAN 13 /* and & */

#define DEX 14 /* potencia */

#define DDI 15 /* divisio */

#define DMU 16 /* multiplicacio */

#define DRE 17 /* resta */

#define DSU 18 /* suma */

#define DCO 19 /* coma */

#define DCM 20 /* cometes */

#define DM1 21 /* multiplicacio if(0)... = 1 */

/* MACROS : Calculs i funcions matematiques */

#define PI ( 3.14159810 )

/* MACROS : retornen 1 si es compleix. 0 si no es compleix */

/* ( control del caracter. utilitzat per QUE_ES i SIGNE ) */

#define SP(x) ( x == 32 ) /* espai */

#define NU(x) ( (x>47) && (x<58) ) /* numero */

#define LE(x) (((x>64)&&(x<91))||((x>96)&&(x<123))) /* lletra */

#define PU(x) ( x == 46 ) /* punt decimal */

#define PO(x) ( x == 40 ) /* parentesi ( */

#define PT(x) ( x == 41 ) /* parentesi ) */

#define IG(x) ( x == 61 ) /* igual */

#define MA(x) ( x == 62 ) /* mayor */

#define ME(x) ( x == 60 ) /* menor */

#define OR(x) ( x == 124 ) /* or | */

#define AN(x) ( x == 38 ) /* and & */

#define EX(x) ( x == 94 ) /* potencia */

#define DI(x) ( x == 47 ) /* divisio */

#define MU(x) ( x == 42 ) /* multiplicacio */

#define RE(x) ( x == 45 ) /* resta */

#define SU(x) ( x == 43 ) /* suma */

#define CO(x) ( x == 44 ) /* coma.separador*/

#define CM(x) ( x == 34 ) /* cometes */

#define M1(x) ( x == 35 ) /* # multipl. */



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

/* Prototipos locales *******************************************/

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

extern int ajusta_marges_buffer( char *buffer , int lon_max , int ample);

extern int ample_lin_buffer( char *ini_linea , int reste_lon_max , int
*no_blancs , int *lon_lin );

extern int ins_blancs_buffer( char *ini_linea , int reste_lon_max , int
no_blancs , int no_blancs_ins );

extern int neteja_hypen_ant(char *buffer,int lon_max);

extern int hypen_buffer(char *buffer,int lon_max,int ample,int sw_hypen);

extern int busca_hypen(char *buffer,int pos_paraula,int pos_tall);

extern int seg_hypen(char *paraula,int pos);

extern int norma_hyp(char *paraula_test,char *norma);

extern int id_norma_hyp(char *norma);

/*e

extern int ajusta_marges_buffer();

extern int ample_lin_buffer();

extern int ins_blancs_buffer();

extern int neteja_hypen_ant();

extern int hypen_buffer();

extern int busca_hypen();

extern int seg_hypen();

extern int norma_hyp();

extern int id_norma_hyp();

#endif

*/

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

/* Macros per detectar el fi de linea i de texte */

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

#define BUF_FI_TEXTE( buf , pos_act , lon_max ) \

( buf[ pos_act ] == 0 || \

pos_act >= lon_max )

#define BUF_FI_LINEA( buf , pos_act , lon_max ) \

( BUF_FI_TEXTE( buf , pos_act , lon_max ) || \

buf[ pos_act ] == LF)

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

/* Actualitza hypenaci� y ajustar marges a un buffer de un camp tipus TXT */

/* Retorna el numero de linees que ocupa */

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

int actu_txt(char *buffer,int lon_max,int ample,int sw_hypen,int sw_ajusta)

{

int no_linees;

/* Treu tots els guions de hypenaci� anteriors */

/* (Els que estan just abans de un salt de linia tou. */

/* Treu tamb, els salts de linia tous (Linefeed) */

/* Respecta els finals de linea durs (Ret+Linefeed) */

neteja_hypen_ant(buffer,lon_max);

/* Efect�a Hypenaci�, (Parteix paraules) */

no_linees = hypen_buffer(buffer,lon_max,ample,sw_hypen);

if(sw_ajusta)

{

/* Ajusta Marges (Inserta espais) */

ajusta_marges_buffer(buffer,lon_max,ample);

}

return(no_linees);

}

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

/* Treu tots els guions de hypenaci� anteriors */

/* (Els que estan just abans de un salt de linia tou. */

/* Treu tamb, els salts de linia tous (Linefeed) */

/* Respecta els finals de linea durs (Ret+Linefeed) */

/* */

/* Si es volen eliminar tamb, els guions */

/* seguits de un fi de linia 'dur', el RET no ha d'afectar */

/* al estat */

/* */

/* Estat : 0 ==> Normal */

/* Estat : 1 ==> Gui� llegit */

/* Estat : 2 ==> Return Llegit */

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

int neteja_hypen_ant(char *buffer,int lon_max)

{

int i,car_act;

int estat,pos_1,pos_2,ample;

estat = 0;

i=0;

car_act=buffer[i];

while(i<lon_max && car_act!=0)

{

switch(car_act)

{

case '-':

pos_1 = i;

estat = 1;

break;

case LF :

switch(estat)

{

case 2: /* Si abans a llegit un RET, segueix normal */

break;

case 0: /* Si abans a llegit un altre caracter */

/* Elimina el LF */

pos_1 = i;

case 1: /* Si abans a llegit un gui� */

/* Elimina el guio i el LF */

pos_2 = i+1; /* Posicio que s'ha de desplassar */

ample = pos_2 - pos_1; /* valor del desplassament */

memmove(buffer+pos_1,buffer+pos_2,lon_max-pos_2);

memset(buffer+lon_max-ample,0,ample); /* Neteija reste buffer */

i-=ample; /* Recupera la posici� */

break;

}

estat = 0;

break;

case SPACE: /* No afecta al estat */

break; /* (Per si el gui� esta separat amb espais del LF) */

case RET:

estat = 2; /* Si es volen eliminar tamb, els guions */

/* seguits de un fi de linia 'dur', el RET no ha d'afectar */

/* al estat */

break;

default :

estat = 0;

break;

}

i++;

car_act=buffer[i];

}

}

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

/* Efect�a Hypenaci�, (Parteix paraules) en un buffer tipus TXT */

/* Estat : 0 ==> Normal */

/* Estat : 1 ==> Espai Llegit */

/* Retorna el numero de linees que ocupa */

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

int hypen_buffer(char *buffer,int lon_max,int ample,int sw_hypen)

{

int pos_paraula,i,car_act,estat,ample_lin,pos_tall;

int pos_1,pos_2;

int no_linees=1; /* Numero de linees en que queda convertit */

i=0;

ample_lin = 0;

pos_paraula = i; /* Possible posici� de la primera paraula */

car_act = buffer[i];

while(i<lon_max && car_act!=0)

{

switch(car_act)

{

case SPACE:

pos_paraula = i + 1; /* Possible posici� de una seg�ent paraula */

ample_lin++;

break;

case LF :

case RET:

ample_lin = 0; /* Torna a comenn?ar la linia */

pos_paraula = i + 1; /* Possible posici� de la primera paraula */

estat = 0;

no_linees++; /* Incrementa el numero de linea */

break;

default :

ample_lin++;

estat = 0;

if(ample_lin>=ample) /* Si s'ha arribat al limit del ample */

{

/* comproba posici� de hypenaci� */

pos_tall = i;

if(sw_hypen) /* Si ha de fer hypenaci� */

pos_tall = busca_hypen(buffer,pos_paraula,pos_tall);

else

pos_tall = -1; /* For?a que talli per principi de la paraula */

if(pos_tall<0) /* Si la primera sil.laba no hi cap */

{

if(pos_paraula <= i-ample_lin) /* Si la paraula comen?a al principi de la
linia */

pos_tall = i; /* Es una paraula que no t, hypenaci� i es talla */

else

pos_tall = pos_paraula; /* S'ha de tallar per el principi de la paraula */

/* Inserta un LF a pos_tall */

pos_1 = pos_tall+1;

pos_2 = pos_tall;

memmove(buffer+pos_1,buffer+pos_2,lon_max-pos_1);

buffer[pos_2] = LF;

i = pos_tall-1; /* Actualitza posici� */

}

else

{

/* Inserta un gui� i un LF a pos_tall */

pos_1 = pos_tall+2;

pos_2 = pos_tall;

memmove(buffer+pos_1,buffer+pos_2,lon_max-pos_1);

buffer[pos_2] = '-';

buffer[pos_2+1] = LF;

i = pos_tall; /* Actualitza posici� */

}

}

break;

}

i++;

car_act = buffer[i];

}

return(no_linees);

}

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

/********** FUNCIONS DE HYPENACIO **********/

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

char *c_lex[]={

/* pars consonants legals */

"pp
([BbCcFfGgKkPpTt][Ll]|[BbCcDdFfGgKkPpTt][Rr]|[Cc][Hh]|[Ll][Ll]|[Rr][Rr])",

/* consonants */

"c ([BCDFGHJKLMN�PQRSTVWXYZ]|[bcdfghjklmn�pqrstvwxyz])",

/* vocals */

"a ([AaEeOo]|[ ,���.S.�])",

"i ([IiUu]|[s�])",

"v ([AaEeOo]|[ ,���.S.�]|[IiUu]|[s�])",

/* cualsevol lletra */

"l
[BCDFGHJKLMN�PQRSTVWXYZ]|[bcdfghjklmn�pqrstvwxyz]|[AaEeOo]|[ ,���.S.�]|[IiUu
]|[s�])",

/* normas de hypenaci�n */

"hp1 ({l}{i}[hH]{i})", /* no */

"hp2 ({l}{a}[hH]{i})", /* no */

"hp3 ({l}{i}[hH]{a})", /* no */

"hp4 ({l}{l}{pp}{v})", /* SI */

"hp5 ({l}{pp}{l})", /* no */

"hp6 ({l}{l}{c}{v})", /* SI */

"hp7 ({l}{a}{a}{l})", /* SI */

""};

char *c_lex_aut[]={

/* pars consonants legals */

"ppl [BbCcFfGgKkPpTt][Ll]",

"ppr [BbCcDdFfGgKkPpTt][Rr]",

"tcl ([Cc][Hh]|[Ll][Ll]|[Rr][Rr])",

"pp ({ppl}|{ppr}|{tcl})",

/* consonants */

"uc [BCDFGHJKLMN�PQRSTVWXYZ]",

"lc [bcdfghjklmn�pqrstvwxyz]",

"c ({uc}|{lc})",

/* vocals */

"open [AaEeOo]",

"closed [IiUu]",

"a ({open}|[ ,���.S.�])",

"i ({closed}|[s�])",

"v ({a}|{i})",

/* cualsevol lletra */

"l ({c}|{v})",

/* normas de hypenaci�n */

"hp1 ({l1}{i1}[hH]{i1})", /* no */

"hp2 ({l1}{a1}[hH]{i1})", /* no */

"hp3 ({l1}{i1}[hH]{a1})", /* no */

"hp4 ({l1}{l1}{pp1}{v1})", /* SI */

"hp5 ({l1}{pp1}{l1})", /* no */

"hp6 ({l1}{l1}{c1}{v1})", /* SI */

"hp7 ({l1}{a1}{a1}{l1})", /* SI */

""};

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

july 1987 Volume 30 Number 7

Notaci� compacte :

a Vocals obertes o accetntuades (obertees i tancades).

i Vocals tancades.

v Vocal.

h Lletra h.

pp Par legal de consonantes.

c Cualquier consonante.

l Cualquier letra.

Normas de hypenaci�n :

mascara acci�

HP1 li-hi NO

HP2 la-hi NO

HP3 li-ha NO

HP4 ll-ppv SI

HP5 lp-pl NO

HP6 ll-cv SI

HP7 la-al SI

HP8 altres NO

Umbral (Threshold) :

Es la posici�, de la paraula, a partir de la que es comencen a

considerar les normes de hypenaci�. Normalment es 2, per� fins

al valor 4 es pot considerar acceptable.

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

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

/* Busca la hypenaci� m,s propera al tall desitjat, en un buffer tipus TXT*/

/* Torna la posici� on s'ha de partir la paraula */

/* Si no hi cap ni la primera sil.laba torna -1 */

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

int busca_hypen(char *buffer,int pos_paraula,int pos_tall)

{

int pos_hyp,ant_pos_hyp;

ant_pos_hyp = pos_paraula;

pos_hyp = seg_hypen(buffer,ant_pos_hyp);

while(pos_hyp>ant_pos_hyp && pos_hyp<=pos_tall)

{

ant_pos_hyp = pos_hyp;

pos_hyp = seg_hypen(buffer,ant_pos_hyp);

}

if(ant_pos_hyp == pos_paraula)

return(-1);

return(ant_pos_hyp);

}

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

/* Calcula Hypenaci�, en un buffer tipus TXT a partir de pos */

/* Torna la posici� on s'ha de partir la paraula */

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

int seg_hypen(char *buffer,int pos)

{

int ret,sw_hypen,pos_hyp;

char *c;

c=buffer+pos;

pos_hyp = pos+2; /* Son els dos caracters de desplassament de la mascara */

/* Doncs quan s'investiga el caracter c a pos, el tall */

/* s'efect�a a la pos+2 */

while(norma_hyp(c,"l")) /* Mentres sigui una lletra */

{

sw_hypen = !(ret = norma_hyp(c,"hp1"));

if(!ret)

sw_hypen = !(ret = norma_hyp(c,"hp2"));

if(!ret)

sw_hypen = !(ret = norma_hyp(c,"hp3"));

if(!ret)

sw_hypen = ret = norma_hyp(c,"hp4");

if(!ret)

sw_hypen = !(ret = norma_hyp(c,"hp5"));

if(!ret)

sw_hypen = ret = norma_hyp(c,"hp6");

if(!ret)

sw_hypen = ret = norma_hyp(c,"hp7");

if(!ret)

sw_hypen = 0;

if(sw_hypen)

return(pos_hyp);

c++;

pos_hyp++;

}

return(pos);

}

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

/*** Separa paraula amb sil.labes ***/

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

int norma_hyp(char * paraula_test,char *norma)

{

int i,i_norma;

int test_norma,test_lletra=0;

int car_avant,car;

char *c;

char *p_test;

p_test = paraula_test;

test_norma=1;

car_avant=0;

i_norma = id_norma_hyp(norma);

c = c_lex[i_norma];

while(*c!=0)

{

switch(*c)

{

case '|':

if(test_norma)

return(car_avant*test_norma);

case '(':

p_test = paraula_test;

test_norma=1;

car_avant=0;

break;

case '{':

if(test_norma)

{

c++;

car = norma_hyp(p_test,c);

test_norma=(car && test_norma);

while(*c!=0 && *c!='}')

c++;

p_test+=car;

car_avant+=car;

}

break;

case '[':

if(test_norma)

{

c++;

test_lletra=0;

while(*c!=0 && *c!=']')

{

test_lletra=((*c==*p_test) || test_lletra);

c++;

}

test_norma=(test_lletra && test_norma);

p_test++;

car_avant++;

}

break;

}

if(*c!=0)

c++;

}

return(car_avant*test_norma);

}





int id_norma_hyp(char *norma)

{

int i,j;

int i_norma=0;

int sw_id;

int l1,l2;

char *c1,*c2;

i=0;

sw_id=0;

while(*c_lex[i]!=0 && !sw_id)

{

c1=c_lex[i];

c2=norma;

for(l1=0;(LE(*c1)) || (NU(*c1));l1++,c1++); /* longitud */

for(l2=0;(LE(*c2)) || (NU(*c2));l2++,c2++); /* longitud */

if(l1==l2)

sw_id=1;

c1=c_lex[i];

c2=norma;

for(j=0;sw_id && l1>0;j++,c1++,c2++,l1--) /* mentres sigui una lletra */

if(*c1!=*c2)

sw_id=0;

i++;

}

if(sw_id)

i_norma=i-1;

else

i_norma=0;

return(i_norma);

}

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

/* Ajusta linees a la mateixa longitud amb espais */

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

int ajusta_marges_buffer( char *buffer , int lon_max , int ample)

{

int i , ample_lin , no_blancs_ins , no_blancs , reste_lon_max , lon_lin ;

char *ini_linea;

ini_linea = buffer;

reste_lon_max = lon_max;

i = 0;

while( !BUF_FI_TEXTE( buffer , i , lon_max ) )

{

/* Calcula l'ample visualitzable actual de la linea, */

/* l'ample real, */

/* i el numero de blancs que hi han */

ample_lin = ample_lin_buffer( ini_linea , reste_lon_max , &no_blancs ,
&lon_lin );

/* Numero total de blancs a insertar per for?ar l'ample de la liniea a
'ample' */

no_blancs_ins = ample - ample_lin;

/* Si no es la ultima linea */

if( !BUF_FI_TEXTE( buffer , i + lon_lin , lon_max )&& buffer[i+lon_lin-2] !=
RET )

/* Inserta els blancs corresponents */

lon_lin += ins_blancs_buffer( ini_linea , /* Inici de linea */

reste_lon_max , /* Reste de longitud disponoble del buffer */

no_blancs , /* Num de blancs que hi han a la linea */

no_blancs_ins + 1 ); /* Num de blancs que s'han d'insertar */

i += lon_lin;

ini_linea += lon_lin;

reste_lon_max -= lon_lin;

}

}

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

/* Calcula l'ample actual de la linea , */

/* l'ample real, */

/* i el numero de blancs que hi han */

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

int ample_lin_buffer( char *ini_linea , int reste_lon_max , int *no_blancs ,
int *lon_lin )

{

int ample_lin , nb , sw_ini_linea;

char *car_act;

nb = 0;

ample_lin = 0;

car_act = ini_linea;

sw_ini_linea = 1;

while( !BUF_FI_LINEA( ini_linea , ample_lin , reste_lon_max ) )

{

/* Incrementa no.blancs si no es l'ultim blanc de la linea */

/* ni es principi de la linea, */

/* Ja que no es conten com blancs els del principi de la linea. */

if( *car_act == SPACE &&

!BUF_FI_LINEA( ini_linea , ample_lin + 1 , reste_lon_max ) &&

!sw_ini_linea )

nb++;

if( *car_act != SPACE ) // Si el caracter no es un espai,

sw_ini_linea = 0; // Ja no es principi de la linea

ample_lin ++;

car_act ++;

}

/* Si no es fi de texte, incrementa una posici� (el LF) */

*lon_lin = ample_lin + !BUF_FI_TEXTE( ini_linea , ample_lin ,
reste_lon_max );

*no_blancs = nb;

return( ample_lin );

}

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

/* Inserta els blancs corresponents */

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

int ins_blancs_buffer( char *ini_linea , int reste_lon_max , int no_blancs ,
int no_blancs_ins )

{

int pos_act , pos_1 , pos_2 , nb_ins , pos_blanc_plus , nb ;

int len_buffer , max_blanc_ins , nbins;

char *car_act;

/* Longitud del string que hi ha en el buffer */

len_buffer = min( strlen( ini_linea ) ,reste_lon_max );

/* Calcula el numero m xim de blancs a insertar */

max_blanc_ins = reste_lon_max - len_buffer;

/* ReCalcula el numero de blancs a insertar */

no_blancs_ins = min( no_blancs_ins , max_blanc_ins );

/* Calcula blancs a insertar per cada blanc que hi ha a la linea */

nb_ins = ( no_blancs == 0 )?( no_blancs_ins ):( no_blancs_ins / no_blancs );

/* Calcula posicions on se n'ha d'insertar un de mes */

pos_blanc_plus = ( no_blancs == 0 )?( 0 ):( no_blancs_ins % no_blancs );

pos_act = 0;

car_act = ini_linea;

nbins = 0;

/* No s'han d'insertar blancs al principi de la linea. */

while( *car_act == SPACE && /* Mentres siguin blancs del principi, */

!BUF_FI_LINEA( ini_linea , pos_act , reste_lon_max )) /* i no sigui fi de
linea */

{

pos_act ++;

car_act ++;

}

while( no_blancs_ins > 0 && /* Mentres hi hagin blancs a insertar */

!BUF_FI_LINEA( ini_linea , pos_act , reste_lon_max )) /* i no sigui fi de
linea */

{

if( *car_act == SPACE ||

*car_act == '"' ||

*car_act == '(' ||

*car_act == '[' ||

*car_act == '{' ||

*car_act == '' ||

*car_act == '�')

{

nb = nb_ins + ( pos_blanc_plus > 0 );/* Calcula blancs a insertar */

pos_blanc_plus--; /* Decrementa posicions de blancs suplementaris */

no_blancs_ins -= nb; /* Decrementa blancs pendents a insertar */

nbins += nb; /* Incrementa blancs insertats */

pos_1 = pos_act + nb;

pos_2 = pos_act;

memmove( ini_linea + pos_1 , ini_linea + pos_2 , reste_lon_max - pos_1 );

memset( ini_linea + pos_2 , SPACE, nb ); /* Neteja resta buffer */

pos_act += nb; /* Actualitza posici� */

car_act += nb; /* Actualitza posici� */

}

pos_act ++;

car_act ++;

}

return( nbins );

}

/*

main(int argc,char**argv)

{

int nl;

int i;

int ancho = 40; // numero de caracteres de la columna

int ajusta = 0; // si > 0 hace justificaci�n

int swhypena = 1; // si 1 partre por guiones



char buffer[800] = "Napster las puso nerviosas y la pirater�a les sigue
achicando el negocio, pero adem�s las grandes compa��as musicales se las
tienen que ver con sus artistas m�s concienciados, los que buscan una
cultura musical rica en colaboraciones y mestizajes, y no est�n por la labor
de encadenarse a sus contratos. Chico C�sar ha tocado este fin de semana en
Canarias, donde ha defendido la colaboraci�n con artistas africanos y de
otros continentes como una red "que trascienda el Show Business".\n";

if( argc > 1 )

ancho = atoi(argv[1]);

if( argc > 2 )

swhypena = atoi(argv[2]);

if( argc > 3 )

ajusta = atoi(argv[3]);



// funcion principal que devueve el numero de linias del texto

nl = actu_txt(buffer,799,ancho,swhypena,ajusta);

printf("\nNumero de lineas = %d\n\n%s",nl,buffer);

}

*/


////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////


"Santiago Romero" <sromero@servicom2000.com> escribi� en el mensaje
news:f1gno9.89k.ln@127.0.0.1...
>
>  �Alguien conoce o tiene por ahi alg�n c�digo GPL que dada
>  una palabra la divida en s�labas?
>
>  (Tampoco me vendr�a mal una lista en texto plano de todas
>  las s�labas diferentes que existen).
>
>  saludos!
>
> --
> Santiago Romero
> Departamento de Sistemas
> sromero@servicom2000.com
>
> Av. Primado Reig 189, entlo
> 46020 Valencia - Spain
> Telf. (+34) 96 332 12 00
> Fax. (+34) 96 332 12 01
> http://www.servicom2000.com
>