int main()
{
Queue myQueue;
queue_init(&myQueue);
assert(queue_isempty(&myQueue));
queue_enqueue(&myQueue, 9);
assert(!queue_isempty(&myQueue));
printf("%d is top\n", queue_first(&myQueue));
queue_enqueue(&myQueue, 1);
queue_enqueue(&myQueue, 2);
queue_enqueue(&myQueue, 3);
queue_enqueue(&myQueue, 4);
queue_enqueue(&myQueue, 5);
queue_enqueue(&myQueue, 6);
queue_enqueue(&myQueue, 7);
queue_print(&myQueue);
printf("%d dequeued\n", queue_dequeue(&myQueue));
printf("%d dequeued\n", queue_dequeue(&myQueue));
printf("%d dequeued\n", queue_dequeue(&myQueue));
printf("%d dequeued\n", queue_dequeue(&myQueue));
queue_print(&myQueue);
queue_destroy(&myQueue);
queue_print(&myQueue);
}
int main (int argc, const char * argv[]) {
//Stack
int numbers[NUMLEN] = {
15, 10, 5, 100
};
int i;
Stack *stack = stack_create();
for(i = 0; i < NUMLEN; i++) {
printf("pushing: %u\n", numbers[i]);
stack_push(stack, numbers[i]);
}
printf("\n");
stack_print(stack);
while(i--) {
unsigned int result = stack_pop(stack);
if(UINT_MAX == result) {
break;
}
printf("popping: %u\n", result);
}
stack_destroy(stack);
//Queue
Queue *queue = queue_create();
for(i = 0; i < NUMLEN; i++) {
printf("\nenqueueing: %u", numbers[i]);
queue_enqueue(queue, numbers[i]);
}
queue_print(queue);
while(i--) {
unsigned int result = queue_dequeue(queue);
if(UINT_MAX == result) {
break;
}
printf("dequeuing: %u\n", result);
}
queue_print(queue);
queue_destroy(queue);
return 0;
}
void queue_test_print(void) {
queue_t* q = queue_init(q_compare, q_print, q_clone, q_destroy);
CU_ASSERT (q != NULL);
CU_ASSERT (queue_push(q, queue_test_s1) != NULL);
CU_ASSERT (queue_push(q, queue_test_s2) != NULL);
CU_ASSERT (queue_push(q, queue_test_s3) != NULL);
CU_ASSERT (queue_push(q, queue_test_s4) != NULL);
queue_print(NULL, stdout);
queue_print(q, stdout);
CU_ASSERT (queue_destroy(q) == 0);
}
/*
return no of items in control queue, including the newly inserted one, or
-1 upon trouble.
*/
int queue_insert(pthread_t tid)
{
struct queue_item *ii, *tmp;
int qd;
tmp=queue_create_item(tid);
if(!tmp) {
diag(SS_MAIN|ERR,"Could not create control queue item");
return -1;
}
pthread_mutex_lock(&queue_mtx);
if(!queue_head) {
queue_head=tmp;
thread_in_control=tid;
}
else {
ii=queue_head;
while(ii->next) ii=ii->next;
ii->next=tmp;
}
qd=++queue_depth;
#if DEBUG_DUMP_QUEUE
queue_print();
#endif
pthread_mutex_unlock(&queue_mtx);
diag(SS_MAIN|DEBUG,"control queue depth %d after insertion\n",queue_depth);
return qd;
}
int main(void)
{
user_tests();
queue_tests();
user_t user1 = user_new(1);
user_t user2 = user_new(2);
queue_t pQueue = queue_new();
clock_t start;
fflush(stdout);
char c = 'f';
while(c != '-')
{
start = clock();
while(clock() - start < CLOCKS_PER_SEC/30)
{
user_checkComm(user1, user2, pQueue);
}
queue_print(pQueue);
printf("\n");
queue_countNull(pQueue);
c = getch();
}
user_delete(user1);
user_delete(user2);
queue_delete(pQueue);
return 0;
}
int reaction(queue_t * self){
if (compare(self)==1){
for(int i = getHead(self); i < getTail(self)-1;i++)
queue_remove(self);
queue_print(self);
}
return 0;
}
void printQueue(queue_t * self, int sum) {
system("cls");
printf("Queue: \n");
queue_print(self);
printf("\nSum : %d", sum);
Sleep(500);
}
int main()
{
Item array[] = {1,2,3,4,5,6,7,8,9,0};
const uint32_t size = sizeof(array)/sizeof(Item);
Queue *queue = queue_init();
queue_create(queue, array, size);
queue_print(queue);
queue_destroy(queue);
return 0;
}
int main() {
// initialize
queue_t testQ;
queue_init(&testQ);
// add some items
queue_enqueue(&testQ, "item 1");
queue_enqueue(&testQ, "item 2");
queue_enqueue(&testQ, "item 3");
// print the queue
queue_print(&testQ);
// dequeue
queue_dequeue(&testQ);
// print the queue
printf("After dequeueing once:\n");
queue_print(&testQ);
printf("The size of the queue: %d\n", queue_size(&testQ));
// the front of the queue
printf("The front of the queue: %s\n", (char *)queue_front(&testQ));
// the back of the queue
printf("The back of the queue: %s\n", (char *)queue_back(&testQ));
// add some more items
queue_enqueue(&testQ, "item4");
queue_enqueue(&testQ, "item5");
printf("After queueing twice more:\n");
queue_print(&testQ);
// free up the queue's memory
queue_destroy(&testQ);
return 0;
}
int main(void){
fprintf(stdout, "Test Case 1\n===========================\n");
Queue *empty_queue = queue_new_empty_queue();
queue_print(empty_queue);
queue_destroy(empty_queue);
Queue *queue_a = queue_new_empty_queue();
for (int i=1; i<=10; i++){
int *value = (int *)malloc(sizeof(int));
*value = i;
queue_enqueue(queue_a, value);
}
queue_print(queue_a);
fprintf(stdout, "\nTest Case 3\n===========================\n");
for (int i=1; i<=5; i++){
void *data = NULL;
queue_dequeue(queue_a, &data);
fprintf(stdout, "dequeued: %d\n", *(int *)data);
// Here, using free() is not a good idea.
free(data);
}
queue_print(queue_a);
fprintf(stdout, "\nTest Case 4\n===========================\n");
for (int i=1; i<=5; i++){
void *data = NULL;
queue_dequeue(queue_a, &data);
fprintf(stdout, "dequeued: %d\n", *(int *)data);
// Here, using free() is not a good idea.
free(data);
}
queue_print(queue_a);
fprintf(stdout, "\nTest Case 5\n===========================\n");
queue_destroy(queue_a);
queue_print(queue_a);
return 0;
}
int main(void) {
A* a = malloc(sizeof(A)), *b = malloc(sizeof(A)), *c = NULL;
List* l = list_init();
Stack* s = stack_init();
Queue* q = queue_init();
DoubleLinkedList* d = dll_init();
printf("a: %d\nB: %d\nc: %d\n", (int)a, (int)b, (int)c);
a->a1 = 1;
a->a2 = 'c';
b->a1 = 2;
b->a2 = 'a';
printf("\n=== LIST TEST ===\n");
list_add(l, a, 0);
list_append(l, b);
list_remove(l, 0);
list_print(l);
c = list_get(l, 0);
printf("c: %d\n", (int)c);
list_delete(l);
printf("\n=== STACK TEST ===\n");
stack_push(s, b);
stack_push(s, a);
stack_pop(s);
stack_print(s);
c = stack_peek(s);
printf("c: %d\n", (int)c);
stack_delete(s);
printf("\n=== QUEUE TEST ===\n");
queue_push(q, a);
queue_push(q, b);
queue_pop(q);
queue_print(q);
c = queue_peek(q);
printf("c: %d\n", (int)c);
queue_delete(q);
printf("\n=== DOUBLE LINKED LIST TEST ===\n");
dll_add(d, b, 0);
dll_prepend(d, a);
dll_remove(d, 1);
dll_print(d);
c = dll_get(d, 0);
printf("c: %d\n", (int)c);
dll_delete(d);
free(a);
free(b);
return 0;
}
int main() {
const int SIZE = 6;
QUEUE queue;
queue.size = SIZE;
queue_init(&queue);
char isRunning = 1;
while (isRunning) {
int choice;
char * data;
printf("\n1. 삽입\n2. 꺼내기\n3. 출력\n4. 전부 삭제\n5. 끝\n입력: ");
scanf("%d", &choice);
getchar();
switch (choice) {
case 1:
if (queue_isFull(&queue)) {
printf("큐가 꽉 찼습니다\n");
break;
}
printf("데이터를 입력해주세요: ");
data = (char *) malloc(256);
gets(data);
queue_add(&queue, data);
break;
case 2:
if (queue_isEmpty(&queue)) {
printf("큐가 비었습니다\n");
break;
}
data = queue_remove(&queue);
printf("읽은 데이터: %s\n", data);
free(data);
break;
case 3:
queue_print(&queue);
break;
case 4:
// This doesn't free the queue, but whatever.
queue_reset(&queue);
break;
case 5:
isRunning = 0;
break;
}
}
}
void queue_remove(pthread_t tid)
{
struct queue_item *prev, *ii;
int found=0;
pthread_mutex_lock(&queue_mtx);
ii=prev=queue_head;
while(ii && !pthread_equal(tid,ii->tid)) {
prev=ii;
ii=ii->next;
}
if(pthread_equal(tid,ii->tid)) {
found=1;
if(ii==queue_head) {
queue_head=queue_head->next;
free(ii);
/* note: we used to set thread_in_control to a special value (0) if
queue_head==0 (empty queue), to make the "Am I in control?" test
in http threads fail for sure.
However, that test is only executed in the C_PENDING state,
which implies that the queue is non-empty - so there's no
point in that assignment.
(Besides, it's not elegant to make assumption about allowed and
available values for an opaque type.)
*/
if(queue_head) thread_in_control=queue_head->tid;
}
else {
prev->next=ii->next;
free(ii);
}
queue_depth--;
}
diag(SS_MAIN|DEBUG,"control queue depth %d after removal\n",queue_depth);
#if DEBUG_DUMP_QUEUE
queue_print();
#endif
pthread_mutex_unlock(&queue_mtx);
if(!found) diag(SS_MAIN|ERROR,"inconsistent control queue (dequeue)");
}
void bro_link(struct node *n)
{
struct node *now, *last = NULL;
queue_clear();
n->level = 1;
enqueue(n);
while (q_num != 0) {
printf("queue: ");
queue_print();
now = dequeue();
if (now == NULL)
break;
if (last) {
if (last->level == now->level)
last->next_brother = now;
else
last->next_brother = NULL;
}
printf("now: %d\n", now->val);
if (now->left) {
now->left->level = now->level + 1;
enqueue(now->left);
}
if (now->right) {
now->right->level = now->level + 1;
enqueue(now->right);
}
last = now;
//sleep(1);
}
}
void *threadBody (void *id){ // LIVRE
queue_t_int *novo,*velho;
while (1){
velho=queue_integer;
queue_remove ((queue_t **)&queue_integer, (queue_t *)velho); // Remove primeiro elemento
novo=(queue_t_int*) malloc (sizeof (queue_t_int)); // Aloca espaço para nova variável
novo->item = random() % 100;
novo->prev= NULL;
novo->next=NULL;
queue_append ((queue_t **)&queue_integer, (queue_t *)novo);
printf("thread %ld: tira %d , poe %d",(long)id,velho->item,novo->item);
queue_print (" Fila: ", (queue_t*) queue_integer, print_elem) ;
qtd++;
if(qtd == PREC){
printf("Realizou %f operações por segundo\n",( PREC/((float)(clock() - start)/CLOCKS_PER_SEC) ) );
exit(0);
}
}
}
int main(){
queue_osnova * q = new_queue_osnova();
char * file = malloc(sizeof(char)*10);
UserChoose(file);
dynamic_t * dll = dynamic_init(file);
if (NULL == dll) {
printf("Can't load dynamic!\n");
return 1;
}
if (NULL == dll->inspection_f) {
printf("Can't get compare function!\n");
return 1;
}
if (NULL == dll->react_f) {
printf("Can't get reaction function!\n");
return 1;
}
printf("Dynamic loaded!");
Sleep(2000);
queue_t * arr;
while(1){
system("cls");
arr = queue_new(q, rand()%20-5);
queue_print(q);
if(dll->inspection_f(q))
dll->react_f();
Sleep(2000);
//system("cls");
}
//dynamic_clean(dll);
return 0;
}
void scan(player_t ** players, int numbOfPlayers, queue_t * queue){
clock_t start;
char * moves;
char index;
struct command com;
while(index != '+')
{
start = clock();
if (kbhit()){
index = getch();
for (int i = 0; i < numbOfPlayers; i++)
{
moves = player_get_moves(players[i]);
if(i == 0) printf("\nplayer 1:");
else printf("\nplayer 2:");
for (int i = 0; i < 5; i++)
if (moves[i] == index)
{
i++;
com.command = i;
com.players = players[i];
queue_add(queue, com);
if (i == 1) printf("up");
if (i == 2) printf("down");
if (i == 3) printf("left");
if (i == 4) printf("right");
if (i == 5) printf("fire");
}
}
}
while(clock() - start < CLOCKS_PER_SEC/30);
}
puts("");
queue_print(queue);
}
int main(int argc, char *argv[]) {
/*unsigned int m = -1;
printf("%ud\n", m);*/
if (argc < 2) {
printf("Usage: ./cpusched in.txt out.txt SCHEDULE_ALGORITHM [quantum]");
exit(1);
}
//get the algorithm indicator
SCHEDULER method;
if (strcmp("FCFS", argv[3]) == 0)
method = FCFS;
else if (strcmp("RR", argv[3]) == 0)
method = RR;
else if (strcmp("SJF", argv[3]) == 0)
method = SJF;
else {
printf("THE ALGORITHM DOESN'T EXISTS\n");
exit(1);
}
//default by 5
int quantum = 5;
if (argc == 5)
quantum = atoi(argv[4]);
queue_init();
//open the input text file
FILE *f_in;
if ((f_in = fopen(argv[1], "r+")) == NULL) {
printf("THE INPUT FILE DOESN'T EXISTS");
}
int pid, atime, burst;
while (fscanf(f_in, "%d\t%d\t%d", &pid, &atime, &burst) != -1) {
printf("%d:%d:%d\n", pid, atime, burst);
priority_queue *queue = malloc(sizeof(priority_queue));
process p;
p.pid = pid;
p.arrival_time = atime;
p.cpu_burst = burst;
p.process_status = PENDING;
p.consume_time = 0;
p.last_exec_tick = 0;
p.done_print = 0;
p.exec_times = 0;
queue->current_process = p;
queue->next_ptr = NULL;
queue_insert(queue, method);
}
printf("out of the castle\n");
if ((f_out = fopen(argv[2], "w+")) == NULL) {
printf("THE OUTPUT FILE CREATED FAILED!\n");
}
queue_process(method, quantum);
if (method == FCFS)
queue_print(f_out);
fclose(f_in);
fclose(f_out);
return 0;
}
int main() {
int i = 0;
char c;
queue_t* firstQueue = queue_create();
queue_t* secondQueue = queue_create();
while (1) {
scanf("%c", &c);
if (c == '+') {
scanf("%c", &c);
if (c == '1') {
firstQueue = queue_add(firstQueue);
}
if (c == '2') {
secondQueue = queue_add(secondQueue);
}
}
if (c == '-') {
scanf("%c", &c);
if (c == '1') {
firstQueue = queue_del(firstQueue);
}
if (c == '2') {
secondQueue = queue_del(secondQueue);
}
}
if (c == 'c') {
firstQueue = queue_concat(firstQueue, secondQueue);
/** WARNING: ????
* Возможно тут имелось ввиду освобождение памяти?
*/
secondQueue = NULL;
secondQueue = queue_create();
}
if (c == 's') {
scanf("%c", &c);
if (c == '1') {
firstQueue = queue_sort(firstQueue);
}
if (c == '2') {
secondQueue = queue_sort(secondQueue);
}
}
if (c == 'q') {
printf("Bye\n");
break;
}
if (c == 'p') {
scanf("%c", &c);
if (c == '1')
queue_print(firstQueue);
if (c == '2')
queue_print(secondQueue);
}
}
return 0;
}
void vtimer_print_short_queue(){
queue_print(&shortterm_queue_root);
}
int main(int argc, char *argv[])
{
char command[32];
int eventsNr, eventId, procId, priority;
int i, iteration;
TStack **eventsStacks;
TQueue *procQ;
// Daca nu exista destule argumente la rularea programului, atunci opreste executia
if (argc < 3)
{
printf("Argumente insuficiente!\n");
return -1;
}
// Seteaza fisierele de intrare si de iesire
freopen(argv[1], "r", stdin);
freopen(argv[2], "w", stdout);
// Citeste numarul de event-uri si creeaza stivele lor
fscanf(stdin, "%d", &eventsNr);
eventsStacks = calloc(eventsNr, sizeof(TStack*));
for (i = 0; i < eventsNr; i++)
{
eventsStacks[i] = stack_new(sizeof(TProcess));
}
// Creeaza coada de prioritati
procQ = queue_new(sizeof(TProcess), compare_process);
// Citeste si executa comenzile din fisierul de intrare
iteration = 0;
while (fscanf(stdin, "%s", command) != EOF)
{
iteration++;
if (strcmp(command, "start") == 0)
{
fscanf(stdin, "%d", &procId);
fscanf(stdin, "%d", &priority);
// Creeaza un proces
TProcess p;
p.id = procId;
p.priority = priority;
p.iteration = iteration;
// Introduce procesul creat in coada de prioritati
queue_push(procQ, &p);
}
else if (strcmp(command, "wait") == 0)
{
fscanf(stdin, "%d", &eventId);
fscanf(stdin, "%d", &procId);
// Creaza o stiva auxiliara
TStack *aux = stack_new(sizeof(TProcess));
// Muta procesele in stiva auxiliara pana cand procesul
// cautat este gasit si mutat in stiva evenimentului
TProcess *p;
while (!queue_isEmpty(procQ))
{
p = queue_pop(procQ);
if (p->id == procId)
{
stack_push(eventsStacks[eventId], p);
free_process(p);
break;
}
stack_push(aux, p);
free_process(p);
}
// Muta procesele din stiva auxiliara inapoi in coada
// de prioritati
while (!stack_isEmpty(aux))
{
p = stack_pop(aux);
queue_push(procQ, p);
free_process(p);
}
// Distruge stiva auxiliara
stack_destroy(&aux, free_process);
}
else if (strcmp(command, "event") == 0)
{
fscanf(stdin, "%d", &eventId);
// Muta procesele din stiva evenimentului in coada
// de prioritati
TProcess *p;
while (!stack_isEmpty(eventsStacks[eventId]))
{
p = stack_pop(eventsStacks[eventId]);
queue_push(procQ, p);
free_process(p);
}
}
else if (strcmp(command, "end") == 0)
{
fscanf(stdin, "%d", &procId);
// Creaza o stiva auxiliara
TStack *aux = stack_new(sizeof(TProcess));
// Muta procesele in stiva auxiliara pana cand procesul
// cautat este gasit si sters
TProcess *p;
while (!queue_isEmpty(procQ))
{
p = queue_pop(procQ);
if (p->id == procId)
{
free_process(p);
break;
}
stack_push(aux, p);
free_process(p);
}
// Muta procesele din stiva auxiliara inapoi in coada
// de prioritati
while (!stack_isEmpty(aux))
{
p = stack_pop(aux);
queue_push(procQ, p);
free_process(p);
}
// Distruge stiva auxiliara
stack_destroy(&aux, free_process);
}
// Afiseaza iteratia
printf("%d\n", iteration);
// Afiseaza coada de prioritati
if (!queue_isEmpty(procQ))
{
queue_print(procQ, print_process);
}
else
{
printf("\n");
}
// Afiseaza stivele
for (i = 0; i < eventsNr; i++)
{
if (!stack_isEmpty(eventsStacks[i]))
{
printf("%d: ", i);
stack_print(eventsStacks[i], print_process);
}
}
printf("\n");
}
// Elibereaza memoria
queue_destroy(&procQ, free_process);
for (i = 0; i < eventsNr; i++)
{
stack_destroy(&eventsStacks[i], free_process);
}
free(eventsStacks);
return 0;
}
int main(void)
{
printf("-----------------------\n");
p_queue_t queue = NULL;
int i;
int *a = (int *)malloc(sizeof(int) * 10);
for (i = 0; i < 10; i++)
{
a[i] = i;
}
for (i = 0; i < 10; i++)
{
printf("%4d", a[i]);
}
putchar('\n');
printf("-----------------------\n");
queue = queue_create();
if (NULL == queue)
err_exit("create error");
queue_print(queue, show);
printf("-----------------------\n");
if (queue_empty(queue))
printf("empty\n");
for (i = 0; i < 10; i++)
{
if (!queue_put(queue, &a[i]))
err_exit("put error");
}
if (!queue_empty(queue))
printf("full\n");
queue_print(queue, show);
printf("\n%d\n", queue->size);
printf("%d\n", *(int*)queue->head->data);
printf("%d\n", *(int*)queue_gethead(queue));
int *c = (int *)malloc(sizeof(int));
*c = 4;
if (queue_put(queue, c))
printf("%d\n", queue->size);
queue_print(queue, show);
if (queue_delete(queue))
printf("\n%d\n", queue->size);
printf("\n%d\n", *(int*)queue->head->data);
printf("%d\n", *(int*)queue_gethead(queue));
queue_print(queue, show);
putchar('\n');
printf("****************************************************\n");
p_queue_t queue_test = NULL;
queue_test = queue_create();
for (i = 0; i < 10; i++)
{
if (queue_insert_maxsize(queue_test, &a[i], compare) == false)
err_exit("put error");
}
queue_print(queue_test, show);
putchar('\n');
printf("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n");
// p_queue_t test = NULL;
// test = queue_create();
// if (NULL == test)
// err_exit("create error");
//
for (i = 0; i < 10; i++)
{
if (queue_insert_minsize(queue_test, &a[i], compare) == false)
err_exit("put error");
}
queue_print(queue_test, show);
printf("\n\n");
for (i = 0; i < 10; i++)
{
if (queue_insert_minsize(queue_test, &a[i], compare) == false)
err_exit("put error");
}
queue_print(queue_test, show);
putchar('\n');
printf("############################################################\n");
int *p = (int *)malloc(sizeof(int)* 10);
for (i = 0; i < 10; i++)
{
p[i] = i % 3;
}
for (i = 0; i < 10; i++)
{
printf("%4d", p[i]);
}
putchar('\n');
p_queue_t test = NULL;
test = queue_create();
if (NULL == test)
err_exit("create error");
for (i = 0; i < 10; i++)
{
if (queue_insert_minsize(test, p + i, compare) == false)
err_exit("put error");
}
queue_print(test, show);
putchar('\n');
printf("%4d\n", test->size);
printf("%4d\n",*((int *)test->head->data));
printf("%4d\n", *((int *)test->head->next->data));
queue_destroy(test);
putchar('\n');
return 0;
}
void vtimer_print_long_queue(){
queue_print(&longterm_queue_root);
}
/**
* Handler to check user input, and see if it matches any avaible commands.
* Will call the right methods for executing commands
*/
void handle_keyboard(sp_session *session, struct play_queue* node)
{
char buffer[1024];
fgets(buffer, sizeof(buffer), stdin);
strtok(buffer, "\n");
if (strcmp(buffer, "search") == 0) {
player_reset();
run_search(session);
} else if ((strcmp(buffer, "list") == 0) || (strcmp(buffer, "ls") == 0 )) {
print_playlists(session, pc);
} else if(strcmp(buffer, "qshuffle") == 0) {
queue_shuffle();
} else if (strcmp(buffer, "queueadd") == 0) {
sp_playlist* pl = parse_play_command(session, buffer, node);
printf("done finding playlist \n");
if(pl != NULL) printf("queueadd: %s\n", sp_playlist_name(pl));
else {
printf("no playlist\n");
return;
}
int index;
char input[10];
fputs("Song number: ", stdout);
fgets(input, sizeof(input) - 1, stdin);
sscanf(input, "%d", &index);
if(sp_playlist_num_tracks(pl) < index) {
printf("index too high!\n");
return;
}
sp_track* track = pl_find_song_by_id(pl, index);
if(track != NULL) queue_add_first(track);
} else if (strcmp(buffer, "list songs") == 0 ) {
//release all threads
sp_playlist* pl = playlist_find_by_num(session, pc);
print_tracks_in_playlist(session, pl);
} else if (strcmp(buffer, "help") == 0) {
print_commands();
} else if (strcmp(buffer, "queue") == 0) {
queue_print(node);
} else if (strcmp(buffer, "shuffle mode") == 0) {
print_commands();
} else if(strncmp(buffer, "play", strlen("play")) == 0) {
player_reset();
sp_playlist* pl = parse_play_command(session, buffer, node);
if(pl!=NULL) queue_add_playlist(pl);
else {
printf("ERROR playlist is null\n");
return;
}
queue_go_next(session);
} else if(strncmp(buffer, "shuffle", strlen("shuffle")) == 0) {
player_reset();
shuffle_mode = TRUE;
sp_playlist* pl = parse_play_command(session, buffer, node);
if(pl!=NULL) queue_add_playlist(pl);
else {
printf("ERROR playlist is null\n");
return;
}
queue_shuffle();
queue_go_next(session);
} else if(strcmp(buffer, "pause") == 0 || strcmp(buffer, "p") == 0) {
player_pause(session);
play_info();
} else if (strcmp(buffer, "next") == 0 || strcmp(buffer, "n") == 0) {
end_track(session);
} else if (strcmp(buffer, "stop") == 0) {
} else if (strcmp(buffer, "info") == 0) {
play_info();
} else if (strcmp(buffer, "quit") == 0) {
queue_free();
quit_program(session);
} else {
printf("Unkown command!\n");
}
printf("> ");
fflush(stdout);
return;
}
