void __assert_float_equal(const char* spec, float expected, float actual, int line, const char* file){
char buf1[31];
char buf2[31];
if(expected!=actual){
format_float(expected, buf1, 31);
format_float(actual, buf2, 31);
printf(fail_message_equal, spec, buf1, buf2, line, file);
}
int pass = expected == actual;
_TEST_CASE_REPORT_RESULT(pass);
}
Ustring format_int(T t, uint64_t flags, int prec) {
static constexpr auto float_flags = Format::digits | Format::exp | Format::fixed | Format::general | Format::stripz;
static constexpr auto int_flags = Format::binary | Format::decimal | Format::hex | Format::roman;
static constexpr auto sign_flags = Format::sign | Format::signz;
if ((flags & float_flags) && ! (flags & int_flags))
return format_float(t, flags, prec);
if (ibits(flags & int_flags) > 1 || ibits(flags & sign_flags) > 1)
throw std::invalid_argument("Inconsistent integer formatting flags");
char sign = 0;
if (t > static_cast<T>(0)) {
if (flags & (Format::sign | Format::signz))
sign = '+';
} else if (t == static_cast<T>(0)) {
if (flags & Format::sign)
sign = '+';
} else {
t = RS_Detail::SimpleAbs<T>()(t);
sign = '-';
}
Ustring s;
if (flags & Format::binary)
s = format_radix(t, 2, prec);
else if (flags & Format::roman)
s = roman(unsigned(t));
else if (flags & Format::hex)
s = format_radix(t, 16, prec);
else
s = format_radix(t, 10, prec);
if (sign)
s.insert(s.begin(), sign);
return s;
}
void native_formatter_invoke(uint8_t mref) {
char * fmt = stack_peek_addr(0);
char res[50];
formatDescr fmtdscr;
make_format_descr(&fmtdscr, fmt);
int len = 0;
if(mref == NATIVE_METHOD_formatI) {
nvm_int_t val = stack_peek_int(1);
len = format_int(res, &fmtdscr, val);
} else if(mref == NATIVE_METHOD_formatZ) {
nvm_int_t val = stack_peek_int(1);
len = format_bool(res, &fmtdscr, val);
} else if(mref == NATIVE_METHOD_formatF) {
nvm_float_t val = stack_peek_float(1);
len = format_float(res, &fmtdscr, val);
} else
error(ERROR_NATIVE_UNKNOWN_METHOD);
uint8_t add = 0;
if (fmtdscr.width>len)
add = (fmtdscr.width-len);
// allocate heap and realign strings (address may be changed by gc...)
heap_id_t id = heap_alloc(FALSE, len + add + fmtdscr.pre_len + fmtdscr.post_len + 1);
int memoffset = (char*)stack_peek_addr(0)-(char*)fmt;
fmt+=memoffset;
fmtdscr.post+=memoffset;
char * dst = heap_get_addr(id);
// build result string
native_strncpy(dst, fmt, fmtdscr.pre_len);
dst+=fmtdscr.pre_len;
if (!(fmtdscr.flags&0x01)){
while(add--)
*dst++=' ';
}
native_strncpy(dst, res, len);
dst+=len;
if (fmtdscr.flags&0x01){
while(add--)
*dst++=' ';
}
native_strncpy(dst, fmtdscr.post, fmtdscr.post_len);
dst+=fmtdscr.post_len;
*dst=0;
stack_pop();
stack_pop();
stack_push(NVM_TYPE_HEAP | id);
}
STATIC void complex_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind) {
mp_obj_complex_t *o = o_in;
#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
char buf[32];
if (o->real == 0) {
format_float(o->imag, buf, sizeof(buf), 'g', 6, '\0');
print(env, "%sj", buf);
} else {
format_float(o->real, buf, sizeof(buf), 'g', 6, '\0');
print(env, "(%s+", buf);
format_float(o->imag, buf, sizeof(buf), 'g', 6, '\0');
print(env, "%sj)", buf);
}
#else
if (o->real == 0) {
print(env, "%.8gj", (double) o->imag);
} else {
print(env, "(%.8g+%.8gj)", (double) o->real, (double) o->imag);
}
#endif
}
STATIC void float_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t o_in, mp_print_kind_t kind) {
mp_obj_float_t *o = o_in;
#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
char buf[32];
format_float(o->value, buf, sizeof(buf), 'g', 6, '\0');
print(env, "%s", buf);
if (strchr(buf, '.') == NULL) {
// Python floats always have decimal point
print(env, ".0");
}
#else
char buf[32];
sprintf(buf, "%.17g", (double) o->value);
print(env, buf);
if (strchr(buf, '.') == NULL) {
// Python floats always have decimal point
print(env, ".0");
}
#endif
}
int pfenv_print_float(const pfenv_t *pfenv, mp_float_t f, char fmt, int flags, char fill, int width, int prec) {
char buf[32];
char sign = '\0';
int chrs = 0;
if (flags & PF_FLAG_SHOW_SIGN) {
sign = '+';
}
else
if (flags & PF_FLAG_SPACE_SIGN) {
sign = ' ';
}
int len;
#if MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_FLOAT
len = format_float(f, buf, sizeof(buf), fmt, prec, sign);
#elif MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
char fmt_buf[6];
char *fmt_s = fmt_buf;
*fmt_s++ = '%';
if (sign) {
*fmt_s++ = sign;
}
*fmt_s++ = '.';
*fmt_s++ = '*';
*fmt_s++ = fmt;
*fmt_s = '\0';
len = snprintf(buf, sizeof(buf), fmt_buf, prec, f);
#else
#error Unknown MICROPY FLOAT IMPL
#endif
char *s = buf;
if ((flags & PF_FLAG_ADD_PERCENT) && (len + 1) < sizeof(buf)) {
buf[len++] = '%';
buf[len] = '\0';
}
// buf[0] < '0' returns true if the first character is space, + or -
if ((flags & PF_FLAG_PAD_AFTER_SIGN) && buf[0] < '0') {
// We have a sign character
s++;
if (*s <= '9' || (flags & PF_FLAG_PAD_NAN_INF)) {
// We have a number, or we have a inf/nan and PAD_NAN_INF is set
// With '{:06e}'.format(float('-inf')) you get '-00inf'
chrs += pfenv_print_strn(pfenv, &buf[0], 1, 0, 0, 1);
width--;
len--;
}
}
if (*s > 'A' && (flags & PF_FLAG_PAD_NAN_INF) == 0) {
// We have one of the inf or nan variants, suppress zero fill.
// With printf, if you use: printf("%06e", -inf) then you get " -inf"
// so suppress the zero fill.
fill = ' ';
}
chrs += pfenv_print_strn(pfenv, s, len, flags, fill, width);
return chrs;
}
void printf(const char* format, ...){
char convertBuffer[BUF_SIZE];
va_list vars;
int iVal = 0;
float fVal = 0.0f;
char* strVal = NULL;
unsigned int uiVal = 0;
int length = 0;
va_start(vars, format);
int skip = 0;
while( *format != '\0' ){
for(; *format!='\0' && *format!='%' ; format++) skip++;
puts_n(format-skip, skip);
skip = 0;
if(*format == '%'){
format++;
switch(*format){
case 'd':
iVal = va_arg(vars, int);
length = format_int(iVal, convertBuffer, BUF_SIZE);
puts_n(convertBuffer, length);
iVal = 0;
format++;
break;
case 'e':
fVal = va_arg(vars, double);
length = format_float(fVal, convertBuffer, BUF_SIZE);
puts_n(convertBuffer, length);
fVal = 0.0f;
format++;
break;
case 's':
strVal = va_arg(vars, char*);
puts(strVal);
strVal = NULL;
format++;
break;
case 'c':
iVal = va_arg(vars, int);
putchar(iVal);
iVal = 0;
format++;
break;
case 'x':
iVal = va_arg(vars, int);
format++;
break;
case 'u':
uiVal = va_arg(vars, unsigned int);
format++;
break;
case '%':
putchar('%');
format++;
break;
default:
break;
}
}
}
/*
* @function fw_vsprintf
*
* @brief Firmware user-define sprintf function
* @date Feb. 24th, 2009
*/
static inline int32u fw_vsprintf(int8u *buf, int32u buf_len, const int8u *format, va_list arg)
{
float64 ft_val;
int32u pre_flag = 0;
int32u width = 0;
int32u prec = 6;// default decimal precesion is 6 bits
int32s int_val;
int64s long_val;
int32u res = 0, len;
int8u *p = (int8u *)format;
int8u *str_val;
while ((*p != '\0') && (res <= buf_len)) {
if (pre_flag == 0) { // search '%' or '\' in format string
if (*p == '%') {
pre_flag = PRT_PRE_PERCENT;
width = 0;
}
else {
*(buf++) = *p;
res++;
}
}
else { // scan format string
switch (*p) {
case '0':
pre_flag |= PRT_FILL_ZERO;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
do {
width = width*10 + (*p)-'0';
p++;
} while (*p>='0' && *p<='9');
pre_flag |= PRT_LEFT_FILL;
p--; // go back to last position in format string
break;
case 'l':
pre_flag |= PRT_LONG_FLAG;
break;
case 'd':
case 'x':
case 'X':
case 'c':
case 'u':
if (pre_flag & PRT_LONG_FLAG)
{
long_val = va_arg(arg, int64s);
len = format_long_integer(buf, long_val, *p, width, pre_flag);
}
else
{
int_val = va_arg(arg, int32s);
len = format_integer(buf, int_val, *p, width, pre_flag);
}
buf += len;
res += len;
pre_flag = 0;
break;
case 'f':
case 'F':
ft_val = va_arg(arg, float64);
len = format_float(buf, ft_val, width, prec, pre_flag);
buf += len;
res += len;
pre_flag = 0;
break;
case 's':
str_val = va_arg(arg, int8u*);
len = format_string(buf, str_val, width, pre_flag);
buf += len;
res += len;
pre_flag = 0;
break;
case '.':
p++;
pre_flag |= PRT_PREC_FLAG;
prec = 0;
do {
prec = prec*10 + (*p)-'0';
p++;
} while (*p>='0' && *p<='9');
p--; // go back to last position in format string
break;
default:
return 0;
}
}
p++;
}
return res;
}
void texture_select_callback(GObject* obj, gpointer user_data) {
GtkTreeView* param_tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "selected_texture_treeview"));
GtkTreeStore* param_store = GTK_TREE_STORE(gtk_tree_view_get_model(param_tree));
GtkTreeView* image_tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "selected_texture_images"));
GtkTreeStore* image_store = GTK_TREE_STORE(gtk_tree_view_get_model(image_tree));
if (!param_store)
return;
if (!image_store)
return;
gtk_tree_store_clear(image_store);
gtk_tree_store_clear(param_store);
GtkTreePath* path;
GtkSpinButton* layer_spinbutton = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton"));
gtk_tree_view_get_cursor(GTK_TREE_VIEW(obj), &path, NULL);
if (!path) {
gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(layer_spinbutton), 0);
return;
}
//Initialize params
size_t tex_index = gtk_tree_path_get_indices(path)[0];
inspect_texture_t* tex = get_inspect_tex_vec(inspector->textures, tex_index);
if (!tex) return;
gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(layer_spinbutton), tex->layer_count-1);
inspect_gl_tex_params_t params = tex->params;
GtkTreeIter row;
#define VAL(name, val) gtk_tree_store_append(param_store, &row, NULL);\
gtk_tree_store_set(param_store, &row, 0, (name), 1, (val), -1);
if (tex->type) {
VAL("Type", static_format("%s", get_enum_str("TextureTarget", tex->type)));
VAL("Depth Stencil Mode", static_format("%s", get_enum_str(NULL, params.depth_stencil_mode)));
VAL("Min Filter", static_format("%s", get_enum_str("TextureMinFilter", params.min_filter)));
VAL("Mag Filter", static_format("%s", get_enum_str("TextureMagFilter", params.mag_filter)));
VAL("Min LOD", static_format("%s", format_float(params.min_lod)));
VAL("Max LOD", static_format("%s", format_float(params.max_lod)));
VAL("LOD bias", static_format("%s", format_float(params.lod_bias)));
VAL("Base Level", static_format("%d", params.base_level));
VAL("Max Level", static_format("%d", params.max_level));
VAL("Swizzle", static_format("[%s, %s, %s, %s]",
get_enum_str(NULL, params.swizzle[0]),
get_enum_str(NULL, params.swizzle[1]),
get_enum_str(NULL, params.swizzle[2]),
get_enum_str(NULL, params.swizzle[3])));
VAL("Wrap S", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0])));
VAL("Wrap T", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0])));
VAL("Wrap R", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0])));
VAL("Border Color", static_format("[%s, %s, %s, %s]",
format_float(params.border_color[0]),
format_float(params.border_color[1]),
format_float(params.border_color[2]),
format_float(params.border_color[3])));
VAL("Compare Mode", static_format("%s", get_enum_str(NULL, params.compare_mode)));
VAL("Compare Func", static_format("%s", get_enum_str("DepthFunction", params.compare_func)));
VAL("View Min Level", static_format("%d", params.view_min_level));
VAL("View Num Levels", static_format("%u", params.view_num_levels));
VAL("View Min Layer", static_format("%d", params.view_min_layer));
VAL("View Num Layers", static_format("%u", params.view_num_layers));
VAL("Immutable levels", static_format("%u", params.immutable_levels));
VAL("Image Format Compat Type", static_format("%s", get_enum_str(NULL, params.image_format_compatibility_type)));
VAL("Immutable Format", static_format("%s", get_enum_str(NULL, params.immutable_format)));
}
if (tex->mipmaps) {
VAL("Width", static_format("%zu", tex->width));
VAL("Height", static_format("%zu", tex->height));
VAL("Depth", static_format("%zu", tex->depth));
VAL("Mipmap Count", static_format("%zu", tex->mipmap_count));
VAL("Layer Count", static_format("%zu", tex->layer_count));
#undef VAL
GtkSpinButton* layer_button = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton"));
uint32_t layer = gtk_spin_button_get_value(GTK_SPIN_BUTTON(layer_button));
GtkComboBox* face_combobox = GTK_COMBO_BOX(gtk_builder_get_object(builder, "face_combobox"));
gint face = gtk_combo_box_get_active(GTK_COMBO_BOX(face_combobox));
//Initialize images
size_t w = tex->width;
size_t h = tex->height;
for (size_t level = 0; level < tex->mipmap_count; level++) {
inspect_image_t* img = inspect_get_tex_mipmap(tex, level, layer, face);
if (img->has_data) {
uint32_t* data = (uint32_t*)malloc(w*h*4);
inspect_get_image_data(img, data);
GtkTreeIter row;
gtk_tree_store_append(image_store, &row, NULL);
GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, w, h);
uint32_t* dest = (uint32_t*)gdk_pixbuf_get_pixels(pixbuf);
for (size_t y = 0; y < h; y++) {
for (size_t x = 0; x < w; x++) {
dest[(h-1-y)*w+x] = data[y*w+x];
}
}
gtk_tree_store_set(image_store, &row, 0, static_format("%u", level), 1, pixbuf, -1);
g_object_unref(pixbuf);
free(data);
}
w /= 2;
h /= 2;
}
}
}
