int main()
{
listInsert(1);
listInsert(1);
listInsert(1);
listInsert(3);
listInsert(3);
listInsert(3);
listInsert(3);
listInsert(3);
listInsert(9);
std::cout << "Inserted elements into list" << std::endl;
Node* curr = head;
while(curr) {
std::cout << " " << curr->value;
curr = curr->next;
}
removeDuplicates();
std::cout << std::endl << "Removed duplicate elements in first list" << std::endl;
curr = head;
while(curr) {
std::cout << " " << curr->value;
curr = curr->next;
}
}
int Graph::MaxFlow(int s, int t)
{
flownode *L;
flownode *itr;
int i, u, oldheight;
//构造每个结点的Neightbour list;
for(u = 0; u < V; ++u)
{
N[u] = new flownode;
N[u]->next = NULL;
}
for(u = 0; u < V; ++u)
{
for(i = 0; i < u; ++i)
if( c[u][i] || c[i][u] )
{
listInsert(N[u],i);
listInsert(N[i],u);
}
}
//构造L
L = new flownode;
L ->next = NULL;
for( i = 0; i < V; ++i)
{
if(i == s || i == t) continue;
listInsert(L,i);
}
//初始化preflow
InitializePreflow(s);
//
for(itr = L; itr->next; itr = itr->next )
{
u = itr->next->adjnum;
oldheight = h[u];
DischargePreflow(u);
if(h[u] > oldheight)
{
listErase(itr);
listInsert(L,u);
itr = L;
}
}
listDestroy(L);
maxflow = 0;
for( itr = N[s]->next; itr; itr = itr->next)
{
if(f[s][itr->adjnum] )
maxflow += f[s][itr->adjnum];
}
neighborDestroy();
return maxflow;
}
void testInserts() {
// Create the list
LList *list = newList( comparisonFunction );
const int numElements = 100;
int prevSize = list->size;
// Insert a bunch of elements into the list
for( int i = 1; i <= numElements; i++ ) {
listInsert( list, mallocInt(i) );
assertTrue( (prevSize + 1) == list->size, "List size should have increased by 1\n" );
prevSize++;
}
// Assert that the right number of elements are present in the list
assertTrue( numElements == list->size, "List should now have %d elements, has %d\n",
numElements, list->size );
// Check that the ordering invariant holds
ListNode *current = list->head;
ComparisonFunction compare = list->comparisonFunction;
int numElementsCompared = 0;
while( current->next != NULL ) {
void *nodeData = current->data;
void *nextNodeData = current->next->data;
// Segfault prevention check
if( nodeData != NULL && nextNodeData != NULL ) {
int comparisonResult = compare(nodeData, nextNodeData);
assertTrue( comparisonResult < 0, "Assert comparisonResult < 0 failed! (Was %d)\n",
comparisonResult );
numElementsCompared++;
}
current = current->next;
}
// Ensure that we made some value comparisons throughout the the loop
assertTrue( numElementsCompared != 0, "Should haven't compared more than 0 elements!\n" );
// Test insert at beginning
listInsert( list, mallocInt( -1 ) );
// Test insert at end
listInsert( list, mallocInt( 1000 ) );
// Free the list
listFree( list );
}
//Initializes Player using starting Values
void initPlayer(Player *p){
*p=(Player){
startSpeedDig,
startSpeedWalk,
startMaxDepth,
startInventorySize,
startMoney
};
listInsert(&p->inventory, &shoesStart);
listInsert(&p->inventory, &pickaxeStart);
listInsert(&p->inventory, &backpackStart);
//Initialize Mineral-Array
memset(p->minerals, 0, sizeof(p->minerals));
}
int in_pcballoc(struct socket *so, struct inpcbinfo *pcbinfo)
{
struct inpcb *inp;
int s;
inp = mb_alloc( sizeof(struct inpcb), MT_PCB, M_DONTWAIT);
if (inp == NULL)
return ENOBUFS;
/* Clear struct */
memset( inp, 0, sizeof(struct inpcb) );
/* Setup struct */
inp->inp_pcbinfo = pcbinfo;
inp->inp_socket = so;
/* Get processor level */
s = splnet();
/* Insert into info list head */
listInsert(pcbinfo->listhead, NULL, &inp->inp_list);
in_pcbinshash(inp);
/* Restore processor level */
splx(s);
/* Setup address */
so->so_pcb = inp;
return 0;
}
int main()
{
struct listItem* start = NULL;
struct listItem* newItem = calloc(1U, sizeof(*newItem));
struct listItem* item1 = calloc(1U, sizeof(*item1));
(*newItem).data = 11; // dereference ptr, to get to listItem struct and access .data element.
(*item1).data = 22;
start = newItem;
printf("&start address in main: %p\n", &start);
printf("start address in main: %p\n", start);
printf("*start address in main: %p\n\n\n", *start);
listInsert(&start, item1);
//listInsert(start, item1);
printf("item1->data: %d\n", item1->data);
struct listItem* current = start;
size_t numberOfElements = 0;
while (current) {
printf("%d\n", (*current).data);
current = (*current).next;
++numberOfElements;
}
printf("numberOfElements: %lu\n", numberOfElements);
}
char * intProccess(char * s) {/*{{{*/
StrInputStream ssin;
// StrOutputStream ssout;
LinkedList * l = createLinkedList(sizeof(int), intGreater);
int x;
initStrInputStream(&ssin, s);
initStrOutputStream(&ssout, 250);
// printf("%d\n", (ssout.length));
while (!sisEof(&ssin)) {
readInt(&ssin, &x);
if (listSearch(l, &x) == l->nil) {
ListNode * a = l->nil->next;
while (a != l->nil && *((int *)(a->key)) < x) {
a = a->next;
}
listInsert(l, a, &x);
}
}
listTravers(l, putInt);
clrListedList(l, NULL);
writeString(&ssout, "\n");
return ssout.begin;
}/*}}}*/
void brelse (
struct buf * bp
) {
LIST *pBufHead = &bp->b_vp->v_mount->mnt_buflist;
if ((bp->b_flags & B_BUSY) == 0) {
#ifdef DIAGNOSTIC
logMsg ("brelse: buffer is not busy",
0, 0, 0, 0, 0, 0);
#endif
return;
}
/* anyone need this very block? */
if (bp->b_flags & B_WANTED) {
bp->b_flags &= ~B_WANTED;
semGive (&bp->b_sem);
}
/* Put buffer at head */
listRemove (pBufHead, &bp->b_node); /* Remove from list */
listInsert (pBufHead, NULL, &bp->b_node); /* Insert at list head */
/* unlock */
bp->b_flags &= ~(B_WANTED | B_BUSY | B_ASYNC);
}
void testRemoval() {
LList *list = newList( comparisonFunction );
const int numElements = 1000;
// Insert elements
for( int i = 0; i < numElements; i++ ) {
listInsert( list, mallocInt(i) );
}
// Remove the elements and ensure that the right elements were removed
for( int i = 0; i < numElements; i++ ) {
int *elementToRemove = mallocInt(i);
int *removedElement = listRemove( list, elementToRemove );
assertNotNull( removedElement, "removedElement is null!\n" );
int comparisonResult = list->comparisonFunction( elementToRemove, removedElement );
assertTrue( comparisonResult == 0, "compare(%d, %d) != 0\n", *elementToRemove,
*removedElement );
free( elementToRemove );
free( removedElement );
}
// Free the list
listFree( list );
}
void testListFind() {
LList *list = newList( comparisonFunction );
const int numElements = 1000;
// Insert the elements
for( int i = 0; i < numElements; i++ ) {
listInsert( list, mallocInt(i) );
}
// Find the elements
for( int i = 0; i < numElements; i++ ) {
int *intToFind = mallocInt(i);
// Ensure that the find didn't return null
ListNode *findResult = listFind( list, intToFind );
assertNotNull( findResult, "find(i) should not be NULL!\n" );
// Ensure that the elements are equal
int comparisonResult = list->comparisonFunction( intToFind, findResult->data );
assertTrue( comparisonResult == 0, "find(%d)->data != %d\n", i, i );
free( intToFind );
}
// Free the list
listFree( list );
}
int buf_wait (
struct buf * bp
) {
LIST *pBufHead = &bp->b_vp->v_mount->mnt_buflist;
/* Make sure I/O is complete */
if ((bp->b_flags & B_DONE) == 0) {
if (bio_wait (bp->b_bio)) {
bp->b_flags |= B_ERROR;
}
buf_done (bp, OK);
}
if ((bp->b_flags & B_ERROR) || bp->b_error) {
if ((bp->b_flags & B_INVAL) == 0) {
bp->b_flags |= B_INVAL;
listRemove (pBufHead, &bp->b_node); /* Remove from list */
listInsert (pBufHead, NULL, &bp->b_node); /* Insert at list head */
}
if (!bp->b_error) {
bp->b_error = EIO;
} else {
bp->b_flags |= B_ERROR;
}
return (bp->b_error);
} else {
return (OK);
}
}
void cmdInsert(heap *ops, bool print)
{
if(print)
printf("String: ");
char *buf = NULL;
list *strbuf = listCreate();
for(;;) {
buf = malloc(sizeof(*buf));
fread(buf, sizeof(*buf), 1, stdin);
if(*buf == '\n')
break;
listInsert(strbuf, buf);
}
free(buf);
int listsize = listSize(strbuf),
i;
buf = malloc(sizeof(char[listsize + 1]));
memset(buf, 0, sizeof(char[listsize + 1]));
for(i = 0, listMoveBack(strbuf);
i < listsize;
i++, listMoveBack(strbuf)) {
char *tmp = listGetCurrent(strbuf);
buf[i] = *tmp;
free(tmp);
}
listFree(strbuf);
hpAdd(ops, buf);
}
void listInsert(struct entityList *list, struct entity ent)
{
if(list->next == NULL){
list->next = (struct entityList*) malloc(sizeof(struct entityList));
}else{
listInsert(list->next, ent);
}
}
void listTest(void)
{
List *list;
int i;
list = createList();
printf("delete when list is empty\n");
listDelete(list, 0);
printf("insert 0\n");
listInsert(list, 0, 0);
listTraverse(list);
printf("delect position:0\n");
listDelete(list, 0);
listTraverse(list);
printf("insert 5 element to list\n");
for(i = 0; i < 5; i++) {
listInsert(list, 5 - i, 0);
}
listTraverse(list);
printf("insert 55 to position 3\n");
listInsert(list, 55, 3);
listTraverse(list);
printf("delete first tree element\n");
for(i = 0; i < 3; i++) {
listDelete(list, 0);
}
listTraverse(list);
printf("delete position 1\n");
listDelete(list, 1);
listTraverse(list);
printf("get position 3\n");
printf("postion 3:%d\n", listGet(list, 3));
destroyList(list);
}
//добавляет узел в конец списка, возвращает указатель на него
//O(1)
ListNode* listPushBack(ListNode** list) {
if(*list)
return listInsert(*list);
//если список пуст, создаём новый список
ListNode* ln = malloc(1);
ln->next = ln->prev = ln;
ln->data = NULL;
*list = ln;
return *list;
}
int main(void) {
unsigned ind;
listInit();
for (ind = 0; ind < MAX; ind++)
listInsert(rand() % (MAX*2), ind);
printf("Списъкът съдържа следните елементи: \n"); listPrint();
printf("\nТестване:\n");
performSearchTest();
printf("Списъкът след търсенето: \n"); listPrint();
return 0;
}
int main(int argc, char* argv[])
{
head_ptr ls_head = (head_ptr)malloc(sizeof(head));
ls_head->head = NULL;
list ele_x1;
ele_x1.key = 1;
list ele_x2;
ele_x2.key = 4;
list ele_x3;
ele_x3.key = 16;
list ele_x4;
ele_x4.key = 9;
listInsert(ls_head, &ele_x1);
listInsert(ls_head, &ele_x2);
listInsert(ls_head, &ele_x3);
listInsert(ls_head, &ele_x4);
printList(ls_head);
list_ptr ele_find = listSearch(ls_head, 4);
if (ele_find != NULL)
printf("find element of key in 4\n");
else
printf("find not element of key in 4\n");
list ele_x5;
ele_x5.key = 25;
listInsert(ls_head, &ele_x5);
printList(ls_head);
if (ele_find != NULL) {
listDelete(ls_head, ele_find);
printList(ls_head);
}
free(ls_head);
ls_head = NULL;
return 0;
}
//Buys an Item, returns true if successful
bool itemBuy(Player *p, Item *i){
//Check if Item is already owned
if(listCount(&p->inventory, i) >= 1 ) return false;
int newmoney = p->money - i->prize;
int newspace = getFreeInvSpace(p) - i->inventorySizeTaken;
if( newmoney >= 0 && newspace >= 0){
p->money = newmoney;
listInsert(&p->inventory, i);
updateItems(p);
return true;
}
return false;
}
/*
* Arrange for <cb> to be called at time <t>, which is the (double precision floating point) number
* of seconds since 00:00:00 UTC on 1970-01-01 (aka. the UNIX epoch). <cb> will be called with the
* given <dis>, <t> and <udata>. You can get the current time using nowd() from utils.c.
*/
void disOnTime(Dispatcher *dis, double t, void (*cb)(Dispatcher *dis, double t, void *udata), const void *udata)
{
DIS_Timer *next_timer, *new_timer = calloc(1, sizeof(DIS_Timer));
new_timer->t = t;
new_timer->cb = cb;
new_timer->udata = udata;
for (next_timer = listHead(&dis->timers); next_timer; next_timer = listNext(next_timer)) {
if (next_timer->t > new_timer->t) break;
}
listInsert(&dis->timers, new_timer, next_timer);
}
// listInsert: insert into a linked list, overwrites duplicate keys
nodeType *listInsert(nodeType *head, unsigned long long int key, unsigned long int value) {
if (!head) {
head = malloc(sizeof(nodeType));
head->key = key;
head->value = value;
head->next = NULL;
}
else if (head->key != key)
head->next = listInsert (head->next, key, value);
else
head->value = value;
return head;
}
/*
* store & intern a prefix, after giving it the
* "xmlns:" prefix. Don't allow storing the same one twice unless 'force'
* is set.
*/
static utf8 storePrefix(genxWriter w, constUtf8 prefix, Boolean force)
{
int high, low;
utf8 * pp = (utf8 *) w->prefixes.pointers;
UTFTYPE buf[1024];
if (prefix[0] == 0)
prefix = (utf8) "xmlns";
else
{
sprintf((char *) buf, "xmlns:%s", prefix);
prefix = buf;
}
high = w->prefixes.count; low = -1;
while (high - low > 1)
{
int probe = (high + low) / 2;
if (strcmp((const char *) prefix, (const char *) pp[probe]) < 0)
high = probe;
else
low = probe;
}
/* already there? */
if (low != -1 && strcmp((const char *) prefix, (const char *) pp[low]) == 0)
{
if (force)
return pp[low];
w->status = GENX_DUPLICATE_PREFIX;
return NULL;
}
/* copy & insert */
if ((prefix = copy(w, prefix)) == NULL)
{
w->status = GENX_ALLOC_FAILED;
return NULL;
}
w->status = listInsert(&w->prefixes, (void *) prefix, high);
if (w->status != GENX_SUCCESS)
return NULL;
return (utf8) prefix;
}
static FIELD* add_world_field(
WORLD *world,
int tx,
int ty,
int tw,
int th
)
{
static int id;
FIELD *field;
int i, j, ie, je;
if (tx < 2 || tx > world->map->w - 2 ||
ty < 2 || ty > world->map->h - 2)
return NULL;
if (tx + tw > world->map->w - 2 ||
ty + th > world->map->h - 2)
return NULL;
field = (FIELD *) malloc( sizeof(FIELD) );
if (field == NULL) {
fprintf(stderr, "Error - Unable to allocate field\n");
exit(1);
}
field->x = tx;
field->y = ty;
field->w = tw;
field->h = th;
field->level = tw * th / 8;
field->id = id++;
listInsert(&world->fieldList, NULL, &field->listNode);
ie = field->x + field->w;
je = field->y + field->h;
for (j = field->y; j < je; j ++)
for (i = field->x; i < ie; i ++)
world->world_map[i + j * world->map->w] = WORLD_FIELD_BLOCK;
return field;
}
struct buf* buf_getblk (
struct vnode * vp,
lblkno_t blkno,
unsigned size
) {
struct buf *bp;
LIST *pBufHead = &vp->v_mount->mnt_buflist;
loop:
if ((bp = buf_incore (vp, blkno)) != NULL) {
if (bp->b_flags & B_BUSY) {
bp->b_flags |= B_WANTED;
semTake (&bp->b_sem, WAIT_FOREVER);
}
bp->b_flags |= (B_BUSY | B_CACHE);
/*
* check for size inconsistancies
*/
if (bp->b_size != size) {
logMsg ("getblk: invalid buffer size: %d\n",
(ARG) bp->b_size,
0, 0, 0, 0, 0);
bp->b_flags |= B_INVAL;
bwrite (bp);
goto loop;
}
} else {
if ((bp = buf_new (vp, blkno)) == NULL) {
logMsg ("buf_getblk: no buffers",
0, 0, 0, 0, 0, 0);
goto loop;
}
bp->b_dev = vp->v_mount->mnt_dev;
bp->b_lblkno = blkno;
bp->b_vp = vp;
bio_new (bp);
/* Put buffer at head */
listRemove (pBufHead, &bp->b_node);
listInsert (pBufHead, NULL, &bp->b_node);
}
return (bp);
}
int main(int argc, char *argv[])
{
pthread_t the_reader[READERS];
int i, random;
time_t start_time, end_time;
// initialize the counters
found = 0;
not_found = 0;
// record the start time
start_time = time(NULL);
// initialize the concurrent list
listInit(&the_list);
// create the reader threads
for (i = 0; i < READERS; i++)
{
pthread_create(&the_reader[i], NULL, reader, NULL);
}
// start writing to the list
for (i = 0; i < NUMWRITES; i++)
{
random = randInt(KEYMIN,KEYMAX);
listInsert(&the_list, random, random);
}
// wait for the reader threads
for (i = 0; i < READERS; i++)
{
pthread_join(the_reader[i], NULL);
}
// print the time taken and the counter values
end_time = time(NULL);
printf("%d items were found. %d items were not found.\n\tTime taken: %d seconds.", found, not_found, end_time-start_time);
printf("\nEnd of processing\n");
return 0;
} /* end main */
void parseSection(MFILE *mfout, const char *params)
{
char *name=(char*)params, *comment=strchr(params, ' '), *cend;
if(secakt!=NULL)
mfprintf(mfout, "\n\";\n");
if(comment!=NULL) {
*comment=0;
comment++;
if(comment[0]!=0 && comment[0]!='\'')
pexit("Section-Comment not started with ' - exiting\n", params);
comment++;
cend=strchr(comment, '\'');
if(cend==NULL) pexit("Section-Comment not ended with ' - exiting\n", params);
*cend=0;
}
secakt=listInsert(name, comment);
mfprintf(mfout, "\nconst char %s[]=\"", name);
}
int main(int argc, char **argv) {
//Establish anything we'll need constantly.
int mode = 1;//Start in sequential mode.
int usepath = 0;//does our path file exist?
int futuremode = mode;//This keeps track of mode changes until the end of the line.
int printPrompt = 0;
char *prompt = "s-term> ";//The prompt string.
printf("%s", prompt);//Print the prompt.
fflush(stdout);
//do pathstuff
char **paths = readFile("shell-config");
if(paths != NULL){
usepath = 1;
}
char **firststep = NULL;//The array of commands made by splitting the buffer along semicolons.
char ***secondstep = NULL;//The array of commands, with each command split along whitespace into its arguments.
struct node *head = NULL;//The head of the linked list of ongoing jobs.
char buffer[1024];//The buffer.
while (1) {//
struct pollfd pfd = {0, POLLIN};
if(printPrompt){
//Need to reprint the prompt.
printf("%s",prompt);
fflush(stdout);
printPrompt = 0;
}
int rv = poll(&pfd, 1, 1000);
if (rv==0){
//No change, use time to do other tasks
struct node *anode = head;
while(anode != NULL){
int pstatus = 0;
int pstate = waitpid((*anode).pid,&pstatus,WNOHANG);
if(pstate>0){
//Process has returned; print confirmation message and delete this node.
printf("Command %s, id %i was executed.\n",(*anode).command, anode->pid);
anode = (*anode).next;
listDelete(pstate, &head);
printPrompt = 1;
} else if(pstate<0){
//Error in waitpid, print error message and break from while loop.
printf("Error retrieving process status.\n");
break;
} else{
//Process has not returned.
anode = (*anode).next;
}
}
} else if (rv < 0){
//Poll went horribly wrong and we're bailing out of the flaming wreckage, screaming at the tops of our lungs.
printf("Polling error; shutting the (s)hell down.");
} else {
//Keyboard I/O
if(fgets(buffer, 1024, stdin) != NULL){
mode = futuremode;//Ensure that mode is up-to-date.
//Remove any comments after a hash.
removeComment(buffer);
//Tokenize buffer by semicolons- each will be an executable command.
firststep = tokenify(buffer,";");
secondstep = tokenify2(firststep," \t\n");
//Free firststep, as it is no longer needed. Free the sub-arrays first, then the array proper.
freeAll1(firststep);
free(firststep);
int j = 0;
int futureExit = 0;
int status = 0;
pid_t p = 1;
//Execute all commands in a loop.
while(secondstep[j] != NULL && secondstep[j][0] != NULL){
//check for the special commands mode or exit. If neither of these, fork and execv.
if(!strcasecmp(secondstep[j][0],"exit")){
int canwequit = 1;
struct node *tmp = head;
while(tmp != NULL){
if(tmp->state != 1){
canwequit = 0;
}
tmp = tmp->next;
}
if (canwequit){
futureExit = 1;//Will be checked at the end of the loop.
} else {
printf("Error: Jobs are currently running. Please wait for tasks to finish before exiting.\n");
}
}
else if(!strcasecmp(secondstep[j][0],"pause")){
setState(atoi(secondstep[j][1]), 1, head);
if(kill(atoi(secondstep[j][1]), SIGSTOP) != -1){
printf("Paused process %i\n",atoi(secondstep[j][1]));
}
else{
printf("Something went terribly wrong\n");
}
}
else if(!strcasecmp(secondstep[j][0],"resume")){
setState(atoi(secondstep[j][1]), 0, head);
if(kill(atoi(secondstep[j][1]), SIGCONT) != -1){
printf("Resumed process %i\n",atoi(secondstep[j][1]));
}
}
else if(!strcasecmp(secondstep[j][0],"jobs")){
struct node *tmp = head;
printf("\npid cmd paused\n");
while(tmp != NULL){
printf("%i %s %i\n",tmp->pid,tmp->command,tmp->state);
tmp = tmp->next;
}
}
/*else if(!strcasecmp(secondstep[j][0],"path")&& !strcasecmp(secondstep[j][1],"refresh")){
if(paths != NULL){
freeAll1(paths);
free(paths);
}
//do pathstuff
char **paths = readFile("shell-config");
if(paths == NULL){
usepath = 0;
}else{
usepath = 1;
}
}*/
else if(!strcasecmp(secondstep[j][0],"MODE")){
if(secondstep[j][1] == NULL){
if(mode == 0){
printf("\nCurrent mode is parallel\n");
}
else {
printf("\nCurrent mode is sequential\n");
}
}
else if(!strcasecmp(secondstep[j][1],"PARALLEL") || !strcasecmp(secondstep[j][1],"p")){
futuremode = 0;
}
else if(!strcasecmp(secondstep[j][1],"SEQUENTIAL") || !strcasecmp(secondstep[j][1],"s")){
futuremode = 1;
}
else {
//Bullshit users with their bullshit commands - throw an error.
printf("\nError: Your command was pretty awful.\n");
}
}
else{
//Fork and execute/wait depending on process id.
p = fork();
if (p == 0){
break;//Child processes handled outside the while loop.
}
if(mode==1){//Sequential mode.
wait(&status);
//Do something with childp; error checking, probably
} else {//Parallel mode; add this to the list
listInsert(p, secondstep[j][0], 0, &head);
}
}
j++;
}
if (p == 0){
if(usepath==1){
int k = 0;
while(paths[k] != NULL){
struct stat sr;
char tempbuffer[1024];
strcpy(tempbuffer, paths[k]);
strcat(tempbuffer, "/");
strcat(tempbuffer, secondstep[j][0]);
int rv = stat(tempbuffer, &sr);
if (rv < 0){
k++;
}
else{
secondstep[j][0]=tempbuffer;
if(execv(secondstep[j][0],secondstep[j])<0){
exit(0);
}
}
}
}
//Execv for an actual, non-hardcoded command.
printf("\n%s\n",secondstep[j][0]);
if(execv(secondstep[j][0],secondstep[j])<0){
fprintf(stderr, "Your command failed, and here's why you're a bad person: %s\n", strerror(errno));
}
exit(0);//Close out the child process corpse.
}
//check if there was an exit command earlier
if(futureExit == 1){
break;
}
//If we don't exit, free current buffer
freeAll2(secondstep);
free(secondstep);
//Make sure firststep and secondstep have an assigned value in case of early termination.
firststep = NULL;
secondstep = NULL;
printf("%s", prompt);
fflush(stdout);
}
if(feof(stdin)){
break;//End of file or Ctrl+D
}
}
}
//on a quit, flush our command array if it's not null already
if(secondstep != NULL){
freeAll2(secondstep);
free(secondstep);
}
//Free the paths array as well.
if(paths!=NULL){
freeAll1(paths);
free(paths);
}
//Check time spent in user mode and kernel mode. Right now I've got it separated by shell and processes, but we can add it together later.
int idParent = RUSAGE_SELF;
int idChild = RUSAGE_CHILDREN;
int statParent = 0;
int statChildren = 0;
struct rusage dataParent;
struct rusage dataChildren;
statParent = getrusage(idParent, &dataParent);
statChildren = getrusage(idChild, &dataChildren);
if(!statParent){//If the getrvalue operation was a success
printf("Shell time in user mode: %ld.%06ld seconds.\n", dataParent.ru_utime.tv_sec, dataParent.ru_utime.tv_usec);
printf("Shell time in kernel mode: %ld.%06ld seconds. \n", dataParent.ru_stime.tv_sec, dataParent.ru_stime.tv_usec);
}
if(!statChildren){
printf("Process time in user mode: %ld.%06ld seconds. \n", dataChildren.ru_utime.tv_sec, dataChildren.ru_utime.tv_usec);
printf("Process time in kernel mode: %ld.%06ld seconds. \n", dataChildren.ru_stime.tv_sec, dataChildren.ru_stime.tv_usec);
}
exit(0);
//Ctrl+D will drop you down here; need to make sure any cleanup also happens here too.
return 0;
}
int main(void)
{
const int N = 10;
int i, isFound, action, pos, arg;
List list;
Iterator it;
listCreate(&list, N);
do
{
printf("Меню:\n");
printf("1) Вставить элемент\n");
printf("2) Удалить элемент\n");
printf("3) Печать списка\n");
printf("4) Размер списка\n");
printf("5) Выполнить задание над списком\n");
printf("6) Выход\n");
printf("Выберите действие: ");
scanf("%d", &action);
switch (action)
{
case 1:
{
printf("Введите позицию элемента: ");
scanf("%d", &pos);
printf("Введите значение элемента (1 - true, 0 - false): ");
scanf("%d", &arg);
if (arg != 0 && arg != 1)
printf("Ошибка. Введено недопустимое значение\n");
else
listInsert(&list, pos - 1, arg);
break;
}
case 2:
{
printf("Введите номер элемента: ");
scanf("%d", &pos);
listRemove(&list, pos - 1);
break;
}
case 3:
{
listPrint(&list);
break;
}
case 4:
{
printf("Длина списка: %d\n", listSize(&list));
break;
}
case 5:
{
printf("Введите значение: ");
scanf("%d", &arg);
if (arg != 0 && arg != 1)
printf("Ошибка. Введено недопустимое значение\n");
else
{
it = itFirst(&list);
isFound = 0;
for (i = 0; i < listSize(&list); i++)
{
if (itFetch(&it) == arg)
{
while (!listEmpty(&list))
listRemove(&list, 0);
isFound = 1;
break;
}
itNext(&it);
}
if (isFound)
printf("Список был очищен, так как в нем было найдено введенное значение\n");
else
printf("Список не был очищен, так как в нем не найдено введенное значение\n");
}
break;
}
case 6: break;
default:
{
printf("Ошибка. Такого пункта меню не существует\n");
break;
}
}
}
while (action != 6);
listDestroy(&list);
return 0;
}
void hashTableInsert(hashTableType *table, handType *hand, unsigned long int response) {
int index = handToIndex(hand);
unsigned long long int key = handToKey(hand);
table->heads[index] = listInsert(table->heads[index], key, response);
}
int main(int argc, char *argv[])
{
List list;
Data *data[6];
int i, errors = 0;
for (i = 0; i < 6; i++) {
data[i] = calloc(1, sizeof(Data));
}
listInitialize(&list);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
listAppendTail(&list, data[0]);
listAppendTail(&list, data[1]);
listAppendTail(&list, data[2]);
listAppendTail(&list, data[3]);
TEST_INT(listLength(&list), 4);
TEST_INT(listIsEmpty(&list), FALSE);
TEST_PTR(listHead(&list), data[0]);
TEST_PTR(listTail(&list), data[3]);
TEST_PTR(listNext(data[0]), data[1]);
TEST_PTR(listNext(data[1]), data[2]);
TEST_PTR(listNext(data[2]), data[3]);
TEST_PTR(listNext(data[3]), NULL);
TEST_PTR(listPrev(data[3]), data[2]);
TEST_PTR(listPrev(data[2]), data[1]);
TEST_PTR(listPrev(data[1]), data[0]);
TEST_PTR(listPrev(data[0]), NULL);
TEST_PTR(listContaining(data[0]), &list);
TEST_PTR(listContaining(data[1]), &list);
TEST_PTR(listContaining(data[2]), &list);
TEST_PTR(listContaining(data[3]), &list);
listRemove(&list, data[0]);
listRemove(&list, data[1]);
listRemove(&list, data[2]);
listRemove(&list, data[3]);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
TEST_PTR(listContaining(data[0]), NULL);
TEST_PTR(listContaining(data[1]), NULL);
TEST_PTR(listContaining(data[2]), NULL);
TEST_PTR(listContaining(data[3]), NULL);
listInsertHead(&list, data[3]);
listInsertHead(&list, data[2]);
listInsertHead(&list, data[1]);
listInsertHead(&list, data[0]);
TEST_INT(listLength(&list), 4);
TEST_INT(listIsEmpty(&list), FALSE);
TEST_PTR(listHead(&list), data[0]);
TEST_PTR(listTail(&list), data[3]);
TEST_PTR(listNext(data[0]), data[1]);
TEST_PTR(listNext(data[1]), data[2]);
TEST_PTR(listNext(data[2]), data[3]);
TEST_PTR(listNext(data[3]), NULL);
TEST_PTR(listPrev(data[3]), data[2]);
TEST_PTR(listPrev(data[2]), data[1]);
TEST_PTR(listPrev(data[1]), data[0]);
TEST_PTR(listPrev(data[0]), NULL);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveTail(&list), data[3]);
TEST_PTR(listRemoveTail(&list), data[2]);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
listAppendTail(&list, data[0]);
listAppendTail(&list, data[3]);
listAppend(&list, data[1], data[0]);
listInsert(&list, data[2], data[3]);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveTail(&list), data[3]);
TEST_PTR(listRemoveTail(&list), data[2]);
data[0]->i = 3;
data[1]->i = 4;
data[2]->i = 5;
data[3]->i = 1;
data[4]->i = 2;
data[5]->i = 3;
listAppendTail(&list, data[0]);
listAppendTail(&list, data[1]);
listAppendTail(&list, data[2]);
listAppendTail(&list, data[3]);
listAppendTail(&list, data[4]);
listAppendTail(&list, data[5]);
listSort(&list, cmp);
TEST_PTR(listRemoveHead(&list), data[3]);
TEST_PTR(listRemoveHead(&list), data[4]);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[5]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveHead(&list), data[2]);
exit(errors);
}
/*
* internal declare-attribute. This one allows colonized values for
* names, so that you can declare xmlns:-type attributes
*/
static genxAttribute declareAttribute(genxWriter w, genxNamespace ns,
constUtf8 name, constUtf8 valuestr,
genxStatus * statusP)
{
int high, low;
genxAttribute * aa = (genxAttribute *) w->attributes.pointers;
genxAttribute a;
w->arec.ns = ns;
w->arec.name = (utf8) name;
if (ns)
w->arec.atype = ATTR_PREFIXED;
else if (strncmp((const char *) name, "xmlns", STRLEN_XMLNS_COLON - 1) == 0)
w->arec.atype = ATTR_NSDECL;
else
w->arec.atype = ATTR_NAKED;
if (ns && (ns->defaultDecl == w->xmlnsEquals))
{
w->status = GENX_ATTRIBUTE_IN_DEFAULT_NAMESPACE;
goto busted;
}
/* attribute list has to be kept sorted per c14n rules */
high = w->attributes.count; low = -1;
while (high - low > 1)
{
int probe = (high + low) / 2;
if (orderAttributes(&w->arec, aa[probe]) < 0)
high = probe;
else
low = probe;
}
/* if it was already there */
if (low != -1 && orderAttributes(&w->arec, aa[low]) == 0)
return aa[low];
/* not there, build it */
a = (genxAttribute) allocate(w, sizeof(struct genxAttribute_rec));
if (a == NULL)
{
w->status = GENX_ALLOC_FAILED;
goto busted;
}
a->writer = w;
a->ns = ns;
a->provided = False;
a->atype = w->arec.atype;
if ((a->name = copy(w, name)) == NULL)
{
w->status = GENX_ALLOC_FAILED;
goto busted;
}
if ((w->status = initCollector(w, &a->value)) != GENX_SUCCESS)
goto busted;
if (valuestr)
if ((w->status = collectString(w, &a->value, valuestr)) != GENX_SUCCESS)
goto busted;
w->status = listInsert(&w->attributes, a, high);
if (w->status != GENX_SUCCESS)
goto busted;
*statusP = GENX_SUCCESS;
return a;
busted:
*statusP = w->status;
return NULL;
}
