UserDefined

Functions
TRIO_PUBLIC trio_pointer_t trio_register	TRIO_ARGS2 ((callback, name), trio_callback_t callback, TRIO_CONST char *name)
void trio_unregister	TRIO_ARGS1 ((handle), trio_pointer_t handle)
TRIO_CONST char *trio_get_format	TRIO_ARGS1 ((ref), trio_pointer_t ref)
void trio_set_width	TRIO_ARGS2 ((ref, width), trio_pointer_t ref, int width)
void trio_set_precision	TRIO_ARGS2 ((ref, precision), trio_pointer_t ref, int precision)
void trio_set_base	TRIO_ARGS2 ((ref, base), trio_pointer_t ref, int base)
void trio_set_long	TRIO_ARGS2 ((ref, is_long), trio_pointer_t ref, int is_long)
void trio_set_longlong	TRIO_ARGS2 ((ref, is_longlong), trio_pointer_t ref, int is_longlong)
void trio_set_longdouble	TRIO_ARGS2 ((ref, is_longdouble), trio_pointer_t ref, int is_longdouble)
void trio_set_short	TRIO_ARGS2 ((ref, is_short), trio_pointer_t ref, int is_short)
void trio_set_shortshort	TRIO_ARGS2 ((ref, is_shortshort), trio_pointer_t ref, int is_shortshort)
void trio_set_alternative	TRIO_ARGS2 ((ref, is_alternative), trio_pointer_t ref, int is_alternative)
void trio_set_alignment	TRIO_ARGS2 ((ref, is_leftaligned), trio_pointer_t ref, int is_leftaligned)
void trio_set_spacing	TRIO_ARGS2 ((ref, is_space), trio_pointer_t ref, int is_space)
void trio_set_sign	TRIO_ARGS2 ((ref, is_sign), trio_pointer_t ref, int is_sign)
void trio_set_padding	TRIO_ARGS2 ((ref, is_padding), trio_pointer_t ref, int is_padding)
void trio_set_quote	TRIO_ARGS2 ((ref, is_quote), trio_pointer_t ref, int is_quote)
void trio_set_upper	TRIO_ARGS2 ((ref, is_upper), trio_pointer_t ref, int is_upper)
void trio_set_largest	TRIO_ARGS2 ((ref, is_largest), trio_pointer_t ref, int is_largest)
void trio_set_ptrdiff	TRIO_ARGS2 ((ref, is_ptrdiff), trio_pointer_t ref, int is_ptrdiff)
void trio_set_size	TRIO_ARGS2 ((ref, is_size), trio_pointer_t ref, int is_size)
void trio_print_int	TRIO_ARGS2 ((ref, number), trio_pointer_t ref, int number)
void trio_print_uint	TRIO_ARGS2 ((ref, number), trio_pointer_t ref, unsigned int number)
void trio_print_double	TRIO_ARGS2 ((ref, number), trio_pointer_t ref, double number)
void trio_print_string	TRIO_ARGS2 ((ref, string), trio_pointer_t ref, char *string)
int trio_print_ref	TRIO_VARGS3 ((ref, format, va_alist), trio_pointer_t ref, TRIO_CONST char *format, TRIO_VA_DECL)
int trio_vprint_ref	TRIO_ARGS3 ((ref, format, arglist), trio_pointer_t ref, TRIO_CONST char *format, va_list arglist)
int trio_printv_ref	TRIO_ARGS3 ((ref, format, argarray), trio_pointer_t ref, TRIO_CONST char *format, trio_pointer_t *argarray)
void trio_print_pointer	TRIO_ARGS2 ((ref, pointer), trio_pointer_t ref, trio_pointer_t pointer)

Detailed Description

Function Documentation

void trio_unregister TRIO_ARGS1	(	(handle)	,
		trio_pointer_t	handle
	)

Unregister an existing user-defined specifier.

Parameters

handle

Definition at line 4359 of file trio.c.

{
  trio_userdef_t *self = (trio_userdef_t *)handle;
  trio_userdef_t *def;
  trio_userdef_t *prev = NULL;

  assert(VALID(self));

  if (self->name)
    {
      def = TrioFindNamespace(self->name, &prev);
      if (def)
    {
      if (internalEnterCriticalRegion)
        (void)internalEnterCriticalRegion(NULL);

      if (prev == NULL)
        internalUserDef = NULL;
      else
        prev->next = def->next;

      if (internalLeaveCriticalRegion)
        (void)internalLeaveCriticalRegion(NULL);
    }
      trio_destroy(self->name);
    }
  TRIO_FREE(self);
}

int trio_get_size TRIO_ARGS1	(	(ref)	,
		trio_pointer_t	ref
	)

Definition at line 4394 of file trio.c.

{
#if defined(FORMAT_USER_DEFINED)
  assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);
#endif

  return (((trio_reference_t *)ref)->parameter->user_data);
}

TRIO_PUBLIC trio_pointer_t trio_register TRIO_ARGS2	(	(callback, name)	,
		trio_callback_t	callback,
		TRIO_CONST char *	name
	)

Register new user-defined specifier.

Parameters

callback
name

Returns

Handle.

Definition at line 4289 of file trio.c.

{
  trio_userdef_t *def;
  trio_userdef_t *prev = NULL;

  if (callback == NULL)
    return NULL;

  if (name)
    {
      /* Handle built-in namespaces */
      if (name[0] == ':')
    {
      if (trio_equal(name, ":enter"))
        {
          internalEnterCriticalRegion = callback;
        }
      else if (trio_equal(name, ":leave"))
        {
          internalLeaveCriticalRegion = callback;
        }
      return NULL;
    }

      /* Bail out if namespace is too long */
      if (trio_length(name) >= MAX_USER_NAME)
    return NULL;

      /* Bail out if namespace already is registered */
      def = TrioFindNamespace(name, &prev);
      if (def)
    return NULL;
    }

  def = (trio_userdef_t *)TRIO_MALLOC(sizeof(trio_userdef_t));
  if (def)
    {
      if (internalEnterCriticalRegion)
    (void)internalEnterCriticalRegion(NULL);

      if (name)
    {
      /* Link into internal list */
      if (prev == NULL)
        internalUserDef = def;
      else
        prev->next = def;
    }
      /* Initialize */
      def->callback = callback;
      def->name = (name == NULL)
    ? NULL
    : trio_duplicate(name);
      def->next = NULL;

      if (internalLeaveCriticalRegion)
    (void)internalLeaveCriticalRegion(NULL);
    }
  return (trio_pointer_t)def;
}

void trio_set_width TRIO_ARGS2	(	(ref, width)	,
		trio_pointer_t	ref,
		int	width
	)

Definition at line 4432 of file trio.c.

{
  ((trio_reference_t *)ref)->parameter->width = width;
}

void trio_set_precision TRIO_ARGS2	(	(ref, precision)	,
		trio_pointer_t	ref,
		int	precision
	)

Definition at line 4452 of file trio.c.

{
  ((trio_reference_t *)ref)->parameter->precision = precision;
}

void trio_set_base TRIO_ARGS2	(	(ref, base)	,
		trio_pointer_t	ref,
		int	base
	)

Definition at line 4472 of file trio.c.

{
  ((trio_reference_t *)ref)->parameter->base = base;
}

void trio_set_long TRIO_ARGS2	(	(ref, is_long)	,
		trio_pointer_t	ref,
		int	is_long
	)

Definition at line 4494 of file trio.c.

{
  if (is_long)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONG;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONG;
}

void trio_set_longlong TRIO_ARGS2	(	(ref, is_longlong)	,
		trio_pointer_t	ref,
		int	is_longlong
	)

Definition at line 4519 of file trio.c.

{
  if (is_longlong)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUAD;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUAD;
}

void trio_set_longdouble TRIO_ARGS2	(	(ref, is_longdouble)	,
		trio_pointer_t	ref,
		int	is_longdouble
	)

Definition at line 4544 of file trio.c.

{
  if (is_longdouble)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONGDOUBLE;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE;
}

void trio_set_short TRIO_ARGS2	(	(ref, is_short)	,
		trio_pointer_t	ref,
		int	is_short
	)

Definition at line 4569 of file trio.c.

{
  if (is_short)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORT;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORT;
}

void trio_set_shortshort TRIO_ARGS2	(	(ref, is_shortshort)	,
		trio_pointer_t	ref,
		int	is_shortshort
	)

Definition at line 4594 of file trio.c.

{
  if (is_shortshort)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORTSHORT;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORTSHORT;
}

void trio_set_alternative TRIO_ARGS2	(	(ref, is_alternative)	,
		trio_pointer_t	ref,
		int	is_alternative
	)

Definition at line 4619 of file trio.c.

{
  if (is_alternative)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_ALTERNATIVE;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE;
}

void trio_set_alignment TRIO_ARGS2	(	(ref, is_leftaligned)	,
		trio_pointer_t	ref,
		int	is_leftaligned
	)

Definition at line 4644 of file trio.c.

{
  if (is_leftaligned)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LEFTADJUST;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LEFTADJUST;
}

void trio_set_spacing TRIO_ARGS2	(	(ref, is_space)	,
		trio_pointer_t	ref,
		int	is_space
	)

Definition at line 4669 of file trio.c.

{
  if (is_space)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SPACE;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SPACE;
}

void trio_set_sign TRIO_ARGS2	(	(ref, is_sign)	,
		trio_pointer_t	ref,
		int	is_sign
	)

Definition at line 4694 of file trio.c.

{
  if (is_sign)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHOWSIGN;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHOWSIGN;
}

void trio_set_padding TRIO_ARGS2	(	(ref, is_padding)	,
		trio_pointer_t	ref,
		int	is_padding
	)

Definition at line 4719 of file trio.c.

{
  if (is_padding)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_NILPADDING;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_NILPADDING;
}

void trio_set_quote TRIO_ARGS2	(	(ref, is_quote)	,
		trio_pointer_t	ref,
		int	is_quote
	)

Definition at line 4744 of file trio.c.

{
  if (is_quote)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUOTE;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUOTE;
}

void trio_set_upper TRIO_ARGS2	(	(ref, is_upper)	,
		trio_pointer_t	ref,
		int	is_upper
	)

Definition at line 4769 of file trio.c.

{
  if (is_upper)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_UPPER;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_UPPER;
}

void trio_set_largest TRIO_ARGS2	(	(ref, is_largest)	,
		trio_pointer_t	ref,
		int	is_largest
	)

Definition at line 4795 of file trio.c.

{
  if (is_largest)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_INTMAX_T;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_INTMAX_T;
}

void trio_set_ptrdiff TRIO_ARGS2	(	(ref, is_ptrdiff)	,
		trio_pointer_t	ref,
		int	is_ptrdiff
	)

Definition at line 4821 of file trio.c.

{
  if (is_ptrdiff)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_PTRDIFF_T;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T;
}

void trio_set_size TRIO_ARGS2	(	(ref, is_size)	,
		trio_pointer_t	ref,
		int	is_size
	)

Definition at line 4847 of file trio.c.

{
  if (is_size)
    ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SIZE_T;
  else
    ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SIZE_T;
}

void trio_print_int TRIO_ARGS2	(	(ref, number)	,
		trio_pointer_t	ref,
		int	number
	)

Definition at line 4863 of file trio.c.

{
  trio_reference_t *self = (trio_reference_t *)ref;

  TrioWriteNumber(self->data,
          (trio_uintmax_t)number,
          self->parameter->flags,
          self->parameter->width,
          self->parameter->precision,
          self->parameter->base);
}

void trio_print_uint TRIO_ARGS2	(	(ref, number)	,
		trio_pointer_t	ref,
		unsigned int	number
	)

Definition at line 4882 of file trio.c.

{
  trio_reference_t *self = (trio_reference_t *)ref;

  TrioWriteNumber(self->data,
          (trio_uintmax_t)number,
          self->parameter->flags | FLAGS_UNSIGNED,
          self->parameter->width,
          self->parameter->precision,
          self->parameter->base);
}

void trio_print_double TRIO_ARGS2	(	(ref, number)	,
		trio_pointer_t	ref,
		double	number
	)

Definition at line 4901 of file trio.c.

{
  trio_reference_t *self = (trio_reference_t *)ref;

  TrioWriteDouble(self->data,
          number,
          self->parameter->flags,
          self->parameter->width,
          self->parameter->precision,
          self->parameter->base);
}

void trio_print_string TRIO_ARGS2	(	(ref, string)	,
		trio_pointer_t	ref,
		char *	string
	)

Definition at line 4920 of file trio.c.

{
  trio_reference_t *self = (trio_reference_t *)ref;

  TrioWriteString(self->data,
          string,
          self->parameter->flags,
          self->parameter->width,
          self->parameter->precision);
}

void trio_print_pointer TRIO_ARGS2	(	(ref, pointer)	,
		trio_pointer_t	ref,
		trio_pointer_t	pointer
	)

Definition at line 4991 of file trio.c.

{
  trio_reference_t *self = (trio_reference_t *)ref;
  trio_flags_t flags;
  trio_uintmax_t number;

  if (NULL == pointer)
    {
      TRIO_CONST char *string = internalNullString;
      while (*string)
    self->data->OutStream(self->data, *string++);
    }
  else
    {
      /*
       * The subtraction of the null pointer is a workaround
       * to avoid a compiler warning. The performance overhead
       * is negligible (and likely to be removed by an
       * optimizing compiler). The (char *) casting is done
       * to please ANSI C++.
       */
      number = (trio_uintmax_t)((char *)pointer - (char *)0);
      /* Shrink to size of pointer */
      number &= (trio_uintmax_t)-1;
      flags = self->parameter->flags;
      flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE |
            FLAGS_NILPADDING);
      TrioWriteNumber(self->data,
              number,
              flags,
              POINTER_WIDTH,
              NO_PRECISION,
              BASE_HEX);
    }
}

int trio_vprint_ref TRIO_ARGS3	(	(ref, format, arglist)	,
		trio_pointer_t	ref,
		TRIO_CONST char *	format,
		va_list	arglist
	)

Definition at line 4959 of file trio.c.

{
  assert(VALID(format));

  return TrioFormatRef((trio_reference_t *)ref, format, TRIO_VA_LIST_ADDR(arglist), NULL);
}

int trio_printv_ref TRIO_ARGS3	(	(ref, format, argarray)	,
		trio_pointer_t	ref,
		TRIO_CONST char *	format,
		trio_pointer_t *	argarray
	)

Definition at line 4974 of file trio.c.

{
  assert(VALID(format));

  return TrioFormatRef((trio_reference_t *)ref, format, NULL, argarray);
}

int trio_print_ref TRIO_VARGS3	(	(ref, format, va_alist)	,
		trio_pointer_t	ref,
		TRIO_CONST char *	format,
		TRIO_VA_DECL
	)

Definition at line 4938 of file trio.c.

{
  int status;
  va_list arglist;

  assert(VALID(format));

  TRIO_VA_START(arglist, format);
  status = TrioFormatRef((trio_reference_t *)ref, format, TRIO_VA_LIST_ADDR(arglist), NULL);
  TRIO_VA_END(arglist);
  return status;
}