int
__printf_size (FILE *fp, const struct printf_info *info,
const void *const *args)
{
/* Units for the both formats. */
#define BINARY_UNITS " kmgtpezy"
#define DECIMAL_UNITS " KMGTPEZY"
static const char units[2][sizeof (BINARY_UNITS)] =
{
BINARY_UNITS, /* For binary format. */
DECIMAL_UNITS /* For decimal format. */
};
const char *tag = units[isupper (info->spec) != 0];
int divisor = isupper (info->spec) ? 1000 : 1024;
/* The floating-point value to output. */
union
{
union ieee754_double dbl;
union ieee854_long_double ldbl;
}
fpnum;
const void *ptr = &fpnum;
int fpnum_sign = 0;
/* "NaN" or "Inf" for the special cases. */
const char *special = NULL;
const wchar_t *wspecial = NULL;
struct printf_info fp_info;
int done = 0;
#if __OPTION_POSIX_C_LANG_WIDE_CHAR
int wide = info->wide;
#else
/* This should never be called on a wide-oriented stream when
OPTION_POSIX_C_LANG_WIDE_CHAR is disabled, but the compiler can't
be trusted to figure that out. */
const int wide = 0;
#endif
int res;
/* Fetch the argument value. */
#ifndef __NO_LONG_DOUBLE_MATH
if (info->is_long_double && sizeof (long double) > sizeof (double))
{
fpnum.ldbl.d = *(const long double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnanl (fpnum.ldbl.d))
{
special = "nan";
wspecial = L"nan";
// fpnum_sign = 0; Already zero
}
else if ((res = __isinfl (fpnum.ldbl.d)))
{
fpnum_sign = res;
special = "inf";
wspecial = L"inf";
}
else
while (fpnum.ldbl.d >= divisor && tag[1] != '\0')
{
fpnum.ldbl.d /= divisor;
++tag;
}
}
else
#endif /* no long double */
{
fpnum.dbl.d = *(const double *) args[0];
/* Check for special values: not a number or infinity. */
if (__isnan (fpnum.dbl.d))
{
special = "nan";
wspecial = L"nan";
// fpnum_sign = 0; Already zero
}
else if ((res = __isinf (fpnum.dbl.d)))
{
fpnum_sign = res;
special = "inf";
wspecial = L"inf";
}
else
while (fpnum.dbl.d >= divisor && tag[1] != '\0')
{
fpnum.dbl.d /= divisor;
++tag;
}
}
if (special)
{
int width = info->prec > info->width ? info->prec : info->width;
if (fpnum_sign < 0 || info->showsign || info->space)
--width;
width -= 3;
if (!info->left && width > 0)
PADN (' ', width);
if (fpnum_sign < 0)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
PRINT (special, wspecial, 3);
if (info->left && width > 0)
PADN (' ', width);
return done;
}
/* Prepare to print the number. We want to use `__printf_fp' so we
have to prepare a `printf_info' structure. */
fp_info = *info;
fp_info.spec = 'f';
fp_info.prec = info->prec < 0 ? 3 : info->prec;
fp_info.wide = wide;
if (fp_info.left && fp_info.pad == L' ')
{
/* We must do the padding ourself since the unit character must
be placed before the padding spaces. */
fp_info.width = 0;
done = __printf_fp (fp, &fp_info, &ptr);
if (done > 0)
{
outchar (*tag);
if (info->width > done)
PADN (' ', info->width - done);
}
}
else
{
/* We can let __printf_fp do all the printing and just add our
unit character afterwards. */
fp_info.width = info->width - 1;
done = __printf_fp (fp, &fp_info, &ptr);
if (done > 0)
outchar (*tag);
}
return done;
}
void
docharacters ( void )
{
byte c ;
indextype k ;
integer ai ;
sortptr = 0 ;
{register integer for_end; c = bc ;for_end = ec ; if ( c <= for_end) do
if ( tfm [4 * ( charbase + c ) ]> 0 )
{
if ( charsonline == 8 )
{
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 1 ;
}
else {
if ( charsonline > 0 )
putc ( ' ' , stderr );
if ( verbose )
charsonline = charsonline + 1 ;
}
if ( verbose )
printoctal ( c ) ;
left () ;
Fputs ( plfile , "CHARACTER" ) ;
outchar ( c ) ;
outln () ;
{
left () ;
Fputs ( plfile , "CHARWD" ) ;
if ( tfm [4 * ( charbase + c ) ]>= nw )
{
perfect = false ;
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
fprintf ( stderr , "%s%s", "Width" , " index for character " ) ;
printoctal ( c ) ;
fprintf ( stderr , "%s\n", " is too large;" ) ;
fprintf ( stderr , "%s\n", "so I reset it to zero." ) ;
}
else outfix ( 4 * ( widthbase + tfm [4 * ( charbase + c ) ]) ) ;
right () ;
}
if ( ( tfm [4 * ( charbase + c ) + 1 ]/ 16 ) > 0 ) {
if ( ( tfm [4 * ( charbase + c ) + 1 ]/ 16 ) >= nh )
{
perfect = false ;
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
fprintf ( stderr , "%s%s", "Height" , " index for character " ) ;
printoctal ( c ) ;
fprintf ( stderr , "%s\n", " is too large;" ) ;
fprintf ( stderr , "%s\n", "so I reset it to zero." ) ;
}
else {
left () ;
Fputs ( plfile , "CHARHT" ) ;
outfix ( 4 * ( heightbase + ( tfm [4 * ( charbase + c ) + 1 ]/ 16
) ) ) ;
right () ;
}
}
if ( ( tfm [4 * ( charbase + c ) + 1 ]% 16 ) > 0 ) {
if ( ( tfm [4 * ( charbase + c ) + 1 ]% 16 ) >= nd )
{
perfect = false ;
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
fprintf ( stderr , "%s%s", "Depth" , " index for character " ) ;
printoctal ( c ) ;
fprintf ( stderr , "%s\n", " is too large;" ) ;
fprintf ( stderr , "%s\n", "so I reset it to zero." ) ;
}
else {
left () ;
Fputs ( plfile , "CHARDP" ) ;
outfix ( 4 * ( depthbase + ( tfm [4 * ( charbase + c ) + 1 ]% 16 )
) ) ;
right () ;
}
}
if ( ( tfm [4 * ( charbase + c ) + 2 ]/ 4 ) > 0 ) {
if ( ( tfm [4 * ( charbase + c ) + 2 ]/ 4 ) >= ni )
{
perfect = false ;
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
fprintf ( stderr , "%s%s", "Italic correction" , " index for character " ) ;
printoctal ( c ) ;
fprintf ( stderr , "%s\n", " is too large;" ) ;
fprintf ( stderr , "%s\n", "so I reset it to zero." ) ;
}
else {
left () ;
Fputs ( plfile , "CHARIC" ) ;
outfix ( 4 * ( italicbase + ( tfm [4 * ( charbase + c ) + 2 ]/ 4 )
) ) ;
right () ;
}
}
switch ( ( tfm [4 * ( charbase + c ) + 2 ]% 4 ) )
{case 0 :
;
break ;
case 1 :
{
left () ;
Fputs ( plfile , "COMMENT" ) ;
outln () ;
i = tfm [4 * ( charbase + c ) + 3 ];
r = 4 * ( ligkernbase + ( i ) ) ;
if ( tfm [r ]> 128 )
i = 256 * tfm [r + 2 ]+ tfm [r + 3 ];
do {
{
k = 4 * ( ligkernbase + ( i ) ) ;
if ( tfm [k ]> 128 )
{
if ( 256 * tfm [k + 2 ]+ tfm [k + 3 ]>= nl )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s\n", "Bad TFM file: " , "Ligature unconditional stop command address is too big." )
;
}
}
else if ( tfm [k + 2 ]>= 128 )
{
if ( ( ( tfm [k + 1 ]< bc ) || ( tfm [k + 1 ]> ec ) || (
tfm [4 * ( charbase + tfm [k + 1 ]) ]== 0 ) ) ) {
if ( tfm [k + 1 ]!= boundarychar )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Kern step for" , " nonexistent character " ) ;
printoctal ( tfm [k + 1 ]) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
tfm [k + 1 ]= bc ;
}
}
left () ;
Fputs ( plfile , "KRN" ) ;
outchar ( tfm [k + 1 ]) ;
r = 256 * ( tfm [k + 2 ]- 128 ) + tfm [k + 3 ];
if ( r >= nk )
{
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s\n", "Bad TFM file: " , "Kern index too large." ) ;
}
Fputs ( plfile , " R 0.0" ) ;
}
else outfix ( 4 * ( kernbase + r ) ) ;
right () ;
}
else {
if ( ( ( tfm [k + 1 ]< bc ) || ( tfm [k + 1 ]> ec ) || (
tfm [4 * ( charbase + tfm [k + 1 ]) ]== 0 ) ) ) {
if ( tfm [k + 1 ]!= boundarychar )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Ligature step for" , " nonexistent character " ) ;
printoctal ( tfm [k + 1 ]) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
tfm [k + 1 ]= bc ;
}
}
if ( ( ( tfm [k + 3 ]< bc ) || ( tfm [k + 3 ]> ec ) || (
tfm [4 * ( charbase + tfm [k + 3 ]) ]== 0 ) ) )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Ligature step produces the" , " nonexistent character " ) ;
printoctal ( tfm [k + 3 ]) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
tfm [k + 3 ]= bc ;
}
left () ;
r = tfm [k + 2 ];
if ( ( r == 4 ) || ( ( r > 7 ) && ( r != 11 ) ) )
{
fprintf ( stderr , "%s\n", "Ligature step with nonstandard code changed to LIG" ) ;
r = 0 ;
tfm [k + 2 ]= 0 ;
}
if ( r % 4 > 1 )
putc ( '/' , plfile );
Fputs ( plfile , "LIG" ) ;
if ( odd ( r ) )
putc ( '/' , plfile );
while ( r > 3 ) {
putc ( '>' , plfile );
r = r - 4 ;
}
outchar ( tfm [k + 1 ]) ;
outchar ( tfm [k + 3 ]) ;
right () ;
}
if ( tfm [k ]> 0 ) {
if ( level == 1 )
{
if ( tfm [k ]>= 128 )
Fputs ( plfile , "(STOP)" ) ;
else {
count = 0 ;
{register integer for_end; ai = i + 1 ;for_end = i + tfm
[k ]; if ( ai <= for_end) do
if ( activity [ai ]== 2 )
count = count + 1 ;
while ( ai++ < for_end ) ;}
fprintf ( plfile , "%s%ld%c", "(SKIP D " , (long)count , ')' ) ;
}
outln () ;
}
}
}
if ( tfm [k ]>= 128 )
i = nl ;
else i = i + 1 + tfm [k ];
} while ( ! ( i >= nl ) ) ;
right () ;
}
break ;
case 2 :
{
r = tfm [4 * ( charbase + c ) + 3 ];
if ( ( ( r < bc ) || ( r > ec ) || ( tfm [4 * ( charbase + r ) ]==
0 ) ) )
{
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Character list link to" , " nonexistent character " ) ;
printoctal ( r ) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
}
tfm [4 * ( charbase + c ) + 2 ]= 4 * ( tfm [4 * ( charbase + c
) + 2 ]/ 4 ) + 0 ;
}
else {
while ( ( r < c ) && ( ( tfm [4 * ( charbase + r ) + 2 ]% 4 ) ==
2 ) ) r = tfm [4 * ( charbase + r ) + 3 ];
if ( r == c )
{
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s\n", "Bad TFM file: " , "Cycle in a character list!" ) ;
}
Fputs ( stderr , "Character " ) ;
printoctal ( c ) ;
fprintf ( stderr , "%s\n", " now ends the list." ) ;
tfm [4 * ( charbase + c ) + 2 ]= 4 * ( tfm [4 * ( charbase +
c ) + 2 ]/ 4 ) + 0 ;
}
else {
left () ;
Fputs ( plfile , "NEXTLARGER" ) ;
outchar ( tfm [4 * ( charbase + c ) + 3 ]) ;
right () ;
}
}
}
break ;
case 3 :
if ( tfm [4 * ( charbase + c ) + 3 ]>= ne )
{
{
perfect = false ;
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
fprintf ( stderr , "%s%s", "Extensible" , " index for character " ) ;
printoctal ( c ) ;
fprintf ( stderr , "%s\n", " is too large;" ) ;
fprintf ( stderr , "%s\n", "so I reset it to zero." ) ;
}
tfm [4 * ( charbase + c ) + 2 ]= 4 * ( tfm [4 * ( charbase + c )
+ 2 ]/ 4 ) + 0 ;
}
else {
left () ;
Fputs ( plfile , "VARCHAR" ) ;
outln () ;
{register integer for_end; k = 0 ;for_end = 3 ; if ( k <= for_end)
do
if ( ( k == 3 ) || ( tfm [4 * ( extenbase + tfm [4 * ( charbase
+ c ) + 3 ]) + k ]> 0 ) )
{
left () ;
switch ( k )
{case 0 :
Fputs ( plfile , "TOP" ) ;
break ;
case 1 :
Fputs ( plfile , "MID" ) ;
break ;
case 2 :
Fputs ( plfile , "BOT" ) ;
break ;
case 3 :
Fputs ( plfile , "REP" ) ;
break ;
}
if ( ( ( tfm [4 * ( extenbase + tfm [4 * ( charbase + c ) + 3
]) + k ]< bc ) || ( tfm [4 * ( extenbase + tfm [4 * (
charbase + c ) + 3 ]) + k ]> ec ) || ( tfm [4 * ( charbase +
tfm [4 * ( extenbase + tfm [4 * ( charbase + c ) + 3 ]) + k ]
) ]== 0 ) ) )
outchar ( c ) ;
else outchar ( tfm [4 * ( extenbase + tfm [4 * ( charbase + c
) + 3 ]) + k ]) ;
right () ;
}
while ( k++ < for_end ) ;}
right () ;
}
break ;
}
right () ;
}
while ( c++ < for_end ) ;}
}
static void
putchar(int c, int *state)
{
int xflag = 0;
Rune r;
int hi, lo;
switch(state[0]){
case Kanahi:
case GBhi:
if(CANS2JH(c) || c == 0xff){
state[0]++;
state[1] = c;
break;
}
/* fall through */
case Utf:
if(c == 0xfe){
state[0] = Kanahi;
break;
}else if(c == 0xff){
state[0] = GBhi;
break;
}
r = chartab[c];
if(r < 0x80 && state[2] == 0)
outchar(r);
else if(r == NONE){
switch(c){
case 0xfb:
if(!xflag){
state[2] = 1;
break;
}
case 0xfc:
if(!xflag){
state[2] = 0;
break;
}
case 0x10:
case 0xc7: case 0xc8:
case 0xd8: case 0xd9: case 0xda:
case 0xdc: case 0xdd: case 0xde: case 0xdf:
case 0xfd:
if(!xflag)
break;
/* fall through */
default:
outprint("\\%.2ux", c);
}
}else if(state[2] == 0)
outrune(r);
break;
case Kanalo:
case GBlo:
if(state[1] == 0xff && c == 0xff){
state[0] = Utf;
break;
}
state[0]--;
hi = state[1];
lo = c;
S2J(hi, lo); /* convert to JIS */
r = hi*100 + lo - 3232; /* convert to jis208 */
if(state[0] == Kanahi && r < JIS208MAX)
r = tabjis208[r];
else if(state[0] == GBhi && r < GB2312MAX)
r = tabgb2312[r];
else
r = NONE;
if(r == NONE)
outprint("\\%.2ux\\%.2ux", state[1], c);
else
outrune(r);
break;
}
}
/*
* cmd is one of:
* 'p': normal print
* 'h': just print headwords
* 'P': print raw
*/
void
pgwprintentry(Entry e, int cmd)
{
char *p, *pe;
int t;
long r, rprev, rlig;
Rune *transtab;
p = e.start;
pe = e.end;
transtab = normtab;
rprev = NONE;
changett(0, 0, 0);
curentry = e;
if(cmd == 'h')
outinhibit = 1;
while(p < pe) {
if(cmd == 'r') {
outchar(*p++);
continue;
}
r = transtab[(*p++)&0x7F];
if(r < NONE) {
/* Emit the rune, but buffer in case of ligature */
if(rprev != NONE)
outrune(rprev);
rprev = r;
} else if(r == SPCS) {
/* Start of special character name */
p = getspec(p, pe);
r = lookassoc(spectab, asize(spectab), spec);
if(r == -1) {
if(debug)
err("spec %ld %d %s",
e.doff, cursize, spec);
r = L'�';
}
if(r >= LIGS && r < LIGE) {
/* handle possible ligature */
rlig = liglookup(r, rprev);
if(rlig != NONE)
rprev = rlig; /* overwrite rprev */
else {
/* could print accent, but let's not */
if(rprev != NONE) outrune(rprev);
rprev = NONE;
}
} else if(r >= MULTI && r < MULTIE) {
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
outrunes(multitab[r-MULTI]);
} else if(r == PAR) {
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
outnl(1);
} else {
if(rprev != NONE) outrune(rprev);
rprev = r;
}
} else if(r == TAGS) {
/* Start of tag name */
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
p = gettag(p, pe);
t = lookassoc(tagtab, asize(tagtab), tag);
if(t == -1) {
if(debug)
err("tag %ld %d %s",
e.doff, cursize, tag);
continue;
}
switch(t) {
case Hw:
if(cmd == 'h') {
if(!tagstarts)
outchar(' ');
outinhibit = !tagstarts;
}
break;
case Sn:
if(tagstarts) {
outnl(2);
}
break;
case P:
outnl(tagstarts);
break;
case Col:
case Br:
case Blockquote:
if(tagstarts)
outnl(1);
break;
case U:
outchar('/');
}
}
}
if(cmd == 'h') {
outinhibit = 0;
outnl(0);
}
}
void sbbs_t::new_scan_cfg(ulong misc)
{
long s;
ulong i,j;
ulong t;
while(online) {
bputs(text[CfgGrpLstHdr]);
for(i=0;i<usrgrps && !msgabort();i++) {
checkline();
if(i<9) outchar(' ');
if(i<99) outchar(' ');
bprintf(text[CfgGrpLstFmt],i+1,cfg.grp[usrgrp[i]]->lname);
}
SYNC;
if(misc&SUB_CFG_NSCAN)
mnemonics(text[NScanCfgWhichGrp]);
else
mnemonics(text[SScanCfgWhichGrp]);
s=getnum(i);
if(s<1)
break;
i=s-1;
while(online) {
if(misc&SUB_CFG_NSCAN)
misc&=~SUB_CFG_YSCAN;
bprintf(text[CfgSubLstHdr],cfg.grp[usrgrp[i]]->lname);
for(j=0;j<usrsubs[i] && !msgabort();j++) {
checkline();
if(j<9) outchar(' ');
if(j<99) outchar(' ');
bprintf(text[CfgSubLstFmt],j+1
,cfg.sub[usrsub[i][j]]->lname
,subscan[usrsub[i][j]].cfg&misc ?
(misc&SUB_CFG_NSCAN && subscan[usrsub[i][j]].cfg&SUB_CFG_YSCAN) ?
"To You Only" : text[On] : text[Off]);
}
SYNC;
if(misc&SUB_CFG_NSCAN)
mnemonics(text[NScanCfgWhichSub]);
else
mnemonics(text[SScanCfgWhichSub]);
s=getkeys("AQ",usrsubs[i]);
if(sys_status&SS_ABORT) {
lncntr=0;
return;
}
if(!s || s==-1 || s=='Q')
break;
if(s=='A') {
t=subscan[usrsub[i][0]].cfg&misc;
if(misc&SUB_CFG_NSCAN && !t && !(useron.misc&FLAG('Q')))
if(!noyes("Messages to you only"))
misc|=SUB_CFG_YSCAN;
for(j=0;j<usrsubs[i] && online;j++) {
checkline();
if(t) subscan[usrsub[i][j]].cfg&=~misc;
else {
if(misc&SUB_CFG_NSCAN)
subscan[usrsub[i][j]].cfg&=~SUB_CFG_YSCAN;
subscan[usrsub[i][j]].cfg|=misc;
}
}
continue;
}
j=(s&~0x80000000L)-1;
if(misc&SUB_CFG_NSCAN && !(subscan[usrsub[i][j]].cfg&misc)) {
if(!(useron.rest&FLAG('Q')) && !noyes("Messages to you only"))
subscan[usrsub[i][j]].cfg|=SUB_CFG_YSCAN;
else
subscan[usrsub[i][j]].cfg&=~SUB_CFG_YSCAN;
}
subscan[usrsub[i][j]].cfg^=misc;
}
}
}
/*
* Write type into the output buffer.
*/
static void
outtype(type_t *tp)
{
int t, s, na;
tspec_t ts;
type_t **ap;
while (tp != NULL) {
if ((ts = tp->t_tspec) == INT && tp->t_isenum)
ts = ENUM;
switch (ts) {
case BOOL: t = 'B'; s = '\0'; break;
case CHAR: t = 'C'; s = '\0'; break;
case SCHAR: t = 'C'; s = 's'; break;
case UCHAR: t = 'C'; s = 'u'; break;
case SHORT: t = 'S'; s = '\0'; break;
case USHORT: t = 'S'; s = 'u'; break;
case INT: t = 'I'; s = '\0'; break;
case UINT: t = 'I'; s = 'u'; break;
case LONG: t = 'L'; s = '\0'; break;
case ULONG: t = 'L'; s = 'u'; break;
case QUAD: t = 'Q'; s = '\0'; break;
case UQUAD: t = 'Q'; s = 'u'; break;
case FLOAT: t = 'D'; s = 's'; break;
case DOUBLE: t = 'D'; s = '\0'; break;
case LDOUBLE: t = 'D'; s = 'l'; break;
case COMPLEX: t = 'X'; s = 's'; break;
case DCOMPLEX: t = 'X'; s = '\0'; break;
case LDCOMPLEX: t = 'X'; s = 'l'; break;
case IMAGINARY: t = 'J'; s = 's'; break;
case DIMAGINARY: t = 'J'; s = '\0'; break;
case LDIMAGINARY:t = 'J'; s = 'l'; break;
case VOID: t = 'V'; s = '\0'; break;
case PTR: t = 'P'; s = '\0'; break;
case ARRAY: t = 'A'; s = '\0'; break;
case ENUM: t = 'T'; s = 'e'; break;
case STRUCT: t = 'T'; s = 's'; break;
case UNION: t = 'T'; s = 'u'; break;
case FUNC:
if (tp->t_args != NULL && !tp->t_proto) {
t = 'f';
} else {
t = 'F';
}
s = '\0';
break;
default:
errx(1, "internal error: outtype() 1");
}
if (tp->t_const)
outchar('c');
if (tp->t_volatile)
outchar('v');
if (s != '\0')
outchar(s);
outchar(t);
if (ts == ARRAY) {
outint(tp->t_dim);
} else if (ts == ENUM || ts == STRUCT || ts == UNION) {
if (tp->t_istag) {
outint(1);
outname(tp->t_tag->h_name);
} else if (tp->t_istynam) {
outint(2);
outname(tp->t_tynam->h_name);
} else {
outint(0);
}
} else if (ts == FUNC && tp->t_args != NULL) {
na = 0;
for (ap = tp->t_args; *ap != NULL; ap++)
na++;
if (tp->t_vararg)
na++;
outint(na);
for (ap = tp->t_args; *ap != NULL; ap++)
outtype(*ap);
if (tp->t_vararg)
outchar('E');
}
tp = tp->t_subt;
}
}
/*
* extracts potential format specifiers for printf() and scanf() and
* writes them, enclosed in "" and qouted if necessary, to the output buffer
*/
static void
outfstrg(strg_t *strg)
{
int c, oc, first;
u_char *cp;
if (strg->st_tspec != CHAR)
lerror("outfstrg() 1");
cp = strg->st_cp;
outchar('"');
c = *cp++;
while (c != '\0') {
if (c != '%') {
c = *cp++;
continue;
}
outqchar('%');
c = *cp++;
/* flags for printf and scanf and *-fieldwidth for printf */
while (c != '\0' && (c == '-' || c == '+' || c == ' ' ||
c == '#' || c == '0' || c == '*')) {
outqchar(c);
c = *cp++;
}
/* numeric field width */
while (c != '\0' && isdigit(c)) {
outqchar(c);
c = *cp++;
}
/* precision for printf */
if (c == '.') {
outqchar(c);
if ((c = *cp++) == '*') {
outqchar(c);
c = *cp++;
} else {
while (c != '\0' && isdigit(c)) {
outqchar(c);
c = *cp++;
}
}
}
/* h, l, L and q flags fpr printf and scanf */
if (c == 'h' || c == 'l' || c == 'L' || c == 'q') {
outqchar(c);
c = *cp++;
}
/*
* The last character. It is always written so we can detect
* invalid format specifiers.
*/
if (c != '\0') {
outqchar(c);
oc = c;
c = *cp++;
/*
* handle [ for scanf. [-] means that a minus sign
* was found at an undefined position.
*/
if (oc == '[') {
if (c == '^')
c = *cp++;
if (c == ']')
c = *cp++;
first = 1;
while (c != '\0' && c != ']') {
if (c == '-') {
if (!first && *cp != ']')
outqchar(c);
}
first = 0;
c = *cp++;
}
if (c == ']') {
outqchar(c);
c = *cp++;
}
}
}
}
outchar('"');
}
int
__printf_fphex (FILE *fp,
const struct printf_info *info,
const void *const *args)
{
/* The floating-point value to output. */
union
{
union ieee754_double dbl;
long double ldbl;
}
fpnum;
/* Locale-dependent representation of decimal point. */
const char *decimal;
wchar_t decimalwc;
/* "NaN" or "Inf" for the special cases. */
const char *special = NULL;
const wchar_t *wspecial = NULL;
/* Buffer for the generated number string for the mantissa. The
maximal size for the mantissa is 128 bits. */
char numbuf[32];
char *numstr;
char *numend;
wchar_t wnumbuf[32];
wchar_t *wnumstr;
wchar_t *wnumend;
int negative;
/* The maximal exponent of two in decimal notation has 5 digits. */
char expbuf[5];
char *expstr;
wchar_t wexpbuf[5];
wchar_t *wexpstr;
int expnegative;
int exponent;
/* Non-zero is mantissa is zero. */
int zero_mantissa;
/* The leading digit before the decimal point. */
char leading;
/* Precision. */
int precision = info->prec;
/* Width. */
int width = info->width;
/* Number of characters written. */
int done = 0;
/* Nonzero if this is output on a wide character stream. */
int wide = info->wide;
/* Figure out the decimal point character. */
if (info->extra == 0)
{
decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
decimalwc = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC);
}
else
{
decimal = _NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT);
decimalwc = _NL_CURRENT_WORD (LC_MONETARY,
_NL_MONETARY_DECIMAL_POINT_WC);
}
/* The decimal point character must never be zero. */
assert (*decimal != '\0' && decimalwc != L'\0');
/* Fetch the argument value. */
#ifndef __NO_LONG_DOUBLE_MATH
if (info->is_long_double && sizeof (long double) > sizeof (double))
{
fpnum.ldbl = *(const long double *) args[0];
/* Check for special values: not a number or infinity. */
if (isnan (fpnum.ldbl))
{
if (isupper (info->spec))
{
special = "NAN";
wspecial = L"NAN";
}
else
{
special = "nan";
wspecial = L"nan";
}
}
else
{
if (isinf (fpnum.ldbl))
{
if (isupper (info->spec))
{
special = "INF";
wspecial = L"INF";
}
else
{
special = "inf";
wspecial = L"inf";
}
}
}
negative = signbit (fpnum.ldbl);
}
else
#endif /* no long double */
{
fpnum.dbl.d = *(const double *) args[0];
/* Check for special values: not a number or infinity. */
if (isnan (fpnum.dbl.d))
{
if (isupper (info->spec))
{
special = "NAN";
wspecial = L"NAN";
}
else
{
special = "nan";
wspecial = L"nan";
}
}
else
{
if (isinf (fpnum.dbl.d))
{
if (isupper (info->spec))
{
special = "INF";
wspecial = L"INF";
}
else
{
special = "inf";
wspecial = L"inf";
}
}
}
negative = signbit (fpnum.dbl.d);
}
if (special)
{
int width = info->width;
if (negative || info->showsign || info->space)
--width;
width -= 3;
if (!info->left && width > 0)
PADN (' ', width);
if (negative)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
PRINT (special, wspecial, 3);
if (info->left && width > 0)
PADN (' ', width);
return done;
}
if (info->is_long_double == 0 || sizeof (double) == sizeof (long double))
{
/* We have 52 bits of mantissa plus one implicit digit. Since
52 bits are representable without rest using hexadecimal
digits we use only the implicit digits for the number before
the decimal point. */
unsigned long long int num;
num = (((unsigned long long int) fpnum.dbl.ieee.mantissa0) << 32
| fpnum.dbl.ieee.mantissa1);
zero_mantissa = num == 0;
if (sizeof (unsigned long int) > 6)
{
wnumstr = _itowa_word (num, wnumbuf + (sizeof wnumbuf) / sizeof (wchar_t), 16,
info->spec == 'A');
numstr = _itoa_word (num, numbuf + sizeof numbuf, 16,
info->spec == 'A');
}
else
{
wnumstr = _itowa (num, wnumbuf + sizeof wnumbuf / sizeof (wchar_t), 16,
info->spec == 'A');
numstr = _itoa (num, numbuf + sizeof numbuf, 16,
info->spec == 'A');
}
/* Fill with zeroes. */
while (wnumstr > wnumbuf + (sizeof wnumbuf - 52) / sizeof (wchar_t))
{
*--wnumstr = L'0';
*--numstr = '0';
}
leading = fpnum.dbl.ieee.exponent == 0 ? '0' : '1';
exponent = fpnum.dbl.ieee.exponent;
if (exponent == 0)
{
if (zero_mantissa)
expnegative = 0;
else
{
/* This is a denormalized number. */
expnegative = 1;
exponent = IEEE754_DOUBLE_BIAS - 1;
}
}
else if (exponent >= IEEE754_DOUBLE_BIAS)
{
expnegative = 0;
exponent -= IEEE754_DOUBLE_BIAS;
}
else
{
expnegative = 1;
exponent = -(exponent - IEEE754_DOUBLE_BIAS);
}
}
#ifdef PRINT_FPHEX_LONG_DOUBLE
else
PRINT_FPHEX_LONG_DOUBLE;
#endif
/* Look for trailing zeroes. */
if (! zero_mantissa)
{
wnumend = &wnumbuf[sizeof wnumbuf / sizeof wnumbuf[0]];
numend = &numbuf[sizeof numbuf / sizeof numbuf[0]];
while (wnumend[-1] == L'0')
{
--wnumend;
--numend;
}
bool do_round_away = false;
if (precision != -1 && precision < numend - numstr)
{
char last_digit = precision > 0 ? numstr[precision - 1] : leading;
char next_digit = numstr[precision];
int last_digit_value = (last_digit >= 'A' && last_digit <= 'F'
? last_digit - 'A' + 10
: (last_digit >= 'a' && last_digit <= 'f'
? last_digit - 'a' + 10
: last_digit - '0'));
int next_digit_value = (next_digit >= 'A' && next_digit <= 'F'
? next_digit - 'A' + 10
: (next_digit >= 'a' && next_digit <= 'f'
? next_digit - 'a' + 10
: next_digit - '0'));
bool more_bits = ((next_digit_value & 7) != 0
|| precision + 1 < numend - numstr);
int rounding_mode = get_rounding_mode ();
do_round_away = round_away (negative, last_digit_value & 1,
next_digit_value >= 8, more_bits,
rounding_mode);
}
if (precision == -1)
precision = numend - numstr;
else if (do_round_away)
{
/* Round up. */
int cnt = precision;
while (--cnt >= 0)
{
char ch = numstr[cnt];
/* We assume that the digits and the letters are ordered
like in ASCII. This is true for the rest of GNU, too. */
if (ch == '9')
{
wnumstr[cnt] = (wchar_t) info->spec;
numstr[cnt] = info->spec; /* This is tricky,
think about it! */
break;
}
else if (tolower (ch) < 'f')
{
++numstr[cnt];
++wnumstr[cnt];
break;
}
else
{
numstr[cnt] = '0';
wnumstr[cnt] = L'0';
}
}
if (cnt < 0)
{
/* The mantissa so far was fff...f Now increment the
leading digit. Here it is again possible that we
get an overflow. */
if (leading == '9')
leading = info->spec;
else if (tolower (leading) < 'f')
++leading;
else
{
leading = '1';
if (expnegative)
{
exponent -= 4;
if (exponent <= 0)
{
exponent = -exponent;
expnegative = 0;
}
}
else
exponent += 4;
}
}
}
}
else
{
if (precision == -1)
precision = 0;
numend = numstr;
wnumend = wnumstr;
}
/* Now we can compute the exponent string. */
expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0);
wexpstr = _itowa_word (exponent,
wexpbuf + sizeof wexpbuf / sizeof (wchar_t), 10, 0);
/* Now we have all information to compute the size. */
width -= ((negative || info->showsign || info->space)
/* Sign. */
+ 2 + 1 + 0 + precision + 1 + 1
/* 0x h . hhh P ExpoSign. */
+ ((expbuf + sizeof expbuf) - expstr));
/* Exponent. */
/* Count the decimal point.
A special case when the mantissa or the precision is zero and the `#'
is not given. In this case we must not print the decimal point. */
if (precision > 0 || info->alt)
width -= wide ? 1 : strlen (decimal);
if (!info->left && info->pad != '0' && width > 0)
PADN (' ', width);
if (negative)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
outchar ('0');
if ('X' - 'A' == 'x' - 'a')
outchar (info->spec + ('x' - 'a'));
else
outchar (info->spec == 'A' ? 'X' : 'x');
if (!info->left && info->pad == '0' && width > 0)
PADN ('0', width);
outchar (leading);
if (precision > 0 || info->alt)
{
const wchar_t *wtmp = &decimalwc;
PRINT (decimal, wtmp, wide ? 1 : strlen (decimal));
}
if (precision > 0)
{
ssize_t tofill = precision - (numend - numstr);
PRINT (numstr, wnumstr, MIN (numend - numstr, precision));
if (tofill > 0)
PADN ('0', tofill);
}
if ('P' - 'A' == 'p' - 'a')
outchar (info->spec + ('p' - 'a'));
else
outchar (info->spec == 'A' ? 'P' : 'p');
outchar (expnegative ? '-' : '+');
PRINT (expstr, wexpstr, (expbuf + sizeof expbuf) - expstr);
if (info->left && info->pad != '0' && width > 0)
PADN (info->pad, width);
return done;
}
/*
* write information about function definition
*
* this is also done for static functions so we are able to check if
* they are called with proper argument types
*/
void
outfdef(sym_t *fsym, pos_t *posp, int rval, int osdef, sym_t *args)
{
int narg;
sym_t *arg;
/* reset the buffer */
outclr();
/*
* line number of .c source, 'd' for declaration, Id of current
* source (.c or .h), and line in current source
*
* we are already at the end of the function. If we are in the
* .c source, posp->p_line is correct, otherwise csrc_pos.p_line
* (for functions defined in header files).
*/
if (posp->p_file == csrc_pos.p_file) {
outint(posp->p_line);
} else {
outint(csrc_pos.p_line);
}
outchar('d');
outint(getfnid(posp->p_file));
outchar('.');
outint(posp->p_line);
/* flags */
/* both SCANFLIKE and PRINTFLIKE imply VARARGS */
if (prflstrg != -1) {
nvararg = prflstrg;
} else if (scflstrg != -1) {
nvararg = scflstrg;
}
if (nvararg != -1) {
outchar('v');
outint(nvararg);
}
if (scflstrg != -1) {
outchar('S');
outint(scflstrg);
}
if (prflstrg != -1) {
outchar('P');
outint(prflstrg);
}
nvararg = prflstrg = scflstrg = -1;
outchar('d');
if (rval)
/* has return value */
outchar('r');
if (llibflg)
/*
* mark it as used so lint2 does not complain about
* unused symbols in libraries
*/
outchar('u');
if (osdef)
/* old style function definition */
outchar('o');
if (fsym->s_scl == STATIC)
outchar('s');
/* name of function */
outname(fsym->s_name);
/* renamed name of function, if necessary */
if (fsym->s_rename) {
outchar('r');
outname(fsym->s_rename);
}
/* argument types and return value */
if (osdef) {
narg = 0;
for (arg = args; arg != NULL; arg = arg->s_nxt)
narg++;
outchar('f');
outint(narg);
for (arg = args; arg != NULL; arg = arg->s_nxt)
outtype(arg->s_type);
outtype(fsym->s_type->t_subt);
} else {
outtype(fsym->s_type);
}
}
/*
* write out all information necessary for lint2 to check function
* calls
*
* rvused is set if the return value is used (asigned to a variable)
* rvdisc is set if the return value is not used and not ignored
* (casted to void)
*/
void
outcall(tnode_t *tn, int rvused, int rvdisc)
{
tnode_t *args, *arg;
int narg, n, i;
int64_t q;
tspec_t t;
/* reset buffer */
outclr();
/*
* line number of .c source, 'c' for function call, Id of current
* source (.c or .h), and line in current source
*/
outint(csrc_pos.p_line);
outchar('c');
outint(getfnid(curr_pos.p_file));
outchar('.');
outint(curr_pos.p_line);
/*
* flags; 'u' and 'i' must be last to make sure a letter
* is between the numeric argument of a flag and the name of
* the function
*/
narg = 0;
args = tn->tn_right;
for (arg = args; arg != NULL; arg = arg->tn_right)
narg++;
/* informations about arguments */
for (n = 1; n <= narg; n++) {
/* the last argument is the top one in the tree */
for (i = narg, arg = args; i > n; i--, arg = arg->tn_right)
continue;
arg = arg->tn_left;
if (arg->tn_op == CON) {
if (isityp(t = arg->tn_type->t_tspec)) {
/*
* XXX it would probably be better to
* explizitly test the sign
*/
if ((q = arg->tn_val->v_quad) == 0) {
/* zero constant */
outchar('z');
} else if (msb(q, t, 0) == 0) {
/* positive if casted to signed */
outchar('p');
} else {
/* negative if casted to signed */
outchar('n');
}
outint(n);
}
} else if (arg->tn_op == AMPER &&
arg->tn_left->tn_op == STRING &&
arg->tn_left->tn_strg->st_tspec == CHAR) {
/* constant string, write all format specifiers */
outchar('s');
outint(n);
outfstrg(arg->tn_left->tn_strg);
}
}
/* return value discarded/used/ignored */
outchar(rvdisc ? 'd' : (rvused ? 'u' : 'i'));
/* name of the called function */
outname(tn->tn_left->tn_left->tn_sym->s_name);
/* types of arguments */
outchar('f');
outint(narg);
for (n = 1; n <= narg; n++) {
/* the last argument is the top one in the tree */
for (i = narg, arg = args; i > n; i--, arg = arg->tn_right)
continue;
outtype(arg->tn_left->tn_type);
}
/* expected type of return value */
outtype(tn->tn_type);
}
/*
* write information about a global declared/defined symbol
* with storage class extern
*
* informations about function definitions are written in outfdef(),
* not here
*/
void
outsym(sym_t *sym, scl_t sc, def_t def)
{
/*
* Static function declarations must also be written to the output
* file. Compatibility of function declarations (for both static
* and extern functions) must be checked in lint2. Lint1 can't do
* this, especially not, if functions are declared at block level
* before their first declaration at level 0.
*/
if (sc != EXTERN && !(sc == STATIC && sym->s_type->t_tspec == FUNC))
return;
/* reset buffer */
outclr();
/*
* line number of .c source, 'd' for declaration, Id of current
* source (.c or .h), and line in current source.
*/
outint(csrc_pos.p_line);
outchar('d');
outint(getfnid(sym->s_dpos.p_file));
outchar('.');
outint(sym->s_dpos.p_line);
/* flags */
switch (def) {
case DEF:
/* defined */
outchar('d');
break;
case TDEF:
/* tentative defined */
outchar('t');
break;
case DECL:
/* declared */
outchar('e');
break;
default:
lerror("outsym() 2");
}
if (llibflg && def != DECL) {
/*
* mark it as used so we get no warnings from lint2 about
* unused symbols in libraries.
*/
outchar('u');
}
if (sc == STATIC)
outchar('s');
/* name of the symbol */
outname(sym->s_name);
/* renamed name of symbol, if necessary */
if (sym->s_rename) {
outchar('r');
outname(sym->s_rename);
}
/* type of the symbol */
outtype(sym->s_type);
}
bool sbbs_t::pack_qwk(char *packet, ulong *msgcnt, bool prepack)
{
char str[MAX_PATH+1],ch,*p;
char tmp[MAX_PATH+1],tmp2[MAX_PATH+1];
char* fname;
char* fmode;
int mode;
uint i,j,k,conf;
long l,size,msgndx,posts,ex;
long mailmsgs=0;
ulong totalcdt,totaltime,lastmsg
,files,submsgs,msgs,netfiles=0,preqwk=0;
ulong subs_scanned=0;
float f; /* Sparky is responsible */
time_t start;
node_t node;
mail_t *mail;
post_t *post;
glob_t g;
FILE *stream,*qwk,*personal,*ndx;
DIR* dir;
DIRENT* dirent;
struct tm tm;
smbmsg_t msg;
ex=EX_OUTL|EX_OUTR; /* Need sh for wildcard expansion */
if(prepack)
ex|=EX_OFFLINE;
delfiles(cfg.temp_dir,ALLFILES);
sprintf(str,"%sfile/%04u.qwk",cfg.data_dir,useron.number);
if(fexistcase(str)) {
for(k=0;k<cfg.total_fextrs;k++)
if(!stricmp(cfg.fextr[k]->ext,useron.tmpext)
&& chk_ar(cfg.fextr[k]->ar,&useron))
break;
if(k>=cfg.total_fextrs)
k=0;
p=cmdstr(cfg.fextr[k]->cmd,str,ALLFILES,NULL);
if((i=external(p,ex))==0)
preqwk=1;
else
errormsg(WHERE,ERR_EXEC,p,i);
}
if(useron.rest&FLAG('Q') && useron.qwk&QWK_RETCTLA)
useron.qwk|=(QWK_NOINDEX|QWK_NOCTRL|QWK_VIA|QWK_TZ|QWK_MSGID);
if(useron.qwk&QWK_EXPCTLA)
mode=A_EXPAND;
else if(useron.qwk&QWK_RETCTLA)
mode=A_LEAVE;
else mode=0;
if(useron.qwk&QWK_TZ)
mode|=QM_TZ;
if(useron.qwk&QWK_VIA)
mode|=QM_VIA;
if(useron.qwk&QWK_MSGID)
mode|=QM_MSGID;
(*msgcnt)=0L;
if(/* !prepack && */ !(useron.qwk&QWK_NOCTRL)) {
/***************************/
/* Create CONTROL.DAT file */
/***************************/
sprintf(str,"%sCONTROL.DAT",cfg.temp_dir);
if((stream=fopen(str,"wb"))==NULL) {
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
now=time(NULL);
if(localtime_r(&now,&tm)==NULL)
return(false);
fprintf(stream,"%s\r\n%s\r\n%s\r\n%s, Sysop\r\n0000,%s\r\n"
"%02u-%02u-%u,%02u:%02u:%02u\r\n"
,cfg.sys_name
,cfg.sys_location
,cfg.node_phone
,cfg.sys_op
,cfg.sys_id
,tm.tm_mon+1,tm.tm_mday,tm.tm_year+1900
,tm.tm_hour,tm.tm_min,tm.tm_sec);
k=0;
for(i=0;i<usrgrps;i++)
for(j=0;j<usrsubs[i];j++)
k++; /* k is how many subs */
fprintf(stream,"%s\r\n\r\n0\r\n0\r\n%u\r\n",useron.alias,k);
fprintf(stream,"0\r\nE-mail\r\n"); /* first conference is e-mail */
char confname[256];
for(i=0;i<usrgrps;i++)
for(j=0;j<usrsubs[i];j++) {
if(useron.qwk&QWK_EXT) /* 255 char max */
sprintf(confname,"%s %s"
,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
,cfg.sub[usrsub[i][j]]->lname);
else /* 10 char max */
strcpy(confname,cfg.sub[usrsub[i][j]]->qwkname);
fprintf(stream,"%u\r\n%s\r\n"
,cfg.sub[usrsub[i][j]]->qwkconf ? cfg.sub[usrsub[i][j]]->qwkconf
: ((i+1)*1000)+j+1,confname);
}
fprintf(stream,"HELLO\r\nBBSNEWS\r\nGOODBYE\r\n");
fclose(stream);
/***********************/
/* Create DOOR.ID File */
/***********************/
sprintf(str,"%sDOOR.ID",cfg.temp_dir);
if((stream=fopen(str,"wb"))==NULL) {
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
p="CONTROLTYPE = ";
fprintf(stream,"DOOR = %.10s\r\nVERSION = %s%c\r\n"
"SYSTEM = %s\r\n"
"CONTROLNAME = SBBS\r\n"
"%sADD\r\n"
"%sDROP\r\n"
"%sYOURS\r\n"
"%sRESET\r\n"
"%sRESETALL\r\n"
"%sFILES\r\n"
"%sATTACH\r\n"
"%sOWN\r\n"
"%smail\r\n"
"%sDELMAIL\r\n"
"%sCTRL-A\r\n"
"%sFREQ\r\n"
"%sNDX\r\n"
"%sTZ\r\n"
"%sVIA\r\n"
"%sCONTROL\r\n"
"MIXEDCASE = YES\r\n"
,VERSION_NOTICE
,VERSION,REVISION
,VERSION_NOTICE
,p,p,p,p
,p,p,p,p
,p,p,p,p
,p,p,p,p
);
fclose(stream);
if(useron.rest&FLAG('Q')) {
/***********************/
/* Create NETFLAGS.DAT */
/***********************/
sprintf(str,"%sNETFLAGS.DAT",cfg.temp_dir);
if((stream=fopen(str,"wb"))==NULL) {
errormsg(WHERE,ERR_CREATE,str,0);
return(false);
}
ch=1; /* Net enabled */
if(usrgrps)
for(i=0;i<(usrgrps*1000)+usrsubs[usrgrps-1];i++)
fputc(ch,stream);
fclose(stream);
}
}
/****************************************************/
/* Create MESSAGES.DAT, write header and leave open */
/****************************************************/
sprintf(str,"%sMESSAGES.DAT",cfg.temp_dir);
if(fexistcase(str))
fmode="r+b";
else
fmode="w+b";
if((qwk=fopen(str,fmode))==NULL) {
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
l=filelength(fileno(qwk));
if(l<1) {
fprintf(qwk,"%-128.128s","Produced by " VERSION_NOTICE " " COPYRIGHT_NOTICE);
msgndx=1;
} else {
msgndx=l/QWK_BLOCK_LEN;
fseek(qwk,0,SEEK_END);
}
sprintf(str,"%sNEWFILES.DAT",cfg.temp_dir);
remove(str);
if(!(useron.rest&FLAG('T')) && useron.qwk&QWK_FILES)
files=create_filelist("NEWFILES.DAT",FL_ULTIME);
else
files=0;
start=time(NULL);
if(useron.rest&FLAG('Q'))
useron.qwk|=(QWK_EMAIL|QWK_ALLMAIL|QWK_DELMAIL);
if(!(useron.qwk&QWK_NOINDEX)) {
sprintf(str,"%sPERSONAL.NDX",cfg.temp_dir);
if((personal=fopen(str,"ab"))==NULL) {
fclose(qwk);
errormsg(WHERE,ERR_OPEN,str,0);
return(false);
}
}
else
personal=NULL;
if(useron.qwk&(QWK_EMAIL|QWK_ALLMAIL) /* && !prepack */) {
sprintf(smb.file,"%smail",cfg.data_dir);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=INVALID_SUB;
if((i=smb_open(&smb))!=0) {
fclose(qwk);
if(personal)
fclose(personal);
errormsg(WHERE,ERR_OPEN,smb.file,i,smb.last_error);
return(false);
}
/***********************/
/* Pack E-mail, if any */
/***********************/
qwkmail_last=0;
mail=loadmail(&smb,&mailmsgs,useron.number,0,useron.qwk&QWK_ALLMAIL ? 0
: LM_UNREAD);
if(mailmsgs && !(sys_status&SS_ABORT)) {
bputs(text[QWKPackingEmail]);
if(!(useron.qwk&QWK_NOINDEX)) {
sprintf(str,"%s000.NDX",cfg.temp_dir);
if((ndx=fopen(str,"ab"))==NULL) {
fclose(qwk);
if(personal)
fclose(personal);
smb_close(&smb);
errormsg(WHERE,ERR_OPEN,str,0);
free(mail);
return(false);
}
}
else
ndx=NULL;
if(useron.rest&FLAG('Q'))
mode|=QM_TO_QNET;
else
mode&=~QM_TO_QNET;
for(l=0;l<mailmsgs;l++) {
bprintf("\b\b\b\b\b\b\b\b\b\b\b\b%4lu of %-4lu"
,l+1,mailmsgs);
memset(&msg,0,sizeof(msg));
msg.idx=mail[l];
if(msg.idx.number>qwkmail_last)
qwkmail_last=msg.idx.number;
if(!loadmsg(&msg,mail[l].number))
continue;
if(msg.hdr.auxattr&MSG_FILEATTACH && useron.qwk&QWK_ATTACH) {
sprintf(str,"%sfile/%04u.in/%s"
,cfg.data_dir,useron.number,msg.subj);
sprintf(tmp,"%s%s",cfg.temp_dir,msg.subj);
if(fexistcase(str) && !fexistcase(tmp))
mv(str,tmp,1);
}
size=msgtoqwk(&msg,qwk,mode,INVALID_SUB,0);
smb_unlockmsghdr(&smb,&msg);
smb_freemsgmem(&msg);
if(ndx) {
msgndx++;
f=ltomsbin(msgndx); /* Record number */
ch=0; /* Sub number, not used */
if(personal) {
fwrite(&f,4,1,personal);
fwrite(&ch,1,1,personal);
}
fwrite(&f,4,1,ndx);
fwrite(&ch,1,1,ndx);
msgndx+=size/QWK_BLOCK_LEN;
}
YIELD(); /* yield */
}
bprintf(text[QWKPackedEmail],mailmsgs);
if(ndx)
fclose(ndx);
}
smb_close(&smb); /* Close the e-mail */
if(mailmsgs)
free(mail);
}
/*********************/
/* Pack new messages */
/*********************/
for(i=0;i<usrgrps;i++) {
for(j=0;j<usrsubs[i] && !msgabort();j++) {
if(subscan[usrsub[i][j]].cfg&SUB_CFG_NSCAN
|| (!(useron.rest&FLAG('Q'))
&& cfg.sub[usrsub[i][j]]->misc&SUB_FORCED)) {
if(!chk_ar(cfg.sub[usrsub[i][j]]->read_ar,&useron))
continue;
lncntr=0; /* defeat pause */
if(useron.rest&FLAG('Q') && !(cfg.sub[usrsub[i][j]]->misc&SUB_QNET))
continue; /* QWK Net Node and not QWK networked, so skip */
subs_scanned++;
msgs=getlastmsg(usrsub[i][j],&lastmsg,0);
if(!msgs || lastmsg<=subscan[usrsub[i][j]].ptr) { /* no msgs */
if(subscan[usrsub[i][j]].ptr>lastmsg) { /* corrupted ptr */
outchar('*');
subscan[usrsub[i][j]].ptr=lastmsg; /* so fix automatically */
subscan[usrsub[i][j]].last=lastmsg;
}
bprintf(text[NScanStatusFmt]
,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
,cfg.sub[usrsub[i][j]]->lname,0L,msgs);
continue;
}
sprintf(smb.file,"%s%s"
,cfg.sub[usrsub[i][j]]->data_dir,cfg.sub[usrsub[i][j]]->code);
smb.retry_time=cfg.smb_retry_time;
smb.subnum=usrsub[i][j];
if((k=smb_open(&smb))!=0) {
errormsg(WHERE,ERR_OPEN,smb.file,k,smb.last_error);
continue;
}
k=0;
if(useron.qwk&QWK_BYSELF)
k|=LP_BYSELF;
if(useron.rest&FLAG('Q') || !(subscan[usrsub[i][j]].cfg&SUB_CFG_YSCAN))
k|=LP_OTHERS;
post=loadposts(&posts,usrsub[i][j],subscan[usrsub[i][j]].ptr,k);
bprintf(text[NScanStatusFmt]
,cfg.grp[cfg.sub[usrsub[i][j]]->grp]->sname
,cfg.sub[usrsub[i][j]]->lname,posts,msgs);
if(!posts) { /* no new messages */
smb_close(&smb);
continue;
}
bputs(text[QWKPackingSubboard]);
submsgs=0;
conf=cfg.sub[usrsub[i][j]]->qwkconf;
if(!conf)
conf=((i+1)*1000)+j+1;
if(!(useron.qwk&QWK_NOINDEX)) {
sprintf(str,"%s%u.NDX",cfg.temp_dir,conf);
if((ndx=fopen(str,"ab"))==NULL) {
fclose(qwk);
if(personal)
fclose(personal);
smb_close(&smb);
errormsg(WHERE,ERR_OPEN,str,0);
free(post);
return(false);
}
}
else
ndx=NULL;
for(l=0;l<posts && !msgabort();l++) {
bprintf("\b\b\b\b\b%-5lu",l+1);
subscan[usrsub[i][j]].ptr=post[l].number; /* set ptr */
subscan[usrsub[i][j]].last=post[l].number; /* set last read */
memset(&msg,0,sizeof(msg));
msg.idx=post[l];
if(!loadmsg(&msg,post[l].number))
continue;
if(useron.rest&FLAG('Q')) {
if(msg.from_net.type && msg.from_net.type!=NET_QWK &&
!(cfg.sub[usrsub[i][j]]->misc&SUB_GATE)) { /* From other */
smb_freemsgmem(&msg); /* net, don't gate */
smb_unlockmsghdr(&smb,&msg);
continue;
}
mode|=(QM_TO_QNET|QM_TAGLINE);
if(msg.from_net.type==NET_QWK) {
mode&=~QM_TAGLINE;
if(route_circ((char *)msg.from_net.addr,useron.alias)
|| !strnicmp(msg.subj,"NE:",3)) {
smb_freemsgmem(&msg);
smb_unlockmsghdr(&smb,&msg);
continue;
}
}
}
else
mode&=~(QM_TAGLINE|QM_TO_QNET);
size=msgtoqwk(&msg,qwk,mode,usrsub[i][j],conf);
smb_unlockmsghdr(&smb,&msg);
if(ndx) {
msgndx++;
f=ltomsbin(msgndx); /* Record number */
ch=0; /* Sub number, not used */
if(personal
&& (!stricmp(msg.to,useron.alias)
|| !stricmp(msg.to,useron.name))) {
fwrite(&f,4,1,personal);
fwrite(&ch,1,1,personal);
}
fwrite(&f,4,1,ndx);
fwrite(&ch,1,1,ndx);
msgndx+=size/QWK_BLOCK_LEN;
}
smb_freemsgmem(&msg);
(*msgcnt)++;
submsgs++;
if(cfg.max_qwkmsgs
&& !(useron.exempt&FLAG('O')) && (*msgcnt)>=cfg.max_qwkmsgs) {
bputs(text[QWKmsgLimitReached]);
break;
}
if(!(l%50))
YIELD(); /* yield */
}
if(!(sys_status&SS_ABORT))
bprintf(text[QWKPackedSubboard],submsgs,(*msgcnt));
if(ndx) {
fclose(ndx);
sprintf(str,"%s%u.NDX",cfg.temp_dir,conf);
if(!flength(str))
remove(str);
}
smb_close(&smb);
free(post);
if(l<posts)
break;
YIELD(); /* yield */
}
}
if(j<usrsubs[i]) /* if sub aborted, abort all */
break;
}
if(online==ON_LOCAL) /* event */
eprintf(LOG_INFO,"%s scanned %lu sub-boards for new messages"
,useron.alias,subs_scanned);
else
lprintf(LOG_INFO,"Node %d %s scanned %lu sub-boards for new messages"
,cfg.node_num,useron.alias,subs_scanned);
if((*msgcnt)+mailmsgs && time(NULL)-start) {
bprintf("\r\n\r\n\1n\1hPacked %lu messages (%lu bytes) in %lu seconds "
"(%lu messages/second)."
,(*msgcnt)+mailmsgs
,ftell(qwk)
,time(NULL)-start
,((*msgcnt)+mailmsgs)/(time(NULL)-start));
sprintf(str,"Packed %lu messages (%lu bytes) in %lu seconds (%lu msgs/sec)"
,(*msgcnt)+mailmsgs
,ftell(qwk)
,(ulong)(time(NULL)-start)
,((*msgcnt)+mailmsgs)/(time(NULL)-start));
if(online==ON_LOCAL) /* event */
eprintf(LOG_INFO,"%s",str);
else
lprintf(LOG_INFO,"%s",str);
}
fclose(qwk); /* close MESSAGE.DAT */
if(personal) {
fclose(personal); /* close PERSONAL.NDX */
sprintf(str,"%sPERSONAL.NDX",cfg.temp_dir);
if(!flength(str))
remove(str);
}
CRLF;
if(!prepack && (sys_status&SS_ABORT || !online))
return(false);
if(/*!prepack && */ useron.rest&FLAG('Q')) { /* If QWK Net node, check for files */
sprintf(str,"%sqnet/%s.out/",cfg.data_dir,useron.alias);
dir=opendir(str);
while(dir!=NULL && (dirent=readdir(dir))!=NULL) { /* Move files into temp dir */
sprintf(str,"%sqnet/%s.out/%s",cfg.data_dir,useron.alias,dirent->d_name);
if(isdir(str))
continue;
sprintf(tmp2,"%s%s",cfg.temp_dir,dirent->d_name);
lncntr=0; /* Default pause */
if(online==ON_LOCAL)
eprintf(LOG_INFO,"Including %s in packet",str);
else
lprintf(LOG_INFO,"Including %s in packet",str);
bprintf(text[RetrievingFile],str);
if(!mv(str,tmp2,1))
netfiles++;
}
if(dir!=NULL)
closedir(dir);
if(netfiles)
CRLF;
}
if(batdn_total) {
for(i=0,totalcdt=0;i<batdn_total;i++)
if(!is_download_free(&cfg,batdn_dir[i],&useron))
totalcdt+=batdn_cdt[i];
if(totalcdt>useron.cdt+useron.freecdt) {
bprintf(text[YouOnlyHaveNCredits]
,ultoac(useron.cdt+useron.freecdt,tmp));
}
else {
for(i=0,totaltime=0;i<batdn_total;i++) {
if(!(cfg.dir[batdn_dir[i]]->misc&DIR_TFREE) && cur_cps)
totaltime+=batdn_size[i]/(ulong)cur_cps;
}
if(!(useron.exempt&FLAG('T')) && !SYSOP && totaltime>timeleft)
bputs(text[NotEnoughTimeToDl]);
else {
for(i=0;i<batdn_total;i++) {
lncntr=0;
unpadfname(batdn_name[i],tmp);
sprintf(tmp2,"%s%s",cfg.temp_dir,tmp);
if(!fexistcase(tmp2)) {
seqwait(cfg.dir[batdn_dir[i]]->seqdev);
bprintf(text[RetrievingFile],tmp);
sprintf(str,"%s%s"
,batdn_alt[i]>0 && batdn_alt[i]<=cfg.altpaths
? cfg.altpath[batdn_alt[i]-1]
: cfg.dir[batdn_dir[i]]->path
,tmp);
mv(str,tmp2,1); /* copy the file to temp dir */
getnodedat(cfg.node_num,&thisnode,1);
thisnode.aux=0xfe;
putnodedat(cfg.node_num,&thisnode);
CRLF;
}
}
}
}
}
if(!(*msgcnt) && !mailmsgs && !files && !netfiles && !batdn_total
&& (prepack || !preqwk)) {
bputs(text[QWKNoNewMessages]);
return(false);
}
if(!(useron.rest&FLAG('Q'))) { /* Don't include in network */
/***********************/ /* packets */
/* Copy QWK Text files */
/***********************/
sprintf(str,"%sQWK/HELLO",cfg.text_dir);
if(fexistcase(str)) {
sprintf(tmp2,"%sHELLO",cfg.temp_dir);
mv(str,tmp2,1);
}
sprintf(str,"%sQWK/BBSNEWS",cfg.text_dir);
if(fexistcase(str)) {
sprintf(tmp2,"%sBBSNEWS",cfg.temp_dir);
mv(str,tmp2,1);
}
sprintf(str,"%sQWK/GOODBYE",cfg.text_dir);
if(fexistcase(str)) {
sprintf(tmp2,"%sGOODBYE",cfg.temp_dir);
mv(str,tmp2,1);
}
sprintf(str,"%sQWK/BLT-*",cfg.text_dir);
glob(str,0,NULL,&g);
for(i=0;i<(uint)g.gl_pathc;i++) { /* Copy BLT-*.* files */
fname=getfname(g.gl_pathv[i]);
padfname(fname,str);
if(isdigit(str[4]) && isdigit(str[9])) {
sprintf(str,"%sQWK/%s",cfg.text_dir,fname);
sprintf(tmp2,"%s%s",cfg.temp_dir,fname);
mv(str,tmp2,1);
}
}
globfree(&g);
}
if(prepack) {
for(i=1;i<=cfg.sys_nodes;i++) {
getnodedat(i,&node,0);
if((node.status==NODE_INUSE || node.status==NODE_QUIET
|| node.status==NODE_LOGON) && node.useron==useron.number)
break;
}
if(i<=cfg.sys_nodes) /* Don't pre-pack with user online */
return(false);
}
/*******************/
/* Compress Packet */
/*******************/
sprintf(tmp2,"%s%s",cfg.temp_dir,ALLFILES);
i=external(cmdstr(temp_cmd(),packet,tmp2,NULL)
,ex|EX_WILDCARD);
if(!fexist(packet)) {
bputs(text[QWKCompressionFailed]);
if(i)
errormsg(WHERE,ERR_EXEC,cmdstr(temp_cmd(),packet,tmp2,NULL),i);
else
errorlog("Couldn't compress QWK packet");
return(false);
}
if(prepack) /* Early return if pre-packing */
return(true);
l=flength(packet);
sprintf(str,"%s.qwk",cfg.sys_id);
bprintf(text[FiFilename],str);
bprintf(text[FiFileSize],ultoac(l,tmp));
if(l>0L && cur_cps)
i=l/(ulong)cur_cps;
else
i=0;
bprintf(text[FiTransferTime],sectostr(i,tmp));
CRLF;
if(!(useron.exempt&FLAG('T')) && i>timeleft) {
bputs(text[NotEnoughTimeToDl]);
return(false);
}
if(useron.rest&FLAG('Q')) {
sprintf(str,"%s.qwk",cfg.sys_id);
dir=opendir(cfg.temp_dir);
while(dir!=NULL && (dirent=readdir(dir))!=NULL) {
if(!stricmp(str,dirent->d_name)) /* QWK packet */
continue;
sprintf(tmp,"%s%s",cfg.temp_dir,dirent->d_name);
if(!isdir(tmp))
remove(tmp);
}
if(dir!=NULL)
closedir(dir);
}
return(true);
}
void
dmk_outstring(char *string)
{
while (*string != '\0')
outchar(*string++);
}
void mainbody( void ) {
initialize () ;
if ( ! organize () )
uexit ( 1 ) ;
dosimplethings () ;
if ( nl > 0 )
{
{register integer for_end; ai = 0 ;for_end = nl - 1 ; if ( ai <=
for_end) do
activity [ai ]= 0 ;
while ( ai++ < for_end ) ;}
if ( tfm [4 * ( ligkernbase + ( 0 ) ) ]== 255 )
{
left () ;
Fputs ( plfile , "BOUNDARYCHAR" ) ;
boundarychar = tfm [4 * ( ligkernbase + ( 0 ) ) + 1 ];
outchar ( boundarychar ) ;
right () ;
activity [0 ]= 1 ;
}
if ( tfm [4 * ( ligkernbase + ( nl - 1 ) ) ]== 255 )
{
r = 256 * tfm [4 * ( ligkernbase + ( nl - 1 ) ) + 2 ]+ tfm [4 * (
ligkernbase + ( nl - 1 ) ) + 3 ];
if ( r >= nl )
{
perfect = false ;
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
Fputs ( stderr , "Ligature/kern starting index for boundarychar is too large;" ) ;
fprintf ( stderr , "%s\n", "so I removed it." ) ;
}
else {
labelptr = 1 ;
labeltable [1 ].cc = 256 ;
labeltable [1 ].rr = r ;
bcharlabel = r ;
activity [r ]= 2 ;
}
activity [nl - 1 ]= 1 ;
}
}
{register integer for_end; c = bc ;for_end = ec ; if ( c <= for_end) do
if ( ( tfm [4 * ( charbase + c ) + 2 ]% 4 ) == 1 )
{
r = tfm [4 * ( charbase + c ) + 3 ];
if ( r < nl )
{
if ( tfm [4 * ( ligkernbase + ( r ) ) ]> 128 )
{
r = 256 * tfm [4 * ( ligkernbase + ( r ) ) + 2 ]+ tfm [4 * (
ligkernbase + ( r ) ) + 3 ];
if ( r < nl ) {
if ( activity [tfm [4 * ( charbase + c ) + 3 ]]== 0 )
activity [tfm [4 * ( charbase + c ) + 3 ]]= 1 ;
}
}
}
if ( r >= nl )
{
perfect = false ;
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
Fputs ( stderr , "Ligature/kern starting index for character " ) ;
printoctal ( c ) ;
fprintf ( stderr , "%s\n", " is too large;" ) ;
fprintf ( stderr , "%s\n", "so I removed it." ) ;
tfm [4 * ( charbase + c ) + 2 ]= 4 * ( tfm [4 * ( charbase + c ) +
2 ]/ 4 ) + 0 ;
}
else {
sortptr = labelptr ;
while ( labeltable [sortptr ].rr > r ) {
labeltable [sortptr + 1 ]= labeltable [sortptr ];
sortptr = sortptr - 1 ;
}
labeltable [sortptr + 1 ].cc = c ;
labeltable [sortptr + 1 ].rr = r ;
labelptr = labelptr + 1 ;
activity [r ]= 2 ;
}
}
while ( c++ < for_end ) ;}
labeltable [labelptr + 1 ].rr = ligsize ;
if ( nl > 0 )
{
left () ;
Fputs ( plfile , "LIGTABLE" ) ;
outln () ;
{register integer for_end; ai = 0 ;for_end = nl - 1 ; if ( ai <=
for_end) do
if ( activity [ai ]== 2 )
{
r = tfm [4 * ( ligkernbase + ( ai ) ) ];
if ( r < 128 )
{
r = r + ai + 1 ;
if ( r >= nl )
{
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%ld%s\n", "Bad TFM file: " , "Ligature/kern step " , (long)ai , " skips too far;" ) ;
}
fprintf ( stderr , "%s\n", "I made it stop." ) ;
tfm [4 * ( ligkernbase + ( ai ) ) ]= 128 ;
}
else activity [r ]= 2 ;
}
}
while ( ai++ < for_end ) ;}
sortptr = 1 ;
{register integer for_end; acti = 0 ;for_end = nl - 1 ; if ( acti <=
for_end) do
if ( activity [acti ]!= 1 )
{
i = acti ;
if ( activity [i ]== 0 )
{
if ( level == 1 )
{
left () ;
Fputs ( plfile , "COMMENT THIS PART OF THE PROGRAM IS NEVER USED!" ) ;
outln () ;
}
}
else if ( level == 2 )
right () ;
while ( i == labeltable [sortptr ].rr ) {
left () ;
Fputs ( plfile , "LABEL" ) ;
if ( labeltable [sortptr ].cc == 256 )
Fputs ( plfile , " BOUNDARYCHAR" ) ;
else outchar ( labeltable [sortptr ].cc ) ;
right () ;
sortptr = sortptr + 1 ;
}
{
k = 4 * ( ligkernbase + ( i ) ) ;
if ( tfm [k ]> 128 )
{
if ( 256 * tfm [k + 2 ]+ tfm [k + 3 ]>= nl )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s\n", "Bad TFM file: " , "Ligature unconditional stop command address is too big." ) ;
}
}
else if ( tfm [k + 2 ]>= 128 )
{
if ( ( ( tfm [k + 1 ]< bc ) || ( tfm [k + 1 ]> ec ) || ( tfm [
4 * ( charbase + tfm [k + 1 ]) ]== 0 ) ) ) {
if ( tfm [k + 1 ]!= boundarychar )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Kern step for" , " nonexistent character " ) ;
printoctal ( tfm [k + 1 ]) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
tfm [k + 1 ]= bc ;
}
}
left () ;
Fputs ( plfile , "KRN" ) ;
outchar ( tfm [k + 1 ]) ;
r = 256 * ( tfm [k + 2 ]- 128 ) + tfm [k + 3 ];
if ( r >= nk )
{
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s\n", "Bad TFM file: " , "Kern index too large." ) ;
}
Fputs ( plfile , " R 0.0" ) ;
}
else outfix ( 4 * ( kernbase + r ) ) ;
right () ;
}
else {
if ( ( ( tfm [k + 1 ]< bc ) || ( tfm [k + 1 ]> ec ) || ( tfm [
4 * ( charbase + tfm [k + 1 ]) ]== 0 ) ) ) {
if ( tfm [k + 1 ]!= boundarychar )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Ligature step for" , " nonexistent character " ) ;
printoctal ( tfm [k + 1 ]) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
tfm [k + 1 ]= bc ;
}
}
if ( ( ( tfm [k + 3 ]< bc ) || ( tfm [k + 3 ]> ec ) || ( tfm [
4 * ( charbase + tfm [k + 3 ]) ]== 0 ) ) )
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Ligature step produces the" , " nonexistent character " ) ;
printoctal ( tfm [k + 3 ]) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
tfm [k + 3 ]= bc ;
}
left () ;
r = tfm [k + 2 ];
if ( ( r == 4 ) || ( ( r > 7 ) && ( r != 11 ) ) )
{
fprintf ( stderr , "%s\n", "Ligature step with nonstandard code changed to LIG" ) ;
r = 0 ;
tfm [k + 2 ]= 0 ;
}
if ( r % 4 > 1 )
putc ( '/' , plfile );
Fputs ( plfile , "LIG" ) ;
if ( odd ( r ) )
putc ( '/' , plfile );
while ( r > 3 ) {
putc ( '>' , plfile );
r = r - 4 ;
}
outchar ( tfm [k + 1 ]) ;
outchar ( tfm [k + 3 ]) ;
right () ;
}
if ( tfm [k ]> 0 ) {
if ( level == 1 )
{
if ( tfm [k ]>= 128 )
Fputs ( plfile , "(STOP)" ) ;
else {
count = 0 ;
{register integer for_end; ai = i + 1 ;for_end = i + tfm [k
]; if ( ai <= for_end) do
if ( activity [ai ]== 2 )
count = count + 1 ;
while ( ai++ < for_end ) ;}
fprintf ( plfile , "%s%ld%c", "(SKIP D " , (long)count , ')' ) ;
}
outln () ;
}
}
}
}
while ( acti++ < for_end ) ;}
if ( level == 2 )
right () ;
right () ;
hashptr = 0 ;
yligcycle = 256 ;
{register integer for_end; hh = 0 ;for_end = hashsize ; if ( hh <=
for_end) do
hash [hh ]= 0 ;
while ( hh++ < for_end ) ;}
{register integer for_end; c = bc ;for_end = ec ; if ( c <= for_end) do
if ( ( tfm [4 * ( charbase + c ) + 2 ]% 4 ) == 1 )
{
i = tfm [4 * ( charbase + c ) + 3 ];
if ( tfm [4 * ( ligkernbase + ( i ) ) ]> 128 )
i = 256 * tfm [4 * ( ligkernbase + ( i ) ) + 2 ]+ tfm [4 * (
ligkernbase + ( i ) ) + 3 ];
do {
hashinput () ;
k = tfm [4 * ( ligkernbase + ( i ) ) ];
if ( k >= 128 )
i = nl ;
else i = i + 1 + k ;
} while ( ! ( i >= nl ) ) ;
}
while ( c++ < for_end ) ;}
if ( bcharlabel < nl )
{
c = 256 ;
i = bcharlabel ;
do {
hashinput () ;
k = tfm [4 * ( ligkernbase + ( i ) ) ];
if ( k >= 128 )
i = nl ;
else i = i + 1 + k ;
} while ( ! ( i >= nl ) ) ;
}
if ( hashptr == hashsize )
{
fprintf ( stderr , "%s\n", "Sorry, I haven't room for so many ligature/kern pairs!" ) ;
uexit ( 1 ) ;
}
{register integer for_end; hh = 1 ;for_end = hashptr ; if ( hh <=
for_end) do
{
r = hashlist [hh ];
if ( classvar [r ]> 0 )
r = ffn ( r , ( hash [r ]- 1 ) / 256 , ( hash [r ]- 1 ) % 256 ) ;
}
while ( hh++ < for_end ) ;}
if ( yligcycle < 256 )
{
Fputs ( stderr , "Infinite ligature loop starting with " ) ;
if ( xligcycle == 256 )
Fputs ( stderr , "boundary" ) ;
else printoctal ( xligcycle ) ;
Fputs ( stderr , " and " ) ;
printoctal ( yligcycle ) ;
{ putc ( '!' , stderr ); putc ( '\n', stderr ); }
Fputs ( plfile , "(INFINITE LIGATURE LOOP MUST BE BROKEN!)" ) ;
uexit ( 1 ) ;
}
}
if ( ne > 0 )
{register integer for_end; c = 0 ;for_end = ne - 1 ; if ( c <= for_end) do
{register integer for_end; d = 0 ;for_end = 3 ; if ( d <= for_end) do
{
k = 4 * ( extenbase + c ) + d ;
if ( ( tfm [k ]> 0 ) || ( d == 3 ) )
{
if ( ( ( tfm [k ]< bc ) || ( tfm [k ]> ec ) || ( tfm [4 * (
charbase + tfm [k ]) ]== 0 ) ) )
{
{
perfect = false ;
if ( charsonline > 0 )
{ putc ( ' ' , stderr ); putc ( '\n', stderr ); }
charsonline = 0 ;
fprintf ( stderr , "%s%s%s", "Bad TFM file: " , "Extensible recipe involves the" , " nonexistent character " ) ;
printoctal ( tfm [k ]) ;
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
}
if ( d < 3 )
tfm [k ]= 0 ;
}
}
}
while ( d++ < for_end ) ;}
while ( c++ < for_end ) ;}
docharacters () ;
if ( verbose )
{ putc ( '.' , stderr ); putc ( '\n', stderr ); }
if ( level != 0 )
fprintf ( stderr , "%s\n", "This program isn't working!" ) ;
if ( ! perfect )
{
Fputs ( plfile , "(COMMENT THE TFM FILE WAS BAD, SO THE DATA HAS BEEN CHANGED!)" ) ;
putc ('\n', plfile );
}
}
/*
* Write type into the output buffer.
* The type is written as a sequence of substrings, each of which describes a
* node of type type_t
* a node is coded as follows:
* char C
* signed char s C
* unsigned char u C
* short S
* unsigned short u S
* int I
* unsigned int u I
* long L
* unsigned long u L
* long long Q
* unsigned long long u Q
* float s D
* double D
* long double l D
* void V
* * P
* [n] A n
* () F
* (void) F 0
* (n arguments) F n arg1 arg2 ... argn
* (n arguments, ...) F n arg1 arg2 ... argn-1 E
* (a, b, c, ...) f n arg1 arg2 ...
* enum tag e T tag_or_typename
* struct tag s T tag_or_typename
* union tag u T tag_or_typename
*
* tag_or_typename 0 no tag or type name
* 1 n tag Tag
* 2 n typename only type name
*
* spaces are only for better readability
* additionally it is possible to prepend the characters 'c' (for const)
* and 'v' (for volatile)
*/
void
outtype(type_t *tp)
{
int t, s, na;
sym_t *arg;
tspec_t ts;
while (tp != NULL) {
if ((ts = tp->t_tspec) == INT && tp->t_isenum)
ts = ENUM;
switch (ts) {
case CHAR: t = 'C'; s = '\0'; break;
case SCHAR: t = 'C'; s = 's'; break;
case UCHAR: t = 'C'; s = 'u'; break;
case SHORT: t = 'S'; s = '\0'; break;
case USHORT: t = 'S'; s = 'u'; break;
case INT: t = 'I'; s = '\0'; break;
case UINT: t = 'I'; s = 'u'; break;
case LONG: t = 'L'; s = '\0'; break;
case ULONG: t = 'L'; s = 'u'; break;
case QUAD: t = 'Q'; s = '\0'; break;
case UQUAD: t = 'Q'; s = 'u'; break;
case FLOAT: t = 'D'; s = 's'; break;
case DOUBLE: t = 'D'; s = '\0'; break;
case LDOUBLE: t = 'D'; s = 'l'; break;
case VOID: t = 'V'; s = '\0'; break;
case PTR: t = 'P'; s = '\0'; break;
case ARRAY: t = 'A'; s = '\0'; break;
case FUNC: t = 'F'; s = '\0'; break;
case ENUM: t = 'T'; s = 'e'; break;
case STRUCT: t = 'T'; s = 's'; break;
case UNION: t = 'T'; s = 'u'; break;
default:
lerror("outtyp() 1");
}
if (tp->t_const)
outchar('c');
if (tp->t_volatile)
outchar('v');
if (s != '\0')
outchar(s);
outchar(t);
if (ts == ARRAY) {
outint(tp->t_dim);
} else if (ts == ENUM) {
outtt(tp->t_enum->etag, tp->t_enum->etdef);
} else if (ts == STRUCT || ts == UNION) {
outtt(tp->t_str->stag, tp->t_str->stdef);
} else if (ts == FUNC && tp->t_proto) {
na = 0;
for (arg = tp->t_args; arg != NULL; arg = arg->s_nxt)
na++;
if (tp->t_vararg)
na++;
outint(na);
for (arg = tp->t_args; arg != NULL; arg = arg->s_nxt)
outtype(arg->s_type);
if (tp->t_vararg)
outchar('E');
}
tp = tp->t_subt;
}
}
void
pcollgprintentry(Entry e, int cmd)
{
uint8_t *p, *pe;
int r, rprev = NONE, rx, over = 0, font;
char buf[16];
p = (uint8_t *)e.start;
pe = (uint8_t *)e.end;
curentry = e;
if(cmd == 'h')
outinhibit = 1;
while(p < pe){
if(cmd == 'r'){
outchar(*p++);
continue;
}
switch(r = intab[*p++]){ /* assign = */
case TAGS:
if(rprev != NONE){
outrune(rprev);
rprev = NONE;
}
p = reach(p, 0x06);
font = tag[0];
if(cmd == 'h')
outinhibit = (font != 'h');
break;
case TAGE: /* an extra one */
break;
case SPCS:
p = reach(p, 0xba);
r = looknassoc(numtab, asize(numtab), strtol(tag,0,0));
if(r < 0){
if(rprev != NONE){
outrune(rprev);
rprev = NONE;
}
sprint(buf, "\\N'%s'", tag);
outchars(buf);
break;
}
/* else fall through */
default:
if(over){
rx = looknassoc(overtab, asize(overtab), r);
if(rx > 0)
rx = liglookup(rx, rprev);
if(rx > 0 && rx != NONE)
outrune(rx);
else{
outrune(rprev);
if(r == ':')
outrune(L'¨');
else{
outrune(L'^');
outrune(r);
}
}
over = 0;
rprev = NONE;
}else if(r == '^'){
over = 1;
}else{
if(rprev != NONE)
outrune(rprev);
rprev = r;
}
}
}
if(rprev != NONE)
outrune(rprev);
if(cmd == 'h')
outinhibit = 0;
outnl(0);
}
int
__quadmath_printf_fphex (struct __quadmath_printf_file *fp,
const struct printf_info *info,
const void *const *args)
{
/* The floating-point value to output. */
ieee854_float128 fpnum;
/* Locale-dependent representation of decimal point. */
const char *decimal;
wchar_t decimalwc;
/* "NaN" or "Inf" for the special cases. */
const char *special = NULL;
const wchar_t *wspecial = NULL;
/* Buffer for the generated number string for the mantissa. The
maximal size for the mantissa is 128 bits. */
char numbuf[32];
char *numstr;
char *numend;
wchar_t wnumbuf[32];
wchar_t *wnumstr;
wchar_t *wnumend;
int negative;
/* The maximal exponent of two in decimal notation has 5 digits. */
char expbuf[5];
char *expstr;
wchar_t wexpbuf[5];
wchar_t *wexpstr;
int expnegative;
int exponent;
/* Non-zero is mantissa is zero. */
int zero_mantissa;
/* The leading digit before the decimal point. */
char leading;
/* Precision. */
int precision = info->prec;
/* Width. */
int width = info->width;
/* Number of characters written. */
int done = 0;
/* Nonzero if this is output on a wide character stream. */
int wide = info->wide;
/* Figure out the decimal point character. */
#ifdef USE_NL_LANGINFO
if (info->extra == 0)
decimal = nl_langinfo (DECIMAL_POINT);
else
{
decimal = nl_langinfo (MON_DECIMAL_POINT);
if (*decimal == '\0')
decimal = nl_langinfo (DECIMAL_POINT);
}
/* The decimal point character must never be zero. */
assert (*decimal != '\0');
#elif defined USE_LOCALECONV
const struct lconv *lc = localeconv ();
if (info->extra == 0)
decimal = lc->decimal_point;
else
{
decimal = lc->mon_decimal_point;
if (decimal == NULL || *decimal == '\0')
decimal = lc->decimal_point;
}
if (decimal == NULL || *decimal == '\0')
decimal = ".";
#else
decimal = ".";
#endif
#ifdef USE_NL_LANGINFO_WC
if (info->extra == 0)
decimalwc = nl_langinfo_wc (_NL_NUMERIC_DECIMAL_POINT_WC);
else
{
decimalwc = nl_langinfo_wc (_NL_MONETARY_DECIMAL_POINT_WC);
if (decimalwc == L_('\0'))
decimalwc = nl_langinfo_wc (_NL_NUMERIC_DECIMAL_POINT_WC);
}
/* The decimal point character must never be zero. */
assert (decimalwc != L_('\0'));
#else
decimalwc = L_('.');
#endif
/* Fetch the argument value. */
{
fpnum.value = **(const __float128 **) args[0];
/* Check for special values: not a number or infinity. */
if (isnanq (fpnum.value))
{
negative = fpnum.ieee.negative != 0;
if (isupper (info->spec))
{
special = "NAN";
wspecial = L_("NAN");
}
else
{
special = "nan";
wspecial = L_("nan");
}
}
else
{
if (isinfq (fpnum.value))
{
if (isupper (info->spec))
{
special = "INF";
wspecial = L_("INF");
}
else
{
special = "inf";
wspecial = L_("inf");
}
}
negative = signbitq (fpnum.value);
}
}
if (special)
{
int width = info->width;
if (negative || info->showsign || info->space)
--width;
width -= 3;
if (!info->left && width > 0)
PADN (' ', width);
if (negative)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
PRINT (special, wspecial, 3);
if (info->left && width > 0)
PADN (' ', width);
return done;
}
{
/* We have 112 bits of mantissa plus one implicit digit. Since
112 bits are representable without rest using hexadecimal
digits we use only the implicit digits for the number before
the decimal point. */
uint64_t num0, num1;
assert (sizeof (long double) == 16);
num0 = fpnum.ieee.mant_high;
num1 = fpnum.ieee.mant_low;
zero_mantissa = (num0|num1) == 0;
if (sizeof (unsigned long int) > 6)
{
numstr = _itoa_word (num1, numbuf + sizeof numbuf, 16,
info->spec == 'A');
wnumstr = _itowa_word (num1,
wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),
16, info->spec == 'A');
}
else
{
numstr = _itoa (num1, numbuf + sizeof numbuf, 16,
info->spec == 'A');
wnumstr = _itowa (num1,
wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),
16, info->spec == 'A');
}
while (numstr > numbuf + (sizeof numbuf - 64 / 4))
{
*--numstr = '0';
*--wnumstr = L_('0');
}
if (sizeof (unsigned long int) > 6)
{
numstr = _itoa_word (num0, numstr, 16, info->spec == 'A');
wnumstr = _itowa_word (num0, wnumstr, 16, info->spec == 'A');
}
else
{
numstr = _itoa (num0, numstr, 16, info->spec == 'A');
wnumstr = _itowa (num0, wnumstr, 16, info->spec == 'A');
}
/* Fill with zeroes. */
while (numstr > numbuf + (sizeof numbuf - 112 / 4))
{
*--numstr = '0';
*--wnumstr = L_('0');
}
leading = fpnum.ieee.exponent == 0 ? '0' : '1';
exponent = fpnum.ieee.exponent;
if (exponent == 0)
{
if (zero_mantissa)
expnegative = 0;
else
{
/* This is a denormalized number. */
expnegative = 1;
exponent = IEEE854_FLOAT128_BIAS - 1;
}
}
else if (exponent >= IEEE854_FLOAT128_BIAS)
{
expnegative = 0;
exponent -= IEEE854_FLOAT128_BIAS;
}
else
{
expnegative = 1;
exponent = -(exponent - IEEE854_FLOAT128_BIAS);
}
}
/* Look for trailing zeroes. */
if (! zero_mantissa)
{
wnumend = &wnumbuf[sizeof wnumbuf / sizeof wnumbuf[0]];
numend = &numbuf[sizeof numbuf / sizeof numbuf[0]];
while (wnumend[-1] == L_('0'))
{
--wnumend;
--numend;
}
if (precision == -1)
precision = numend - numstr;
else if (precision < numend - numstr
&& (numstr[precision] > '8'
|| (('A' < '0' || 'a' < '0')
&& numstr[precision] < '0')
|| (numstr[precision] == '8'
&& (precision + 1 < numend - numstr
/* Round to even. */
|| (precision > 0
&& ((numstr[precision - 1] & 1)
^ (isdigit (numstr[precision - 1]) == 0)))
|| (precision == 0
&& ((leading & 1)
^ (isdigit (leading) == 0)))))))
{
/* Round up. */
int cnt = precision;
while (--cnt >= 0)
{
char ch = numstr[cnt];
/* We assume that the digits and the letters are ordered
like in ASCII. This is true for the rest of GNU, too. */
if (ch == '9')
{
wnumstr[cnt] = (wchar_t) info->spec;
numstr[cnt] = info->spec; /* This is tricky,
think about it! */
break;
}
else if (tolower (ch) < 'f')
{
++numstr[cnt];
++wnumstr[cnt];
break;
}
else
{
numstr[cnt] = '0';
wnumstr[cnt] = L_('0');
}
}
if (cnt < 0)
{
/* The mantissa so far was fff...f Now increment the
leading digit. Here it is again possible that we
get an overflow. */
if (leading == '9')
leading = info->spec;
else if (tolower (leading) < 'f')
++leading;
else
{
leading = '1';
if (expnegative)
{
exponent -= 4;
if (exponent <= 0)
{
exponent = -exponent;
expnegative = 0;
}
}
else
exponent += 4;
}
}
}
}
else
{
if (precision == -1)
precision = 0;
numend = numstr;
wnumend = wnumstr;
}
/* Now we can compute the exponent string. */
expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0);
wexpstr = _itowa_word (exponent,
wexpbuf + sizeof wexpbuf / sizeof (wchar_t), 10, 0);
/* Now we have all information to compute the size. */
width -= ((negative || info->showsign || info->space)
/* Sign. */
+ 2 + 1 + 0 + precision + 1 + 1
/* 0x h . hhh P ExpoSign. */
+ ((expbuf + sizeof expbuf) - expstr));
/* Exponent. */
/* Count the decimal point.
A special case when the mantissa or the precision is zero and the `#'
is not given. In this case we must not print the decimal point. */
if (precision > 0 || info->alt)
width -= wide ? 1 : strlen (decimal);
if (!info->left && info->pad != '0' && width > 0)
PADN (' ', width);
if (negative)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
outchar ('0');
if ('X' - 'A' == 'x' - 'a')
outchar (info->spec + ('x' - 'a'));
else
outchar (info->spec == 'A' ? 'X' : 'x');
if (!info->left && info->pad == '0' && width > 0)
PADN ('0', width);
outchar (leading);
if (precision > 0 || info->alt)
{
const wchar_t *wtmp = &decimalwc;
PRINT (decimal, wtmp, wide ? 1 : strlen (decimal));
}
if (precision > 0)
{
ssize_t tofill = precision - (numend - numstr);
PRINT (numstr, wnumstr, MIN (numend - numstr, precision));
if (tofill > 0)
PADN ('0', tofill);
}
if ('P' - 'A' == 'p' - 'a')
outchar (info->spec + ('p' - 'a'));
else
outchar (info->spec == 'A' ? 'P' : 'p');
outchar (expnegative ? '-' : '+');
PRINT (expstr, wexpstr, (expbuf + sizeof expbuf) - expstr);
if (info->left && info->pad != '0' && width > 0)
PADN (info->pad, width);
return done;
}
void sbbs_t::new_scan_ptr_cfg()
{
uint i,j;
long s;
uint32_t l;
time_t t;
while(online) {
bputs(text[CfgGrpLstHdr]);
for(i=0;i<usrgrps && !msgabort();i++) {
checkline();
if(i<9) outchar(' ');
if(i<99) outchar(' ');
bprintf(text[CfgGrpLstFmt],i+1,cfg.grp[usrgrp[i]]->lname);
}
SYNC;
mnemonics(text[WhichOrAll]);
s=getkeys("AQ",usrgrps);
if(!s || s==-1 || s=='Q')
break;
if(s=='A') {
mnemonics("\r\nEnter number of messages from end, ~Date, ~Quit, or"
" [Last Message]: ");
s=getkeys("DLQ",9999);
if(s==-1 || s=='Q')
continue;
if(s=='D') {
t=time(NULL);
if(inputnstime(&t) && !(sys_status&SS_ABORT)) {
bputs(text[LoadingMsgPtrs]);
for(i=0;i<usrgrps && online;i++)
for(j=0;j<usrsubs[i] && online;j++) {
checkline();
subscan[usrsub[i][j]].ptr=getmsgnum(usrsub[i][j],t);
}
}
continue;
}
if(s=='L')
s=0;
if(s)
s&=~0x80000000L;
bputs(text[LoadingMsgPtrs]);
for(i=0;i<usrgrps;i++)
for(j=0;j<usrsubs[i] && online;j++) {
checkline();
getlastmsg(usrsub[i][j],&l,0);
if(s>(long)l)
subscan[usrsub[i][j]].ptr=0;
else
subscan[usrsub[i][j]].ptr=l-s;
}
continue;
}
i=(s&~0x80000000L)-1;
while(online) {
l=0;
bprintf(text[CfgSubLstHdr],cfg.grp[usrgrp[i]]->lname);
for(j=0;j<usrsubs[i] && !msgabort();j++) {
checkline();
if(j<9) outchar(' ');
if(j<99) outchar(' ');
t=getmsgtime(usrsub[i][j],subscan[usrsub[i][j]].ptr);
if(t>(long)l)
l=(uint32_t)t;
bprintf(text[SubPtrLstFmt],j+1,cfg.sub[usrsub[i][j]]->lname
,timestr(t),nulstr);
}
SYNC;
mnemonics(text[WhichOrAll]);
s=getkeys("AQ",usrsubs[i]);
if(sys_status&SS_ABORT) {
lncntr=0;
return;
}
if(s==-1 || !s || s=='Q')
break;
if(s=='A') { /* The entire group */
mnemonics("\r\nEnter number of messages from end, ~Date, ~Quit, or"
" [Last Message]: ");
s=getkeys("DLQ",9999);
if(s==-1 || s=='Q')
continue;
if(s=='D') {
t=l;
if(inputnstime(&t) && !(sys_status&SS_ABORT)) {
bputs(text[LoadingMsgPtrs]);
for(j=0;j<usrsubs[i] && online;j++) {
checkline();
subscan[usrsub[i][j]].ptr=getmsgnum(usrsub[i][j],t);
}
}
continue;
}
if(s=='L')
s=0;
if(s)
s&=~0x80000000L;
bputs(text[LoadingMsgPtrs]);
for(j=0;j<usrsubs[i] && online;j++) {
checkline();
getlastmsg(usrsub[i][j],&l,0);
if(s>(long)l)
subscan[usrsub[i][j]].ptr=0;
else
subscan[usrsub[i][j]].ptr=l-s;
}
continue;
}
else {
j=(s&~0x80000000L)-1;
mnemonics("\r\nEnter number of messages from end, ~Date, ~Quit, or"
" [Last Message]: ");
s=getkeys("DLQ",9999);
if(s==-1 || s=='Q')
continue;
if(s=='D') {
t=getmsgtime(usrsub[i][j],subscan[usrsub[i][j]].ptr);
if(inputnstime(&t) && !(sys_status&SS_ABORT)) {
bputs(text[LoadingMsgPtrs]);
subscan[usrsub[i][j]].ptr=getmsgnum(usrsub[i][j],t);
}
continue;
}
if(s=='L')
s=0;
if(s)
s&=~0x80000000L;
getlastmsg(usrsub[i][j],&l,0);
if(s>(long)l)
subscan[usrsub[i][j]].ptr=0;
else
subscan[usrsub[i][j]].ptr=l-s;
}
}
}
}
static void
prt_ctp(char *name)
{
int idx, i, mem;
int first = 1;
static const char *reg_names[] = {
"upper", "lower", "alpha", "digit", "space", "cntrl",
"punct", "graph", "print", "xdigit", "blank", NULL
};
for (idx = 0; reg_names[idx] != NULL; idx++) {
if (strcmp(name, reg_names[idx]) == 0) {
break;
}
}
if (reg_names[idx] == NULL) {
return;
}
for (i = 0; i < CSSIZE; i++) {
mem = 0;
switch (idx) {
case 0:
mem = isupper(i);
break;
case 1:
mem = islower(i);
break;
case 2:
mem = isalpha(i);
break;
case 3:
mem = isdigit(i);
break;
case 4:
mem = isspace(i);
break;
case 5:
mem = iscntrl(i);
break;
case 6:
mem = ispunct(i);
break;
case 7:
mem = isgraph(i);
break;
case 8:
mem = isprint(i);
break;
case 9:
mem = isxdigit(i);
break;
case 10:
mem = isblank(i);
break;
}
if (mem) {
if (!first) {
(void) putchar(';');
}
first = 0;
(void) printf("\"");
outchar(i);
(void) printf("\"");
}
}
}
/*
* Format c for printing. Handle funnies of upper case terminals
* and crocky hazeltines which don't have ~.
*/
int
normchar(register int c)
{
int u;
#ifdef UCVISUAL
register char *colp;
if (c == '~' && xHZ) {
normchar('\\');
c = '^';
}
#endif
if (c & MULTICOL) {
c &= ~MULTICOL;
if (c == 0)
return MULTICOL;
}
c &= (TRIM|QUOTE);
u = c & TRIM;
if (c & QUOTE) {
if (c == (' ' | QUOTE) || c == ('\b' | QUOTE))
/*EMPTY*/;
else if (c == QUOTE)
return c;
else
c &= TRIM;
}
#ifdef BIT8
else {
if (!printable(c) && (u != '\b' || !OS) &&
u != '\n' && u != '\t')
c = printof(u);
else {
c = u;
if (0)
/*EMPTY*/;
#else /* !BIT8 */
else if (c < ' ' && (c != '\b' || !OS) && c != '\n' && c != '\t')
putchar('^'), c = ctlof(c);
#endif /* !BIT8 */
#ifdef UCVISUAL
else if (UPPERCASE)
if (xisupper(c)) {
outchar('\\');
c = tolower(c);
} else {
colp = "({)}!|^~'`";
while (*colp++)
if (c == *colp++) {
outchar('\\');
c = colp[-2];
break;
}
}
#endif /* UCVISUAL */
#ifdef BIT8
}
}
#endif
outchar(c);
return c;
}
void sbbs_t::ctrl_a(char x)
{
char tmp1[128],atr=curatr;
struct tm tm;
if(x && (uchar)x<=CTRL_Z) { /* Ctrl-A through Ctrl-Z for users with MF only */
if(!(useron.flags1&FLAG(x+64)))
console^=(CON_ECHO_OFF);
return;
}
if((uchar)x>0x7f) {
cursor_right((uchar)x-0x7f);
return;
}
switch(toupper(x)) {
case '!': /* level 10 or higher */
if(useron.level<10)
console^=CON_ECHO_OFF;
break;
case '@': /* level 20 or higher */
if(useron.level<20)
console^=CON_ECHO_OFF;
break;
case '#': /* level 30 or higher */
if(useron.level<30)
console^=CON_ECHO_OFF;
break;
case '$': /* level 40 or higher */
if(useron.level<40)
console^=CON_ECHO_OFF;
break;
case '%': /* level 50 or higher */
if(useron.level<50)
console^=CON_ECHO_OFF;
break;
case '^': /* level 60 or higher */
if(useron.level<60)
console^=CON_ECHO_OFF;
break;
case '&': /* level 70 or higher */
if(useron.level<70)
console^=CON_ECHO_OFF;
break;
case '*': /* level 80 or higher */
if(useron.level<80)
console^=CON_ECHO_OFF;
break;
case '(': /* level 90 or higher */
if(useron.level<90)
console^=CON_ECHO_OFF;
break;
case ')': /* turn echo back on */
console&=~CON_ECHO_OFF;
break;
case '+': /* push current attribte */
if(attr_sp<(int)sizeof(attr_stack))
attr_stack[attr_sp++]=curatr;
break;
case '-': /* pop current attribute OR optimized "normal" */
if(attr_sp>0)
attr(attr_stack[--attr_sp]);
else /* turn off all attributes if */
if(atr&(HIGH|BLINK|BG_LIGHTGRAY)) /* high intensity, blink or */
attr(LIGHTGRAY); /* background bits are set */
break;
case '_': /* turn off all attributes if */
if(atr&(BLINK|BG_LIGHTGRAY)) /* blink or background is set */
attr(LIGHTGRAY);
break;
case 'P': /* Pause */
pause();
break;
case 'Q': /* Pause reset */
lncntr=0;
break;
case 'T': /* Time */
now=time(NULL);
localtime_r(&now,&tm);
if(cfg.sys_misc&SM_MILITARY)
bprintf("%02u:%02u:%02u"
,tm.tm_hour, tm.tm_min, tm.tm_sec);
else
bprintf("%02d:%02d %s"
,tm.tm_hour==0 ? 12
: tm.tm_hour>12 ? tm.tm_hour-12
: tm.tm_hour, tm.tm_min, tm.tm_hour>11 ? "pm":"am");
break;
case 'D': /* Date */
now=time(NULL);
bputs(unixtodstr(&cfg,(time32_t)now,tmp1));
break;
case ',': /* Delay 1/10 sec */
mswait(100);
break;
case ';': /* Delay 1/2 sec */
mswait(500);
break;
case '.': /* Delay 2 secs */
mswait(2000);
break;
case 'S': /* Synchronize */
ASYNC;
break;
case 'L': /* CLS (form feed) */
CLS;
break;
case '>': /* CLREOL */
cleartoeol();
break;
case '<': /* Non-destructive backspace */
outchar(BS);
break;
case '[': /* Carriage return */
outchar(CR);
break;
case ']': /* Line feed */
outchar(LF);
break;
case 'A': /* Ctrl-A */
outchar(CTRL_A);
break;
case 'H': /* High intensity */
atr|=HIGH;
attr(atr);
break;
case 'I': /* Blink */
atr|=BLINK;
attr(atr);
break;
case 'N': /* Normal */
attr(LIGHTGRAY);
break;
case 'R':
atr=(atr&0xf8)|RED;
attr(atr);
break;
case 'G':
atr=(atr&0xf8)|GREEN;
attr(atr);
break;
case 'B':
atr=(atr&0xf8)|BLUE;
attr(atr);
break;
case 'W': /* White */
atr=(atr&0xf8)|LIGHTGRAY;
attr(atr);
break;
case 'C':
atr=(atr&0xf8)|CYAN;
attr(atr);
break;
case 'M':
atr=(atr&0xf8)|MAGENTA;
attr(atr);
break;
case 'Y': /* Yellow */
atr=(atr&0xf8)|BROWN;
attr(atr);
break;
case 'K': /* Black */
atr=(atr&0xf8)|BLACK;
attr(atr);
break;
case '0': /* Black Background */
atr=(atr&0x8f);
attr(atr);
break;
case '1': /* Red Background */
atr=(atr&0x8f)|(uchar)BG_RED;
attr(atr);
break;
case '2': /* Green Background */
atr=(atr&0x8f)|(uchar)BG_GREEN;
attr(atr);
break;
case '3': /* Yellow Background */
atr=(atr&0x8f)|(uchar)BG_BROWN;
attr(atr);
break;
case '4': /* Blue Background */
atr=(atr&0x8f)|(uchar)BG_BLUE;
attr(atr);
break;
case '5': /* Magenta Background */
atr=(atr&0x8f)|(uchar)BG_MAGENTA;
attr(atr);
break;
case '6': /* Cyan Background */
atr=(atr&0x8f)|(uchar)BG_CYAN;
attr(atr);
break;
case '7': /* White Background */
atr=(atr&0x8f)|(uchar)BG_LIGHTGRAY;
attr(atr);
break;
}
}
int
__printf_dfp (FILE *fp,
const struct printf_info *info,
const void *const *args)
{
int wide = info->wide;
/* Counter for number of written characters. */
int done = 0;
/* Locale-dependent representation of decimal point. */
const char *decimal;
union { const char *mb; int wc; } decimalwc;
char spec = tolower(info->spec);
/* Locale-dependent thousands separator and grouping specification. */
const char *thousands_sep = NULL;
wchar_t thousands_sepwc = 0;
const char * thousands_sepmb;
const char *grouping;
#ifdef OPTION_EGLIBC_LOCALE_CODE
if (info->extra == 0)
{
decimal = nl_langinfo (__DECIMAL_POINT);
decimalwc.mb = nl_langinfo (_NL_NUMERIC_DECIMAL_POINT_WC);
}
else
{
decimal = nl_langinfo (__MON_DECIMAL_POINT);
if (*decimal == '\0')
decimal = nl_langinfo (__DECIMAL_POINT);
decimalwc.mb = nl_langinfo (_NL_MONETARY_DECIMAL_POINT_WC);
if (decimalwc.wc == L'\0')
decimalwc.mb = nl_langinfo (_NL_NUMERIC_DECIMAL_POINT_WC);
}
/* The decimal point character must not be zero. */
assert (*decimal != '\0');
assert (decimalwc.wc != L'\0');
#else
/* Hard-code values from 'C' locale. */
decimal = ".";
decimalwc.wc = L'.';
#endif
#ifdef OPTION_EGLIBC_LOCALE_CODE
if (info->group)
{
if (info->extra == 0)
grouping = nl_langinfo (__GROUPING);
else
grouping = nl_langinfo (__MON_GROUPING);
if (*grouping <= 0 || *grouping == CHAR_MAX)
grouping = NULL;
else
{
/* Figure out the thousands separator character. */
if (wide)
{
if (info->extra == 0)
{
thousands_sepmb = nl_langinfo (_NL_NUMERIC_THOUSANDS_SEP_WC);
mbrtowc(&thousands_sepwc,thousands_sepmb, CHAR_MAX, NULL);
}
else
{
thousands_sepmb = nl_langinfo (_NL_MONETARY_THOUSANDS_SEP_WC);
mbrtowc(&thousands_sepwc,thousands_sepmb, CHAR_MAX, NULL);
}
}
else
{
if (info->extra == 0)
thousands_sep = nl_langinfo (__THOUSANDS_SEP);
else
thousands_sep = nl_langinfo (__MON_THOUSANDS_SEP);
}
if ((wide && thousands_sepwc == L'\0')
|| (! wide && *thousands_sep == '\0'))
grouping = NULL;
else if (thousands_sepwc == L'\0')
/* If we are printing multibyte characters and there is a
multibyte representation for the thousands separator,
we must ensure the wide character thousands separator
is available, even if it is fake. */
thousands_sepwc = 0xfffffffe;
}
}
else
grouping = NULL;
#else
grouping = NULL;
#endif
/* Seriously, only touch this code if you MUST. */
{
char digits[DECIMAL_PRINTF_BUF_SIZE];
int exp, /* The exponent. */
is_neg, /* Is negative? */
is_nan, /* Is not a number? */
is_inf, /* Is infinite? */
decpt = 2, /* decimal point offset into digits[] */
prec, /* number of digits that follow the decimal point, or number of significant digits for %g */
default_prec = 6, /* Default precision, per the C Spec. */
input_prec = 0, /* Precision of the _Decimal* value. */
mw, /* Mantissa Width */
n, /* Current digit offset into digits[] */
nd, /* num_digits before the get_digits call. */
width, /* Width of the field */
is_zero = 0; /* Used in some of the output tests. */
digits[0] = '0'; /* need an extra digit for rounding up */
if (info->user & mod_D)
{
_Decimal64 d64 = **(_Decimal64**)args[0];
if (d64 == 0) is_zero = 1;
nd = numdigitsd64(d64);
__get_digits_d64 (d64, digits+1, &exp, &is_neg, &is_nan, &is_inf);
mw = __DEC64_MANT_DIG__ + 1;
}
else if (info->user & mod_DD)
{
_Decimal128 d128 = **(_Decimal128**)args[0];
if (d128 == 0) is_zero = 1;
nd = numdigitsd128(d128);
__get_digits_d128 (d128, digits+1, &exp, &is_neg, &is_nan, &is_inf);
mw = __DEC128_MANT_DIG__ + 1;
}
else if (info->user & mod_H)
{
_Decimal32 d32 = **(_Decimal32**)args[0];
if (d32 == 0) is_zero = 1;
nd = numdigitsd32(d32);
__get_digits_d32 (d32, digits+1, &exp, &is_neg, &is_nan, &is_inf);
mw = __DEC32_MANT_DIG__ + 1;
}
else /* We shouldn't get here, but it is possible. */
return -2;
/* The first digit is always a zero to allow rounding. */
n = 0;
/* 'n' = position of first non-zero digit in the right-justified mantissa. */
n = mw - nd;
/* Width and precision can not both be set or the results are undefined per
* the C Spec. */
width = info->width;
/* The user specified precision overrides the input's inherent precision.
* This gets complicated quickly. */
prec = info->prec;
if (is_nan || is_inf)
{
width -= 3;
/*if (is_nan) is_neg = 0;*/
if (is_neg || info->showsign || info->space) width--;
if (!info->left && width > 0)
PADN (' ', width);
if (is_neg)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
if (is_nan)
{
if (isupper(info->spec))
{ outchar ('N'); outchar ('A'); outchar ('N'); }
else
{ outchar ('n'); outchar ('a'); outchar ('n'); }
}
else
{
if (isupper(info->spec))
{ outchar ('I'); outchar ('N'); outchar ('F'); }
else
{ outchar ('i'); outchar ('n'); outchar ('f'); }
}
if (info->left && width > 0)
PADN (' ', width);
return 0;
}
/* The term "precision" refers to the number of significant digits right of
* the decimal place. Determine the implicit precision of the input value.
* There are special rules for each of the supported flags.*/
switch (spec)
{
case 'a':
{
/* The DFP spec addition for %a refers to all of the significant
* digits in the precision. */
input_prec = nd;
/* This same check is done in two different places but it'll only
* effect a single pass through once. If prec is not set it'll hit
* this instance. If prec is set it'll hit the next instance. This
* is because the DFP spec requires this to be run after rounding
* when prec < input_prec. */
if (prec < 0 || prec >= input_prec)
{
/* Per the DFP specification (s,c,q), c == digits, q = exp, s ==
* is_neg. */
if (exp >= -(nd+5) && exp <= 0)
{
prec = -exp;
spec = 'f';
}
else
{
prec = nd - 1;
spec = 'e';
input_prec = nd - 1;
}
}
break;
}
case 'g':
{
int P = prec;
/* When the C specification refers to X as the exponent it means the
* exponent when the input value encoding is normalized to the form
* d.dddd. This means we have to do that before we can do the goof
* check.
*
* e.g., 123.456E-5
* right-justified -> 00123456E-9
* normalized -> 1.23456E-4
*
* Normalize X to d.ddd... form by taking (exp) + (nd - 1)
*
* X == -4 */
int X = exp + (nd -1);
/* The C Specification also indicates how to compute P. */
if (prec < 0)
P = 6;
else if (prec == 0)
P = 1;
/* Straight from the specification which assumes X is exponent normalized to
* d.ddd... form. */
if (X >= -4 && P > X)
{
prec = (P - (X + 1));
spec = 'f';
}
else
{
prec = P - 1;
spec = 'e';
}
input_prec = nd - 1;
break;
}
case 'e':
input_prec = nd - 1;
break;
case 'f':
if(exp < 0 && (-exp) > default_prec)
/* 00123456E-7 has an input_prec of 7. */
input_prec = (-exp);
else
/* 01234567E-6 has an input_prec of 6. */
/* 00000190E6 has an input_prec of 6. */
/* 00000123E1 has an input_prec of 6. */
/* 00000123E0 has an input_prec of 6. */
input_prec = default_prec;
break;
}
/* The specs 'g' and 'a' may have already modified prec so this won't happen for
* those cases. */
if (prec < 0)
prec = default_prec;
/* Do rounding if precision is less than the decimal type. On hardware DFP
* this could probably easily be done with quantize but on soft-dfp the
* existing method would be faster. */
if (prec < input_prec)
{
int index, roundmode = 0;
char rounddigit = '4';
if (spec == 'f')
/* This may force index to negative, in which case we ignore it at a
* later time. */
index = n + nd + exp + prec;
/* Goofy special case where we round significant digits which aren't
* right of the decimal place. */
else if (tolower(info->spec) == 'a' && prec > 0)
{
index = n + prec;
}
else
index = n + prec + 1;
/* FIXME: we should check rounding mode for %a */
if (__printf_dfp_getround_callback)
{
roundmode = (*__printf_dfp_getround_callback)();
switch (roundmode)
{
case FE_DEC_TONEAREST: rounddigit = '4'; break;
case FE_DEC_TOWARDZERO: rounddigit = '9'; break;
case FE_DEC_UPWARD: rounddigit = (is_neg ? '9' : '0'-1); break;
case FE_DEC_DOWNWARD: rounddigit = (is_neg ? '0'-1 : '9'); break;
case FE_DEC_TONEARESTFROMZERO: rounddigit = '4'; break;
case 5: rounddigit = '4'; break; /* nearest, ties toward zero */
case 6: rounddigit = '0'-1; break; /* away from zero */
case 7: rounddigit = '4'; break; /* round for shorter precision */
default: rounddigit = '4'; break;
}
}
/* If this is true then the requested precision is smaller than the
* default and rounding is required. If 'exp' was sufficiently negative
* 'index' may be negative, in which case we don't need to round. */
if (index > 0 && index < mw && digits[index] > rounddigit)
do {
int trailzero = index+1;
if (digits[index] == rounddigit+1)
{
while (trailzero < mw)
{
if (digits[trailzero] != '0')
{
trailzero = 0;
break;
}
++trailzero;
}
if (roundmode == FE_DEC_TONEAREST && trailzero &&
(digits[index-1] & 1) == 0) break;
if (roundmode == FE_DEC_UPWARD && !trailzero) break;
if (roundmode == FE_DEC_DOWNWARD && !trailzero) break;
if (roundmode == 5 && trailzero) break;
if (roundmode == 6 && trailzero) break;
}
while (digits[--index] == '9')
digits[index] = '0';
digits[index]++;
if (index < n)
{
n--;
nd++;
}
} while (0);
} /* Done rounding. */
/* If spec == 'a' at this point it means that prec was set by the user
* and rounding had to be considered. The spec now requires that the
* 'a' format presentation algorithm be calculated again. If prec
* wasn't set by the user then this was handled earlier and spec has already
* been set to either 'e' or 'f'. */
if (spec == 'a')
{
int old_exp = exp;
/* The goofy DFP specification requires that we now assume that after
* rounding the digits are right justified and truncated and the
* algorithm recomputed using the new values for nd and exp, e.g.,
*
* 00654300E-2 with %.1Hf -> 00000007E3. */
exp = nd + exp - prec;
nd = prec;
/* Per the DFP specification (s,c,q), c == digits, q = exp, s ==
* is_neg. */
if (exp >= -(nd+5) && exp <= 0)
{
prec = -exp;
spec = 'f';
}
else
{
prec = nd - 1;
if (prec < 0) prec = 0;
spec = 'e';
input_prec = nd - 1;
/* Return exp to the original value because the 'e' case below will
* recompute it. */
exp = old_exp;
}
/* spec will have been changed to 'e' or 'f' at this point, so determine
* the decimal point now. */
}
/* Calculate decimal point, adjust prec and exp if necessary.
* By this point everything should be represented as either %e or %f. */
if (spec == 'f')
{
if (exp < 0)
decpt = exp + nd + n;
else if (is_zero)
decpt = n + 1;
else
decpt = n + nd + exp;
}
else if (spec == 'e')
{
decpt = n + 1;
exp = mw + exp - decpt;
}
/* Remove trailing zeroes for %g */
if (tolower(info->spec) == 'g' && !info->alt)
{
while (prec > 0 && decpt+prec > mw) prec--;
while (prec > 0 && digits[decpt+prec-1] == '0') prec--;
}
/* Remove trailing zeroes for %a, but only if they are not significant. */
if (tolower(info->spec) == 'a')
{
while (prec > 0 && decpt+prec > mw) prec--;
while (prec > 0 && decpt+prec > n+nd && digits[decpt+prec-1] == '0') prec--;
}
/* Digits to the left of the decimal pt. */
if (n < decpt)
{
width -= decpt - n;
if (grouping) width -= (decpt-n)/3;
}
else width--; /* none to the left of the decimal point */
/* Digits to the right of the decimal pt. */
if (prec > 0) width -= 1 + prec;
else if (info->alt) width -= 1;
if (spec != 'f')
{
width -= 3;
if (0!=(exp/10) || spec!='a') --width;
if (0!=(exp/100)) --width;
if (0!=(exp/1000)) --width;
}
if (is_neg || info->showsign || info->space) width--;
if (!info->left && info->pad != '0' && width > 0)
PADN (info->pad, width);
if (is_neg)
outchar ('-');
else if (info->showsign)
outchar ('+');
else if (info->space)
outchar (' ');
if (!info->left && info->pad == '0' && width > 0)
PADN ('0', width);
/* Print zero, decimal point and leading zeroes if needed */
if (decpt <= n)
{
n = decpt;
outchar ('0');
if (n < 0)
{
outchar (wide ? decimalwc.wc : *decimal);
while (n < 0 && n < decpt + prec)
{
outchar ('0');
n++;
}
}
}
/* Print the digits. If decpt exceeds mw then we know that
* they're simply trailing zeros and we don't need to display them. */
while (n < mw && n < decpt + prec)
{
if (n == decpt)
{
outchar (wide ? decimalwc.wc : *decimal);
}
else if (grouping && n < decpt && (decpt-n)%3 == 0)
outchar (wide ? thousands_sepwc : *thousands_sep);
outchar (digits[n]);
n++;
}
/* print trailing zeroes */
while (n < decpt + prec)
{
if (n == decpt)
outchar (wide ? decimalwc.wc : *decimal);
else if (grouping && n < decpt && (decpt-n)%3 == 0)
outchar (wide ? thousands_sepwc : *thousands_sep);
outchar ('0');
n++;
}
/* print decimal point, if needed */
if (n == decpt && info->alt) outchar (wide ? decimalwc.wc : *decimal);
/* The C spec says that for %e, if the value is zero the exponent is zero.
* This isn't true for the DFP spec for %a so make sure to check info->spec
* and not spec since it could have promoted 'a' to 'e'. */
if(spec == 'e' && (tolower(info->spec) != 'a' && is_zero))
exp = 0;
/* Don't display the exponent part for 'f' because it is never used and don't
* do it for 'g' if the value is zero. */
if (spec != 'f' && !((tolower(info->spec) == 'g') && is_zero))
{
outchar (isupper(info->spec) ? 'E' : 'e');
if (exp < 0)
{ outchar ('-'); n = -exp; }
else
{ outchar ('+'); n = exp; }
if (n >= 1000) outchar ('0'+((n/1000)%10));
if (n >= 100) outchar ('0'+((n/100)%10));
if (n >= 10 || (tolower(info->spec) != 'a')) outchar ('0'+((n/10)%10));
outchar ('0'+(n%10));
}
if (info->left && width > 0)
PADN (info->pad, width);
} /* Done output block. */
return 0;
}
// Prints a single character
void printChar(char cChar)
{
outchar(cChar);
}
