The CDPD Public Domain Collection for CDTV 4/CDPD_IV.bin/utilities/print/aroff/sources/fichiers.c

C/C++ Source or Header | 1994-06-28 | 4.6 KB | 227 lines

/*
 * Fonctions d'acces aux fichiers
 * (c)1991 par Denis GOUNELLE
 */

#include "aroff.h"
#include "pile.h"

extern struct TeteListe TMac ;
extern struct Macro *CurrentMacro ;
extern struct String *CurrentString ;
extern unsigned char OutputBuf[], Arg[] ;
extern struct InputFile *CurrentInputFile ;
extern long InputMode, OutputLen, TmpLineLen, ArgLen, Flg, EmptyToWrite ;

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

static long GetFromMac()
{
  register long c ;
  register struct Macro *m ;

  m = CurrentMacro ;

  if ( (m->m_NextL) && (m->m_NextC >= m->m_NextL->ml_Len) )
  {
    m->m_NextC = 0 ;
    m->m_NextL = (struct MLine *)m->m_NextL->ml_Node.el_Suivant ;
    return( '\n' ) ;
  }

  if ( m->m_NextL )
  {
    c = m->m_NextL->ml_Text[m->m_NextC] ;
    m->m_NextC++ ;
    return( c ) ;
  }

  return( EOF ) ;
}

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

long GetChar()
{
  char *p ;
  register long c ;
  struct InputFile *f ;
  register struct Macro *m ;
  register struct String *s ;

  if ( InputMode & IM_EXMACRO )
  {

_restart:

    for (;;)
    {
      c = GetFromMac() ;
      if ( c != EOF ) return( c ) ;

      BCLR( Flg , F_TRAP ) ;
      InputMode = Pop( TE_INMODE , 1 ) ;

      if ( InputMode & IM_STRING )
      {
        s = (struct String *)Pop( TE_STRING , 1 ) ;
        CurrentString = s ;
      }
      if (! (InputMode & IM_EXMACRO)) break ;

      m = (struct Macro *)Pop( TE_MACRO , 1 ) ;

      CurrentMacro = m ;
      if ( m->m_Flag & MF_TRAP ) BSET( Flg , F_TRAP ) ;
      if ( m->m_Flag & MF_WAIT )
      {
    BCLR( m->m_Flag , MF_WAIT ) ;
    p = (char *)Pop( TE_OUTLINE , 1 ) ;
    c = Pop( TE_TOWRITE , 0 ) ;
    if ( c != -1 ) EmptyToWrite = c ;
    LigneSuiv( p ) ;
    free( p ) ;
      }
    }

    while (! (Flg & F_TRAP))
    {
      p = (char *)Pop( TE_OUTLINE , 0 ) ;
      if ( (! p) || (p == (char *)-1) ) break ;
      c = Pop( TE_TOWRITE , 0 ) ;
      if ( c != -1 ) EmptyToWrite = c ;
      LigneSuiv( p ) ;
      free( p ) ;
    }

    if ( Flg & F_TRAP ) goto _restart ;
    BCLR( InputMode , IM_EXMACRO ) ;
    CurrentMacro = NULL ;
  }

  if ( InputMode & IM_STRING )
  {
    s = CurrentString ;
    c = s->s_val[s->s_pos] ;
    s->s_pos++ ;
    if ( s->s_pos >= s->s_len )
    {
      InputMode = Pop( TE_INMODE , 1 ) ;
      if ( InputMode & IM_STRING )
      {
        s = (struct String *)Pop( TE_STRING , 1 ) ;
        CurrentString = s ;
      }
      else if ( InputMode & IM_EXMACRO )
      {
        m = (struct Macro *)Pop( TE_MACRO , 1 ) ;
        CurrentMacro = m ;
      }
    }
    return( c ) ;
  }

  f = CurrentInputFile ;

  /* si fin du tampon, lit LGMAXBUF octets dans le fichier */
  if ( f->if_NextC >= f->if_BufLen )
  {
    f->if_NextC = 0 ;
    f->if_BufLen = read( f->if_Desc , f->if_Buf , LGMAXBUF ) ;
    if (! f->if_BufLen) return( EOF ) ;
  }

  /* lecture normale */
  c = f->if_Buf[f->if_NextC] ;
  f->if_NextC++ ;
  return( c ) ;
}

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

long PutChar( c )
char c ;

{
  register struct MLine *l ;

  if ( InputMode & IM_RDMACRO )
  {
    if ( c == '\n' ) CurrentMacro->m_NextL = NULL ;

    l = CurrentMacro->m_NextL ;
    if ( ! l )
    {
      l = (struct MLine *)myalloc( sizeof(struct MLine) , 1 ) ;
      InsereQueue( &(CurrentMacro->m_Def) , l ) ;
      CurrentMacro->m_NextL = l ;
      CurrentMacro->m_NextC = 0 ;
    }

    if ( c == '\n' ) return( 0 ) ;

    if ( l->ml_Len >= LGMAXSTR ) Fatal( ERR_OVERFLOW ) ;
    l->ml_Text[l->ml_Len] = c ;
    l->ml_Len++ ;
    return( 0 ) ;
  }

  if ( InputMode & IM_RDARGS )
  {
    if ( ArgLen >= LGMAXSTR ) Fatal( ERR_OVERFLOW ) ;
    Arg[ArgLen] = c ;
    ArgLen++ ;
    return( 0 ) ;
  }

  if ( OutputLen >= LGMAXBUF ) Fatal( ERR_OVERFLOW ) ;
  OutputBuf[OutputLen] = c ;
  OutputLen++ ;
  return( OutputLen > TmpLineLen ) ;
}

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

struct InputFile *NewFile( name )
char *name ;

{
  struct InputFile *f ;

  f = (struct InputFile *)myalloc( sizeof(struct InputFile) , 1 ) ;

  if (! strcmp( name , "-" ))
  {
    strcpy( f->if_Name , "stdin" ) ;
    f->if_Desc = 0 ;
    BSET( f->if_Flag , IFF_STDIN ) ;
  }
  else
  {
    strcpy( f->if_Name , name ) ;
    f->if_Desc = open( name , O_RDONLY ) ;
  }

  if ( f->if_Desc == -1 ) Fatal( ERR_OPEN ) ;
  f->if_Line = 1 ;
  return( f ) ;
}

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

void CloseFile( f )
struct InputFile *f ;

{
  if ( (f != NULL) &&
       (f != (struct InputFile *)-1) &&
       (f->if_Desc > 0) &&
       (! (f->if_Flag & IFF_STDIN)) )
  {
    close( f->if_Desc ) ;
    f->if_Desc = -1 ;
  }

}