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;
}
 
 
/***** Global functions *****************************************************/
 
//================================================================
void mrbc_putchar(char c)
{
#if defined(MRBC_CONVERT_CRLF)
  static const char CRLF[2] = "\r\n";
  if( c == '\n' ) {
    hal_write(1, CRLF, 2);
  } else {
    hal_write(1, &c, 1);
  }
 
#else
    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' ) {
      hal_write(1, p2, p1 - p2 - 1);
      hal_write(1, CRLF, 2);
      p2 = p1;
    }
  }
  if( p1 != p2 ) {
    hal_write(1, p2, p1 - p2);
  }
 
#else
  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 );
    if( !newbuf ) break;
    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');
}
 
 
//================================================================
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:{
    mrbc_putchar('"');
    const unsigned char *s = (const unsigned char *)mrbc_string_cstr(v);
 
    for( int i = 0; i < mrbc_string_size(v); i++ ) {
      if( s[i] < ' ' || 0x7f <= s[i] ) {        // tiny isprint()
        mrbc_printf("\\x%02X", s[i]);
      } else {
        mrbc_putchar(s[i]);
      }
    }
    mrbc_putchar('"');
  } break;
#endif
 
  case MRBC_TT_RANGE:{
    mrbc_value v1 = mrbc_range_first(v);
    mrbc_p_sub(&v1);
    mrbc_print( mrbc_range_exclude_end(v) ? "..." : ".." );
    v1 = mrbc_range_last(v);
    mrbc_p_sub(&v1);
  } 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:      mrbc_printf("%g", v->d);    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(v);
    mrbc_print_sub(&v1);
    mrbc_print( mrbc_range_exclude_end(v) ? "..." : ".." );
    v1 = mrbc_range_last(v);
    mrbc_print_sub(&v1);
  } 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(vk);
      mrbc_print("=>");
      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;
}