fardata.c

open arj source

      rc=pause();
      #ifdef COLOR_OUTPUT
       /* Restore the color after implicit recursion to msg_cprintf() */
       if(!no_colors)
        textcolor(color_table[ccode&H_COLORMASK].color);
      #endif
      if(!rc&&(ccode&H_WEAK))
       longjmp(main_proc, 1);
     }
    }
   #endif
  }
  t_text++;
 }
#ifdef COLOR_OUTPUT
 if(redirected)
  #if SFX_LEVEL>=ARJSFXV
   fprintf(new_stdout, strform, n_text);
  #else
   printf(strform, n_text);
  #endif
 else
  scr_out(n_text);
#else
 printf(strform, n_text);
#endif
}

/* vcprintf() implementation */

int vcprintf(int ccode, FMSG *fmt, va_list args)
{
 int len;
 unsigned long num;
 int i, base;
 char FAR *s;
 int flags;                             /* flags to number() */
 int field_width;                       /* width of output field */
 int precision;                         /* min. # of digits for integers; max
                                           number of chars for from string */
 int qualifier;                         /* 'h', 'l', or 'L' for integer
                                           fields */
 int far_str;                           /* Far string qualifier */
 char buf[CHUNK_SIZE];                  /* Output buffer */
 int p_buf;
 int rc=0;
 int ocode;                             /* Output color code for formatted
                                           fields (that's what the whole
                                           routine is about!) */
 long *ipl;
 int *ipi;
 int last_fmt=0;

 ocode=(ccode&H_NFMT)?H_STD:ccode;
 for(p_buf=0; *fmt; ++fmt)
 {
  if(last_fmt&&ccode&H_NFMT)
  {
   last_fmt=0;
   buf[p_buf]='\0';
   rc+=p_buf;
   p_buf=0;
   flush_cbuf(ocode, buf);
  }
  if(*fmt!='%'||*(fmt+1)=='%')
  {
   if(p_buf>=CHUNK_SIZE-1)
   {
    buf[p_buf]='\0';
    rc+=p_buf;
    p_buf=0;
    flush_cbuf(ccode, buf);
   }
   buf[p_buf++]=*fmt;
   if(*fmt=='%')
    ++fmt;                              /* Skip over the 2nd percent - we've handled
                                           it here */
   continue;
  }
  /* A format symbol is found - flush the buffer if:
     1. It's H_NFMT, so we need to change the brush, OR
     2. CHUNK_THRESHOLD has been exceeded (for numeric) */
  if(ccode&H_NFMT||p_buf>=CHUNK_THRESHOLD)
  {
   buf[p_buf]='\0';
   rc+=p_buf;
   p_buf=0;
   flush_cbuf(ccode, buf);
  }
  last_fmt=1;
  /* Process flags */
  flags=0;
  repeat:
  ++fmt;                                /* This also skips first '%' */
  switch(*fmt)
  {
   case '-': flags|=LEFT; goto repeat;
   case '+': flags|=PLUS; goto repeat;
   case ' ': flags|=SPACE; goto repeat;
   case '#': flags|=SPECIAL; goto repeat;
   case '0': flags|=ZEROPAD; goto repeat;
   case 'F': flags|=FAR_STR; goto repeat;
  }
  /* Get field width */
  field_width=-1;
  if(isdigit(*fmt))
   field_width=skip_atoi((FMSG **)&fmt);
  else if(*fmt=='*')
  {
   ++fmt;
   /* It's the next argument */
   field_width=va_arg(args, int);
   if(field_width<0)
   {
    field_width=-field_width;
    flags|=LEFT;
   }
  }
  /* Get the precision */
  precision=-1;
  if(*fmt=='.')
  {
   ++fmt; 
   if(isdigit(*fmt))
    precision=skip_atoi((FMSG **)&fmt);
   else if(*fmt=='*')
   {
    ++fmt;
    /* It's the next argument */
    precision=va_arg(args, int);
   }
   if(precision<0)
    precision=0;
  }
  /* Get the conversion qualifier */
  qualifier=-1;
  if(*fmt=='h'||*fmt=='l'||*fmt=='L')
  {
   qualifier=*fmt;
   ++fmt;
  }
  /* Default base */
  base=10;
  switch(*fmt)
  {
   case 'c':
    if(!(flags&LEFT))
     while(--field_width>0)
      buf[p_buf++]=' ';
    buf[p_buf++]=(unsigned char)va_arg(args, int);
    while(--field_width>0)
     buf[p_buf++]=' ';
    continue;
   case 's':
    if(!(flags&FAR_STR))
     s=(char FAR *)va_arg(args, char NEAR *);
    else
     s=va_arg(args, char FAR *);
#ifdef DEBUG
    if(!s)
     s="(null)";
#endif
    len=strnlen(s, precision);
    if(!(flags&LEFT))
    {
     while(len<field_width--)
     {
      if(p_buf>=CHUNK_SIZE-1)
      {
       buf[p_buf]='\0';
       rc+=p_buf;
       p_buf=0;
       flush_cbuf(ocode, buf);
      }
      buf[p_buf++]=' ';
     }
    }
    for(i=0; i<len; ++i)
    {
     if(p_buf>=CHUNK_SIZE-1)
     {
      buf[p_buf]='\0';
      rc+=p_buf;
      p_buf=0;
      flush_cbuf(ocode, buf);
     }
     buf[p_buf++]=*s++;
    }
    while(len<field_width--)
    {
     if(p_buf>=CHUNK_SIZE-1)
     {
      buf[p_buf]='\0';
      rc+=p_buf;
      p_buf=0;
      flush_cbuf(ocode, buf);
     }
     buf[p_buf++]=' ';
    }
    continue;
   case 'p':
    if(field_width==-1)
    {
     field_width=2*sizeof(void *);
     flags|=ZEROPAD;
    }
    p_buf+=number(buf+p_buf, (unsigned long)va_arg(args, void *), 16,
                  field_width, precision, flags);
    continue;
   case 'n':
    if(qualifier=='l')
    {
     ipl=va_arg(args, long *);
     *ipl=p_buf;
    }
    else
    {
     ipi=va_arg(args, int *);
     *ipi=p_buf;
    }
    continue;
   /* Integer number formats - set up the flags and "break" */
   case 'o':
    base=8;
    break;
   case 'X':
    flags|=LARGE;
   case 'x':
    base=16;
    break;
   case 'd':
   case 'i':
    flags|=SIGN;
   case 'u':
    break;
   default:
    if(*fmt!='%')
     buf[p_buf++]='%';
    if(*fmt)
     buf[p_buf++]=*fmt;
    else
     --fmt;
    continue;
   }
   if(qualifier=='l')
    num=va_arg(args, unsigned long);
   else if(qualifier=='h')
   {
#ifdef __linux__
    if (flags&SIGN)
     num=va_arg(args, int);             /* num=va_arg(args, short);      */
    else
     num=va_arg(args, int);             /* num=va_arg(args, unsigned short);*/
#else
    if(flags&SIGN)
     num=va_arg(args, short);
    else
     num=va_arg(args, unsigned short);
#endif
   }
   else if(flags&SIGN)
    num=va_arg(args, int);
   else
    num=va_arg(args, unsigned int);
   p_buf+=number(buf+p_buf, num, base, field_width, precision, flags);
 }
 if(p_buf>0)
 {
  buf[p_buf]='\0';
  rc+=p_buf;
  flush_cbuf(last_fmt?ocode:ccode, buf);
 }
 return(rc);
}

#endif /* CUSTOM_PRINTF */

#if SFX_LEVEL>=ARJSFX||defined(REARJ)

/* Helper routine for scrprintf() */

int msg_cprintf(int ccode, FMSG *fmt, ...)
{
 #ifndef CUSTOM_PRINTF
  char *storage;
 #endif
 va_list marker;
 int result;

 #ifndef CUSTOM_PRINTF
  #ifdef FMSG_ST
   storage=malloc_far_str(fmt);
  #else
   storage=fmt;
  #endif
 #endif
 va_start(marker, fmt);
 #if defined(CUSTOM_PRINTF)
  result=vcprintf(ccode, fmt, marker);
 #elif SFX_LEVEL>=ARJSFXV
  result=vfprintf(new_stdout, (FMSG *)storage, marker);
 #else
  result=vprintf(storage, marker);
 #endif
 va_end(marker);
 #if defined(FMSG_ST)&&!defined(CUSTOM_PRINTF)
  free(storage);
 #endif
 return(result);
}

#endif

#if SFX_LEVEL>=ARJSFX&&defined(TILED)

/* A model-independent movedata() function (it must go to ENVIRON.C) */

void far_memmove(char FAR *dest, char FAR *src, int length)
{
 movedata(FP_SEG(src), FP_OFF(src), FP_SEG(dest), FP_OFF(dest), length);
}

#endif

#if SFX_LEVEL>=ARJ

/* Initializes CRC32 subsystem (only used by main()) */

void init_crc()
{
 build_crc32_table();
}

/* Returns CRC32 for the given block */

void crc_for_block(char *block, unsigned int length)
{
 crc32_for_block(block, length);
}

/* Returns CRC32 for the given string */

void crc_for_string(char *str)
{
 crc32_for_string(str);
}

#endif

#ifdef COLOR_OUTPUT

/* Parse the color table */

int parse_colors(char *opt)
{
 int i, c;
 char *p;
 int rc=0;

 if(*opt=='\0')
 {
  no_colors=1;
  textcolor(7);                         /* HACK */
  return(0);
 }
 while(*opt!='\0')
 {
  for(p=opt; !isdigit(*p); p++)
  {
   if(*p=='\0')
   {
    opt=p;
    goto next_opt;
   }
  }
  c=atoi(p);
  if(c>=32)
   rc++;
  else
  {
   for(i=0; color_table[i].arg!='\0'||!(++rc); i++)
   {
    if(color_table[i].arg==tolower(*opt))
    {
     color_table[i].color=(char)c;
     break;
    }
   }
  }
  next_opt:
  while(*opt!='\0'&&!isdigit(*opt))
   opt++;
  while(*opt!='\0'&&(isdigit(*opt)||!isalpha(*opt)))
   opt++;
 }
 return(rc);
}

#endif