void testdb_setup(t_testdb *d)
{
if (!d->d_db) {
short path = packages_getpackagepath("testpackage");
char fullpath[MAX_PATH_CHARS];
short apppath = path_getapppath();
char appfullpath[MAX_PATH_CHARS];
unsigned long appfullpathlen;
int i;
char dbfilename[MAX_PATH_CHARS];
t_db_result *dbresult = NULL;
path_topathname(apppath, "", appfullpath);
appfullpathlen = strlen(appfullpath);
for (i=0; i<appfullpathlen; i++) {
if (appfullpath[i] == ':' || appfullpath[i] == '/')
appfullpath[i] ='-';
}
strncpy_zero(dbfilename, appfullpath, MAX_PATH_CHARS);
strncat_zero(dbfilename, "--maxtestresults.db3", MAX_PATH_CHARS);
path_topathname(path, "", fullpath);
strncat_zero(fullpath, "/", MAX_PATH_CHARS);
strncat_zero(fullpath, dbfilename, MAX_PATH_CHARS);
db_open(gensym("unittestdb"), fullpath, &d->d_db);
// cache the fullpath so it can be requested from the outside world
{
short apath;
char afilename[MAX_FILENAME_CHARS];
path_frompathname(fullpath, &apath, afilename);
path_toabsolutesystempath(apath, afilename, g_dbpath);
}
db_query(d->d_db, &dbresult, "SELECT name FROM sqlite_master WHERE type='table' AND name='tests'");
if (!db_result_numrecords(dbresult)) {
db_query_table_new(d->d_db, "tests");
db_query_table_addcolumn(d->d_db, "tests", "test_name", "VARCHAR(512)", 0);
db_query_table_addcolumn(d->d_db, "tests", "test_start", "DATETIME", 0);
db_query_table_addcolumn(d->d_db, "tests", "test_finish", "DATETIME", 0);
db_query_table_new(d->d_db, "assertions");
db_query_table_addcolumn(d->d_db, "assertions", "test_id_ext", "INTEGER", 0);
db_query_table_addcolumn(d->d_db, "assertions", "assertion_name", "VARCHAR(512)", 0);
db_query_table_addcolumn(d->d_db, "assertions", "assertion_value", "VARCHAR(512)", 0);
db_query_table_addcolumn(d->d_db, "assertions", "assertion_data", "VARCHAR(512)", 0);
db_query_table_addcolumn(d->d_db, "assertions", "assertion_start", "DATETIME", 0);
db_query_table_addcolumn(d->d_db, "assertions", "assertion_finish", "DATETIME", 0);
db_query_table_addcolumn(d->d_db, "assertions", "assertion_tags", "VARCHAR(512)", 0);
db_query_table_new(d->d_db, "logs");
db_query_table_addcolumn(d->d_db, "logs", "test_id_ext", "INTEGER", 0);
db_query_table_addcolumn(d->d_db, "logs", "text", "VARCHAR(512)", 0);
db_query_table_addcolumn(d->d_db, "logs", "timestamp", "DATETIME", 0);
}
object_free(dbresult);
}
}
void tralala_paintStrncatPanel(char *dst, long argc, t_atom *argv)
{
long k = 0;
char *p = NULL;
if (!(atom_gettext(argc - 1, argv + 1, &k, &p, OBEX_UTIL_ATOM_GETTEXT_SYM_NO_QUOTE))) {
strncat_zero(dst, p, TLL_STRING_SIZE);
strncat_zero(dst, "\n", TLL_STRING_SIZE);
sysmem_freeptr(p);
}
}
void _dict_recurse_array(t_dict_recurse *x, t_atomarray *atomarray, t_int32 depth)
{
TRACE("_dict_recurse_array");
t_atom *value;
// ==== Store the state variables on the beginning of the function
t_int32 path_len = (t_int32)strlen(x->path);
t_value_type type_iter_ini = x->type_iter;
t_atomarray *array_iter_ini = x->array_iter;
t_int32 index_iter_ini = x->index_iter;
// ==== Add [ to the path
strncat_zero(x->path, "[", x->path_len_max);
// ==== Set the trailing variables before the recursions
x->type_iter = VALUE_TYPE_ARRAY;
x->array_iter = atomarray;
// ==== Get the array of atoms associated with the atomarray
long array_len;
t_atom *atom_arr;
atomarray_getatoms(atomarray, &array_len, &atom_arr);
t_int32 test;
// ==== Loop through the array
for (t_int32 ind = 0; ind < array_len; ind++) {
value = atom_arr + ind;
x->index_iter = ind;
// == Update the path
snprintf_zero(x->str_tmp, MAX_LEN_NUMBER, "%i]", ind);
strncat_zero(x->path, x->str_tmp, x->path_len_max);
// == Recurse to the value
test = _dict_recurse_value(x, value, depth);
// == If there was a deletion reset the array and shift the index
if (test == VALUE_DEL) {
atomarray_getatoms(atomarray, &array_len, &atom_arr);
ind--; }
// == In loop resetting of the values that changed in this function
x->path[path_len + 1] = '\0'; } // End of the loop through the array
// ==== Restore the remaining state variables to their beginning values
x->type_iter = type_iter_ini;
x->array_iter = array_iter_ini;
x->index_iter = index_iter_ini;
}
void _filesys_get_path(t_filesys *x, const char* str_src, char *str_dest)
{
char str_tmp[MAX_PATH_CHARS];
if (_filesys_is_abs(x, str_src)) {
strncpy_zero(str_tmp, str_src, MAX_PATH_CHARS); }
else {
strncpy_zero(str_tmp, x->dir_s, MAX_PATH_CHARS);
strncat_zero(str_tmp, str_src, MAX_PATH_CHARS); }
path_nameconform(str_tmp, str_dest, PATH_STYLE_NATIVE, PATH_TYPE_PATH);
}
void tralala_paintStrncatNote(char *dst, long argc, t_atom *argv)
{
char a[5];
char temp[32];
long p = atom_getlong(argv + 1);
long v = atom_getlong(argv + 3);
long d = atom_getlong(argv + 4);
long c = atom_getlong(argv + 5);
tralala_paintPitchAsString(a, atom_getlong(argv + 2), 5);
snprintf_zero(temp, 32, "%ld %s %ld %ld %ld\n", p, a, v, d, c);
strncat_zero(dst, temp, TLL_STRING_SIZE);
}
void hub_getstate(t_hub *x)
{
subscriberList* subscriber = x->subscriber; // head of the linked list
subscriberIterator i;
t_subscriber* t;
char* text = NULL;
long textsize = 0;
if(!x->textEditor)
x->textEditor = (t_object*)object_new(_sym_nobox, _sym_jed, x, 0);
if(!x->textSize){
x->textSize = 4096;
x->text = (char*)malloc(sizeof(char) * x->textSize);
}
x->text[0] = 0;
critical_enter(0);
for(i = subscriber->begin(); i != subscriber->end(); ++i) {
t = *i;
if(t->type == jps_subscribe_parameter){
long ac = NULL;
t_atom* av = NULL;
object_attr_getvalueof(t->object, jps_value, &ac, &av); // get
atom_gettext(ac, av, &textsize, &text, 0);
// this is a really lame way to do this...
if(strlen(x->text) > (x->textSize - 1024)){
x->textSize += 4096;
x->text = (char*)realloc(x->text, x->textSize);
}
strncat_zero(x->text, x->osc_name->s_name, x->textSize);
strncat_zero(x->text, "/", x->textSize);
strncat_zero(x->text, t->name->s_name, x->textSize);
strncat_zero(x->text, " ", x->textSize);
strncat_zero(x->text, text, x->textSize);
strncat_zero(x->text, "\n", x->textSize);
sysmem_freeptr(text);
text = NULL;
textsize = 0;
}
}
critical_exit(0);
object_method(x->textEditor, _sym_settext, x->text, _sym_utf_8);
object_attr_setchar(x->textEditor, gensym("scratch"), 1);
object_attr_setsym(x->textEditor, _sym_title, gensym("jamoma module state"));
sysmem_freeptr(text);
}
void tralala_paintStrncatZone(char *dst, long argc, t_atom *argv, long status)
{
char a[5];
char b[5];
char temp[32];
tralala_paintPitchAsString(a, atom_getlong(argv + 3), 5);
tralala_paintPitchAsString(b, atom_getlong(argv + 4), 5);
if (status >= TLL_SELECTED_START) {
//
switch (status) {
case TLL_SELECTED_START : snprintf_zero(temp, 32, "Start : %ld\n", atom_getlong(argv + 1)); break;
case TLL_SELECTED_END : snprintf_zero(temp, 32, "End : %ld\n", atom_getlong(argv + 2)); break;
case TLL_SELECTED_DOWN : snprintf_zero(temp, 32, "Down : %s\n", a); break;
case TLL_SELECTED_UP : snprintf_zero(temp, 32, "Up : %s\n", b); break;
}
//
} else {
snprintf_zero(temp, 32, "%ld %ld %s %s\n", atom_getlong(argv + 1), atom_getlong(argv + 2), a, b);
}
strncat_zero(dst, temp, TLL_STRING_SIZE);
}
t_max_err attr_set_prefix(t_ui *obj, void *attr, long argc, t_atom *argv)
{
uiInternalObject *anObject;
t_max_err err = MAX_ERR_NONE;
char name[256];
if(argc && argv)
obj->attrPrefix = atom_getsym(argv);
else
obj->attrPrefix = _sym_nothing;
err = hashtab_lookup(obj->hash_internals, gensym("mute"), (t_object**)&anObject);
if(!err){
name[0] = 0;
if (obj->attrPrefix!=gensym(""))
{
if(obj->attrPrefix && obj->attrPrefix->s_name[0])
strncpy_zero(name, obj->attrPrefix->s_name, 256);
strncat_zero(name, "/mute", 256);
}
else
strncat_zero(name, "mute", 256);
anObject->setName(name);
}
err = hashtab_lookup(obj->hash_internals, gensym("bypass"), (t_object**)&anObject);
if(!err){
name[0] = 0;
if (obj->attrPrefix!=gensym(""))
{
if(obj->attrPrefix && obj->attrPrefix->s_name[0])
strncpy_zero(name, obj->attrPrefix->s_name, 256);
strncat_zero(name, "/bypass", 256);
}
else
strncat_zero(name, "bypass", 256);
anObject->setName(name);
}
err = hashtab_lookup(obj->hash_internals, gensym("mix"), (t_object**)&anObject);
if(!err){
name[0] = 0;
if (obj->attrPrefix!=gensym(""))
{
if(obj->attrPrefix && obj->attrPrefix->s_name[0])
strncpy_zero(name, obj->attrPrefix->s_name, 256);
strncat_zero(name, "/mix", 256);
}
else
strncat_zero(name, "mix", 256);
anObject->setName(name);
}
err = hashtab_lookup(obj->hash_internals, gensym("gain"), (t_object**)&anObject);
if(!err){
name[0] = 0;
if (obj->attrPrefix!=gensym(""))
{
if(obj->attrPrefix && obj->attrPrefix->s_name[0])
strncpy_zero(name, obj->attrPrefix->s_name, 256);
strncat_zero(name, "/gain", 256);
}
else
strncat_zero(name, "gain", 256);
anObject->setName(name);
}
err = hashtab_lookup(obj->hash_internals, gensym("freeze"), (t_object**)&anObject);
if(!err){
name[0] = 0;
if (obj->attrPrefix!=gensym(""))
{
if(obj->attrPrefix && obj->attrPrefix->s_name[0])
strncpy_zero(name, obj->attrPrefix->s_name, 256);
strncat_zero(name, "/freeze", 256);
}
else
strncat_zero(name, "freeze", 256);
anObject->setName(name);
}
err = hashtab_lookup(obj->hash_internals, gensym("preview"), (t_object**)&anObject);
if(!err){
name[0] = 0;
if (obj->attrPrefix!=gensym(""))
{
if(obj->attrPrefix && obj->attrPrefix->s_name[0])
strncpy_zero(name, obj->attrPrefix->s_name, 256);
strncat_zero(name, "/preview", 256);
}
else
strncat_zero(name, "preview", 256);
anObject->setName(name);
}
return MAX_ERR_NONE;
}
void tralala_paintCurrent(t_tll *x, t_object *pv)
{
long zoneStatus = 0;
long i, argc, n = 0;
t_atom *argv = NULL;
t_symbol *mark = NULL;
t_symbol **keys = NULL;
PIZError err = PIZ_GOOD;
char string[TLL_STRING_SIZE] = "";
t_symbol *s[ ] = {
TLL_SYM_BPM,
TLL_SYM_CHANCE,
TLL_SYM_VELOCITY,
TLL_SYM_CHANNEL,
TLL_SYM_CHORD,
TLL_SYM_CELL,
TLL_SYM_VALUE,
TLL_SYM_SCALE
};
pizArrayClear(x->temp[0]);
pizArrayClear(x->temp[1]);
pizArrayClear(x->temp[2]);
TLL_DATA_LOCK
dictionary_getlong(x->status, TLL_SYM_ZONE, &zoneStatus);
for (i = 0; i < 9; i++) {
if (!(dictionary_getatoms(x->current, s[i], &argc, &argv)) && (argc > 1)) {
tralala_paintStrncatPanel(string, argc, argv);
}
}
if (!(dictionary_getatoms(x->current, TLL_SYM_MUTE, &argc, &argv))
&& (argc > 1)
&& (atom_gettype(argv + 1) == A_LONG)
&& (atom_getlong(argv + 1) == 1)) {
strncat_zero(string, "•\n", TLL_STRING_SIZE);
} else {
strncat_zero(string, "\n", TLL_STRING_SIZE);
}
if (dictionary_hasentry(x->status, TLL_SYM_ZONE)) {
if (!(dictionary_getatoms(x->current, TLL_SYM_ZONE, &argc, &argv))) {
tralala_paintStrncatZone(string, argc, argv, zoneStatus);
}
} else if (!(dictionary_getsym(x->status, TLL_SYM_MARK, &mark))
&& (!(dictionary_getatoms(x->current, mark, &argc, &argv)))) {
tralala_paintStrncatNote(string, argc, argv);
}
if (!(dictionary_getkeys(x->current, &n, &keys))) {
//
for (i = 0; i < n; i++) {
//
long k, j, p, status = 0;
t_symbol *key = (*(keys + i));
if (!(dictionary_getatoms(x->current, key, &argc, &argv))
&& (atom_getsym(argv) == TLL_SYM_NOTE)
&& (argc == 6)) {
if (k = dictionary_hasentry(x->status, key)) {
dictionary_getlong(x->status, key, &status);
}
if (!k || (status == TLL_LASSO_UNSELECTED)) {
p = 0;
} else if (key != mark) {
p = 1;
} else {
p = 2;
}
for (j = 1; j < 5; j++) {
pizArrayAppend(x->temp[p], atom_getlong(argv + j));
}
}
//
}
dictionary_freekeys(x->current, n, keys);
//
}
err |= (dictionary_getatoms(x->current, TLL_SYM_ZONE, &argc, &argv)) != MAX_ERR_NONE;
TLL_DATA_UNLOCK
if (!err) {
if (!zoneStatus) {
tralala_paintCurrentZone(x, pv, argc, argv, zoneStatus);
tralala_paintCurrentNote(x, pv);
} else {
tralala_paintCurrentNote(x, pv);
tralala_paintCurrentZone(x, pv, argc, argv, zoneStatus);
}
if (x->viewText) {
tralala_paintCurrentText(x, pv, string);
}
}
}
void _dict_recurse_dict(t_dict_recurse *x, t_dictionary *dict, t_int32 depth)
{
TRACE("_dict_recurse_dict");
t_atom atom[1];
// ==== Store the state variables on the beginning of the function
t_bool has_match_ini = x->has_match;
t_int32 path_len_ini = (t_int32)strlen(x->path);
t_value_type type_iter_ini = x->type_iter;
t_dictionary *dict_iter_ini = x->dict_iter;
t_symbol *key_iter_ini = x->key_iter;
// ==== Add :: to the path
strncat_zero(x->path, "::", x->path_len_max);
// ==== Get the dictionary keys
long key_cnt = 0;
t_symbol **key_arr = NULL;
dictionary_getkeys(dict, &key_cnt, &key_arr);
// ==== Increment the depth
depth++;
// ==== Set the trailing variables before for the recursions
x->type_iter = VALUE_TYPE_DICT;
x->dict_iter = dict;
// ==== Loop through the keys
for (t_int32 ind = 0; ind < key_cnt; ind++) {
x->key_iter = key_arr[ind];
// == Opening actions depending on which command is being processed
switch (x->command) {
case CMD_FIND_KEY_IN:
case CMD_FIND_KEY:
if (regexpr_match(x->search_key_expr, x->key_iter)) {
x->has_match = true; x->count++; } // x->has_match changed
break;
case CMD_REPLACE_KEY:
if (regexpr_match(x->search_key_expr, x->key_iter)) {
dictionary_getatom(dict, x->key_iter, atom);
dictionary_chuckentry(dict, x->key_iter);
dictionary_appendatom(dict, x->replace_key_sym, atom);
x->count++;
if (x->a_verbose == true) {
POST(" %s%s replaced by \"%s\"",
x->path, x->key_iter->s_name, x->replace_key_sym->s_name); }
x->key_iter = x->replace_key_sym; }
break;
case CMD_DELETE_KEY:
if (regexpr_match(x->search_key_expr, x->key_iter)) {
dictionary_deleteentry(dict, x->key_iter);
x->count++;
if (x->a_verbose == true) {
POST(" %s%s deleted",
x->path, x->key_iter->s_name, x->replace_key_sym->s_name); }
continue; } // NB: No further recursion
break;
case CMD_REPLACE_VALUE_FROM_DICT:
if (regexpr_match(x->search_key_expr, x->key_iter)
&& dictionary_hasentry(x->replace_dict, x->key_iter)) {
t_symbol *key_iter[2]; key_iter[0] = x->key_iter; key_iter[1] = NULL;
dictionary_copyentries(x->replace_dict, dict, key_iter); // NB: Strange it does not require the array size
x->count++;
if (x->a_verbose == true) {
POST(" %s%s replaced from \"%s\"",
x->path, x->key_iter->s_name, x->replace_dict_sym->s_name); }
continue; } // NB: No further recursion
break;
default: break;
} // >>>> END switch through potential commands
// == Set the trailing variables before for the recursion
strncat_zero(x->path, x->key_iter->s_name, x->path_len_max); // NB: x->path changed
// == Get the value and recurse to it
dictionary_getatom(dict, x->key_iter, atom); // NB: This creates a copy
_dict_recurse_value(x, atom, depth);
// == Reset the values that changed in this loop
x->path[path_len_ini + 2] = '\0';
x->has_match = has_match_ini; } // >>>> END of loop through the keys
// ==== Restore the remaining state variables to their beginning values
x->type_iter = type_iter_ini;
x->dict_iter = dict_iter_ini;
x->key_iter = key_iter_ini;
if (key_arr) { dictionary_freekeys(dict, key_cnt, key_arr); }
}
