void
queue_print (queue *q)
{
int c;
for (c = 0; c < q->length; c++)
{
printf(
"%d,%d -> ",
queue_start(q).x,
queue_start(q).y
);
queue_enqueue(q, queue_dequeue(q));
}
printf("End of queue.\n");
}
fs_ret_t fs_store(fs_config_t const * const p_config,
uint32_t const * const p_dest,
uint32_t const * const p_src,
uint16_t const length_words)
{
fs_op_t * p_op;
if (!(m_flags & FS_FLAG_INITIALIZED))
{
return FS_ERR_NOT_INITIALIZED;
}
if (!check_config(p_config))
{
return FS_ERR_INVALID_CFG;
}
if ((p_src == NULL) || (p_dest == NULL))
{
return FS_ERR_NULL_ARG;
}
// Check that both pointers are word aligned.
if (((uint32_t)p_src & 0x03) ||
((uint32_t)p_dest & 0x03))
{
return FS_ERR_UNALIGNED_ADDR;
}
// Check that the operation doesn't go outside the client's memory boundaries.
if ((p_config->p_start_addr > p_dest) ||
(p_config->p_end_addr < (p_dest + length_words)))
{
return FS_ERR_INVALID_ADDR;
}
if (length_words == 0)
{
return FS_ERR_INVALID_ARG;
}
if (!queue_get_next_free(&p_op))
{
return FS_ERR_QUEUE_FULL;
}
// Initialize the operation.
p_op->p_config = p_config;
p_op->op_code = FS_OP_STORE;
p_op->store.p_src = p_src;
p_op->store.p_dest = p_dest;
p_op->store.length_words = length_words;
queue_start();
return FS_SUCCESS;
}
fs_ret_t fs_erase(fs_config_t const * const p_config,
uint32_t const * const p_page_addr,
uint16_t const num_pages)
{
fs_op_t * p_op;
if (!(m_flags & FS_FLAG_INITIALIZED))
{
return FS_ERR_NOT_INITIALIZED;
}
if (!check_config(p_config))
{
return FS_ERR_INVALID_CFG;
}
if (p_page_addr == NULL)
{
return FS_ERR_NULL_ARG;
}
// Check that the page is aligned to a page boundary.
if (((uint32_t)p_page_addr % FS_PAGE_SIZE) != 0)
{
return FS_ERR_UNALIGNED_ADDR;
}
// Check that the operation doesn't go outside the client's memory boundaries.
if ((p_page_addr < p_config->p_start_addr) ||
(p_page_addr + (FS_PAGE_SIZE_WORDS * num_pages) > p_config->p_end_addr))
{
return FS_ERR_INVALID_ADDR;
}
if (num_pages == 0)
{
return FS_ERR_INVALID_ARG;
}
if (!queue_get_next_free(&p_op))
{
return FS_ERR_QUEUE_FULL;
}
// Initialize the operation.
p_op->p_config = p_config;
p_op->op_code = FS_OP_ERASE;
p_op->erase.page = ((uint32_t)p_page_addr / FS_PAGE_SIZE);
p_op->erase.pages_to_erase = num_pages;
queue_start();
return FS_SUCCESS;
}
int main(void)
{
srand(time(NULL));
cmocka_tests();
getchar();
system("cls");
queue_t * queue = queue_new();
user_t * user1 = user_new("User1");
user_t * user2 = user_new("User2");
user_t * user3 = user_new("User3");
user_t * userArr[] =
{
user1,
user2,
user3
};
int userArrSize = sizeof(userArr)/sizeof(userArr[0]);
event_t* firstEvent = event_new("First event");
event_t* secondEvent = event_new("Second event");
event_t* thirdEvent = event_new("Third event");
event_addReceiver(firstEvent, user1, alert_callback);
event_addReceiver(firstEvent, user2, alert_callback);
event_addReceiver(secondEvent, user1, alert_callback);
event_addReceiver(thirdEvent, user1, alert_callback);
event_addReceiver(secondEvent, user2, alert_callback);
event_addReceiver(thirdEvent, user3, alert_callback);
event_addReceiver(secondEvent, user3, alert_callback);
event_addReceiver(thirdEvent, user2, alert_callback);
while(!kbhit() && queue_status(queue) != QUEUE_FULL)
{
queue_start(firstEvent, secondEvent, thirdEvent, queue);
}
event_free(firstEvent);
event_free(secondEvent);
event_free(thirdEvent);
for(int i = 0; i<userArrSize; i++)
user_free(userArr[i]);
queue_free(queue);
return 0;
}
pos
queue_dequeue (queue *q)
{
if (queue_is_empty(q))
{
printf("ERROR: Empty queue. (dequeue)\n");
return position(0,0);
}
pos e = queue_start(q); q->length--;
q->start = ++q->start % q->size;
return e;
}
void socket_stub_close_connection(void)
{
queue_stop(&qinput);
queue_start(&qinput);
}
