Text-CPP

 view release on metacpan or  search on metacpan

cpphash.h  view on Meta::CPAN

  /* At EOF, a buffer is automatically popped.  If RETURN_AT_EOF is
     true, a CPP_EOF token is then returned.  Otherwise, the next
     token from the enclosing buffer is returned.  */
  bool return_at_eof;

  /* The directory of the this buffer's file.  Its NAME member is not
     allocated, so we don't need to worry about freeing it.  */
  struct search_path dir;

  /* Used for buffer overlays by cpptrad.c.  */
  const uchar *saved_cur, *saved_rlimit;
};

/* A cpp_reader encapsulates the "state" of a pre-processor run.
   Applying cpp_get_token repeatedly yields a stream of pre-processor
   tokens.  Usually, there is only one cpp_reader object active.  */
struct cpp_reader
{
  /* Top of buffer stack.  */
  cpp_buffer *buffer;

cpphash.h  view on Meta::CPAN

extern void _cpp_do__Pragma	PARAMS ((cpp_reader *));
extern void _cpp_init_directives PARAMS ((cpp_reader *));
extern void _cpp_init_internal_pragmas PARAMS ((cpp_reader *));
extern void _cpp_do_file_change PARAMS ((cpp_reader *, enum lc_reason,
					 const char *,
					 unsigned int, unsigned int));
extern void _cpp_pop_buffer PARAMS ((cpp_reader *));

/* In cpptrad.c.  */
extern bool _cpp_read_logical_line_trad PARAMS ((cpp_reader *));
extern void _cpp_overlay_buffer PARAMS ((cpp_reader *pfile, const uchar *,
					 size_t));
extern void _cpp_remove_overlay PARAMS ((cpp_reader *));
extern bool _cpp_create_trad_definition PARAMS ((cpp_reader *, cpp_macro *));
extern bool _cpp_expansions_different_trad PARAMS ((const cpp_macro *,
						    const cpp_macro *));
extern uchar *_cpp_copy_replacement_text PARAMS ((const cpp_macro *, uchar *));
extern size_t _cpp_replacement_text_len PARAMS ((const cpp_macro *));

/* Utility routines and macros.  */
#define DSC(str) (const uchar *)str, sizeof str - 1
#define xnew(T)		(T *) xmalloc (sizeof(T))
#define xcnew(T)	(T *) xcalloc (1, sizeof(T))

cpplex.c  view on Meta::CPAN

{
  cpp_buffer *buffer = pfile->buffer;
  bool more = false;

  buffer->saved_flags = BOL;
  if (CPP_OPTION (pfile, traditional))
    {
      if (pfile->state.in_directive)
	return false;

      _cpp_remove_overlay (pfile);
      more = _cpp_read_logical_line_trad (pfile);
      _cpp_overlay_buffer (pfile, pfile->out.base,
			   pfile->out.cur - pfile->out.base);
      pfile->line = pfile->out.first_line;
    }
  else
    {
      /* Stop parsing arguments with a CPP_EOF.  When we finally come
	 back here, do the work of popping the buffer.  */
      if (!pfile->state.parsing_args)
	{
	  if (buffer->cur != buffer->line_base)

cpplib.c  view on Meta::CPAN

end_directive (pfile, skip_line)
     cpp_reader *pfile;
     int skip_line;
{
  if (CPP_OPTION (pfile, traditional))
    {
      /* Revert change of prepare_directive_trad.  */
      pfile->state.prevent_expansion--;

      if (pfile->directive != &dtable[T_DEFINE])
	_cpp_remove_overlay (pfile);
    }
  /* We don't skip for an assembler #.  */
  else if (skip_line)
    {
      skip_rest_of_line (pfile);
      if (!pfile->keep_tokens)
	{
	  pfile->cur_run = &pfile->base_run;
	  pfile->cur_token = pfile->base_run.base;
	}

cpplib.c  view on Meta::CPAN

      pfile->state.skipping = false;
      pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
				    || pfile->directive == &dtable[T_ELIF]);
      if (no_expand)
	pfile->state.prevent_expansion++;
      _cpp_read_logical_line_trad (pfile);
      if (no_expand)
	pfile->state.prevent_expansion--;
      pfile->state.skipping = was_skipping;
      _cpp_overlay_buffer (pfile, pfile->out.base,
			   pfile->out.cur - pfile->out.base);
    }

  /* Stop ISO C from expanding anything.  */
  pfile->state.prevent_expansion++;
}

/* Output diagnostics for a directive DIR.  INDENTED is nonzero if
   the '#' was indented.  */
static void

cpptrad.c  view on Meta::CPAN

  result = (cpp_hashnode *) ht_lookup (pfile->hash_table, pfile->out.cur,
				       len, HT_ALLOC);
  pfile->out.cur = out;
  return result;
}

/* Overlays the true file buffer temporarily with text of length LEN
   starting at START.  The true buffer is restored upon calling
   restore_buff().  */
void
_cpp_overlay_buffer (pfile, start, len)
     cpp_reader *pfile;
     const uchar *start;
     size_t len;
{
  cpp_buffer *buffer = pfile->buffer;

  pfile->overlaid_buffer = buffer;
  buffer->saved_cur = buffer->cur;
  buffer->saved_rlimit = buffer->rlimit;

  buffer->cur = start;
  buffer->rlimit = start + len;

  pfile->saved_line = pfile->line;
}

/* Restores a buffer overlaid by _cpp_overlay_buffer().  */
void
_cpp_remove_overlay (pfile)
     cpp_reader *pfile;
{
  cpp_buffer *buffer = pfile->overlaid_buffer;

  buffer->cur = buffer->saved_cur;
  buffer->rlimit = buffer->saved_rlimit;

  pfile->line = pfile->saved_line;
}