static ERR_VALUE _init_lookasides(const uint32_t KmerSize, PUTILS_LOOKASIDE *VA, PUTILS_LOOKASIDE *EA)
{
ERR_VALUE ret = ERR_SUCCESS;
int threadIndex = omp_get_thread_num();
if (_vertexLAs[threadIndex] == NULL) {
ret = utils_malloc(sizeof(UTILS_LOOKASIDE), _vertexLAs + threadIndex);
if (ret == ERR_SUCCESS) {
ret = utils_lookaside_init(_vertexLAs[threadIndex], sizeof(KMER_VERTEX) + KmerSize, 3000);
if (ret != ERR_SUCCESS) {
utils_free(_vertexLAs[threadIndex]);
_vertexLAs[threadIndex] = NULL;
}
}
}
if (ret == ERR_SUCCESS) {
*VA = _vertexLAs[threadIndex];
if (_edgeLAs[threadIndex] == NULL) {
ret = utils_malloc(sizeof(UTILS_LOOKASIDE), _edgeLAs + threadIndex);
if (ret == ERR_SUCCESS) {
ret = utils_lookaside_init(_edgeLAs[threadIndex], sizeof(KMER_EDGE), 5000);
if (ret != ERR_SUCCESS) {
utils_free(_edgeLAs[threadIndex]);
_edgeLAs[threadIndex] = NULL;
}
}
}
if (ret == ERR_SUCCESS)
*EA = _edgeLAs[threadIndex];
}
return ret;
}
/* Convenience function. Free the three program name strings stored
* by utils_remember_program_name(). This can safely be called
* without really storing them, though there is probably no reason not
* to do that in the first place.
*/
void
utils_free_program_name_strings (void)
{
utils_free (full_program_name);
utils_free (short_program_name);
utils_free (program_directory);
}
int xml_cleanup(void) {
int i;
for (i = 0; i < xml_numAttr; i++) {
if (xattr[i].node != NULL)
xattr[i].node = utils_free("xml.xml_cleanup.xattr[].node", xattr[i].node);
if (xattr[i].name != NULL)
xattr[i].name = utils_free("xml.xml_cleanup.xattr[].name", xattr[i].name);
if (xattr[i].value != NULL)
xattr[i].value = utils_free("xml.xml_cleanup.xattr[].value", xattr[i].value);
if (xattr[i].filename != NULL)
xattr[i].filename = utils_free("xml.xml_cleanup.xattr[].filename", xattr[i].filename);
xattr[i].node = NULL;
xattr[i].name = NULL;
xattr[i].value = NULL;
xattr[i].filename = NULL;
}
//xattr = utils_free("xml.xml_cleanup.xattr", xattr);
return 0;
}
void xml_free_all(char **ret, int num)
{
int i;
for (i = 0; i < num; i++)
ret[i] = utils_free("xml.xml_free_all.ret[]", ret[i]);
ret = utils_free("xml.xml_free_all.ret", ret);
}
void assembly_task_finit(PASSEMBLY_TASK Task)
{
if (Task->Allocated) {
read_set_destroy((PONE_READ)Task->Reads, Task->ReadCount);
utils_free((char *)Task->Alternate2);
utils_free((char *)Task->Alternate1);
utils_free((char *)Task->Reference);
}
return;
}
ERR_VALUE read_copy(PONE_READ Dest, const ONE_READ *Source)
{
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = ERR_SUCCESS;
*Dest = *Source;
if (Dest->CIGARLen > 0)
ret = utils_copy_string(Source->CIGAR, &Dest->CIGAR);
if (ret == ERR_SUCCESS) {
if (Dest->TemplateNameLen > 0)
ret = utils_copy_string(Source->TemplateName, &Dest->TemplateName);
if (ret == ERR_SUCCESS) {
if (Dest->ReadSequenceLen > 0)
ret = utils_copy_string(Source->ReadSequence, &Dest->ReadSequence);
if (ret == ERR_SUCCESS) {
if (Dest->QualityLen > 0) {
ret = utils_calloc(Dest->QualityLen + 1, sizeof(uint8_t), &Dest->Quality);
if (ret == ERR_SUCCESS) {
memcpy(Dest->Quality, Source->Quality, Dest->QualityLen);;
Dest->Quality[Dest->QualityLen] = 0;
}
}
if (ret == ERR_SUCCESS && Source->RNameLen > 0)
ret = utils_copy_string(Source->RName, &Dest->RName);
if (ret == ERR_SUCCESS && Source->RNextLen > 0)
ret = utils_copy_string(Source->RNext, &Dest->RNext);
if (ret != ERR_SUCCESS) {
if (Dest->ReadSequenceLen > 0)
utils_free(Dest->ReadSequence);
}
}
if (ret != ERR_SUCCESS) {
if (Dest->TemplateNameLen > 0)
utils_free(Dest->TemplateName);
}
}
if (ret != ERR_SUCCESS) {
if (Dest->CIGARLen > 0)
utils_free(Dest->CIGAR);
}
}
return ret;
}
ERR_VALUE read_set_generate_from_sequence(const char *Seq, const size_t SeqLen, const uint32_t ReadLength, const size_t ReadCount, PONE_READ *ReadSet)
{
PONE_READ r = NULL;
PONE_READ tmpReadSet = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(ReadCount, sizeof(ONE_READ), &tmpReadSet);
if (ret == ERR_SUCCESS) {
r = tmpReadSet;
for (size_t i = 0; i < ReadCount; ++i) {
memset(r, 0, sizeof(ONE_READ));
r->Pos = utils_ranged_rand(0, SeqLen - ReadLength + 1);
r->PosQuality = 254;
r->ReadSequenceLen = ReadLength;
ret = utils_calloc(r->ReadSequenceLen + 1, sizeof(char), &r->ReadSequence);
if (ret == ERR_SUCCESS) {
memcpy(r->ReadSequence, Seq + r->Pos, r->ReadSequenceLen*sizeof(char));
r->ReadSequence[r->ReadSequenceLen] = '\0';
r->QualityLen = r->ReadSequenceLen;
ret = utils_calloc(r->QualityLen, sizeof(uint8_t), &r->Quality);
if (ret == ERR_SUCCESS)
memset(r->Quality, 254, r->QualityLen);
if (ret != ERR_SUCCESS)
utils_free(r->ReadSequence);
}
if (ret != ERR_SUCCESS) {
--r;
for (size_t j = 0; j < i; ++j) {
_read_destroy_structure(r);
--r;
}
break;
}
++r;
}
if (ret == ERR_SUCCESS)
*ReadSet = tmpReadSet;
if (ret != ERR_SUCCESS)
utils_free(tmpReadSet);
}
return ret;
}
int process_data(xmlDocPtr doc, xmlNodePtr node, char *xpath, int level, char *fn) {
char *newxpath = NULL;
char *data = NULL;
int size, i, found;
node = node->xmlChildrenNode;
while (node != NULL) {
data = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
if ((data != NULL) && ((strlen(data) == 0) || (data[0] == 10))) {
size = strlen(xpath) + strlen((const char *)node->name) + 2;
newxpath = (char *)utils_alloc( "xml.process_data.newxpath", size * sizeof(char) );
snprintf(newxpath, size, "%s/%s", xpath, node->name);
process_recursive(doc, newxpath, level + 1, fn);
newxpath = utils_free("xml.process_data.newxpath", newxpath);
}
else if (data != NULL) {
found = 0;
for (i = 0; i < xml_numAttr; i++) {
if ((strcmp(xattr[i].name, (const char *)node->name) == 0)
&& ((strcmp(xattr[i].node, xpath) == 0))
&& ((strcmp(xattr[i].value, data) == 0))
&& ((strcmp(xattr[i].filename, fn) == 0)))
found = 1;
}
if (!found) {
if (xattr == NULL)
xattr = (tAttr *)utils_alloc( "xml.process_data.xattr", sizeof(tAttr) );
else
xattr = (tAttr *)realloc( xattr, (xml_numAttr + 1) * sizeof(tAttr) );
xattr[xml_numAttr].name = strdup( (const char *)node->name);
xattr[xml_numAttr].node = strdup(xpath);
xattr[xml_numAttr].value = strdup(data);
xattr[xml_numAttr].filename = strdup(fn);
xattr[xml_numAttr].numIter = xml_numIter;
xml_numAttr++;
}
}
data = utils_free("xml.process_data.data", data);
node = node->next;
}
xml_numIter++;
return 0;
}
static ERR_VALUE _examine_read_coverage(const ONE_READ *Reads, const size_t ReadCount, const char *RefSeq, const size_t RefSeqLen, const char *Alternate)
{
uint32_t *c = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(RefSeqLen, sizeof(uint32_t), &c);
if (ret == ERR_SUCCESS) {
memset(c, 0, RefSeqLen*sizeof(uint32_t));
for (size_t i = 0; i < ReadCount; ++i) {
for (size_t j = 0; j < Reads[i].ReadSequenceLen; ++j)
c[Reads[i].Pos + j]++;
}
printf("Not covered: ");
for (size_t i = 0; i < RefSeqLen; ++i) {
if (c[i] == 0) {
printf("%u ", i);
if (RefSeq[i] != Alternate[i]) {
printf("%u: The position has SNPs but is not covered in any read (%c %c)\n", i, RefSeq[i], Alternate[i]);
ret = ERR_BAD_READ_COVERAGE;
}
}
}
printf("\n");
utils_free(c);
}
return ret;
}
ERR_VALUE read_set_load(FILE *Stream, PONE_READ *ReadSet, size_t *Count)
{
uint32_t count32 = 0;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
PONE_READ tmpReadSet = NULL;
ret = utils_fread(&count32, sizeof(count32), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_calloc(count32, sizeof(ONE_READ), &tmpReadSet);
if (ret == ERR_SUCCESS) {
for (uint32_t i = 0; i < count32; ++i) {
ret = read_load(Stream, tmpReadSet + i);
if (ret != ERR_SUCCESS) {
for (uint32_t j = 0; j < i; ++j)
_read_destroy_structure(tmpReadSet + j);
break;
}
}
if (ret == ERR_SUCCESS) {
*ReadSet = tmpReadSet;
*Count = count32;
}
if (ret != ERR_SUCCESS)
utils_free(tmpReadSet);
}
}
return ret;
}
void read_destroy(PONE_READ Read)
{
_read_destroy_structure(Read);
utils_free(Read);
return;
}
ERR_VALUE kmer_table_create(const size_t KMerSize, const size_t Size, const KMER_TABLE_CALLBACKS *Callbacks, PKMER_TABLE *Table)
{
PKMER_TABLE tmpTable = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_malloc_KMER_TABLE(&tmpTable);
if (ret == ERR_SUCCESS) {
tmpTable->KHashTable = kh_init(vertexTable);
if (tmpTable != NULL) {
tmpTable->LastOrder = 0;
tmpTable->KMerSize = KMerSize;
if (Callbacks == NULL) {
tmpTable->Callbacks.Context = NULL;
tmpTable->Callbacks.OnInsert = _on_insert_dummy_callback;
tmpTable->Callbacks.OnDelete = _on_delete_dummy_callback;
tmpTable->Callbacks.OnCopy = _on_copy_dummy_callback;
tmpTable->Callbacks.OnPrint = _on_print_dummy_callback;
} else tmpTable->Callbacks = *Callbacks;
*Table = tmpTable;
ret = ERR_SUCCESS;
} else ret = ERR_OUT_OF_MEMORY;
if (ret != ERR_SUCCESS)
utils_free(tmpTable);
} else ret = ERR_OUT_OF_MEMORY;
return ret;
}
ERR_VALUE read_set_merge(PONE_READ *Target, const size_t TargetCount, struct _ONE_READ *Source, const size_t SourceCount)
{
PONE_READ tmp = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(TargetCount + SourceCount, sizeof(ONE_READ), &tmp);
if (ret == ERR_SUCCESS) {
memcpy(tmp, *Target, TargetCount*sizeof(ONE_READ));
memcpy(tmp + TargetCount, Source, SourceCount*sizeof(ONE_READ));
utils_free(Source);
utils_free(*Target);
*Target = tmp;
}
return ret;
}
ERR_VALUE read_load(FILE *Stream, PONE_READ Read)
{
uint32_t rsLen32 = 0;
uint32_t qLen32 = 0;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
memset(Read, 0, sizeof(ONE_READ));
ret = utils_fread(&rsLen32, sizeof(rsLen32), 1, Stream);
if (ret == ERR_SUCCESS) {
Read->ReadSequenceLen = rsLen32;
ret = utils_calloc(Read->ReadSequenceLen + 1, sizeof(char), &Read->ReadSequence);
if (ret == ERR_SUCCESS) {
Read->ReadSequence[Read->ReadSequenceLen] = '\0';
ret = utils_fread(Read->ReadSequence, sizeof(char), Read->ReadSequenceLen, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&qLen32, sizeof(qLen32), 1, Stream);
if (ret == ERR_SUCCESS) {
Read->QualityLen = qLen32;
ret = utils_calloc(Read->QualityLen, sizeof(uint8_t), &Read->Quality);
if (ret == ERR_SUCCESS) {
ret = utils_fread(Read->Quality, sizeof(uint8_t), Read->QualityLen, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&Read->Pos, sizeof(Read->Pos), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&Read->PosQuality, sizeof(Read->PosQuality), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_fread(&Read->Flags, sizeof(Read->Flags), 1, Stream);
if (ret == ERR_SUCCESS)
read_split(Read);
}
}
}
if (ret != ERR_SUCCESS)
utils_free(Read->Quality);
}
}
}
if (ret != ERR_SUCCESS)
utils_free(Read->ReadSequence);
}
}
return ret;
}
inline static void
pop_condition_stack (void)
{
ConditionStackEntry *entry = condition_stack;
condition_stack = entry->next;
utils_free (entry);
}
void
configuration_set_string_value (char **configuration_variable,
const char *string)
{
assert (configuration_variable);
utils_free (*configuration_variable);
*configuration_variable = utils_duplicate_string (string);
}
void xmlrpc_process_param(xmlDocPtr doc, xmlNodePtr node, int ignore_check, int level)
{
char *data = NULL;
while (node != NULL) {
data = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
if (data != NULL) {
if ((!ignore_check) && (!is_valid_data_type((char *)node->name)))
DPRINTF("WARNING: Invalid data in %s\n", node->name);
else {
if (!((_xlastElement != NULL) && (strcmp(data, _xlastElement) == 0)))
xmlrpc_variable_add((char *)node->name, data);
}
}
else
if ((node->name != NULL) && (data == NULL)) {
if ((strcmp((char *)node->name, "member") == 0)) {
char *tmp = (char *)xmlNodeListGetString(doc, node->xmlChildrenNode->xmlChildrenNode, 1);
if (tmp != NULL) {
if (_xlastElement)
xmlrpc_variable_add("struct", data);
_xlastElement = utils_free("xmlrpc.xmlrpc_process_param._xlastElement", _xlastElement);
_xlastElement = strdup(tmp);
tmp = utils_free("xmlrpc.xmlrpc_process_param.tmp", tmp);
}
}
xmlrpc_process_param(doc, node->xmlChildrenNode,
(strcmp((char *)node->name, "member") == 0) ? 1 : 0, level + 1);
if ((strcmp((char *)node->name, "value") == 0)
|| (_xlastElement != NULL)) {
if (_xlastElement == NULL)
_xIdParent = 0;
_xlastElement = utils_free("xmlrpc.xmlrpc_process_param._xlastElement", _xlastElement);
}
}
data = utils_free("xmlrpc.xmlrpc_process_param.data", data);
node = node->next;
}
}
GtkWidget *
gtk_utils_create_titled_page (GtkWidget *contents,
const gchar *icon_stock_id, const gchar *title)
{
GtkWidget *image = NULL;
GtkWidget *label = NULL;
GtkWidget *title_widget;
GtkWidget *hseparator;
g_return_val_if_fail (GTK_IS_WIDGET (contents), NULL);
g_return_val_if_fail (icon_stock_id || title, NULL);
if (icon_stock_id) {
image = gtk_image_new_from_stock (icon_stock_id,
GTK_ICON_SIZE_LARGE_TOOLBAR);
}
if (title) {
gchar *title_escaped = g_markup_escape_text (title, -1);
char *marked_up_title
= utils_cat_strings (NULL,
"<span weight=\"bold\" size=\"x-large\">",
title_escaped, "</span>", NULL);
g_free (title_escaped);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), marked_up_title);
utils_free (marked_up_title);
}
if (image && label) {
title_widget = gtk_utils_pack_in_box (GTK_TYPE_HBOX, QUARRY_SPACING_SMALL,
image, GTK_UTILS_FILL, label, 0,
NULL);
}
else if (label) {
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
title_widget = label;
}
else
title_widget = image;
gtk_widget_show_all (title_widget);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
return gtk_utils_pack_in_box (GTK_TYPE_VBOX, QUARRY_SPACING_SMALL,
title_widget, GTK_UTILS_FILL,
hseparator, GTK_UTILS_FILL,
contents, GTK_UTILS_PACK_DEFAULT, NULL);
}
char *
parse_multiline_string (char **line, const char *type,
const char *line_separator, int null_allowed)
{
const char *string_chunk;
char *string;
string_chunk = parse_thing (null_allowed ? STRING_OR_NULL : STRING,
line, type);
if (!string_chunk)
return NULL;
string = utils_duplicate_string (string_chunk);
if (*string != '"')
return string;
while (! **line) {
*line = read_line ();
if (! *line) {
utils_free (string);
return NULL;
}
if (**line == '"') {
string_chunk = parse_thing (STRING, line, type);
if (!string_chunk) {
utils_free (string);
return NULL;
}
string = utils_cat_strings (string, line_separator, string_chunk, NULL);
}
else {
reuse_last_line (line);
break;
}
}
return string;
}
void kmer_table_destroy(PKMER_TABLE Table)
{
for (khiter_t it = kh_begin(Table->KHashTable); it != kh_end(Table->KHashTable); ++it) {
if (kh_exist(Table->KHashTable, it))
Table->Callbacks.OnDelete(Table, kh_val(Table->KHashTable, it), Table->Callbacks.Context);
}
kh_destroy(vertexTable, Table->KHashTable);
utils_free(Table);
return;
}
void read_set_destroy(PONE_READ ReadSet, const size_t Count)
{
PONE_READ tmp = ReadSet;
for (size_t i = 0; i < Count; ++i) {
_read_destroy_structure(tmp);
++tmp;
}
utils_free(ReadSet);
return;
}
void cdvws_process() {
char *v = NULL;
v = variable_get_element_as_string("module_var", NULL);
if (v != NULL) {
DPRINTF("We have module var set to '%s'\n", v);
variable_add("module_var", v, TYPE_MODULE, 0, TYPE_STRING);
}
else {
DPRINTF("We don't have module var set, setting to \"unset\"\n");
variable_add("module_var", "unset", TYPE_MODULE, 0, TYPE_STRING);
}
v = utils_free("mod_test.v", v);
}
void xmlrpc_variable_free_all(void)
{
int i;
if (_xmlrpc_vars == NULL)
return;
for (i = 0; i < _xmlrpc_vars_num; i++) {
_xmlrpc_vars[i].id = 0;
_xmlrpc_vars[i].idParent = 0;
_xmlrpc_vars[i].iValue = 0;
_xmlrpc_vars[i].shValue = 0;
_xmlrpc_vars[i].sValue = utils_free("xmlrpc.xmlrpc_variable_free_all", _xmlrpc_vars[i].sValue);
_xmlrpc_vars[i].sValue = NULL;
_xmlrpc_vars[i].dValue = 0;
}
_xmlrpc_vars_num = 0;
}
static const char *_sam_read_string_field(const char *Start, char **String, size_t *Length)
{
char *tmpString = NULL;
const char *end = NULL;
size_t len = 0;
end = _sam_read_field(Start);
len = (end - Start);
if (len > 0) {
if (utils_malloc((len + 1)*sizeof(char), &tmpString) == ERR_SUCCESS) {
memcpy(tmpString, Start, len*sizeof(char));
tmpString[len] = '\0';
if (String != NULL) {
*String = tmpString;
*Length = len;
} else utils_free(tmpString);
} else end = NULL;
} else end = NULL;
return end;
}
ERR_VALUE read_create_from_test_line(const char *Line, const size_t Length, PONE_READ *Read)
{
PONE_READ tmpRead = NULL;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_calloc(1, sizeof(ONE_READ), &tmpRead);
if (ret == ERR_SUCCESS) {
memset(tmpRead, 0, sizeof(ONE_READ));
tmpRead->Pos = (uint64_t)-1;
tmpRead->ReadSequenceLen = Length;
ret = utils_calloc(Length + 1, sizeof(char), &tmpRead->ReadSequence);
if (ret == ERR_SUCCESS) {
memcpy(tmpRead->ReadSequence, Line, Length*sizeof(char));
tmpRead->ReadSequence[Length] = '\0';
*Read = tmpRead;
}
if (ret != ERR_SUCCESS)
utils_free(tmpRead);
}
return ret;
}
static void _on_delete_edge(const KMER_GRAPH *Graph, const KMER_EDGE *Edge, void *Context)
{
size_t i = 0;
PGEN_ARRAY_KMER_EDGE_PAIR pairs = (PGEN_ARRAY_KMER_EDGE_PAIR)Context;
PKMER_EDGE_PAIR p = pairs->Data;
while (i < gen_array_size(pairs)) {
if (p->U == Edge || p->V == Edge) {
if (p->Edges != NULL) {
utils_free(p->Edges);
p->Edges = NULL;
}
dym_array_remove_fastKMER_EDGE_PAIR(pairs, i);
continue;
}
++p;
++i;
}
return;
}
ERR_VALUE seq_load(FILE *Stream, char **RefSeq, size_t *Length)
{
char *tmpSeq = NULL;
uint32_t length32 = 0;
ERR_VALUE ret = ERR_INTERNAL_ERROR;
ret = utils_fread(&length32, sizeof(length32), 1, Stream);
if (ret == ERR_SUCCESS) {
ret = utils_calloc(length32 + 1, sizeof(char), &tmpSeq);
if (ret == ERR_SUCCESS) {
tmpSeq[length32] = '\0';
ret = utils_fread(tmpSeq, sizeof(char), length32, Stream);
if (ret == ERR_SUCCESS) {
*RefSeq = tmpSeq;
*Length = length32;
}
if (ret != ERR_SUCCESS)
utils_free(tmpSeq);
}
}
return ret;
}
void _read_destroy_structure(PONE_READ Read)
{
if (Read->Quality != NULL)
utils_free(Read->Quality);
if (Read->ReadSequence != NULL)
utils_free(Read->ReadSequence);
if (Read->RNext != NULL)
utils_free(Read->RNext);
if (Read->CIGAR != NULL)
utils_free(Read->CIGAR);
if (Read->RName != NULL)
utils_free(Read->RName);
if (Read->TemplateName != NULL)
utils_free(Read->TemplateName);
return;
}
int _script_builtin_function(char *var, char *fn, char *args)
{
int ret = 0;
struct timespec ts;
struct timespec tse;
if (_perf_measure)
ts = utils_get_time( TIME_CURRENT );
if (strcmp(fn, "set_all_variables_overwritable") == 0) {
if (args != NULL) {
int var = get_boolean(args);
if ((var == 0) || (var == 1))
variable_allow_overwrite(NULL, var);
else
desc_printf(gIO, gFd, "Invalid value for %s(): %s\n",
fn, args);
}
}
else
if (strcmp(fn, "get_all_variables_overwritable") == 0) {
if (var != NULL) {
char tmp[4] = { 0 };
snprintf(tmp, sizeof(tmp), "%d", variable_get_overwrite(NULL));
variable_add(var, tmp, TYPE_QSCRIPT, -1, TYPE_INT);
}
else
desc_printf(gIO, gFd, "All variables overwritable: %s\n",
(variable_get_overwrite(NULL) == 1) ? "true" : "false");
}
else
if (strcmp(fn, "set_variable_overwritable") == 0) {
tTokenizer t;
t = tokenize(args, ",");
if (t.numTokens == 2)
variable_allow_overwrite(trim(t.tokens[0]), get_boolean(t.tokens[1]));
else
desc_printf(gIO, gFd, "Syntax: set_variable_overwritable(variable, true|false)\n");
free_tokens(t);
}
else
if (strcmp(fn, "get_variable_overwritable") == 0) {
char tmp[4] = { 0 };
if ((args != NULL) && (strlen(args) > 0))
{
snprintf(tmp, sizeof(tmp), "%d", variable_get_overwrite(args));
if (var != NULL)
variable_add(var, tmp, TYPE_QSCRIPT, -1, TYPE_INT);
else
desc_printf(gIO, gFd, "Variable %s overwritable: %s\n",
args, (strcmp(tmp, "1") == 0) ? "true" :
((strcmp(tmp, "0") == 0) ? "false" : "not found"));
}
else
desc_printf(gIO, gFd, "Variable name is missing\n");
}
else
if (strcmp(fn, "enable_perf") == 0) {
int enable = get_boolean(args);
if ((enable == 0) || (enable == 1)) {
DPRINTF("%sabling performance measuring\n", enable ? "En" : "Dis");
_perf_measure = enable;
}
else
DPRINTF("Incorrect setting for performace measuring: %d\n", enable);
if (_perf_measure)
ts = utils_get_time( TIME_CURRENT );
}
else
if (strcmp(fn, "del") == 0) {
variable_set_deleted(args, 1);
}
else
if (strcmp(fn, "get") == 0) {
char *val = variable_get_element_as_string(args, "get");
if (val != NULL) {
DPRINTF("%s: Processing internal 'get' function for arguments: %s\n", __FUNCTION__, args);
DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val);
if (var != NULL)
variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val));
}
}
else
if (strcmp(fn, "dumpvars") == NULL) {
desc_variable_dump(gIO, gFd, args);
}
else
if (strcmp(fn, "post") == 0) {
char *val = variable_get_element_as_string(args, "post");
if (val != NULL) {
DPRINTF("%s: Processing internal 'post' function for arguments: %s\n", __FUNCTION__, args);
DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val);
if (var != NULL)
variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val));
}
}
else
if (strcmp(fn, "cookie") == 0) {
char *val = variable_get_element_as_string(args, "cookie");
if (val != NULL) {
DPRINTF("%s: Processing internal 'cookie' function for arguments: %s\n", __FUNCTION__, args);
DPRINTF("%s: Variable %s processed to %s\n", __FUNCTION__, var, val);
if (var != NULL)
variable_add(var, val, TYPE_QSCRIPT, -1, gettype(val));
}
}
else
if (strcmp(fn, "sleep") == 0) {
int num = atoi(args);
DPRINTF("%s: Sleeping for %d seconds...\n", __FUNCTION__, num);
sleep(num);
}
else
if (strcmp(fn, "dumptype") == 0) {
char *str = variable_get_type_string(args, "any");
desc_printf(gIO, gFd, "%s\n", str ? str : "<null>");
str = utils_free("scripting.dumptype.str", str);
}
else
if (strcmp(fn, "print") == 0) {
if (args != NULL) {
if ((args[0] == '"') || (args[0] == '\'')) {
*args++;
args[strlen(args) - 1] = 0;
args = replace(args, "\\n", "\n");
desc_printf(gIO, gFd, "%s", args);
}
else {
char *var = variable_get_element_as_string(args, NULL);
desc_printf(gIO, gFd, "%s", var ? var : "");
var = utils_free("scripting.print.var", var);
}
}
}
else
if (strcmp(fn, "printf") == 0) {
if ((args != NULL) && (strlen(args) > 0)) {
int i;
tTokenizer t;
*args++;
t = tokenize(args, "\"");
if (t.numTokens == 1) {
char *instr = NULL;
instr = strdup(t.tokens[0]);
while (strstr(instr, "\\n") != NULL)
instr = replace(instr, "\\n", "\n");
desc_printf(gIO, gFd, "%s", instr);
instr = utils_free("scripting.printf.instr", instr);
}
else
if (t.numTokens == 2) {
tTokenizer t2;
char *instr = NULL;
char *vars = NULL;
instr = strdup( t.tokens[0] );
vars = strdup( t.tokens[1] + 1 );
t2 = tokenize(vars, ",");
for (i = 0; i < t2.numTokens; i++) {
DPRINTF("%s: Replacing variable %s\n", __FUNCTION__, trim(t2.tokens[i]));
char *tmp = variable_get_element_as_string(trim(t2.tokens[i]), NULL);
if (tmp != NULL)
instr = replace(instr, "%s", tmp);
else {
instr = replace(instr, "%s", "NULL");
DPRINTF("%s: Variable \"%s\" not found\n", __FUNCTION__, trim(t2.tokens[i]));
}
}
while (strstr(instr, "\\n") != NULL)
instr = replace(instr, "\\n", "\n");
desc_printf(gIO, gFd, "%s", instr);
free_tokens(t2);
}
else {
free_tokens(t);
ret = -EINVAL;
goto cleanup;
}
free_tokens(t);
}
else {
desc_printf(gIO, gFd, "Invalid syntax for printf()\n");
ret = -EINVAL;
goto cleanup;
}
}
else
if (strcmp(fn, "idb_dump_query_set") == 0) {
idb_results_show( gIO, gFd, idb_get_last_select_data() );
}
else
if (strcmp(fn, "idb_query") == 0) {
char *filename = NULL;
char *query = NULL;
tTokenizer t;
int i;
t = tokenize(args, "\"");
if (t.numTokens > 1) {
int num = 0;
for (i = 0; i < t.numTokens; i++) {
if (strcmp(trim(t.tokens[i]), ",") != 0) {
if (num == 0)
filename = strdup(t.tokens[i]);
else
if (num == 1)
query = strdup(t.tokens[i]);
num++;
}
}
}
free_tokens(t);
if (((filename == NULL) || (query == NULL)) && (args[0] == '@')) {
*args++;
DPRINTF("Reading query file '%s'\n", args);
if (access(args, R_OK) == 0) {
FILE *fp = NULL;
char buf[BUFSIZE];
fp = fopen(args, "r");
if (fp != NULL) {
int num = 0;
while (!feof(fp)) {
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), fp);
if ((strlen(buf) > 0)
&& (buf[strlen(buf) - 1] == '\n'))
buf[strlen(buf) - 1] = 0;
if (strlen(buf) > 0) {
num++;
int ret = idb_query(buf);
desc_printf(gIO, gFd, "Query '%s' returned with code %d\n",
buf, ret);
}
}
desc_printf(gIO, gFd, "%d queries processed\n", num);
fclose(fp);
}
else
desc_printf(gIO, gFd, "Error: Cannot open file %s for reading\n",
args);
}
else
desc_printf(gIO, gFd, "Error: Cannot access file %s\n", t.tokens[1]);
}
else
if ((filename != NULL) && (query != NULL)) {
char tmp[4096] = { 0 };
snprintf(tmp, sizeof(tmp), "INIT %s", filename);
ret = 0;
if (idb_query(tmp) != 0) {
DPRINTF("Error while trying to initialize file '%s'\n", filename);
ret = -EIO;
}
if (idb_query(query) != 0) {
DPRINTF("Error while running query '%s'\n", query);
ret = -EIO;
}
else
if ((strncmp(query, "SELECT", 6) == 0) || (strcmp(query, "SHOW TABLES") == 0))
idb_results_show( gIO, gFd, idb_get_last_select_data() );
idb_query("COMMIT");
idb_query("CLOSE");
}
}
else {
ret = -EINVAL;
goto cleanup;
}
cleanup:
if (_perf_measure) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "\nPERF: Function %s() was running for %.3f microseconds (%.3f ms)\n",
fn, get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
return ret;
}
int script_process_line(char *buf)
{
int ret = -ENOTSUP;
struct timespec ts = { .tv_sec = 0, .tv_nsec = 0 };
struct timespec tse;
if (_perf_measure)
ts = utils_get_time( TIME_CURRENT );
/* Skip if it's a one line comment (more to be implemented) */
if (is_comment(buf) == 1) {
DPRINTF("%s: Found comment, skipping\n", __FUNCTION__);
ret = 0;
goto cleanup;
}
else
if (strcmp(buf, "else {") == 0) {
/* Reverse the condition */
if ((_script_in_condition_and_met == 1)
|| (_script_in_condition_and_met == -10))
_script_in_condition_and_met = 0;
else
if ((_script_in_condition_and_met == 0)
|| (_script_in_condition_and_met == -20))
_script_in_condition_and_met = 1;
else
if (_script_in_condition_and_met != -1) {
DPRINTF("%s: Invalid state for else statement\n", __FUNCTION__);
ret = -EINVAL;
goto cleanup;
}
ret = 0;
goto cleanup;
}
else
if (strcmp(buf, "}") == 0) {
_script_in_condition_and_met = (_script_in_condition_and_met == 1) ? -10 : -20;
ret = 0;
goto cleanup;
}
if (_script_in_condition_and_met < -1)
_script_in_condition_and_met = 1;
if (_script_in_condition_and_met == 0) {
ret = 0;
goto cleanup;
}
/* Comparison with no ternary operator support... yet */
if (regex_match("if \\(([^(]*)([^)]*)\\)", buf)) {
if (regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf)) {
char **matches = NULL;
int i, num_matches;
matches = (char **)utils_alloc( "scripting.script_process_line.matches", sizeof(char *) );
_regex_match("if \\(([^(]*) == ([^)]*)\\) {", buf, matches, &num_matches);
if (num_matches >= 2)
_script_in_condition_and_met = (valcmp(matches[0], matches[1]) == 0) ? 1 : 0;
for (i = 0; i < num_matches; i++)
matches[i] = utils_free("scripting.condition.matches[]", matches[i]);
matches = utils_free("scripting.condition.matches", matches);
}
}
else
/* Definition */
if (strncmp(buf, "define ", 7) == 0) {
tTokenizer t;
t = tokenize(buf + 7, " ");
if (t.numTokens != 2) {
ret = -EINVAL;
goto cleanup;
}
if (variable_create(trim(t.tokens[0]), trim(t.tokens[1])) != 1) {
ret = -EIO;
goto cleanup;
}
}
else
/* Operators */
if ((strstr(buf, "+=") != NULL) || (strstr(buf, "-=") != NULL) ||
(strstr(buf, "%=") != NULL) || (strstr(buf, "*=") != NULL) ||
(strstr(buf, "/=") != NULL)) {
tTokenizer t;
char *var;
char *val;
int op, vtype;
t = tokenize(buf, "=");
if (t.numTokens != 2) {
ret = -EINVAL;
goto cleanup;
}
var = trim(strdup(t.tokens[0]));
val = trim(strdup(t.tokens[1]));
op = var[ strlen(var) - 1];
var[ strlen(var) - 1] = 0;
var = trim(var);
if (val[strlen(val) - 1] == ';')
val[strlen(val) - 1] = 0;
val = trim(val);
vtype = variable_get_type(var, NULL);
if ((vtype == TYPE_INT) || (vtype == TYPE_LONG)) {
char tmp[32] = { 0 };
long value = atol(variable_get_element_as_string(var, NULL));
if (op == '+')
value += atol(val);
else
if (op == '-')
value -= atol(val);
else
if (op == '*')
value *= atol(val);
else
if (op == '%')
value %= atol(val);
else
if (op == '/')
value /= atol(val);
snprintf(tmp, sizeof(tmp), "%ld", value);
variable_set_deleted(var, 1);
variable_add(var, tmp, TYPE_QSCRIPT, -1, vtype);
ret = 0;
}
else
ret = -EINVAL;
var = utils_free("scripting.operators.var", var);
val = utils_free("scripting.operators.val", val);
free_tokens(t);
return ret;
}
else
/* Assignment */
if (is_assignment(buf)) {
tTokenizer t;
t = tokenize(buf, "=");
char *val = strdup( trim(t.tokens[1]) );
if (val[strlen(val) - 1] == ';') {
val[strlen(val) - 1] = 0;
if (is_numeric(val) || is_string(val)) {
if (is_string(val)) {
*val++;
val[strlen(val) - 1] = 0;
}
if (variable_add(trim(t.tokens[0]), val, TYPE_QSCRIPT, -1, gettype(val)) < 0) {
desc_printf(gIO, gFd, "Cannot set new value to variable %s\n", trim(t.tokens[0]));
ret = -EEXIST;
}
else
ret = 0;
}
else
if (regex_match("([^(]*)([^)]*)", val)) {
tTokenizer t2;
char *args = NULL;
char *fn;
t2 = tokenize(val, "(");
if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ')') {
ret = -EINVAL;
goto cleanup;
}
t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0;
fn = strdup(t2.tokens[0]);
/* We need to make sure parenthesis won't break script line */
if (t2.numTokens > 1) {
int i;
char argstmp[8192] = { 0 };
for (i = 1; i < t2.numTokens; i++) {
strcat(argstmp, t2.tokens[i]);
if (i < t2.numTokens - 1)
strcat(argstmp, "(");
}
args = strdup(argstmp);
}
if (args != NULL) {
char args2[1024] = { 0 };
snprintf(args2, sizeof(args2), "%s", args + 1);
args2[ strlen(args2) - 1] = 0;
args = utils_free("scripting.function-call.args", args);
args = strdup( args2 );
}
free_tokens(t2);
if (_script_builtin_function(trim(t.tokens[0]), fn, args) != 0)
DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn);
DPRINTF("%s: Should be a function with return value\n", __FUNCTION__);
args = utils_free("scripting.function-call.args", args);
fn = utils_free("scripting.function-call.fn", fn);
ret = 0;
}
else
ret = -EINVAL;
}
free_tokens(t);
}
else
if (regex_match("([^(]*)([^)]*)", buf)) {
tTokenizer t2;
char *args = NULL;
char *fn;
t2 = tokenize(buf, "(");
if (t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] != ';') {
ret = -EINVAL;
goto cleanup;
}
t2.tokens[t2.numTokens - 1][strlen(t2.tokens[t2.numTokens - 1]) - 1] = 0;
fn = strdup(t2.tokens[0]);
/* We need to make sure parenthesis won't break script line */
if (t2.numTokens > 1) {
int i;
char argstmp[8192] = { 0 };
for (i = 1; i < t2.numTokens; i++) {
strcat(argstmp, t2.tokens[i]);
if (i < t2.numTokens - 1)
strcat(argstmp, "(");
}
args = strdup(argstmp);
}
if (args != NULL) {
if (args[strlen(args) - 1] == ')')
args[strlen(args) - 1] = 0;
}
free_tokens(t2);
if (_script_builtin_function(NULL, fn, args) != 0)
DPRINTF("Function %s doesn't seem to be builtin, we should try user-defined function\n", fn);
args = utils_free("scripting.function-call.args", args);
fn = utils_free("scripting.function-call.fn", fn);
ret = 0;
}
else
DPRINTF("%s: Not implemented yet\n", __FUNCTION__);
cleanup:
if ((_perf_measure) && ((ts.tv_nsec > 0) && (ts.tv_sec > 0)) && (_script_in_condition_and_met > 0)) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "PERF: Line \"%s\" was being processed for %.3f microseconds (%.3f ms)\n\n",
buf, get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
return ret;
}
int run_script(char *filename)
{
FILE *fp;
int opened = 0;
char buf[4096] = { 0 };
struct timespec ts = utils_get_time( TIME_CURRENT );
struct timespec tse;
if (access(filename, R_OK) != 0)
return -ENOENT;
_script_in_condition_and_met = -1;
fp = fopen(filename, "r");
if (fp == NULL)
return -EPERM;
if (gHttpHandler)
http_host_header(gIO, gFd, HTTP_CODE_OK, gHost, "text/html", NULL, myRealm, 0);
while (!feof(fp)) {
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), fp);
if ((strlen(buf) > 1) && (buf[strlen(buf) - 1] == '\n'))
buf[strlen(buf) - 1] = 0;
if ((strlen(buf) > 1) && (buf[0] != '\n')) {
if (strcmp(buf, "<$") == 0)
opened = 1;
if (strcmp(buf, "$>") == 0)
opened = 0;
if ((opened) && (strcmp(buf, "<$") != 0))
script_process_line(trim(buf));
}
}
fclose(fp);
idb_free_last_select_data();
if (_perf_measure) {
tse = utils_get_time( TIME_CURRENT );
desc_printf(gIO, gFd, "PERF: File \"%s\" has been processed in %.3f microseconds (%.3f ms)\n\n",
basename(filename), get_time_float_us( tse, ts ), get_time_float_us(tse, ts) / 1000.);
}
variable_dump();
variable_free_all();
return 0;
}
