\$(NXT_CC) -o $NXT_BUILD_DIR/$nxt_bin \$(NXT_CFLAGS) \\
\$(NXT_LIB_INCS) $nxt_dep_flags \\
$nxt_src $NXT_BUILD_DIR/libnxt.a \\
- $nxt_dep_post
+ $nxt_dep_post -lm
-include $NXT_BUILD_DIR/$nxt_dep
#include <njs_fs.h>
#include <njs_crypto.h>
#include <string.h>
-#include <stdio.h>
typedef struct {
#include <nxt_sha1.h>
#include <nxt_sha2.h>
#include <njs_crypto.h>
-#include <stdio.h>
#include <string.h>
#include <math.h>
#include <njs_core.h>
#include <njs_date.h>
-#include <stdio.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
*/
#include <njs_core.h>
-#include <stdio.h>
static void njs_disassemble(u_char *start, u_char *end);
n = vm->code->items;
while (n != 0) {
- printf("%.*s:%.*s\n", (int) code->file.length, code->file.start,
- (int) code->name.length, code->name.start);
+ nxt_printf("%V:%V\n", &code->file, &code->name);
njs_disassemble(code->start, code->end);
code++;
n--;
if (operation == njs_vmcode_array) {
array = (njs_vmcode_array_t *) p;
- printf("%05zd ARRAY %04zX %zd%s\n",
- p - start, (size_t) array->retval, (size_t) array->length,
- array->code.ctor ? " INIT" : "");
+ nxt_printf("%05uz ARRAY %04Xz %uz%s\n",
+ p - start, (size_t) array->retval,
+ (size_t) array->length, array->code.ctor ? " INIT" : "");
p += sizeof(njs_vmcode_array_t);
cond_jump = (njs_vmcode_cond_jump_t *) p;
sign = (cond_jump->offset >= 0) ? "+" : "";
- printf("%05zd JUMP IF TRUE %04zX %s%zd\n",
- p - start, (size_t) cond_jump->cond, sign,
- (size_t) cond_jump->offset);
+ nxt_printf("%05uz JUMP IF TRUE %04Xz %s%uz\n",
+ p - start, (size_t) cond_jump->cond, sign,
+ (size_t) cond_jump->offset);
p += sizeof(njs_vmcode_cond_jump_t);
cond_jump = (njs_vmcode_cond_jump_t *) p;
sign = (cond_jump->offset >= 0) ? "+" : "";
- printf("%05zd JUMP IF FALSE %04zX %s%zd\n",
- p - start, (size_t) cond_jump->cond, sign,
- (size_t) cond_jump->offset);
+ nxt_printf("%05uz JUMP IF FALSE %04Xz %s%uz\n",
+ p - start, (size_t) cond_jump->cond, sign,
+ (size_t) cond_jump->offset);
p += sizeof(njs_vmcode_cond_jump_t);
jump = (njs_vmcode_jump_t *) p;
sign = (jump->offset >= 0) ? "+" : "";
- printf("%05zd JUMP %s%zd\n",
- p - start, sign, (size_t) jump->offset);
+ nxt_printf("%05uz JUMP %s%uz\n",
+ p - start, sign, (size_t) jump->offset);
p += sizeof(njs_vmcode_jump_t);
if (operation == njs_vmcode_if_equal_jump) {
equal = (njs_vmcode_equal_jump_t *) p;
- printf("%05zd JUMP IF EQUAL %04zX %04zX +%zd\n",
- p - start, (size_t) equal->value1, (size_t) equal->value2,
- (size_t) equal->offset);
+ nxt_printf("%05uz JUMP IF EQUAL %04Xz %04Xz +%uz\n",
+ p - start, (size_t) equal->value1,
+ (size_t) equal->value2, (size_t) equal->offset);
p += sizeof(njs_vmcode_equal_jump_t);
if (operation == njs_vmcode_test_if_true) {
test_jump = (njs_vmcode_test_jump_t *) p;
- printf("%05zd TEST IF TRUE %04zX %04zX +%zd\n",
- p - start, (size_t) test_jump->retval,
- (size_t) test_jump->value, (size_t) test_jump->offset);
+ nxt_printf("%05uz TEST IF TRUE %04Xz %04Xz +%uz\n",
+ p - start, (size_t) test_jump->retval,
+ (size_t) test_jump->value, (size_t) test_jump->offset);
p += sizeof(njs_vmcode_test_jump_t);
if (operation == njs_vmcode_test_if_false) {
test_jump = (njs_vmcode_test_jump_t *) p;
- printf("%05zd TEST IF FALSE %04zX %04zX +%zd\n",
- p - start, (size_t) test_jump->retval,
- (size_t) test_jump->value, (size_t) test_jump->offset);
+ nxt_printf("%05uz TEST IF FALSE %04Xz %04Xz +%uz\n",
+ p - start, (size_t) test_jump->retval,
+ (size_t) test_jump->value, (size_t) test_jump->offset);
p += sizeof(njs_vmcode_test_jump_t);
if (operation == njs_vmcode_function_frame) {
function = (njs_vmcode_function_frame_t *) p;
- printf("%05zd FUNCTION FRAME %04zX %zd%s\n",
- p - start, (size_t) function->name, function->nargs,
- function->code.ctor ? " CTOR" : "");
+ nxt_printf("%05uz FUNCTION FRAME %04Xz %uz%s\n",
+ p - start, (size_t) function->name, function->nargs,
+ function->code.ctor ? " CTOR" : "");
p += sizeof(njs_vmcode_function_frame_t);
if (operation == njs_vmcode_method_frame) {
method = (njs_vmcode_method_frame_t *) p;
- printf("%05zd METHOD FRAME %04zX %04zX %zd%s\n",
- p - start, (size_t) method->object, (size_t) method->method,
- method->nargs, method->code.ctor ? " CTOR" : "");
+ nxt_printf("%05uz METHOD FRAME %04Xz %04Xz %uz%s\n",
+ p - start, (size_t) method->object,
+ (size_t) method->method, method->nargs,
+ method->code.ctor ? " CTOR" : "");
p += sizeof(njs_vmcode_method_frame_t);
if (operation == njs_vmcode_property_foreach) {
prop_foreach = (njs_vmcode_prop_foreach_t *) p;
- printf("%05zd PROPERTY FOREACH %04zX %04zX +%zd\n",
- p - start, (size_t) prop_foreach->next,
- (size_t) prop_foreach->object,
- (size_t) prop_foreach->offset);
+ nxt_printf("%05uz PROPERTY FOREACH %04Xz %04Xz +%uz\n",
+ p - start, (size_t) prop_foreach->next,
+ (size_t) prop_foreach->object,
+ (size_t) prop_foreach->offset);
p += sizeof(njs_vmcode_prop_foreach_t);
if (operation == njs_vmcode_property_next) {
prop_next = (njs_vmcode_prop_next_t *) p;
- printf("%05zd PROPERTY NEXT %04zX %04zX %04zX %zd\n",
- p - start, (size_t) prop_next->retval,
- (size_t) prop_next->object, (size_t) prop_next->next,
- (size_t) prop_next->offset);
+ nxt_printf("%05uz PROPERTY NEXT %04Xz %04Xz %04Xz %uz\n",
+ p - start, (size_t) prop_next->retval,
+ (size_t) prop_next->object, (size_t) prop_next->next,
+ (size_t) prop_next->offset);
p += sizeof(njs_vmcode_prop_next_t);
if (operation == njs_vmcode_try_start) {
try_start = (njs_vmcode_try_start_t *) p;
- printf("%05zd TRY START %04zX %04zX +%zd\n",
- p - start, (size_t) try_start->exception_value,
- (size_t) try_start->exit_value,
- (size_t) try_start->offset);
+ nxt_printf("%05uz TRY START %04Xz %04Xz +%uz\n",
+ p - start, (size_t) try_start->exception_value,
+ (size_t) try_start->exit_value,
+ (size_t) try_start->offset);
p += sizeof(njs_vmcode_try_start_t);
if (operation == njs_vmcode_try_break) {
try_tramp = (njs_vmcode_try_trampoline_t *) p;
- printf("%05zd TRY BREAK %04zX %zd\n",
- p - start, (size_t) try_tramp->exit_value,
- (size_t) try_tramp->offset);
+ nxt_printf("%05uz TRY BREAK %04Xz %uz\n",
+ p - start, (size_t) try_tramp->exit_value,
+ (size_t) try_tramp->offset);
p += sizeof(njs_vmcode_try_trampoline_t);
if (operation == njs_vmcode_try_continue) {
try_tramp = (njs_vmcode_try_trampoline_t *) p;
- printf("%05zd TRY CONTINUE %04zX %zd\n",
- p - start, (size_t) try_tramp->exit_value,
- (size_t) try_tramp->offset);
+ nxt_printf("%05uz TRY CONTINUE %04Xz %uz\n",
+ p - start, (size_t) try_tramp->exit_value,
+ (size_t) try_tramp->offset);
p += sizeof(njs_vmcode_try_trampoline_t);
if (operation == njs_vmcode_try_return) {
try_return = (njs_vmcode_try_return_t *) p;
- printf("%05zd TRY RETURN %04zX %04zX +%zd\n",
- p - start, (size_t) try_return->save,
- (size_t) try_return->retval,
- (size_t) try_return->offset);
+ nxt_printf("%05uz TRY RETURN %04Xz %04Xz +%uz\n",
+ p - start, (size_t) try_return->save,
+ (size_t) try_return->retval,
+ (size_t) try_return->offset);
p += sizeof(njs_vmcode_try_return_t);
if (operation == njs_vmcode_catch) {
catch = (njs_vmcode_catch_t *) p;
- printf("%05zd CATCH %04zX +%zd\n",
- p - start, (size_t) catch->exception,
- (size_t) catch->offset);
+ nxt_printf("%05uz CATCH %04Xz +%uz\n",
+ p - start, (size_t) catch->exception,
+ (size_t) catch->offset);
p += sizeof(njs_vmcode_catch_t);
if (operation == njs_vmcode_try_end) {
try_end = (njs_vmcode_try_end_t *) p;
- printf("%05zd TRY END +%zd\n",
- p - start, (size_t) try_end->offset);
+ nxt_printf("%05uz TRY END +%uz\n",
+ p - start, (size_t) try_end->offset);
p += sizeof(njs_vmcode_try_end_t);
if (operation == njs_vmcode_finally) {
finally = (njs_vmcode_finally_t *) p;
- printf("%05zd TRY FINALLY %04zX %04zX +%zd +%zd\n",
- p - start, (size_t) finally->retval,
- (size_t) finally->exit_value,
- (size_t) finally->continue_offset,
- (size_t) finally->break_offset);
+ nxt_printf("%05uz TRY FINALLY %04Xz %04Xz +%uz +%uz\n",
+ p - start, (size_t) finally->retval,
+ (size_t) finally->exit_value,
+ (size_t) finally->continue_offset,
+ (size_t) finally->break_offset);
p += sizeof(njs_vmcode_finally_t);
if (code_name->size == sizeof(njs_vmcode_3addr_t)) {
code3 = (njs_vmcode_3addr_t *) p;
- printf("%05zd %*s %04zX %04zX %04zX\n",
- p - start, (int) name->length, name->start,
- (size_t) code3->dst, (size_t) code3->src1,
- (size_t) code3->src2);
+ nxt_printf("%05uz %*s %04Xz %04Xz %04Xz\n",
+ p - start, (int) name->length, name->start,
+ (size_t) code3->dst, (size_t) code3->src1,
+ (size_t) code3->src2);
} else if (code_name->size == sizeof(njs_vmcode_2addr_t)) {
code2 = (njs_vmcode_2addr_t *) p;
- printf("%05zd %*s %04zX %04zX\n",
- p - start, (int) name->length, name->start,
- (size_t) code2->dst, (size_t) code2->src);
+ nxt_printf("%05uz %*s %04Xz %04Xz\n",
+ p - start, (int) name->length, name->start,
+ (size_t) code2->dst, (size_t) code2->src);
} else if (code_name->size == sizeof(njs_vmcode_1addr_t)) {
code1 = (njs_vmcode_1addr_t *) p;
- printf("%05zd %*s %04zX\n",
- p - start, (int) name->length, name->start,
- (size_t) code1->index);
+ nxt_printf("%05uz %*s %04Xz\n",
+ p - start, (int) name->length, name->start,
+ (size_t) code1->index);
}
p += code_name->size;
} while (n != 0);
- printf("%05zd UNKNOWN %04zX\n",
- p - start, (size_t) (uintptr_t) operation);
+ nxt_printf("%05uz UNKNOWN %04Xz\n",
+ p - start, (size_t) (uintptr_t) operation);
p += sizeof(njs_vmcode_operation_t);
*/
#include <njs_core.h>
-#include <stdio.h>
#include <string.h>
#include <math.h>
#include <njs_core.h>
#include <string.h>
-#include <stdio.h>
typedef struct njs_extern_part_s njs_extern_part_t;
#include <fcntl.h>
#include <sys/stat.h>
#include <errno.h>
-#include <stdio.h>
typedef struct {
#include <njs_core.h>
#include <njs_module.h>
#include <string.h>
-#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <njs_core.h>
#include <math.h>
#include <string.h>
-#include <stdio.h>
#include <float.h>
#include <math.h>
-#include <stdio.h>
uint32_t njs_value_to_index(const njs_value_t *value);
#include <njs_core.h>
#include <njs_regexp.h>
#include <string.h>
-#include <stdio.h>
static njs_ret_t njs_parser_scope_begin(njs_vm_t *vm, njs_parser_t *parser,
#include <njs_regexp_pattern.h>
#include <string.h>
-#include <stdio.h>
static void *njs_regexp_malloc(size_t size, void *memory_data);
#include <time.h>
#include <errno.h>
#include <string.h>
-#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <locale.h>
+#include <stdio.h>
#include <readline.h>
}
if (opts.version != 0) {
- printf("%s\n", NJS_VERSION);
+ nxt_printf("%s\n", NJS_VERSION);
ret = NXT_OK;
goto done;
}
if (opts.file == NULL) {
p = getcwd(path, sizeof(path));
if (p == NULL) {
- fprintf(stderr, "getcwd() failed:%s\n", strerror(errno));
+ nxt_error("getcwd() failed:%s\n", strerror(errno));
ret = NXT_ERROR;
goto done;
}
opts->n_paths++;
paths = realloc(opts->paths, opts->n_paths * sizeof(char *));
if (paths == NULL) {
- fprintf(stderr, "failed to add path\n");
+ nxt_error("failed to add path\n");
return NXT_ERROR;
}
break;
}
- fprintf(stderr, "option \"-p\" requires directory name\n");
+ nxt_error("option \"-p\" requires directory name\n");
return NXT_ERROR;
case 'v':
break;
default:
- fprintf(stderr, "Unknown argument: \"%s\" "
- "try \"%s -h\" for available options\n", argv[i], argv[0]);
+ nxt_error("Unknown argument: \"%s\" "
+ "try \"%s -h\" for available options\n", argv[i],
+ argv[0]);
return NXT_ERROR;
}
}
proto = njs_vm_external_prototype(vm, &njs_externals[0]);
if (proto == NULL) {
- fprintf(stderr, "failed to add console proto\n");
+ nxt_error("failed to add console proto\n");
return NXT_ERROR;
}
nxt_str_t line;
if (njs_editline_init() != NXT_OK) {
- fprintf(stderr, "failed to init completions\n");
+ nxt_error("failed to init completions\n");
return NXT_ERROR;
}
}
if (!opts->quiet) {
- printf("interactive njs %s\n\n", NJS_VERSION);
+ nxt_printf("interactive njs %s\n\n", NJS_VERSION);
- printf("v.<Tab> -> the properties and prototype methods of v.\n");
- printf("type console.help() for more information\n\n");
+ nxt_printf("v.<Tab> -> the properties and prototype methods of v.\n");
+ nxt_printf("type console.help() for more information\n\n");
}
for ( ;; ) {
} else {
fd = open(file, O_RDONLY);
if (fd == -1) {
- fprintf(stderr, "failed to open file: '%s' (%s)\n",
- file, strerror(errno));
+ nxt_error("failed to open file: '%s' (%s)\n",
+ file, strerror(errno));
return NXT_ERROR;
}
}
if (fstat(fd, &sb) == -1) {
- fprintf(stderr, "fstat(%d) failed while reading '%s' (%s)\n",
- fd, file, strerror(errno));
+ nxt_error("fstat(%d) failed while reading '%s' (%s)\n",
+ fd, file, strerror(errno));
ret = NXT_ERROR;
goto close_fd;
}
script.length = 0;
script.start = realloc(NULL, size);
if (script.start == NULL) {
- fprintf(stderr, "alloc failed while reading '%s'\n", file);
+ nxt_error("alloc failed while reading '%s'\n", file);
ret = NXT_ERROR;
goto done;
}
}
if (n < 0) {
- fprintf(stderr, "failed to read file: '%s' (%s)\n",
- file, strerror(errno));
+ nxt_error("failed to read file: '%s' (%s)\n",
+ file, strerror(errno));
ret = NXT_ERROR;
goto done;
}
start = realloc(script.start, size);
if (start == NULL) {
- fprintf(stderr, "alloc failed while reading '%s'\n", file);
+ nxt_error("alloc failed while reading '%s'\n", file);
ret = NXT_ERROR;
goto done;
}
vm = njs_vm_create(vm_options);
if (vm == NULL) {
- fprintf(stderr, "failed to create vm\n");
+ nxt_error("failed to create vm\n");
return NULL;
}
if (njs_externals_init(vm, vm_options->external) != NXT_OK) {
- fprintf(stderr, "failed to add external protos\n");
+ nxt_error("failed to add external protos\n");
return NULL;
}
ret = njs_vm_add_path(vm, &path);
if (ret != NXT_OK) {
- fprintf(stderr, "failed to add path\n");
+ nxt_error("failed to add path\n");
return NULL;
}
}
ret = njs_vm_add_path(vm, &path);
if (ret != NXT_OK) {
- fprintf(stderr, "failed to add path\n");
+ nxt_error("failed to add path\n");
return NULL;
}
}
if (ret != NJS_OK) {
- fprintf(stderr, "%.*s\n", (int) out.length, out.start);
+ nxt_error("%V\n", &out);
} else if (opts->interactive) {
- printf("%.*s\n", (int) out.length, out.start);
+ nxt_printf("%V\n", &out);
}
}
if (ret == NXT_OK) {
if (opts->disassemble) {
njs_disassembler(vm);
- printf("\n");
+ nxt_printf("\n");
}
ret = njs_vm_start(vm);
ret = njs_process_events(console, opts);
if (nxt_slow_path(ret != NXT_OK)) {
- fprintf(stderr, "njs_process_events() failed\n");
+ nxt_error("njs_process_events() failed\n");
ret = NJS_ERROR;
break;
}
if (njs_vm_waiting(vm) && !njs_vm_posted(vm)) {
/*TODO: async events. */
- fprintf(stderr, "njs_process_script(): "
- "async events unsupported\n");
+ nxt_error("njs_process_script(): async events unsupported\n");
ret = NJS_ERROR;
break;
}
return NJS_ERROR;
}
- printf("%s%.*s", (n != 1) ? " " : "", (int) msg.length, msg.start);
+ nxt_printf("%s%V", (n != 1) ? " " : "", &msg);
n++;
}
if (nargs > 1) {
- printf("\n");
+ nxt_printf("\n");
}
vm->retval = njs_value_undefined;
return NJS_ERROR;
}
- printf("%s%.*s", (n != 1) ? " " : "", (int) msg.length, msg.start);
+ nxt_printf("%s%V", (n != 1) ? " " : "", &msg);
n++;
}
if (nargs > 1) {
- printf("\n");
+ nxt_printf("\n");
}
vm->retval = njs_value_undefined;
{
const njs_object_init_t *obj, **objpp;
- printf("VM built-in objects:\n");
+ nxt_printf("VM built-in objects:\n");
for (objpp = njs_constructor_init; *objpp != NULL; objpp++) {
obj = *objpp;
- printf(" %.*s\n", (int) obj->name.length, obj->name.start);
+ nxt_printf(" %V\n", &obj->name);
}
for (objpp = njs_object_init; *objpp != NULL; objpp++) {
obj = *objpp;
- printf(" %.*s\n", (int) obj->name.length, obj->name.start);
+ nxt_printf(" %V\n", &obj->name);
}
- printf("\nEmbedded objects:\n");
- printf(" console\n");
+ nxt_printf("\nEmbedded objects:\n");
+ nxt_printf(" console\n");
- printf("\n");
+ nxt_printf("\n");
vm->retval = njs_value_undefined;
ms = ns / 1000000;
ns = ns % 1000000;
- printf("default: %" PRIu64 ".%06" PRIu64 "ms\n", ms, ns);
+ nxt_printf("default: %uL.%06uLms\n", ms, ns);
console->time = UINT64_MAX;
} else {
- printf("Timer \"default\" doesn’t exist.\n");
+ nxt_printf("Timer \"default\" doesn’t exist.\n");
}
vm->retval = njs_value_undefined;
nxt_lvlhsh_query_t lhq;
if (delay != 0) {
- fprintf(stderr, "njs_console_set_timer(): async timers unsupported\n");
+ nxt_error("njs_console_set_timer(): async timers unsupported\n");
return NULL;
}
ret = nxt_lvlhsh_delete(&console->events, &lhq);
if (ret != NXT_OK) {
- fprintf(stderr, "nxt_lvlhsh_delete() failed\n");
+ nxt_error("nxt_lvlhsh_delete() failed\n");
}
nxt_mp_free(vm->mem_pool, ev);
#include <njs_core.h>
#include <njs_time.h>
#include <string.h>
-#include <stdio.h>
static njs_ret_t
#include <njs_core.h>
#include <njs_regexp.h>
#include <string.h>
-#include <stdio.h>
#include <njs.h>
#include <string.h>
#include <stdlib.h>
-#include <stdio.h>
+#include <nxt_sprintf.h>
#include <sys/resource.h>
#include <time.h>
vm = njs_vm_create(&options);
if (vm == NULL) {
- printf("njs_vm_create() failed\n");
+ nxt_printf("njs_vm_create() failed\n");
goto done;
}
ret = njs_vm_compile(vm, &start, start + script->length);
if (ret != NXT_OK) {
- printf("njs_vm_compile() failed\n");
+ nxt_printf("njs_vm_compile() failed\n");
goto done;
}
nvm = njs_vm_clone(vm, NULL);
if (nvm == NULL) {
- printf("njs_vm_clone() failed\n");
+ nxt_printf("njs_vm_clone() failed\n");
goto done;
}
(void) njs_vm_start(nvm);
if (njs_vm_retval_to_ext_string(nvm, &s) != NXT_OK) {
- printf("njs_vm_retval_to_ext_string() failed\n");
+ nxt_printf("njs_vm_retval_to_ext_string() failed\n");
goto done;
}
success = nxt_strstr_eq(result, &s);
if (!success) {
- printf("failed: \"%.*s\" vs \"%.*s\"\n",
- (int) result->length, result->start, (int) s.length,
- s.start);
+ nxt_printf("failed: \"%V\" vs \"%V\"\n", result, &s);
goto done;
}
+ usage.ru_stime.tv_sec * 1000000 + usage.ru_stime.tv_usec;
if (n == 1) {
- printf("%s: %.3fs\n", msg, (double) us / 1000000);
+ nxt_printf("%s: %.3fs\n", msg, (double) us / 1000000);
} else {
- printf("%s: %.3fµs, %d times/s\n",
- msg, (double) us / n, (int) ((uint64_t) n * 1000000 / us));
+ nxt_printf("%s: %.3fµs, %d times/s\n",
+ msg, (double) us / n, (int) ((uint64_t) n * 1000000 / us));
}
rc = NXT_OK;
}
}
- printf("unknown agrument\n");
+ nxt_printf("unknown agrument\n");
return EXIT_FAILURE;
}
#include <njs.h>
#include <string.h>
-#include <stdio.h>
+#include <nxt_sprintf.h>
#include <sys/resource.h>
#include <time.h>
test = &njs_test[i];
if (verbose) {
- printf("\"%.*s\"\n", (int) test->script.length, test->script.start);
- fflush(stdout);
+ nxt_printf("\"%V\"\n", &test->script);
}
nxt_memzero(&options, sizeof(njs_vm_opt_t));
vm = njs_vm_create(&options);
if (vm == NULL) {
- printf("njs_vm_create() failed\n");
+ nxt_printf("njs_vm_create() failed\n");
goto done;
}
}
if (njs_vm_retval_to_ext_string(vm, &s) != NXT_OK) {
- printf("njs_vm_retval_to_ext_string() failed\n");
+ nxt_printf("njs_vm_retval_to_ext_string() failed\n");
goto done;
}
continue;
}
- printf("njs_interactive(\"%.*s\") failed: \"%.*s\" vs \"%.*s\"\n",
- (int) test->script.length, test->script.start,
- (int) test->ret.length, test->ret.start,
- (int) s.length, s.start);
+ nxt_printf("njs_interactive(\"%V\") failed: \"%V\" vs \"%V\"\n",
+ &test->script, &test->ret, &s);
goto done;
}
ret = NXT_OK;
- printf("njs interactive tests passed\n");
+ nxt_printf("njs interactive tests passed\n");
done:
#include <nxt_djb_hash.h>
#include <string.h>
#include <stdlib.h>
-#include <stdio.h>
#include <sys/resource.h>
#include <time.h>
proto = njs_vm_external_prototype(vm, &nxt_test_external[0]);
if (proto == NULL) {
- printf("njs_vm_external_prototype() failed\n");
+ nxt_printf("njs_vm_external_prototype() failed\n");
return NXT_ERROR;
}
ret = njs_vm_external_create(vm, njs_value_arg(&requests[i].value),
proto, &requests[i]);
if (ret != NXT_OK) {
- printf("njs_vm_external_create() failed\n");
+ nxt_printf("njs_vm_external_create() failed\n");
return NXT_ERROR;
}
ret = njs_vm_external_bind(vm, &nxt_test_requests[i].name,
njs_value_arg(&requests[i].value));
if (ret != NXT_OK) {
- printf("njs_vm_external_bind() failed\n");
+ nxt_printf("njs_vm_external_bind() failed\n");
return NXT_ERROR;
}
&nxt_test_requests[i].props[j].value);
if (prop == NULL) {
- printf("lvlhsh_unit_test_alloc() failed\n");
+ nxt_printf("lvlhsh_unit_test_alloc() failed\n");
return NXT_ERROR;
}
ret = lvlhsh_unit_test_add(&requests[i], prop);
if (ret != NXT_OK) {
- printf("lvlhsh_unit_test_add() failed\n");
+ nxt_printf("lvlhsh_unit_test_add() failed\n");
return NXT_ERROR;
}
}
for (i = 0; i < num; i++) {
if (verbose) {
- printf("\"%.*s\"\n",
- (int) njs_test[i].script.length, njs_test[i].script.start);
- fflush(stdout);
+ nxt_printf("\"%V\"\n", &njs_test[i].script);
}
nxt_memzero(&options, sizeof(njs_vm_opt_t));
vm = njs_vm_create(&options);
if (vm == NULL) {
- printf("njs_vm_create() failed\n");
+ nxt_printf("njs_vm_create() failed\n");
goto done;
}
if (ret == NXT_OK) {
if (disassemble) {
njs_disassembler(vm);
- fflush(stdout);
}
nvm = njs_vm_clone(vm, NULL);
if (nvm == NULL) {
- printf("njs_vm_clone() failed\n");
+ nxt_printf("njs_vm_clone() failed\n");
goto done;
}
ret = njs_vm_start(nvm);
if (njs_vm_retval_to_ext_string(nvm, &s) != NXT_OK) {
- printf("njs_vm_retval_to_ext_string() failed\n");
+ nxt_printf("njs_vm_retval_to_ext_string() failed\n");
goto done;
}
} else {
if (njs_vm_retval_to_ext_string(vm, &s) != NXT_OK) {
- printf("njs_vm_retval_to_ext_string() failed\n");
+ nxt_printf("njs_vm_retval_to_ext_string() failed\n");
goto done;
}
}
continue;
}
- printf("njs(\"%.*s\")\nexpected: \"%.*s\"\n got: \"%.*s\"\n",
- (int) njs_test[i].script.length, njs_test[i].script.start,
- (int) njs_test[i].ret.length, njs_test[i].ret.start,
- (int) s.length, s.start);
+ nxt_printf("njs(\"%V\")\nexpected: \"%V\"\n got: \"%V\"\n",
+ &njs_test[i].script, &njs_test[i].ret, &s);
goto done;
}
success = nxt_strstr_eq(&tests[i].expected, &name);
if (!success) {
- printf("nxt_file_basename_test(\"%.*s\"):\n"
- "expected: \"%.*s\"\n got: \"%.*s\"\n",
- (int) tests[i].path.length, tests[i].path.start,
- (int) tests[i].expected.length, tests[i].expected.start,
- (int) name.length, name.start);
+ nxt_printf("nxt_file_basename_test(\"%V\"):\n"
+ "expected: \"%V\"\n got: \"%V\"\n",
+ &tests[i].path, &tests[i].expected, &name);
return NXT_ERROR;
}
}
success = nxt_strstr_eq(&tests[i].expected, &name);
if (!success) {
- printf("nxt_file_dirname_test(\"%.*s\"):\n"
- "expected: \"%.*s\"\n got: \"%.*s\"\n",
- (int) tests[i].path.length, tests[i].path.start,
- (int) tests[i].expected.length, tests[i].expected.start,
- (int) name.length, name.start);
+ nxt_printf("nxt_file_dirname_test(\"%V\"):\n"
+ "expected: \"%V\"\n got: \"%V\"\n",
+ &tests[i].path, &tests[i].expected, &name);
return NXT_ERROR;
}
}
return ret;
}
- printf("njs unit tests passed\n");
+ nxt_printf("njs unit tests passed\n");
/*
* Chatham Islands NZ-CHAT time zone.
return ret;
}
- printf("njs timezone tests passed\n");
+ nxt_printf("njs timezone tests passed\n");
} else {
- printf("njs timezone tests skipped, timezone is unavailable\n");
+ nxt_printf("njs timezone tests skipped, timezone is unavailable\n");
}
ret = njs_vm_json_test(disassemble, verbose);
#define nxt_printf(fmt, ...) \
nxt_dprintf(STDOUT_FILENO, fmt, ##__VA_ARGS__)
+#define nxt_error(fmt, ...) \
+ nxt_dprintf(STDERR_FILENO, fmt, ##__VA_ARGS__)
+
#endif /* _NXT_SPRINTF_H_INCLUDED_ */
#include <nxt_malloc.h>
#include <nxt_sprintf.h>
#include <nxt_trace.h>
-#include <stdio.h>
static u_char *
#include <nxt_auto_config.h>
#include <nxt_types.h>
#include <nxt_clang.h>
+#include <nxt_sprintf.h>
#include <nxt_string.h>
#include <nxt_stub.h>
#include <nxt_malloc.h>
#include <nxt_lvlhsh.h>
#include <nxt_murmur_hash.h>
#include <nxt_mp.h>
-#include <stdio.h>
-#include <stdarg.h>
#include <string.h>
return NXT_OK;
case NXT_DECLINED:
- printf("lvlhsh unit test failed: key %08lX is already in hash\n",
- (long) key);
+ nxt_printf("lvlhsh unit test failed: key %08Xl is already in hash\n",
+ (long) key);
/* Fall through. */
default:
}
}
- printf("lvlhsh unit test failed: key %08lX not found in hash\n",
- (long) key);
+ nxt_printf("lvlhsh unit test failed: key %08Xl not found in hash\n",
+ (long) key);
return NXT_ERROR;
}
ret = nxt_lvlhsh_delete(lh, &lhq);
if (ret != NXT_OK) {
- printf("lvlhsh unit test failed: key %08lX not found in hash\n",
+ nxt_printf("lvlhsh unit test failed: key %08lX not found in hash\n",
(long) key);
}
static void
lvlhsh_alert(void *mem, const char *fmt, ...)
{
- int n;
+ u_char buf[1024], *p;
va_list args;
- char buf[1024];
va_start(args, fmt);
- n = vsnprintf(buf, sizeof(buf), fmt, args);
+ p = nxt_sprintf(buf, buf + sizeof(buf), fmt, args);
va_end(args);
- (void) printf("alert: \"%.*s\"\n", n, buf);
+ (void) nxt_error("alert: \"%*s\"\n", p - buf, buf);
}
return NXT_ERROR;
}
- printf("lvlhsh unit test started: %ld items\n", (long) n);
+ nxt_printf("lvlhsh unit test started: %l items\n", (long) n);
nxt_memzero(&lh, sizeof(nxt_lvlhsh_t));
key = nxt_murmur_hash2(&key, sizeof(uint32_t));
if (lvlhsh_unit_test_add(&lh, &lvlhsh_proto, pool, key) != NXT_OK) {
- printf("lvlhsh add unit test failed at %ld\n", (long) i);
+ nxt_printf("lvlhsh add unit test failed at %l\n", (long) i);
return NXT_ERROR;
}
}
}
if (i != n) {
- printf("lvlhsh each unit test failed at %ld of %ld\n",
- (long) i, (long) n);
+ nxt_printf("lvlhsh each unit test failed at %l of %l\n",
+ (long) i, (long) n);
return NXT_ERROR;
}
}
if (!nxt_mp_is_empty(pool)) {
- printf("mem cache pool is not empty\n");
+ nxt_printf("mem cache pool is not empty\n");
return NXT_ERROR;
}
nxt_mp_destroy(pool);
- printf("lvlhsh unit test passed\n");
+ nxt_printf("lvlhsh unit test passed\n");
return NXT_OK;
}
#include <nxt_auto_config.h>
#include <nxt_types.h>
#include <nxt_clang.h>
+#include <nxt_sprintf.h>
#include <nxt_string.h>
#include <nxt_stub.h>
#include <nxt_random.h>
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
}
if (nxt_random(&r) == 0x6FCAE186) {
- printf("random unit test passed\n");
+ nxt_printf("random unit test passed\n");
nxt_random_stir(&r, getpid());
- printf("random unit test: 0x%08X\n", nxt_random(&r));
+ nxt_printf("random unit test: 0x%08uXD\n", nxt_random(&r));
return NXT_OK;
}
}
- printf("random unit test failed\n");
+ nxt_printf("random unit test failed\n");
return NXT_ERROR;
}
#include <nxt_types.h>
#include <nxt_clang.h>
#include <nxt_stub.h>
+#include <nxt_sprintf.h>
#include <nxt_string.h>
#include <nxt_rbtree.h>
#include <nxt_murmur_hash.h>
-#include <stdio.h>
#include <stdlib.h>
#include <string.h>
nxt_rbtree_node_t *node;
nxt_rbtree_test_t *items, *item;
- printf("rbtree unit test started: %ld nodes\n", (long) n);
+ nxt_printf("rbtree unit test started: %l nodes\n", (long) n);
nxt_rbtree_init(&tree, rbtree_unit_test_comparison);
node = nxt_rbtree_find(&tree, &items[i].node);
if (node != (nxt_rbtree_node_t *) &items[i].node) {
- printf("rbtree unit test failed: %08X not found\n", items[i].key);
+ nxt_printf("rbtree unit test failed: %08uXD not found\n",
+ items[i].key);
goto fail;
}
}
item = (nxt_rbtree_test_t *) node;
if (keys[i] != item->key) {
- printf("rbtree unit test failed: %ld: %08X %08X\n",
- (long) i, keys[i], item->key);
+ nxt_printf("rbtree unit test failed: %l: %08uXD %08uXD\n",
+ (long) i, keys[i], item->key);
goto fail;
}
}
if (i != n) {
- printf("rbtree unit test failed: %ld\n", (long) i);
+ nxt_printf("rbtree unit test failed: %l\n", (long) i);
goto fail;
}
}
if (!nxt_rbtree_is_empty(&tree)) {
- printf("rbtree unit test failed: tree is not empty\n");
+ nxt_printf("rbtree unit test failed: tree is not empty\n");
goto fail;
}
/* Check that the sentinel callback was not modified. */
if (mark != tree.sentinel.right) {
- printf("rbtree sentinel unit test failed\n");
+ nxt_printf("rbtree sentinel unit test failed\n");
goto fail;
}
free(keys);
free(items);
- printf("rbtree unit test passed\n");
+ nxt_printf("rbtree unit test passed\n");
return NXT_OK;
#include <nxt_auto_config.h>
#include <nxt_types.h>
#include <nxt_clang.h>
+#include <nxt_sprintf.h>
#include <nxt_string.h>
#include <nxt_stub.h>
#include <nxt_utf8.h>
-#include <stdio.h>
#include <string.h>
u = (u << 8) + overlong[i];
}
- printf("nxt_utf8_decode(%05Xd, %zd) failed: %05Xd, %zd\n",
- u, len, d, size);
+ nxt_printf("nxt_utf8_decode(%05uXD, %uz) failed: %05uXD, %uz\n",
+ u, len, d, size);
return NXT_ERROR;
}
nxt_uint_t i, k, l, m;
const u_char *pp;
- printf("utf8 unit test started\n");
+ nxt_printf("utf8 unit test started\n");
/* Test valid UTF-8. */
p = nxt_utf8_encode(utf8, u);
if (p == NULL) {
- printf("nxt_utf8_encode(%05Xd) failed\n", u);
+ nxt_printf("nxt_utf8_encode(%05uXD) failed\n", u);
return NXT_ERROR;
}
d = nxt_utf8_decode(&pp, p);
if (u != d) {
- printf("nxt_utf8_decode(%05Xd) failed: %05uxD\n", u, d);
+ nxt_printf("nxt_utf8_decode(%05uXD) failed: %05uxD\n", u, d);
return NXT_ERROR;
}
}
u = (u << 8) + utf8[i];
}
- printf("nxt_utf8_decode(%05Xd, %zd) failed: %05Xd\n", u, len, d);
+ nxt_printf("nxt_utf8_decode(%05uXD, %uz) failed: %05uXD\n",
+ u, len, d);
return NXT_ERROR;
}
}
nxt_length("abc абв αβγ"));
if (n != 0) {
- printf("nxt_utf8_casecmp() failed\n");
+ nxt_printf("nxt_utf8_casecmp() failed\n");
return NXT_ERROR;
}
- printf("utf8 unit test passed\n");
+ nxt_printf("utf8 unit test passed\n");
return NXT_OK;
}
projects / njs.git / commitdiff