char * test_peek_two(void) {
int v;
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(18) == q_success);
mu_assert("insert", q_insert(42) == q_success);
mu_assert("peek", q_peek(&v) == q_success);
mu_assert("value", v == 18);
mu_assert("destroy", q_destroy() == q_success);
return NULL;
}
char * test_peek_two_empty(void) {
int v;
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(18) == q_success);
mu_assert("insert", q_insert(42) == q_success);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("peek", q_peek(&v) == q_failure);
return NULL;
}
char * test_two_insert_remove(void) {
int v;
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(8) == q_success);
mu_assert("insert", q_insert(91) == q_success);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 8);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 91);
mu_assert("destroy", q_destroy() == q_success);
return NULL;
}
char * test_indexed_insert_remove(void) {
int v;
mu_assert("init", q_init() == q_success);
for(int i = 0; i < 30; i++) {
mu_assert("insert", q_insert(i) == q_success);
}
for(int i = 0; i < 1000; i++) {
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == i);
mu_assert("insert", q_insert(30 + i) == q_success);
}
mu_assert("destroy", q_destroy() == q_success);
return NULL;
}
char * test_three_insert_remove(void) {
int v;
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(7) == q_success);
mu_assert("insert", q_insert(18) == q_success);
mu_assert("insert", q_insert(30) == q_success);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 7);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 18);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 30);
mu_assert("destroy", q_destroy() == q_success);
return NULL;
}
unsigned int q_put (queue_t *q, void * msg, unsigned int msize, unsigned int MaxWait)
{
int tstatus = 0, put_msg = 0, time_inc = (MaxWait + 999) /1000;
struct timespec timeout;
timeout.tv_nsec = 0;
if (q_destroyed(q)) return 1;
pthread_mutex_lock (&q->q_guard);
while (q_full (q) && 0 == tstatus) {
if (MaxWait != INFINITE) {
timeout.tv_sec = time(NULL) + time_inc;
tstatus = pthread_cond_timedwait (&q->q_nf, &q->q_guard, &timeout);
} else {
tstatus = pthread_cond_wait (&q->q_nf, &q->q_guard);
}
}
/* Insert the message into the queue if there's room */
if (0 == tstatus && !q_full (q)) {
q_insert (q, msg, msize);
put_msg = 1;
/* Signal that the queue is not empty as we've inserted a message */
pthread_cond_broadcast (&q->q_ne);
}
pthread_mutex_unlock (&q->q_guard);
return (0 == tstatus && put_msg == 1 ? 0 : max(1, tstatus)); /* 0 indictates success */
}
int main()
{
struct queue q;
int data;
q_init(&q);
while (1)
{
printf("Enter\n\t1: Insert\n\t2: Delete\n\t3: Exit\n\t: ");
scanf("%d", &data);
switch (data)
{
case (1):
printf("\nEnter Number: ");
scanf("%d", &data);
q_insert(&q, data);
printf("Done\n");
break;
case (2):
data = q_delete(&q);
printf("\nData = %d\n", data);
break;
default:
exit(1);
break;
}
}
return 0;
}
// removes all trailing whitespaces
struct queue *
save_file (const char *filename)
{
if (!is_file(filename))
return NULL;
struct queue *q = malloc (sizeof (struct queue));
if (q == NULL)
return NULL;
q_init (q);
FILE *fp = fopen(filename, "r");
char buf[128];
int i;
while (fgets(buf, 128, fp) != NULL)
{
// cut all trailing whitespace
for (i=strlen(buf) - 1; i >= 0; --i)
{
if (buf[i] == ' ' || buf[i] == '\t' || buf[i] == '\n')
buf[i] = '\0';
else
break;
}
// do not save empty line when whitespace is deleted
if (strlen(buf) == 0)
continue;
struct str_elem *se = malloc (sizeof(struct str_elem));
char *line = malloc ((strlen(buf)+1) * sizeof(char));
if (se == NULL || line == NULL)
{
if (se != NULL)
free (se);
if (line != NULL)
free (line);
while (!q_empty (q))
{
struct q_elem *e = q_delete(q);
se = q_entry (e, struct str_elem, elem);
if (se->line != NULL)
free(se->line);
free(se);
}
free (q);
puts("[FILEIO] MEMORY INSUFFICIENT");
return NULL;
}
strcpy (line, buf);
se->line = line;
q_insert (q, &se->elem);
}
fclose(fp);
return q;
}
void
q_insertPar(
q_expr expr,
q_expr par)
{
assert(expr->kind == T_FNC);
expr->info.function->params = q_insert(expr->info.function->params,par);
}
char * test_one_insert_remove(void) {
int v;
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(16) == q_success);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 16);
mu_assert("destroy", q_destroy() == q_success);
return NULL;
}
char * test_multi_insert_remove(void) {
int v;
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(8) == q_success);
mu_assert("insert", q_insert(91) == q_success);
for(int i = 0; i < 1000; i++) {
mu_assert("insert", q_insert(8) == q_success);
mu_assert("insert", q_insert(91) == q_success);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 8);
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 91);
}
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == 8);
mu_assert("destroy", q_destroy() == q_success);
return NULL;
}
void srvr_enque_dnfmw(int htyp, int hlen, int clen, BYTE *buf)
{
PKBDF *pkbdf;
pkbdf = dnfmw_packet_alloc(clen); /* head(did)+binary body */
pkbdf->h_rlen = clen; /* total binary len */
memcpy(&pkbdf->buffer_body.deid, buf, clen);
q_insert((PKBH *)pkbdf, htyp);
}
/*--------------------------------------------------------*
queueing subroutines for downward commands & firmware
*--------------------------------------------------------*/
void srvr_enque_dncmd(int htyp, int hlen, int clen, BYTE *buf)
{
PKBDC *pkbdc;
pkbdc = dncmd_packet_alloc(clen); /* head+esced body */
pkbdc->h_rlen = hlen + SRVD_HEADLN_CMD; /*real binary len */
memcpy(pkbdc->b_data, buf, clen);
pkbdc->b_data[clen] = E_CHR;
q_insert((PKBH *)pkbdc, htyp);
}
int main()
{
int q[MAX_Q];
int front;
int rear;
q_init(q, MAX_Q, &front, &rear); q_print(q, MAX_Q, &front, &rear);
q_insert(q, MAX_Q, &front, &rear, 10); q_print(q, MAX_Q, &front, &rear);
q_insert(q, MAX_Q, &front, &rear, 20); q_print(q, MAX_Q, &front, &rear);
q_insert(q, MAX_Q, &front, &rear, 30); q_print(q, MAX_Q, &front, &rear);
printf("Val = %d\n", q_delete(q, MAX_Q, &front, &rear));
printf("Val = %d\n", q_delete(q, MAX_Q, &front, &rear));
printf("Val = %d\n", q_delete(q, MAX_Q, &front, &rear));
q_insert(q, MAX_Q, &front, &rear, 40); q_print(q, MAX_Q, &front, &rear);
q_insert(q, MAX_Q, &front, &rear, 50); q_print(q, MAX_Q, &front, &rear);
printf("Val = %d\n", q_delete(q, MAX_Q, &front, &rear));
q_insert(q, MAX_Q, &front, &rear, 60); q_print(q, MAX_Q, &front, &rear);
printf("Val = %d\n", q_delete(q, MAX_Q, &front, &rear));
printf("Val = %d\n", q_delete(q, MAX_Q, &front, &rear));
return 0;
}
char * test_insert_too_many_remove(void) {
int v;
mu_assert("init", q_init() == q_success);
for(int i = 0; i < 30; i++) {
mu_assert("insert", q_insert(i) == q_success);
}
for(int i = 0; i < 30; i++) {
mu_assert("remove", q_remove(&v) == q_success);
mu_assert("value", v == i);
}
mu_assert("remove", q_remove(&v) == q_failure);
return NULL;
}
static RIFFIOSuccess
cbClefStart(NIFFIOChunkContext *pctxChunk, niffClef *p)
{
symbol_p s;
cbChunkStart(pctxChunk);
s = clef_create(p);
q_insert(voice_current, s);
printSymbol(NIFFIOSymbolCLEFSHAPE, p->shape, "shape");
printSIGNEDBYTE(p->staffStep, "staffStep");
printSymbol(NIFFIOSymbolCLEFOCT, p->octaveNumber, "octaveNumber");
return RIFFIO_OK;
}
static RIFFIOSuccess
cbRestStart(NIFFIOChunkContext *pctxChunk, niffRest *p)
{
symbol_p n;
n = rest_create(p);
symbol_current = n;
note_current = n;
q_insert(voice_current, symbol_current);
cbChunkStart(pctxChunk);
// extern void debugMeAt(mpq_t);
// debugMeAt(n->start);
printSymbol(NIFFIOSymbolREST, p->shape, "shape");
printSIGNEDBYTE(p->staffStep, "staff step");
printRATIONAL (p->duration, "duration");
return RIFFIO_OK;
}
void SavingSettingsTabView::saveTestResultInDB(const StudentResult &result)
{
//create db if it doesn't exist
createResultTable(m_dbname);
QSqlDatabase dbPtr = QSqlDatabase::addDatabase("QSQLITE");
dbPtr.setDatabaseName(m_dbname);
if (!dbPtr.open()) {
QMessageBox::critical(0, "Can not open database", "Не могу открыть базу данных.");
return;
}
QSqlQuery q_select(dbPtr);
q_select.prepare("SELECT id FROM studentresults WHERE testname=:testname AND firstname=:firstname AND secondName=:secondName AND surname=:surname AND groupname=:groupname");
q_select.bindValue(":testname", result.testName);
q_select.bindValue(":firstname", result.firstName);
q_select.bindValue(":secondName", result.secondName);
q_select.bindValue(":surname", result.surname);
q_select.bindValue(":groupname", result.group);
if (q_select.exec()) {
if (q_select.next()) {
dbPtr.close();
return;
}
// populate with some data
QSqlQuery q_insert(dbPtr);
q_insert.prepare("INSERT INTO studentresults (testname, firstname, secondName, surname, groupname, scorevalue, maxvalue, testtime) VALUES ( :testname, :firstname, :secondName, :surname, :groupname, :scorevalue, :maxvalue, :testtime)");
q_insert.bindValue(":testname", result.testName);
q_insert.bindValue(":firstname", result.firstName);
q_insert.bindValue(":secondName", result.secondName);
q_insert.bindValue(":surname", result.surname);
q_insert.bindValue(":groupname", result.group);
q_insert.bindValue(":scorevalue", result.score);
q_insert.bindValue(":maxvalue", result.maxPosibleScore);
q_insert.bindValue(":testtime", QDateTime::currentDateTime());
qDebug() << "insert data row: " << q_insert.exec() << q_insert.lastError();
}
QSqlQuery q_existed(dbPtr);
q_existed.prepare("SELECT id FROM studentresults WHERE testname=:testname AND firstname=:firstname AND secondName=:secondName AND surname=:surname AND groupname=:groupname");
q_existed.bindValue(":testname", result.testName);
q_existed.bindValue(":firstname", result.firstName);
q_existed.bindValue(":secondName", result.secondName);
q_existed.bindValue(":surname", result.surname);
q_existed.bindValue(":groupname", result.group);
if (q_existed.exec()) {
while (q_existed.next()) {
int resID = q_existed.value(q_existed.record().indexOf("id")).toInt();
for (int i = 0; i < result.answerInfo.count(); i++) {
QSqlQuery q_fullinfo(dbPtr);
q_fullinfo.prepare("INSERT INTO studentresultanswers (resultid, statement, chosenvar, assuarance, iscorrect) "
"VALUES (:resultid, :statement, :chosenvar, :assuarance, :iscorrect)");
q_fullinfo.bindValue(":resultid", resID);
q_fullinfo.bindValue(":statement", result.answerInfo.at(i).statement);
q_fullinfo.bindValue(":chosenvar", result.answerInfo.at(i).chosenAnswer);
q_fullinfo.bindValue(":assuarance", result.answerInfo.at(i).assurance);
q_fullinfo.bindValue(":iscorrect", result.answerInfo.at(i).isCorrectAnswer);
q_fullinfo.exec();
}
}
}
dbPtr.close();
}
int
main(void)
{
// INITIALIZING
struct queue cmd_queue;
q_init (&cmd_queue);
uint8_t *mem = calloc (__MEMORY_SIZE, sizeof(uint8_t));
struct queue *oplist = malloc (sizeof(struct queue)
* __TABLE_SIZE);
char *input = malloc (sizeof(char)*__INPUT_SIZE);
char *cmd = malloc (sizeof(char)*__CMD_SIZE);
if (mem == NULL || input == NULL
|| cmd == NULL || oplist == NULL)
{
puts("MEMORY INSUFFICIENT");
goto memory_clear;
}
// OPCODE READ
int i;
for (i=0; i<__TABLE_SIZE; ++i)
q_init (&oplist[i]);
// Open file for opcode reference
FILE * fp = fopen(__OPCODE_FILENAME, "r");
if (fp == NULL)
{
printf("%s NOT FOUND\n", __OPCODE_FILENAME);
goto memory_clear;
}
// Formatting string
i = snprintf((char *) __CMD_FORMAT, __CMD_FORMAT_SIZE,
"%%hhx %%%ds %%s", __CMD_SIZE - 1);
if (i < 0 || i > __CMD_FORMAT_SIZE)
{
puts("COMMAND SIZE IS TOO BIG");
goto memory_clear;
}
// opcode hash table generation
while (fgets(input, __INPUT_SIZE, fp) != NULL)
{
uint8_t code;
char form[__OPCODE_FORMAT_SIZE];
if (sscanf(input, (const char *) __CMD_FORMAT,
&code, cmd, &form) != 3)
{
printf("%s IS BROKEN\n", __OPCODE_FILENAME);
goto memory_clear;
}
// Saving opcode
struct op_elem *oe = malloc(sizeof(struct op_elem));
if (oe == NULL)
{
puts("MEMORY INSUFFICIENT");
goto memory_clear;
}
oe->opcode = malloc(sizeof(char)*(strlen(cmd)+1));
if(oe->opcode == NULL)
{
puts("MEMORY INSUFFICIENT");
goto memory_clear;
}
strcpy(oe->opcode, cmd);
strcpy(oe->format, form);
oe->code = code;
code = str_hash (cmd) % __TABLE_SIZE;
q_insert (&oplist[code], &(oe->elem));
}
// COMMAND PROCESSING
while (true)
{
struct q_elem *qe;
uint8_t value;
uint32_t start, end;
DIR *dirp = NULL;
struct dirent *dir = NULL;
char check[2];
bool is_valid_cmd = false;
printf("%s", __SHELL_FORM);
if (!get_chars(input, __INPUT_SIZE))
goto memory_clear;
// Processing input string
snprintf((char *) __CMD_FORMAT, __CMD_FORMAT_SIZE,
"%%%ds", __CMD_SIZE - 1);
if (sscanf(input, (const char *) __CMD_FORMAT, cmd)!=1)
cmd[0] = '\0';
// Switching with commands
switch(get_cmd_index(cmd))
{
case CMD_HELP:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
puts(__HELP_FORM);
is_valid_cmd = true;
break;
case CMD_DIR:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
// open directory and read through all elem.
i = 1;
dirp = opendir(".");
dir = readdir(dirp);
for(; dir!=NULL; dir = readdir(dirp))
{
struct stat st;
if(stat((const char*) dir->d_name, &st)!=0)
{
puts("FILE NOT FOUND");
goto memory_clear;
}
// FIX: ignore . and ..
if(_SAME_STR(dir->d_name, ".")
|| _SAME_STR(dir->d_name, ".."))
continue;
printf("%20s", dir->d_name);
if(S_ISDIR(st.st_mode)) // is Directory?
putchar('/');
else if( (st.st_mode & S_IXUSR) // is exe?
|| (st.st_mode & S_IXGRP)
|| (st.st_mode & S_IXOTH) )
putchar('*');
putchar('\t');
// print newline after 3 elements
if((i++)%3==0)
putchar('\n');
}
if((i-1)%3!=0)
putchar('\n');
is_valid_cmd = true;
break;
case CMD_QUIT:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
is_valid_cmd = true;
goto memory_clear;
case CMD_HISTORY:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
qe = q_begin (&cmd_queue);
i = 1;
// print every formatted history
for (; qe!=q_end(&cmd_queue); qe=q_next(qe))
printf("%-4d %s\n", i++,
q_entry(qe, struct cmd_elem, elem)->cmd);
printf("%-4d %s\n", i, input);
is_valid_cmd = true;
break;
case CMD_DUMP:
switch(sscanf(input, "%s %x , %x", cmd, &start, &end))
{
case 1:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
start = get_location (0, false);
end = start + 0x10 * 10 - 1;
// if end is too large, point to end and go 0
if ( end >= __MEMORY_SIZE )
end = __MEMORY_SIZE - 1;
hexdump (mem, start, end);
if ( end == __MEMORY_SIZE - 1)
get_location (0, true);
else
get_location (end + 1, true);
is_valid_cmd = true;
break;
case 2:
if(sscanf(input, "%*s %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (start >= __MEMORY_SIZE)
{
puts("OUT OF MEMORY BOUNDS.");
break;
}
end = start + 0x10 * 10 - 1;
// if end is too large, point to end and go 0
if ( end >= __MEMORY_SIZE )
end = __MEMORY_SIZE - 1;
hexdump (mem, start, end);
if ( end == __MEMORY_SIZE - 1)
get_location (0, true);
else
get_location (end + 1, true);
is_valid_cmd = true;
break;
case 3:
if(sscanf(input, "%*s %*x , %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (!(start<=end && end<__MEMORY_SIZE))
{
puts("OUT OF MEMORY BOUNDS.");
break;
}
hexdump (mem, start, end);
// if end is too large, point to end and go 0
if ( end == __MEMORY_SIZE - 1)
get_location (0, true);
else
get_location (end + 1, true);
is_valid_cmd = true;
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_EDIT:
switch(sscanf(input, "%s %x , %hhx",
cmd, &start, &value))
{
case 3:
if(sscanf(input, "%*s %*x , %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
hexfill (mem, __MEMORY_SIZE, start, start, value);
is_valid_cmd = true;
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_FILL:
switch(sscanf(input, "%s %x , %x , %hhx",
cmd, &start, &end, &value))
{
case 4:
if(sscanf(input,
"%*s %*x , %*x , %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
hexfill (mem, __MEMORY_SIZE, start, end, value);
is_valid_cmd = true;
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_RESET:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
// equivalent to fill 0, __MEMORY_SIZE-1
hexfill (mem, __MEMORY_SIZE, 0, __MEMORY_SIZE - 1, 0);
is_valid_cmd = true;
break;
case CMD_OPCODE:
switch(sscanf(input, "%*s %s", cmd))
{
case 1:
if(sscanf(input, "%*s %*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
// look for opcode in hash table
i = str_hash(cmd) % __TABLE_SIZE;
if (!q_empty(&oplist[i]))
{
bool found = false;
qe = q_begin (&oplist[i]);
for(; qe != q_end(&oplist[i]); qe = q_next(qe))
{
struct op_elem *oe
= q_entry (qe, struct op_elem, elem);
if (_SAME_STR(cmd, oe->opcode))
{
printf("opcode is %2X\n", oe->code);
found = true;
break;
}
}
if (found)
{
is_valid_cmd = true;
break;
}
}
printf("%s: NO SUCH OPCODE\n", cmd);
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_OPCODELIST:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
// traverse through every table
for(i=0; i<__TABLE_SIZE; ++i)
{
printf("%d : ", i);
if (!q_empty(&oplist[i]))
{
qe = q_begin (&oplist[i]);
struct op_elem *oe
= q_entry (qe, struct op_elem, elem);
printf ("[%s:%02X] ", oe->opcode, oe->code);
for(qe = q_next(qe); qe != q_end(&oplist[i]);
qe = q_next(qe))
{
oe = q_entry (qe, struct op_elem, elem);
printf ("-> [%s:%02X] ",
oe->opcode, oe->code);
}
}
puts("");
}
is_valid_cmd = true;
break;
default:
if(sscanf(input, "%1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
}
int
main(void)
{
// INITIALIZING
struct queue cmd_queue;
q_init (&cmd_queue);
uint8_t *mem = calloc (__MEMORY_SIZE, sizeof(uint8_t));
char *input = malloc (sizeof(char)*__INPUT_SIZE);
char *cmd = malloc (sizeof(char)*__CMD_SIZE);
char *filename = malloc (sizeof(char)*__FILENAME_SIZE);
if (mem == NULL || input == NULL || filename == NULL
|| cmd == NULL)
{
puts("MEMORY INSUFFICIENT");
goto memory_clear;
}
if (!init_oplist (__OPCODE_FILENAME))
{
puts("OPCODE LIST INITIALIZATION FAILED.");
goto memory_clear;
}
// COMMAND PROCESSING
while (true)
{
int i;
struct q_elem *qe;
uint8_t value;
uint32_t start, end;
DIR *dirp = NULL;
struct dirent *dir = NULL;
char check[2];
bool is_valid_cmd = false;
char *tok = NULL;
printf("%s", __SHELL_FORM);
if (!get_chars(input, __INPUT_SIZE))
goto memory_clear;
// Processing input string
snprintf((char *) __CMD_FORMAT, __CMD_FORMAT_SIZE,
"%%%ds", __CMD_SIZE - 1);
if (sscanf(input, (const char *) __CMD_FORMAT, cmd)!=1)
cmd[0] = '\0';
// Switching with commands
switch(get_cmd_index(cmd))
{
case CMD_HELP:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
puts(__HELP_FORM);
is_valid_cmd = true;
break;
case CMD_DIR:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
// open directory and read through all elem.
i = 1;
dirp = opendir(".");
dir = readdir(dirp);
for(; dir!=NULL; dir = readdir(dirp))
{
struct stat st;
if(stat((const char*) dir->d_name, &st)!=0)
{
puts("FILE NOT FOUND");
goto memory_clear;
}
// FIX: ignore . and ..
if(_SAME_STR(dir->d_name, ".")
|| _SAME_STR(dir->d_name, ".."))
continue;
printf("%20s", dir->d_name);
if(S_ISDIR(st.st_mode)) // is Directory?
putchar('/');
else if( (st.st_mode & S_IXUSR) // is exe?
|| (st.st_mode & S_IXGRP)
|| (st.st_mode & S_IXOTH) )
putchar('*');
putchar('\t');
// print newline after 3 elements
if((i++)%3==0)
putchar('\n');
}
if((i-1)%3!=0)
putchar('\n');
is_valid_cmd = true;
break;
case CMD_QUIT:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
is_valid_cmd = true;
goto memory_clear;
case CMD_HISTORY:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
qe = q_begin (&cmd_queue);
i = 1;
// print every formatted history
for (; qe!=q_end(&cmd_queue); qe=q_next(qe))
printf("%-4d %s\n", i++,
q_entry(qe, struct cmd_elem, elem)->cmd);
printf("%-4d %s\n", i, input);
is_valid_cmd = true;
break;
case CMD_DUMP:
switch(sscanf(input, "%s %x , %x", cmd, &start, &end))
{
case 1:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
start = get_location (0, false);
end = start + 0x10 * 10 - 1;
// if end is too large, point to end and go 0
if ( end >= __MEMORY_SIZE )
end = __MEMORY_SIZE - 1;
hexdump (mem, start, end);
if ( end == __MEMORY_SIZE - 1)
get_location (0, true);
else
get_location (end + 1, true);
is_valid_cmd = true;
break;
case 2:
if(sscanf(input, "%*s %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (start >= __MEMORY_SIZE)
{
puts("OUT OF MEMORY BOUNDS.");
break;
}
end = start + 0x10 * 10 - 1;
// if end is too large, point to end and go 0
if ( end >= __MEMORY_SIZE )
end = __MEMORY_SIZE - 1;
hexdump (mem, start, end);
if ( end == __MEMORY_SIZE - 1)
get_location (0, true);
else
get_location (end + 1, true);
is_valid_cmd = true;
break;
case 3:
if(sscanf(input, "%*s %*x , %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (!(start<=end && end<__MEMORY_SIZE))
{
puts("OUT OF MEMORY BOUNDS.");
break;
}
hexdump (mem, start, end);
// if end is too large, point to end and go 0
if ( end == __MEMORY_SIZE - 1)
get_location (0, true);
else
get_location (end + 1, true);
is_valid_cmd = true;
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_EDIT:
switch(sscanf(input, "%s %x , %hhx",
cmd, &start, &value))
{
case 3:
if(sscanf(input, "%*s %*x , %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
hexfill (mem, __MEMORY_SIZE, start, start, value);
is_valid_cmd = true;
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_FILL:
switch(sscanf(input, "%s %x , %x , %hhx",
cmd, &start, &end, &value))
{
case 4:
if(sscanf(input,
"%*s %*x , %*x , %*x %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
hexfill (mem, __MEMORY_SIZE, start, end, value);
is_valid_cmd = true;
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_RESET:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
// equivalent to fill 0, __MEMORY_SIZE-1
hexfill (mem, __MEMORY_SIZE, 0, __MEMORY_SIZE - 1, 0);
is_valid_cmd = true;
break;
case CMD_OPCODE:
switch(sscanf(input, "%*s %s", cmd))
{
case 1:
if(sscanf(input, "%*s %*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
i = find_oplist (cmd);
if (i != -1)
printf("opcode is %02X\n", i);
else
{
printf("%s: NO SUCH OPCODE\n", cmd);
is_valid_cmd = false;
}
break;
default:
puts("WRONG INSTRUCTION");
break;
}
break;
case CMD_OPCODELIST:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
print_oplist ();
is_valid_cmd = true;
break;
case CMD_ASSEMBLE:
// Processing input string
snprintf((char *) __CMD_FORMAT,
__CMD_FORMAT_SIZE,
"%%%ds %%%ds %%1s",
__CMD_SIZE - 1,
__FILENAME_SIZE - 1);
if (sscanf(input,
(const char *) __CMD_FORMAT,
cmd, filename, check)!=2)
{
puts("WRONG INSTRUCTION");
break;
}
if (!is_file((const char*)filename))
{
puts("FILE NOT FOUND");
break;
}
is_valid_cmd = assemble_file (filename);
break;
case CMD_TYPE:
// Processing input string
snprintf((char *) __CMD_FORMAT,
__CMD_FORMAT_SIZE,
"%%%ds %%%ds %%1s",
__CMD_SIZE - 1,
__FILENAME_SIZE - 1);
if (sscanf(input,
(const char *) __CMD_FORMAT,
cmd, filename, check)!=2)
{
puts("WRONG INSTRUCTION");
break;
}
if (!is_file((const char*)filename))
{
puts("FILE NOT FOUND");
break;
}
else
{
print_file((const char*)filename);
is_valid_cmd = true;
}
break;
case CMD_SYMBOL:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
print_symbol_table ();
is_valid_cmd = true;
break;
case CMD_PROGADDR:
if(sscanf(input, "%*s %*x %1s", check) == 1
|| sscanf(input, "%*s %x", &i) != 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (i < 0 || i >= __MEMORY_SIZE - 1)
{
puts("INVALID PROGRAM ADDRESS");
break;
}
set_progaddr ((uint32_t) i);
is_valid_cmd = true;
break;
case CMD_LOADER:
init_loader ();
tok = strtok (input, " ");
while ( (tok = strtok (NULL, " ")) != NULL)
{
if (!is_file (tok))
{
printf ("[%s]: INVALID FILE\n", tok);
free_loader ();
break;
}
if (!add_obj_loader (tok))
{
printf ("[%s]: LOADER FAILED\n", tok);
free_loader ();
break;
}
}
// if normally added
if (tok == NULL)
{
// address __MEMORY_SIZE is reserved for boot
if (get_proglen()+get_progaddr()>=__MEMORY_SIZE-1)
{
puts ("PROGRAM IS TOO BIG: LOADER FAILED");
free_loader ();
break;
}
if (!run_loader (mem))
{
puts ("LOADER FAILED");
free_loader ();
break;
}
print_load_map ();
}
free_loader ();
is_valid_cmd = true;
break;
case CMD_RUN:
if(sscanf(input, "%*s %1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (!init_run ())
{
puts ("RUN FAILED");
free_run ();
break;
}
run (mem);
free_run ();
is_valid_cmd = true;
break;
case CMD_BP:
if(sscanf(input, "%*s %1s", check) != 1)
{
print_bp ();
is_valid_cmd = true;
break;
}
if(sscanf(input, "%*s %6s %1s", cmd, check) == 2
|| sscanf(input, "%*s %6s", cmd) != 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (_SAME_STR(cmd, "clear"))
{
puts ("\t[ok] clear all breakpoints");
free_bp ();
is_valid_cmd = true;
break;
}
if(sscanf(input, "%*s %*x %1s", check) == 1
|| sscanf(input, "%*s %x", &start) != 1)
{
puts("WRONG INSTRUCTION");
break;
}
if (start >= __MEMORY_SIZE - 1)
{
puts ("INVALID BREAKPOINT ADDRESS");
break;
}
if (add_bp (start))
printf ("\t[ok] create breakpoint %x\n", start);
is_valid_cmd = true;
break;
default:
if(sscanf(input, "%1s", check) == 1)
{
puts("WRONG INSTRUCTION");
break;
}
}
if (is_valid_cmd)
{
// Saving commands
struct cmd_elem *e = malloc(sizeof(struct cmd_elem));
if (e == NULL)
{
puts("MEMORY INSUFFICIENT.");
goto memory_clear;
}
e->cmd = malloc(sizeof(char)*(strlen(input)+1));
if (e->cmd == NULL)
{
puts("MEMORY INSUFFICIENT.");
goto memory_clear;
}
strcpy(e->cmd, input);
q_insert (&cmd_queue, &(e->elem));
}
}
memory_clear:
if (mem != NULL)
free (mem);
if (input != NULL)
free (input);
if (cmd != NULL)
free (cmd);
while (!q_empty(&cmd_queue))
{
struct q_elem *e = q_delete(&cmd_queue);
struct cmd_elem *ce = q_entry(e, struct cmd_elem, elem);
if (ce->cmd != NULL)
free(ce->cmd);
free(ce);
}
free_oplist ();
free_loader ();
free_bp ();
free_run ();
return 0;
}
q_expr
q_takeField(
q_expr *e,
c_string name)
{
q_expr *l,*r,p,q,x;
c_long i;
c_char qn[1024];
q_tag tag;
if (e == NULL) return NULL;
if (*e == NULL) return NULL;
switch (q_getKind(*e)) {
case T_FNC:
tag = q_getTag(*e);
switch (tag) {
case Q_EXPR_PROGRAM:
return q_takeField(&(*e)->info.function->params->expr,name);
case Q_EXPR_OR:
/* This function should never be used upon an OR expression.
However if that functionality is required then this function should be redesigned.
*/
assert(FALSE);
break;
case Q_EXPR_AND:
l = &(*e)->info.function->params->expr;
r = &(*e)->info.function->params->next->expr;
p = q_takeField(l,name);
q = q_takeField(r,name);
if ((*l == NULL) && (*r == NULL)) {
q_dispose(*e); *e = NULL;
} else if ((*l == NULL) && (*r != NULL)) {
x = *r; *r = NULL; q_dispose(*e); *e = x;
} else if ((*l != NULL) && (*r == NULL)) {
x = *l; *l = NULL; q_dispose(*e); *e = x;
}
if (p == NULL) {
if (q == NULL) return NULL;
return q;
} else {
if (q == NULL) {
return p;
}
return q_newFnc(tag,q_insert(q_insert(NULL,p),q));
}
case Q_EXPR_EQ:
case Q_EXPR_NE:
case Q_EXPR_LT:
case Q_EXPR_LE:
case Q_EXPR_GT:
case Q_EXPR_GE:
case Q_EXPR_LIKE:
l = &(*e)->info.function->params->expr;
r = &(*e)->info.function->params->next->expr;
p = *e;
if (q_takeField(l,name) != NULL) { *e = NULL; return p; }
if (q_takeField(r,name) != NULL) { *e = NULL; return p; }
return NULL;
case Q_EXPR_NOT:
p = *e;
if (q_takeField(&(*e)->info.function->params->expr,name) != NULL) {
*e = NULL;
return p;
}
break;
case Q_EXPR_PROPERTY:
i=0; qn[0]=0;
while ((p = q_getPar(*e,i)) != NULL) {
if (i!=0) os_strcat(qn,".");
os_strcat(qn,q_getId(p));
i++;
}
if (strcmp(qn,name) == 0) return *e;
return NULL;
case Q_EXPR_CALLBACK:
return q_exprCopy(*e);
default:
assert(FALSE);
break;
}
break;
case T_TYP:
case T_VAR:
case T_INT:
case T_DBL:
case T_CHR:
case T_STR:
case T_ERR:
break;
case T_ID:
if (strcmp(q_getId(*e),name) == 0) return *e;
return NULL;
default:
assert(FALSE);
break;
}
return NULL;
}
q_expr
q_takeKey(
q_expr *e,
c_array keyList)
{
q_expr *l,*r,p,q,x;
c_long i,len;
c_char qn[1024];
q_tag tag;
if (e == NULL) return NULL;
if (*e == NULL) return NULL;
len = c_arraySize(keyList);
if (len == 0) {
return NULL;
}
switch (q_getKind(*e)) {
case T_FNC:
tag = q_getTag(*e);
switch (tag) {
case Q_EXPR_AND:
l = &(*e)->info.function->params->expr;
r = &(*e)->info.function->params->next->expr;
p = q_takeKey(l,keyList);
q = q_takeKey(r,keyList);
if ((*l == NULL) && (*r == NULL)) {
q_dispose(*e); *e = NULL;
} else if ((*l == NULL) && (*r != NULL)) {
x = *r; *r = NULL; q_dispose(*e); *e = x;
} else if ((*l != NULL) && (*r == NULL)) {
x = *l; *l = NULL; q_dispose(*e); *e = x;
}
if (p == NULL) {
if (q == NULL) return NULL;
return q;
} else {
if (q == NULL) {
return p;
}
return q_newFnc(tag,q_insert(q_insert(NULL,p),q));
}
case Q_EXPR_EQ:
case Q_EXPR_NE:
case Q_EXPR_LT:
case Q_EXPR_LE:
case Q_EXPR_GT:
case Q_EXPR_GE:
case Q_EXPR_LIKE:
l = &(*e)->info.function->params->expr;
r = &(*e)->info.function->params->next->expr;
if (q_takeKey(l,keyList) != NULL) {
if (q_takeKey(r,keyList) != NULL) {
p = *e; *e = NULL;
return p;
}
}
return NULL;
case Q_EXPR_PROPERTY:
i=0; qn[0]=0;
while ((p = q_getPar(*e,i)) != NULL) {
if (i!=0) os_strcat(qn,".");
os_strcat(qn,q_getId(p));
i++;
}
for (i=0; i<len; i++) {
if (strcmp(qn,c_fieldName(keyList[i])) == 0) {
return *e;
}
}
return NULL;
case Q_EXPR_CALLBACK:
return NULL;
default:
assert(FALSE);
break;
}
break;
case T_VAR:
case T_INT:
case T_DBL:
case T_CHR:
case T_STR:
return *e;
case T_TYP:
case T_ERR:
break;
case T_ID:
for (i=0; i<len; i++) {
if (strcmp(qn,c_fieldName(keyList[i])) == 0) {
return *e;
}
}
return NULL;
default:
assert(FALSE);
break;
}
return NULL;
}
char * test_not_empty(void) {
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(5) == q_success);
mu_assert("is_empty", q_is_empty() == 0);
return NULL;
}
char * test_peek_null(void) {
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(18) == q_success);
mu_assert("peek", q_peek(NULL) == q_failure);
return NULL;
}
/**
* The following method like many other implement a generic expr walk with specific functionality.
*/
void
q_prefixFieldNames (
q_expr *e,
c_char *prefix)
{
q_tag tag;
q_expr p;
q_list list;
if (e == NULL) return;
if (*e == NULL) return;
if (prefix == NULL) return;
if (strlen(prefix) == 0) return;
switch (q_getKind(*e)) {
case T_FNC:
tag = q_getTag(*e);
switch (tag) {
case Q_EXPR_AND:
case Q_EXPR_OR:
case Q_EXPR_EQ:
case Q_EXPR_NE:
case Q_EXPR_LT:
case Q_EXPR_LE:
case Q_EXPR_GT:
case Q_EXPR_GE:
case Q_EXPR_LIKE:
q_prefixFieldNames(&(*e)->info.function->params->expr,prefix);
q_prefixFieldNames(&(*e)->info.function->params->next->expr,prefix);
return;
case Q_EXPR_NOT:
q_prefixFieldNames(&(*e)->info.function->params->expr,prefix);
break;
case Q_EXPR_PROPERTY:
list = q_listCopy(q_getLst(*e,0));
list = q_insert(list,q_newId(prefix));
p = q_newFnc(Q_EXPR_PROPERTY,list);
q_swapExpr(*e,p);
q_dispose(p);
return;
case Q_EXPR_CALLBACK:
return;
case Q_EXPR_PROGRAM:
q_prefixFieldNames(&(*e)->info.function->params->expr,prefix);
break;
default:
assert(FALSE);
break;
}
break;
case T_VAR:
case T_INT:
case T_DBL:
case T_CHR:
case T_STR:
case T_TYP:
case T_ERR:
break;
case T_ID:
list = q_insert(NULL,q_newId(q_getId(*e)));
list = q_insert(list,q_newId(prefix));
p = q_newFnc(Q_EXPR_PROPERTY,list);
q_swapExpr(*e,p);
q_dispose(p);
return;
default:
assert(FALSE);
break;
}
}
char * test_one_insert(void) {
mu_assert("init", q_init() == q_success);
mu_assert("insert", q_insert(7) == q_success);
mu_assert("destroy", q_destroy() == q_success);
return NULL;
}
void si_insert(sorted_intlist si, int to_insert) {
q_insert(si->q, (void *)to_insert);
}
