console.c

Go to the documentation of this file.

 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include "vm_config.h"
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#if MRBC_USE_FLOAT
#include <stdio.h>
#endif
//@endcond
 
/***** Local headers ********************************************************/
#include "mrubyc.h"
 
/***** Constant values ******************************************************/
#define MRBC_PRINTF_MAX_WIDTH 82
 
 
/***** Macros ***************************************************************/
/***** Typedefs *************************************************************/
/***** Function prototypes **************************************************/
/***** Local variables ******************************************************/
/***** Global variables *****************************************************/
/***** Signal catching functions ********************************************/
/***** Local functions ******************************************************/
//----------------------------------------------------------------
/* sub function for mrbc_printf
*/
static int mrbc_printf_sub_output_arg( mrbc_printf_t *pf, va_list *ap )
{
  int ret;
 
  switch(pf->fmt.type) {
  case 'c':
    ret = mrbc_printf_char( pf, va_arg(*ap, int) );
    break;
 
  case 's':
    ret = mrbc_printf_str( pf, va_arg(*ap, char *), ' ');
    break;
 
  case 'd':
  case 'i':
  case 'u':
    ret = mrbc_printf_int( pf, va_arg(*ap, int), 10);
    break;
 
  case 'D':     // for mrbc_int_t (see mrbc_print_sub)
    ret = mrbc_printf_int( pf, va_arg(*ap, mrbc_int_t), 10);
    break;
 
  case 'b':
  case 'B':
    ret = mrbc_printf_bit( pf, va_arg(*ap, unsigned int), 1);
    break;
 
  case 'x':
  case 'X':
    ret = mrbc_printf_bit( pf, va_arg(*ap, unsigned int), 4);
    break;
 
#if MRBC_USE_FLOAT
  case 'f':
  case 'e':
  case 'E':
  case 'g':
  case 'G':
    ret = mrbc_printf_float( pf, va_arg(*ap, double) );
    break;
#endif
  case 'p':
    ret = mrbc_printf_pointer( pf, va_arg(*ap, void *) );
    break;
 
  default:
    ret = 0;
    break;
  }
 
  return ret;
}
 
/* sub function to print a hashkey
 */
static int mrbc_p_sub_hashkey(const mrbc_value *v)
{
  switch( mrbc_type(*v) ) {
    case MRBC_TT_SYMBOL:{
      const char *s = mrbc_symbol_cstr(v);
      const char *fmt = strchr(s, ':') ? "\"%s\": " : "%s: ";
      mrbc_printf(fmt, s);
      break;
    }
    default: {
      mrbc_p_sub(v);
      mrbc_print(" => ");
      break;
    }
  }
  return 0;
}
 
 
/***** Global functions *****************************************************/
 
//================================================================
void mrbc_putchar(char c)
{
#if defined(MRBC_CONVERT_CRLF)
  static const char CRLF[2] = "\r\n";
  if( c == '\n' ) {
    mrbc_hal_write(1, CRLF, 2);
  } else {
    mrbc_hal_write(1, &c, 1);
  }
 
#else
    mrbc_hal_write(1, &c, 1);
#endif
}
 
 
//================================================================
void mrbc_print_symbol(mrbc_sym sym_id)
{
  // normal case
  if( !mrbc_is_nested_symid(sym_id) ) {
    mrbc_print( mrbc_symid_to_str(sym_id) );
    return;
  }
 
  // nested case
  mrbc_sym id1, id2;
  mrbc_separate_nested_symid( sym_id, &id1, &id2 );
 
  mrbc_print_symbol( id1 );
  mrbc_print("::");
  mrbc_print_symbol( id2 );
}
 
 
//================================================================
void mrbc_nprint(const char *str, int size)
{
#if defined(MRBC_CONVERT_CRLF)
  static const char CRLF[2] = "\r\n";
  const char *p1 = str;
  const char *p2 = str;
 
  for( int i = 0; i < size; i++ ) {
    if( *p1++ == '\n' ) {
      mrbc_hal_write(1, p2, p1 - p2 - 1);
      mrbc_hal_write(1, CRLF, 2);
      p2 = p1;
    }
  }
  if( p1 != p2 ) {
    mrbc_hal_write(1, p2, p1 - p2);
  }
 
#else
  mrbc_hal_write(1, str, size);
#endif
}
 
 
//================================================================
void mrbc_printf(const char *fstr, ...)
{
  va_list ap;
  va_start(ap, fstr);
 
  mrbc_vprintf( fstr, ap );
 
  va_end(ap);
}
 
 
//================================================================
void mrbc_asprintf(char **buf, int bufsiz, const char *fstr, ...)
{
  va_list ap;
  va_start(ap, fstr);
 
  mrbc_vasprintf( buf, bufsiz, fstr, ap );
 
  va_end(ap);
}
 
 
//================================================================
void mrbc_snprintf(char *buf, int bufsiz, const char *fstr, ...)
{
  va_list ap;
  va_start(ap, fstr);
 
  mrbc_printf_t pf;
  mrbc_printf_init( &pf, buf, bufsiz, fstr );
 
  while( 1 ) {
    if( mrbc_printf_main( &pf ) <= 0 ) break;
                                // normal end (==0) or buffer full (<0).
    if( mrbc_printf_sub_output_arg( &pf, &ap ) != 0 ) break;
  }
 
  mrbc_printf_end( &pf );
  va_end(ap);
}
 
 
//================================================================
void mrbc_vprintf(const char *fstr, va_list ap)
{
  va_list ap1;
  va_copy( ap1, ap );
 
  mrbc_printf_t pf;
  char buf[MRBC_PRINTF_MAX_WIDTH];
  mrbc_printf_init( &pf, buf, sizeof(buf), fstr );
 
  while( 1 ) {
    int ret = mrbc_printf_main( &pf );
    if( mrbc_printf_len( &pf ) ) {
      mrbc_nprint( buf, mrbc_printf_len( &pf ) );
      mrbc_printf_clear( &pf );
    }
    if( ret == 0 ) break;
    if( ret < 0 ) continue;
 
    mrbc_printf_sub_output_arg( &pf, &ap1 );
    mrbc_nprint( buf, mrbc_printf_len( &pf ) );
    mrbc_printf_clear( &pf );
  }
 
  va_end(ap1);
}
 
 
//================================================================
void mrbc_vasprintf(char **buf, int bufsiz, const char *fstr, va_list ap)
{
  va_list ap1, ap_bak;
  va_copy( ap1, ap );
 
  mrbc_printf_t pf;
  mrbc_printf_init( &pf, *buf, bufsiz, fstr );
 
  while( 1 ) {
    va_copy(ap_bak, ap1);
    mrbc_printf_t pf_bak = pf;
 
    int ret = mrbc_printf_main( &pf );
    if( ret == 0 ) break;       // normal break loop.
    if( ret < 0 ) goto INCREASE_BUFFER;
 
    ret = mrbc_printf_sub_output_arg( &pf, &ap1 );
    if( ret >= 0 ) goto NEXT_LOOP;
 
    va_end(ap1);
    va_copy(ap1, ap_bak);
    pf = pf_bak;
 
  INCREASE_BUFFER:
    bufsiz += 64;
    void *newbuf = mrbc_raw_realloc( pf.buf, bufsiz );
 
    mrbc_printf_replace_buffer( &pf, newbuf, bufsiz );
    *buf = newbuf;
 
  NEXT_LOOP:
    va_end(ap_bak);
  }
 
  mrbc_printf_end( &pf );
  va_end(ap1);
  va_end(ap_bak);
}
 
 
//================================================================
void mrbc_p(const mrbc_value *v)
{
  mrbc_p_sub( v );
  mrbc_putchar('\n');
}
 
 
//================================================================
void mrbc_char_to_s( char *buf, const void *src )
{
  unsigned char ch = *((unsigned char *)src);
 
  if( ch == 0x7f ) goto hex;
  if( ch < ' ' ) {
    char ch1 = "\0\0\0\0\0\0\0abtnvfr\0\0\0\0\0\0\0\0\0\0\0\0\0e\0\0\0"[ ch ];
    if( ch1 == 0 ) goto hex;
    ch = ch1;
    goto esc;
  }
  if( ch == '"' || ch == '\\' ) {
    goto esc;
  }
 
  buf[0] = ch;
  buf[1] = 0;
  return;
 
 hex:
  buf[0] = '\\';
  buf[1] = 'x';
  buf[2] = "0123456789ABCDEF"[ch >> 4];
  buf[3] = "0123456789ABCDEF"[ch & 0x0f];
  buf[4] = 0;
  return;
 
 esc:
  buf[0] = '\\';
  buf[1] = ch;
  buf[2] = 0;
}
 
 
//================================================================
int mrbc_p_sub(const mrbc_value *v)
{
  if( !v ) {
    mrbc_print("(null)");       // wrong things are happen. but it give me a clue.
    return 0;
  }
 
  switch( mrbc_type(*v) ) {
  case MRBC_TT_NIL:
    mrbc_print("nil");
    break;
 
  case MRBC_TT_SYMBOL:{
    const char *s = mrbc_symbol_cstr( v );
    const char *fmt = strchr(s, ':') ? "\":%s\"" : ":%s";
    mrbc_printf(fmt, s);
  } break;
 
#if MRBC_USE_STRING
  case MRBC_TT_STRING:{
    const char *s = mrbc_string_cstr(v);
    int size = mrbc_string_size(v);
 
    mrbc_putchar('"');
#if MRBC_USE_STRING_UTF8
    for( int i = 0; i < size; ) {
      unsigned char uch = (unsigned char)s[i];
      if( uch < 0x80 ) {
        char buf[10];
        mrbc_char_to_s( buf, s + i );
        mrbc_print( buf );
        i++;
      } else {
        int raw_len = mrbc_string_utf8_size(s + i);
        int valid = (raw_len >= 2 && i + raw_len <= size);
        if( valid ) {
          for( int j = 1; j < raw_len; j++ ) {
            if( ((unsigned char)s[i + j] & 0xC0) != 0x80 ) { valid = 0; break; }
          }
        }
        if( valid ) {
          mrbc_nprint(s + i, raw_len);
          i += raw_len;
        } else {
          char buf[5];
          buf[0] = '\\'; buf[1] = 'x';
          buf[2] = "0123456789ABCDEF"[uch >> 4];
          buf[3] = "0123456789ABCDEF"[uch & 0x0f];
          buf[4] = 0;
          mrbc_print( buf );
          i++;
        }
      }
    }
#else
    for( int i = 0; i < size; i++ ) {
      char buf[10];
      mrbc_char_to_s( buf, s + i );
      mrbc_print( buf );
    }
#endif
    mrbc_putchar('"');
  } break;
#endif
 
  case MRBC_TT_RANGE:{
    const mrbc_value *v1 = mrbc_range_first_p(v);
    const mrbc_value *v2 = mrbc_range_last_p(v);
 
    if( mrbc_type(*v1) != MRBC_TT_NIL ||
        mrbc_type(*v2) == MRBC_TT_NIL ) mrbc_p_sub(v1);
 
    mrbc_print( mrbc_range_exclude_end(v) ? "..." : ".." );
 
    if( mrbc_type(*v1) == MRBC_TT_NIL ||
        mrbc_type(*v2) != MRBC_TT_NIL ) mrbc_p_sub(v2);
  } break;
 
  default:
    mrbc_print_sub(v);
    break;
  }
 
#if 0
  // display reference counter
  if( mrbc_type(*v) > MRBC_TT_INC_DEC_THRESHOLD ) {
    mrbc_printf("#%d", v->obj->ref_count);
  }
#endif
 
  return 0;
}
 
 
//================================================================
int mrbc_puts_sub(const mrbc_value *v)
{
  if( mrbc_type(*v) == MRBC_TT_ARRAY ) {
 
    for( int i = 0; i < mrbc_array_size(v); i++ ) {
      if( i != 0 ) mrbc_putchar('\n');
      mrbc_value v1 = mrbc_array_get(v, i);
      mrbc_puts_sub(&v1);
    }
    return 0;
  }
 
  return mrbc_print_sub(v);
}
 
 
//================================================================
int mrbc_print_sub(const mrbc_value *v)
{
  int ret = 0;
 
  switch( mrbc_type(*v) ) {
  case MRBC_TT_EMPTY:   mrbc_print("(empty)");          break;
  case MRBC_TT_NIL:                                     break;
  case MRBC_TT_FALSE:   mrbc_print("false");            break;
  case MRBC_TT_TRUE:    mrbc_print("true");             break;
  case MRBC_TT_INTEGER: mrbc_printf("%D", v->i);        break;
#if MRBC_USE_FLOAT
  case MRBC_TT_FLOAT: {
    char buf[32];
    mrbc_format_float(buf, sizeof(buf), v->d);
    mrbc_printf("%s", buf);
  } break;
#endif
  case MRBC_TT_SYMBOL:  mrbc_print_symbol(v->sym_id);   break;
  case MRBC_TT_CLASS:   // fall through.
  case MRBC_TT_MODULE:  mrbc_print_symbol(v->cls->sym_id); break;
 
  case MRBC_TT_OBJECT:{
    mrbc_printf("#<");
    mrbc_print_symbol( find_class_by_object(v)->sym_id );
    mrbc_printf(":%08x", MRBC_PTR_TO_UINT32(v->instance) );
 
    mrbc_kv_iterator ite = mrbc_kv_iterator_new( &(v->instance->ivar) );
    while( mrbc_kv_i_has_next( &ite ) ) {
      mrbc_printf( mrbc_kv_i_is_first(&ite) ? " " : ", " );
      const mrbc_kv *kv = mrbc_kv_i_next( &ite );
      mrbc_printf("@%s=", mrbc_symid_to_str(kv->sym_id));
      mrbc_p_sub(&kv->value);
    }
    mrbc_printf(">");
  } break;
 
  case MRBC_TT_PROC:
    mrbc_printf("#<Proc:%08x>", MRBC_PTR_TO_UINT32(v->proc) );
    //mrbc_printf("#<Proc:%08x, callinfo=%p>", MRBC_PTR_TO_UINT32(v->proc), MRBC_PTR_TO_UINT32(v->proc->callinfo) );
    break;
 
  case MRBC_TT_ARRAY:{
    mrbc_putchar('[');
    for( int i = 0; i < mrbc_array_size(v); i++ ) {
      if( i != 0 ) mrbc_print(", ");
      mrbc_value v1 = mrbc_array_get(v, i);
      mrbc_p_sub(&v1);
    }
    mrbc_putchar(']');
  } break;
 
#if MRBC_USE_STRING
  case MRBC_TT_STRING:
    mrbc_nprint( mrbc_string_cstr(v), mrbc_string_size(v) );
    if( mrbc_string_size(v) != 0 &&
        mrbc_string_cstr(v)[ mrbc_string_size(v) - 1 ] == '\n' ) ret = 1;
    break;
#endif
 
  case MRBC_TT_RANGE:{
    mrbc_value *v1 = mrbc_range_first_p(v);
    mrbc_value *v2 = mrbc_range_last_p(v);
 
    mrbc_print_sub(v1);
    mrbc_print( mrbc_range_exclude_end(v) ? "..." : ".." );
    mrbc_print_sub(v2);
  } break;
 
  case MRBC_TT_HASH:{
    mrbc_putchar('{');
    mrbc_hash_iterator ite = mrbc_hash_iterator_new(v);
    while( mrbc_hash_i_has_next(&ite) ) {
      mrbc_value *vk = mrbc_hash_i_next(&ite);
      mrbc_p_sub_hashkey(vk);
      mrbc_p_sub(vk+1);
      if( mrbc_hash_i_has_next(&ite) ) mrbc_print(", ");
    }
    mrbc_putchar('}');
  } break;
 
  case MRBC_TT_HANDLE:
    mrbc_printf("#<Handle:%08x>", MRBC_PTR_TO_UINT32(v->handle) );
    break;
 
  case MRBC_TT_EXCEPTION:
    mrbc_printf("#<%s: %s>", mrbc_symid_to_str(v->exception->cls->sym_id),
                 v->exception->message ?
                   (const char *)v->exception->message :
                   mrbc_symid_to_str(v->exception->cls->sym_id) );
    break;
 
  default:
    mrbc_printf("Not support MRBC_TT_XX(%d)", mrbc_type(*v));
    break;
  }
 
  return ret;
}
 
 
//================================================================
void mrbc_printf_replace_buffer(mrbc_printf_t *pf, char *buf, int size)
{
  int p_ofs = pf->p - pf->buf;
  pf->buf = buf;
  pf->buf_end = buf + size - 1;
  pf->p = pf->buf + p_ofs;
}
 
 
//================================================================
int mrbc_printf_main( mrbc_printf_t *pf )
{
  int ch = -1;
  pf->fmt = (struct RPrintfFormat){0};
 
  while( pf->p < pf->buf_end && (ch = *pf->fstr) != '\0' ) {
    pf->fstr++;
    if( ch == '%' ) {
      if( *pf->fstr == '%' ) {  // is "%%"
        pf->fstr++;
      } else {
        goto PARSE_FLAG;
      }
    }
    *pf->p++ = ch;
  }
  return -(ch != '\0');
 
 
 PARSE_FLAG:
  // parse format - '%' [flag] [width] [.precision] type
  //   e.g. "%05d"
  while( (ch = *pf->fstr) ) {
    switch( ch ) {
    case '+': pf->fmt.flag_plus = 1; break;
    case ' ': pf->fmt.flag_space = 1; break;
    case '-': pf->fmt.flag_minus = 1; break;
    case '0': pf->fmt.flag_zero = 1; break;
    default : goto PARSE_WIDTH;
    }
    pf->fstr++;
  }
 
 PARSE_WIDTH:
  while( (void)(ch = *pf->fstr - '0'), (0 <= ch && ch <= 9)) {  // isdigit()
    pf->fmt.width = pf->fmt.width * 10 + ch;
    pf->fstr++;
  }
  if( *pf->fstr == '.' ) {
    pf->fstr++;
    while( (void)(ch = *pf->fstr - '0'), (0 <= ch && ch <= 9)) {
      pf->fmt.precision = pf->fmt.precision * 10 + ch;
      pf->fstr++;
    }
  }
  if( *pf->fstr ) pf->fmt.type = *pf->fstr++;
 
  return 1;
}
 
 
//================================================================
int mrbc_printf_char( mrbc_printf_t *pf, int ch )
{
  if( pf->fmt.flag_minus ) {
    if( pf->p == pf->buf_end ) return -1;
    *pf->p++ = ch;
  }
 
  int width = pf->fmt.width;
  while( --width > 0 ) {
    if( pf->p == pf->buf_end ) return -1;
    *pf->p++ = ' ';
  }
 
  if( !pf->fmt.flag_minus ) {
    if( pf->p == pf->buf_end ) return -1;
    *pf->p++ = ch;
  }
 
  return 0;
}
 
 
//================================================================
int mrbc_printf_bstr( mrbc_printf_t *pf, const char *str, int len, int pad )
{
  int ret = 0;
 
  if( str == NULL ) {
    str = "(null)";
    len = 6;
  }
  if( pf->fmt.precision && len > pf->fmt.precision ) len = pf->fmt.precision;
 
  int tw = len;
  if( pf->fmt.width > len ) tw = pf->fmt.width;
 
  int remain = pf->buf_end - pf->p;
  if( len > remain ) {
    len = remain;
    ret = -1;
  }
  if( tw > remain ) {
    tw = remain;
    ret = -1;
  }
 
  int n_pad = tw - len;
 
  if( !pf->fmt.flag_minus ) {
    while( n_pad-- > 0 ) {
      *pf->p++ = pad;
    }
  }
  while( len-- > 0 ) {
    *pf->p++ = *str++;
  }
  while( n_pad-- > 0 ) {
    *pf->p++ = pad;
  }
 
  return ret;
}
 
 
 
//================================================================
int mrbc_printf_int( mrbc_printf_t *pf, mrbc_int_t value, unsigned int base )
{
  int sign = 0;
  mrbc_uint_t v = value;
  char *pf_p_ini_val = pf->p;
 
  if( value < 0 ) {
    sign = '-';
    v = -value;
  } else if( pf->fmt.flag_plus ) {
    sign = '+';
  } else if( pf->fmt.flag_space ) {
    sign = ' ';
  }
 
  // disable zero padding if conflict parameters exists.
  if( pf->fmt.flag_minus || pf->fmt.width == 0 || pf->fmt.precision != 0 ) {
    pf->fmt.flag_zero = 0;
  }
 
  // create string to temporary buffer
  char buf[sizeof(mrbc_int_t) * 8];
  char *p = buf + sizeof(buf);
 
  do {
    unsigned int ch = v % base;
    *--p = ch + ((ch < 10)? '0' : 'a' - 10);
    v /= base;
  } while( v != 0 );
 
  int dig_width = buf + sizeof(buf) - p;
 
  // write padding character, if adjust right.
  if( !pf->fmt.flag_minus && pf->fmt.width ) {
    int pad = pf->fmt.flag_zero ? '0' : ' ';
    int pad_width = pf->fmt.width - !!sign;
    pad_width -= (pf->fmt.precision > dig_width)? pf->fmt.precision: dig_width;
 
    for( ; pad_width > 0; pad_width-- ) {
      *pf->p++ = pad;
      if( pf->p >= pf->buf_end ) return -1;
    }
  }
 
  // sign
  if( sign ) {
    *pf->p++ = sign;
    if( pf->p >= pf->buf_end ) return -1;
  }
 
  // precision
  int pre_width = pf->fmt.precision - dig_width;
  for( ; pre_width > 0; pre_width-- ) {
    *pf->p++ = '0';
    if( pf->p >= pf->buf_end ) return -1;
  }
 
  // digit
  for( ; dig_width > 0; dig_width-- ) {
    *pf->p++ = *p++;
    if( pf->p >= pf->buf_end ) return -1;
  }
 
  // write space, if adjust left.
  if( pf->fmt.flag_minus && pf->fmt.width ) {
    int pad_width = pf->fmt.width - (pf->p - pf_p_ini_val);
    for( ; pad_width > 0; pad_width-- ) {
      *pf->p++ = ' ';
      if( pf->p >= pf->buf_end ) return -1;
    }
  }
 
  return 0;
}
 
 
 
//================================================================
int mrbc_printf_bit( mrbc_printf_t *pf, mrbc_int_t value, int bit )
{
  if( pf->fmt.flag_plus || pf->fmt.flag_space ) {
    return mrbc_printf_int( pf, value, 1 << bit );
  }
 
  if( pf->fmt.flag_minus || pf->fmt.width == 0 ) {
    pf->fmt.flag_zero = 0; // disable zero padding if left align or width zero.
  }
  pf->fmt.precision = 0;
 
  mrbc_int_t v = value;
  int offset_a = (pf->fmt.type == 'X') ? 'A' - 10 : 'a' - 10;
  int mask = (1 << bit) - 1;    // 0x0f, 0x07, 0x01
  int mchar = mask + ((mask < 10)? '0' : offset_a);
 
  // create string to local buffer
  char buf[sizeof(mrbc_int_t) * 8 + 5];
  assert( sizeof(buf) > (sizeof(mrbc_int_t) * 8 + 4) );
  char *p = buf + sizeof(buf) - 1;
  *p = '\0';
  int n;
  do {
    assert( p >= buf );
    n = v & mask;
    *--p = n + ((n < 10)? '0' : offset_a);
    v >>= bit;
  } while( v != 0 && v != -1 );
 
  // add "..f" for negative value?
  // (note) '0' flag such as "%08x" is incompatible with ruby.
  if( value < 0 && !pf->fmt.flag_zero ) {
    if( n != mask ) *--p = mchar;
    *--p = '.';
    *--p = '.';
    assert( p >= buf );
  }
 
  // decide pad character and output sign character
  int pad;
  if( pf->fmt.flag_zero ) {
    pad = (value < 0) ? mchar : '0';
  } else {
    pad = ' ';
  }
 
  return mrbc_printf_str( pf, p, pad );
}
 
 
 
#if MRBC_USE_FLOAT
//================================================================
int mrbc_printf_float( mrbc_printf_t *pf, double value )
{
  char fstr[16];
  const char *p1 = pf->fstr;
  char *p2 = fstr + sizeof(fstr) - 1;
 
  *p2 = '\0';
  while( (*--p2 = *--p1) != '%' )
    ;
 
  snprintf( pf->p, (pf->buf_end - pf->p + 1), p2, value );
 
  while( *pf->p != '\0' )
    pf->p++;
 
  return -(pf->p == pf->buf_end);
}
#endif
 
 
 
//================================================================
int mrbc_printf_pointer( mrbc_printf_t *pf, void *ptr )
{
  uint32_t v = MRBC_PTR_TO_UINT32(ptr);
  int n = sizeof(ptr) * 2;
  if( n > 8 ) n = 8;
 
  // check buffer size.
  if( (pf->buf_end - pf->p) < n+1 ) return -1;
 
  // write pointer value.
  *pf->p++ = '$';
  pf->p += n;
  char *p = pf->p - 1;
 
  for(; n > 0; n-- ) {
    *p-- = (v & 0xf) < 10 ? (v & 0xf) + '0' : (v & 0xf) - 10 + 'a';
    v >>= 4;
  }
 
  return 0;
}