static void verify_tree (c_avl_node_t *n)
{
if (n == NULL)
return;
verify_tree (n->left);
verify_tree (n->right);
assert ((BALANCE (n) >= -1) && (BALANCE (n) <= 1));
assert ((n->parent == NULL) || (n->parent->right == n) || (n->parent->left == n));
} /* void verify_tree */
/* Simple stress test procedure for the red-black tree routines. Does
the following:
* Generate a random number seed. By default this is generated from
the current time. You can also pass an integer seed value on the
command line if you want to test the same case. The seed value is
displayed.
* Create a tree and insert the integers from 0 up to TREE_SIZE - 1
into it, in random order. Verifies and displays the tree structure
after each insertion.
* Removes each integer from the tree, in a different random order.
Verifies and displays the tree structure after each deletion.
* Destroys the tree.
This is pretty good test code if you write some of your own red-black
tree routines. If you do so you will probably want to modify the
code below so that it increments the random seed and goes on to new
test cases automatically. */
int main(int argc, char **argv)
{
int array[TREE_SIZE];
struct rb_tree *tree;
int i;
randomize(argc, argv);
for (i = 0; i < TREE_SIZE; i++)
array[i] = i;
shuffle(array, TREE_SIZE);
tree = rb_create();
for (i = 0; i < TREE_SIZE; i++) {
int result = rb_insert(tree, array[i]);
if (result != 1) {
printf("Error %d inserting element %d, %d, into tree.\n",
result, i, array[i]);
exit(EXIT_FAILURE);
}
printf("Inserted %d: ", array[i]);
/*print_structure(tree->root, 0);*/
rb_walk(tree);
putchar('\n');
verify_tree(tree, array);
}
shuffle(array, TREE_SIZE);
for (i = 0; i < TREE_SIZE; i++) {
if (rb_delete(tree, array[i]) == 0) {
printf("Error removing element %d, %d, from tree.\n", i, array[i]);
exit(EXIT_FAILURE);
}
printf("Removed %d: ", array[i]);
/*print_structure(tree->root, 0);*/
rb_traverse(tree);
putchar('\n');
verify_tree(tree, array + i + 1);
}
rb_destroy(tree);
printf("Success!\n");
return EXIT_SUCCESS;
}
static void
copy_ustar(void)
{
const char *target = "ustar";
int r;
/* NOTE: for proper operation on cygwin-1.5 and windows, the
* length of the name of the directory below, "ustar", must be
* less than or equal to the lengthe of the name of the original
* directory, "original" This restriction derives from the
* extremely limited pathname lengths on those platforms.
*/
assertMakeDir(target, 0775);
assertEqualInt(0, chdir(target));
/*
* Use the tar program to create an archive.
*/
r = systemf("%s cf archive --format=ustar -C ../original f d l m s >pack.out 2>pack.err",
testprog);
failure("Error invoking \"%s cf archive --format=ustar\"", testprog);
assertEqualInt(r, 0);
/* Verify that nothing went to stdout. */
assertEmptyFile("pack.out");
/* Stderr is non-empty, since there are a bunch of files
* with filenames too long to archive. */
/*
* Use tar to unpack the archive into another directory.
*/
r = systemf("%s xf archive >unpack.out 2>unpack.err", testprog);
failure("Error invoking %s xf archive", testprog);
assertEqualInt(r, 0);
/* Verify that nothing went to stdout or stderr. */
assertEmptyFile("unpack.err");
assertEmptyFile("unpack.out");
verify_tree(LIMIT_USTAR);
assertEqualInt(0, chdir("../.."));
}
static void
copy_basic(void)
{
int r;
/* NOTE: for proper operation on cygwin-1.5 and windows, the
* length of the name of the directory below, "plain", must be
* less than or equal to the lengthe of the name of the original
* directory, "original" This restriction derives from the
* extremely limited pathname lengths on those platforms.
*/
assertMakeDir("plain", 0775);
assertEqualInt(0, chdir("plain"));
/*
* Use the tar program to create an archive.
*/
r = systemf("%s cf archive -C ../original f d l m s >pack.out 2>pack.err",
testprog);
failure("Error invoking \"%s cf\"", testprog);
assertEqualInt(r, 0);
/* Verify that nothing went to stdout or stderr. */
assertEmptyFile("pack.err");
assertEmptyFile("pack.out");
/*
* Use tar to unpack the archive into another directory.
*/
r = systemf("%s xf archive >unpack.out 2>unpack.err", testprog);
failure("Error invoking %s xf archive", testprog);
assertEqualInt(r, 0);
/* Verify that nothing went to stdout or stderr. */
assertEmptyFile("unpack.err");
assertEmptyFile("unpack.out");
verify_tree(LIMIT_NONE);
assertEqualInt(0, chdir(".."));
}
/* reads, corrects and parses the verity table, validates parameters, and if
`f->flags' does not have `FEC_VERITY_DISABLE' set, calls `verify_tree' to
load and validate the hash tree */
static int parse_table(fec_handle *f, uint64_t offset, uint32_t size, bool useecc)
{
check(f);
check(size >= VERITY_MIN_TABLE_SIZE);
check(size <= VERITY_MAX_TABLE_SIZE);
debug("offset = %" PRIu64 ", size = %u", offset, size);
verity_info *v = &f->verity;
std::unique_ptr<char[]> table(new (std::nothrow) char[size + 1]);
if (!table) {
errno = ENOMEM;
return -1;
}
if (!useecc) {
if (!raw_pread(f, table.get(), size, offset)) {
error("failed to read verity table: %s", strerror(errno));
return -1;
}
} else if (fec_pread(f, table.get(), size, offset) != (ssize_t)size) {
error("failed to ecc read verity table: %s", strerror(errno));
return -1;
}
table[size] = '\0';
debug("verity table: '%s'", table.get());
int i = 0;
std::unique_ptr<uint8_t[]> salt;
uint8_t root[SHA256_DIGEST_LENGTH];
auto tokens = android::base::Split(table.get(), " ");
for (const auto& token : tokens) {
switch (i++) {
case 0: /* version */
if (token != stringify(VERITY_TABLE_VERSION)) {
error("unsupported verity table version: %s", token.c_str());
return -1;
}
break;
case 3: /* data_block_size */
case 4: /* hash_block_size */
/* assume 4 KiB block sizes for everything */
if (token != stringify(FEC_BLOCKSIZE)) {
error("unsupported verity block size: %s", token.c_str());
return -1;
}
break;
case 5: /* num_data_blocks */
if (parse_uint64(token.c_str(), f->data_size / FEC_BLOCKSIZE,
&v->data_blocks) == -1) {
error("invalid number of verity data blocks: %s",
token.c_str());
return -1;
}
break;
case 6: /* hash_start_block */
if (parse_uint64(token.c_str(), f->data_size / FEC_BLOCKSIZE,
&v->hash_start) == -1) {
error("invalid verity hash start block: %s", token.c_str());
return -1;
}
v->hash_start *= FEC_BLOCKSIZE;
break;
case 7: /* algorithm */
if (token != "sha256") {
error("unsupported verity hash algorithm: %s", token.c_str());
return -1;
}
break;
case 8: /* digest */
if (parse_hex(root, sizeof(root), token.c_str()) == -1) {
error("invalid verity root hash: %s", token.c_str());
return -1;
}
break;
case 9: /* salt */
v->salt_size = token.size();
check(v->salt_size % 2 == 0);
v->salt_size /= 2;
salt.reset(new (std::nothrow) uint8_t[v->salt_size]);
if (!salt) {
errno = ENOMEM;
return -1;
}
if (parse_hex(salt.get(), v->salt_size, token.c_str()) == -1) {
error("invalid verity salt: %s", token.c_str());
return -1;
}
break;
default:
break;
}
}
if (i < VERITY_TABLE_ARGS) {
error("not enough arguments in verity table: %d; expected at least "
stringify(VERITY_TABLE_ARGS), i);
return -1;
}
check(v->hash_start < f->data_size);
if (v->metadata_start < v->hash_start) {
check(v->data_blocks == v->metadata_start / FEC_BLOCKSIZE);
} else {
check(v->data_blocks == v->hash_start / FEC_BLOCKSIZE);
}
if (v->salt) {
delete[] v->salt;
v->salt = NULL;
}
v->salt = salt.release();
if (v->table) {
delete[] v->table;
v->table = NULL;
}
v->table = table.release();
if (!(f->flags & FEC_VERITY_DISABLE)) {
if (verify_tree(f, root) == -1) {
return -1;
}
check(v->hash);
uint8_t zero_block[FEC_BLOCKSIZE];
memset(zero_block, 0, FEC_BLOCKSIZE);
if (verity_hash(f, zero_block, v->zero_hash) == -1) {
error("failed to hash");
return -1;
}
}
return 0;
}
int main (int argc, char *argv[])
{
RUMATI_AVL_TREE *tree;
RUMATI_AVL_ERROR err;
bool in_tree[MAX_TEST_NUMBER];
int num[MAX_TEST_NUMBER];
int i, n, retv;
if ((err = rumati_avl_new(&tree, int_comparator, NULL)) != RUMATI_AVL_OK){
printf("Error creating avl tree: %d\n", err);
return 1;
}
retv = 0;
for (i = 0; i < MAX_TEST_NUMBER; i++){
in_tree[i] = false;
num[i] = i;
}
if (verify_tree(tree, in_tree) == false){
retv = 1;
goto out1;
}
for (i = 0; i < 8000; i++){
n = random() % MAX_TEST_NUMBER;
printf("INSERT: %d\n", n);
in_tree[n] = true;
if ((err = rumati_avl_put(tree, &num[n], NULL)) != RUMATI_AVL_OK){
retv = 1;
printf("Error adding %d to tree: %d\n", n, err);
break;
}
if (verify_tree(tree, in_tree) == false){
retv = 1;
goto out1;
}
}
for (i = 0; i < 5000; i++){
n = random() % MAX_TEST_NUMBER;
printf("DELETE: %d\n", n);
err = rumati_avl_delete(tree, &num[n], NULL);
if (in_tree[n] == true){
if (err != RUMATI_AVL_OK){
retv = 1;
printf("Error removing number %d tree, when it did exist in the tree: %d\n", n, err);
goto out1;
}
}else{
if (err == RUMATI_AVL_OK){
retv = 1;
printf("Error, number %d successfully deleted from tree, when it wasn't in the tree\n", n);
goto out1;
}else if (err != RUMATI_AVL_ENOENT){
retv = 1;
printf("Error removing number %d from tree when it did not exist in tree: %d\n", n, err);
goto out1;
}
}
in_tree[n] = false;
if (verify_tree(tree, in_tree) == false){
retv = 1;
goto out1;
}
}
printf("OK! Tests passed successfully!\n");
out1:
rumati_avl_destroy(tree, destructor);
return retv;
}
TREE *csoundParseOrc(CSOUND *csound, const char *str)
{
int err;
OPARMS *O = csound->oparms;
csound->parserNamedInstrFlag = 2;
{
PRE_PARM qq;
/* Preprocess */
memset(&qq, 0, sizeof(PRE_PARM));
//csp_orc_sa_print_list(csound);
csound_prelex_init(&qq.yyscanner);
csound_preset_extra(&qq, qq.yyscanner);
qq.line = csound->orcLineOffset;
csound->expanded_orc = corfile_create_w();
file_to_int(csound, "**unknown**");
if (str == NULL) {
char bb[80];
if (csound->orchstr==NULL && !csound->oparms->daemon)
csound->Die(csound,
Str("Failed to open input file %s\n"), csound->orchname);
else if(csound->orchstr==NULL && csound->oparms->daemon) return NULL;
add_include_udo_dir(csound->orchstr);
if (csound->orchname==NULL ||
csound->orchname[0]=='\0') csound->orchname = csound->csdname;
/* We know this is the start so stack is empty so far */
snprintf(bb, 80, "#source %d\n",
qq.lstack[0] = file_to_int(csound, csound->orchname));
corfile_puts(bb, csound->expanded_orc);
snprintf(bb, 80, "#line %d\n", csound->orcLineOffset);
corfile_puts(bb, csound->expanded_orc);
}
else {
if (csound->orchstr == NULL ||
corfile_body(csound->orchstr) == NULL)
csound->orchstr = corfile_create_w();
else
corfile_reset(csound->orchstr);
corfile_puts(str, csound->orchstr);
corfile_puts("\n#exit\n", csound->orchstr);
corfile_putc('\0', csound->orchstr);
corfile_putc('\0', csound->orchstr);
}
csound->DebugMsg(csound, "Calling preprocess on >>%s<<\n",
corfile_body(csound->orchstr));
//csound->DebugMsg(csound,"FILE: %s \n", csound->orchstr->body);
// csound_print_preextra(&qq);
cs_init_math_constants_macros(csound, &qq);
cs_init_omacros(csound, &qq, csound->omacros);
// csound_print_preextra(&qq);
csound_prelex(csound, qq.yyscanner);
if (UNLIKELY(qq.ifdefStack != NULL)) {
csound->Message(csound, Str("Unmatched #ifdef\n"));
csound->LongJmp(csound, 1);
}
csound_prelex_destroy(qq.yyscanner);
csound->DebugMsg(csound, "yielding >>%s<<\n",
corfile_body(csound->expanded_orc));
corfile_rm(&csound->orchstr);
}
{
/* VL 15.3.2015 allocating memory here will cause
unwanted growth.
We just pass a pointer, which will be allocated
by make leaf */
TREE* astTree = NULL;// = (TREE *)csound->Calloc(csound, sizeof(TREE));
TREE* newRoot;
PARSE_PARM pp;
TYPE_TABLE* typeTable = NULL;
/* Parse */
memset(&pp, '\0', sizeof(PARSE_PARM));
init_symbtab(csound);
csound_orcdebug = O->odebug;
csound_orclex_init(&pp.yyscanner);
csound_orcset_extra(&pp, pp.yyscanner);
csound_orc_scan_buffer(corfile_body(csound->expanded_orc),
corfile_tell(csound->expanded_orc), pp.yyscanner);
//csound_orcset_lineno(csound->orcLineOffset, pp.yyscanner);
//printf("%p \n", astTree);
err = csound_orcparse(&pp, pp.yyscanner, csound, &astTree);
//printf("%p \n", astTree);
// print_tree(csound, "AST - AFTER csound_orcparse()\n", astTree);
//csp_orc_sa_cleanup(csound);
corfile_rm(&csound->expanded_orc);
if (csound->synterrcnt) err = 3;
if (LIKELY(err == 0)) {
if(csound->oparms->odebug) csound->Message(csound,
Str("Parsing successful!\n"));
}
else {
if (err == 1){
csound->Message(csound, Str("Parsing failed due to invalid input!\n"));
}
else if (err == 2){
csound->Message(csound,
Str("Parsing failed due to memory exhaustion!\n"));
}
else if (err == 3){
csound->Message(csound, Str("Parsing failed due to %d syntax error%s!\n"),
csound->synterrcnt, csound->synterrcnt==1?"":"s");
}
goto ending;
}
if (UNLIKELY(PARSER_DEBUG)) {
print_tree(csound, "AST - INITIAL\n", astTree);
}
//print_tree(csound, "AST - INITIAL\n", astTree);
typeTable = csound->Malloc(csound, sizeof(TYPE_TABLE));
typeTable->udos = NULL;
typeTable->globalPool = csoundCreateVarPool(csound);
typeTable->instr0LocalPool = csoundCreateVarPool(csound);
typeTable->localPool = typeTable->instr0LocalPool;
typeTable->labelList = NULL;
/**** THIS NEXT LINE IS WRONG AS err IS int WHILE FN RETURNS TREE* ****/
astTree = verify_tree(csound, astTree, typeTable);
// csound->Free(csound, typeTable->instr0LocalPool);
// csound->Free(csound, typeTable->globalPool);
// csound->Free(csound, typeTable);
//print_tree(csound, "AST - FOLDED\n", astTree);
//FIXME - synterrcnt should not be global
if (astTree == NULL || csound->synterrcnt){
err = 3;
if (astTree)
csound->Message(csound,
Str("Parsing failed due to %d semantic error%s!\n"),
csound->synterrcnt, csound->synterrcnt==1?"":"s");
else if (csound->synterrcnt)
csound->Message(csound, Str("Parsing failed to syntax errors\n"));
else
csound->Message(csound, Str("Parsing failed due no input!\n"));
goto ending;
}
err = 0;
//csp_orc_analyze_tree(csound, astTree);
// astTree = csound_orc_expand_expressions(csound, astTree);
//
if (UNLIKELY(PARSER_DEBUG)) {
print_tree(csound, "AST - AFTER VERIFICATION/EXPANSION\n", astTree);
}
ending:
csound_orclex_destroy(pp.yyscanner);
if (err) {
csound->ErrorMsg(csound, Str("Stopping on parser failure"));
csoundDeleteTree(csound, astTree);
if (typeTable != NULL) {
csoundFreeVarPool(csound, typeTable->globalPool);
if(typeTable->instr0LocalPool != NULL) {
csoundFreeVarPool(csound, typeTable->instr0LocalPool);
}
if(typeTable->localPool != typeTable->instr0LocalPool) {
csoundFreeVarPool(csound, typeTable->localPool);
}
csound->Free(csound, typeTable);
}
return NULL;
}
astTree = csound_orc_optimize(csound, astTree);
// small hack: use an extra node as head of tree list to hold the
// typeTable, to be used during compilation
newRoot = make_leaf(csound, 0, 0, 0, NULL);
newRoot->markup = typeTable;
newRoot->next = astTree;
/* if(str!=NULL){ */
/* if (typeTable != NULL) { */
/* csoundFreeVarPool(csound, typeTable->globalPool); */
/* if(typeTable->instr0LocalPool != NULL) { */
/* csoundFreeVarPool(csound, typeTable->instr0LocalPool); */
/* } */
/* if(typeTable->localPool != typeTable->instr0LocalPool) { */
/* csoundFreeVarPool(csound, typeTable->localPool); */
/* } */
/* csound->Free(csound, typeTable); */
/* } */
/* } */
return newRoot;
}
}
