예제 #1
0
/**************************************************************************
                        v m C r e a t e
** Creates a virtual machine either from scratch (if pVM is NULL on entry)
** or by resizing and reinitializing an existing VM to the specified stack
** sizes.
**************************************************************************/
FICL_VM *vmCreate(FICL_VM *pVM, unsigned nPStack, unsigned nRStack)
{
    if (pVM == NULL)
    {
        pVM = (FICL_VM *)ficlMalloc(sizeof (FICL_VM));
        assert (pVM);
        memset(pVM, 0, sizeof (FICL_VM));
    }

    if (pVM->pStack)
        stackDelete(pVM->pStack);
    pVM->pStack = stackCreate(nPStack);

    if (pVM->rStack)
        stackDelete(pVM->rStack);
    pVM->rStack = stackCreate(nRStack);

#if FICL_WANT_FLOAT
    if (pVM->fStack)
        stackDelete(pVM->fStack);
    pVM->fStack = stackCreate(nPStack);
#endif

    pVM->textOut = ficlTextOut;

    vmReset(pVM);
    return pVM;
}
void test1( int* pfailed)
{
  stack_t myStack;
  char* scenario;
  int ret;
  *pfailed = 0;
  ret = stackCreate( NULL, 0 );   scenario = "creating an empty stack must fail\n";
  checkResult( 0, (ret == -1), pfailed, scenario );
  ret = stackCreate( &myStack, 0 );  scenario = "creating a stack of no length must fail\n";
  checkResult( 1, (ret == -1), pfailed, scenario );
  ret = stackCreate( &myStack, 65536 );  scenario = "creating a very big stack must fail\n";
  checkResult( 2, (ret == -1), pfailed, scenario );
  ret = stackCreate( &myStack, 1024 );  scenario = "creating the max-size stack must succeed\n";
  checkResult( 3, (ret == 0), pfailed, scenario );
  scenario = "status of the newly-created stack\n";
  checkResult( 4, (myStack.state == STACK_CREATED), pfailed, scenario );
  scenario = "new stack's index must be at the beginning\n";
  checkResult( 5, (myStack.index == 0), pfailed, scenario );
  scenario = "top element OK\n";
  checkResult( 6, (myStack.max == 1024), pfailed, scenario );
  scenario = "stack is non-empty\n";
  checkResult( 7, (myStack.storage != (int *)0), pfailed, scenario );
  ret = stackDestroy( NULL );  scenario = "destroying an empty stack must fail\n";
  checkResult( 8, (ret == -1), pfailed, scenario );
  ret = stackDestroy( &myStack );  scenario = "destroying the non-empty stack should be OK\n";
  checkResult( 9, (ret == 0), pfailed, scenario );
  scenario = "The destroyed stack should be in a non-created state\n";
  checkResult( 10, (myStack.state != STACK_CREATED), pfailed, scenario );
  if (*pfailed == 0) printf( "test1 passed.\n");  /* all 10 test cases succeeded ? */
  else printf("test1 failed\n");
}
queue_t * queueCreate(int slots){

	queue_t * queue=malloc(sizeof(queue_t));

	STACK stack1=stackCreate(slots);
	STACK stack2=stackCreate(slots);
	(queue->s1)=stack1;
	(queue->s2)=stack2;

	return queue;
}
예제 #4
0
void __CUT_BRINGUP__Explode(void)
{
	int ret;
	printf("Stack test bringup called\n");

	ret = stackCreate(&myStack_1, 5);
	ASSERT((ret == 0), "Stack 1 creation.");

	ret = stackCreate(&myStack_2, 5);
	ASSERT((ret == 0), "Stack 2 creation.");
}
예제 #5
0
void main(void) 
{
    int k;
    Queue* q = qCreate(10);
    for (int i = 0; i < 16; ++i) {
        qEnqueue(q, i);
    }
    while (!qEmpty(q)) {
        printf("%d ", qDequeue(q));
        printf(" (size left = %d)\n",  qSize(q));
    }
    for (int i = 0; i < 16; ++i) {
        qEnqueue(q, i);
        printf("(size = %d)\n",  qSize(q));
    }

    Stack s;
    stackCreate(&s, 128);

    for (int i = 0; i < 255; ++i) {
        stackPush(&s, i);
    }

    while (!stackEmpty(&s)) {
        printf("%d ", stackTop(&s));
        stackPop(&s);
    }
}
예제 #6
0
파일: test.c 프로젝트: nolink/algorithm
void RBDestroy(RBTree* tree){

  Stack* stack = (Stack*)malloc(sizeof(Stack));
  stackCreate(stack, 16);

  RBNode* current = tree->nil;
  do{
    if(!stackEmpty(stack)){
        current = stackTop(stack);
        stackPop(stack);
    }else{
        current = tree->root;
    }
    if(current->right != tree->nil){
        stackPush(stack, current->right);
    }
    if(current->left != tree->nil){
        stackPush(stack, current->left);
    }
    free(current);
  }while(!stackEmpty(stack));
  
  stackDestroy(stack);
  free(stack);

  free(tree->root);
  free(tree->nil);
  free(tree);
}
예제 #7
0
void
test_flush_stack_empty() {
	stack *stack = stackCreate();

	stack = stackFlush(stack);

	CU_ASSERT_EQUAL(stack -> size, 0);
}
예제 #8
0
void
test_pop_stack_empty() {
	stack *stack = stackCreate();

	int *poppedValue = (int*)stackPop(stack);

	CU_ASSERT_EQUAL(stack -> size, 0);
	CU_ASSERT_PTR_NULL(poppedValue);
}
예제 #9
0
void
test_peek_stack_empty() {
	stack *stack = stackCreate();

	int *position1 = stackPeek(stack);
	
	CU_ASSERT_EQUAL(stack -> size, 0);
	CU_ASSERT_PTR_NULL(position1);
}
char * Reverse(char * array){
	int i;

	size_t len = strlen(array);
	STACK Stack1=(STACK)stackCreate(100);
	for(i = 0; i <len; i++)
		stackPush(Stack1,array[i]);
	for(i = 0; i <len; i++)
		stackPop(Stack1,&(array[i]));
	
	return array;
}
예제 #11
0
파일: gc.c 프로젝트: lborwell/gc
/*
* RUN THE COLLECTOR
* args
* Stack* s -- local variable stack
* heap** h -- current (pointer to pointer to) from-space
* int bd -- are we collecting BigData heap? (bool: 0 false, otherwise true)
*/
void collect(Stack* s, heap** h, int bd){
    heap* to = heapCreate();
    weakptrs = stackCreate();

    // If stack is empty, return empty heap
    if(!s){ 
        *h = to;
        return; 
    }

    //evacuate things pointed to from the stack, update stack references
    do{
        s->data = evac(s->data, *h, to);
    }while(s=s->next);

    // if collecting bigdata heap, no need to scavenge
    if(bd){
        *h = to;
        return;
    }

    //scavenge the to-space
    scavenge(*h,to);

    /*
    * Check weak pointer references. If data is already forwarded, we know
    * it's got another reference -- copy the forwarding pointer loc.
    * Otherwise, we collect the data.
    */
    int i;
    while((i = pop(&weakptrs)) != -1){
        if((*h)->heap[to->heap[i+1]] == FWD)
            to->heap[i+1] = (*h)->heap[to->heap[i+1]+1];
        else
            to->heap[i+1] = -1;
    }

    //Change reference of from-space to to-space
    free(*h);
    *h = to;

    //collect big data heap
    if(!(collectioncount % BIGDATACOLLECT)){
        if(!bigdataindex) return;

        collect(bigdataindex, &bigdataheap, 1);
        Stack* bdi = bigdataindex;
        do{
            (*h)->heap[bdi->bdloc] = bdi->data;
        }while(bdi=bdi->next);
    }
}
예제 #12
0
int main(void){
		
	int i;
	
	struct node *top;
	struct node *top2;
	//create two stack
	stackCreate(&top);
	stackCreate(&top2);
	
	//push data to stack
	stackPush(&top,3);	
	stackPush(&top,5);
	stackPush(&top,7);
	stackPush(&top,9);
	
	for(i=0;i<4;i++)
	printf("%d\n",stackPop(&top,&top2)); //to pop top element
	

return 0;
}
예제 #13
0
void
test_push_stack_empty() {
	stack *stack = stackCreate();

	int pageNumber = 394;
	
	stackPush(stack, &pageNumber);

	int *tail = (int*)stack -> array -> array[0];

	CU_ASSERT_EQUAL(stack -> size, 1);
	CU_ASSERT_PTR_EQUAL(tail, &pageNumber);
}
예제 #14
0
파일: Stack.c 프로젝트: yenng/Stack
StackElement *stackRemove(Stack *stack){
  if (stack->head == NULL){
    stack = stackCreate();
    stack->length --;
  }
  else{
    stack->head = stack->head->next;
    stack->length --;
    if (stack->head == NULL){
      stack->tail = NULL;
      stack->length = 0;
    }
  }
}
int main()
{
  int failed = 0;
  test1(&failed);
  stack_t anotherstack;
  int stackElem;
  int result = stackCreate( &anotherstack, 8 );
  if(result == 0)
    for(int i=10; i < 50; i+=10)
      stackPush(&anotherstack, i);
  while( stackPop(&anotherstack, &stackElem) == 0 ){
      printf(" Poped out element : %d \n",stackElem);
  }
  return 0;
}
STACK queueToStack(queue_t * queue){

STACK stack=stackCreate(queue->s1->cap);
int i=0;
int in=(queue->s1->index)-1;
DATA_TYPE data[queue->s1->cap];
while(dequeue(queue,&data[i])){
i++;
}

while(stackPush(stack,data[in])){
in--;
if(in==-1) break;
}
	return stack;
}
예제 #17
0
void
test_peek_stack_filled() {
	stack *stack = stackCreate();

	int value1 = 3;
	int value2 = 2;
	int value3 = 1;

	stack = stackPush(stack, &value1);
	stack = stackPush(stack, &value2);
	stack = stackPush(stack, &value3);

	int *position3 = stackPeek(stack);

	CU_ASSERT_EQUAL(stack -> size, 3);
	CU_ASSERT_PTR_EQUAL(position3, &value3);
}
예제 #18
0
void test_pop_stack_filled() {
	stack *stack = stackCreate();
	
	int value1 = 3;
	int value2 = 2;
	int value3 = 1;

	stack = stackPush(stack, &value1);
	stack = stackPush(stack, &value2);
	stack = stackPush(stack, &value3);

	CU_ASSERT_EQUAL(stack -> size, 3);
	CU_ASSERT_PTR_EQUAL((int*)stackPop(stack), &value3);
	CU_ASSERT_PTR_EQUAL(stackPop(stack), &value2);
	CU_ASSERT_PTR_EQUAL(stackPop(stack), &value1);
	// Now that we've popped off all values, we need to see if the size has been
	// updated correctly
	CU_ASSERT_EQUAL(stack -> size, 0);
}
예제 #19
0
void
test_flush_stack_filled() {
	stack *stack = stackCreate();

	int value1 = 1;
	int value2 = 2;
	int value3 = 3;

	stack = stackPush(stack, &value1);
	stack = stackPush(stack, &value2);
	stack = stackPush(stack, &value3);

	stack = stackFlush(stack);

	int *position1 = (int*)stackPop(stack);

	CU_ASSERT_PTR_NOT_NULL(stack);
	CU_ASSERT_EQUAL(stack -> size, 0);
	CU_ASSERT_PTR_NULL(position1);
}
예제 #20
0
void 
test_push_stack_filled() {
	stack *stack = stackCreate();
	
	int value1 = 3;
	int value2 = 2;
	int value3 = 1;

	stack = stackPush(stack, &value1);
	stack = stackPush(stack, &value2);
	stack = stackPush(stack, &value3);

	CU_ASSERT_EQUAL(stack -> size, 3);

	int *position1 = (int*) stack -> array -> array[2];
	int *position2 = (int*) stack -> array -> array[1];
	int *position3 = (int*) stack -> array -> array[0];

	CU_ASSERT_PTR_EQUAL(position1, &value3);
	CU_ASSERT_EQUAL(position2, &value2);
	CU_ASSERT_EQUAL(position3, &value1);
}
예제 #21
0
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    
    *returnSize = 0;
    if(NULL == root){
        return NULL;
    }
    
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    stackCreate(stack, 16);
    
    int* result = (int*)malloc(sizeof(int)*16);
    
    struct TreeNode* current = NULL;
    do{
        if(!stackEmpty(stack)){
            current = stackTop(stack);
            stackPop(stack);
        }else{
            current = root;
        }
        result[*returnSize] = current->val;
        *returnSize = *returnSize + 1;
        if(*returnSize > 16){
        	result = (int*)realloc(result, sizeof(int)*(*returnSize+16));
        }
        if(current->right){
            stackPush(stack, current->right);
        }
        if(current->left){
            stackPush(stack, current->left);
        }
    }while(!stackEmpty(stack));
    
    stackDestroy(stack);
    free(stack);
    return result;
}
예제 #22
0
파일: testgc.c 프로젝트: lborwell/gc
Test* test1(){
	Test* t = malloc(sizeof(Test));

    t->s = stackCreate();
    push(&(t->s),24);
    push(&(t->s),13);
    push(&(t->s),0);

    collectioncount = 2;
    int data[] = { 2,4,28 };
    int bigdata[] = { 3,1,19,21,6 };
    int range[] = { 0,32 };
    int lambda[] = { 8,1,6 };
    int phantom[] = { 4,0 };
    int* soft = malloc(sizeof(int));
    *soft = 0;
    int* weak = malloc(sizeof(int));
    *weak = 2;

    //build test heap
    t->h = initHeaps();
    heap* h = t->h;
    heapAdd(h,INT,inn);
    heapAdd(h,BOOL,boo);
    heapAdd(h,WEAK,weak);
    heapAdd(h,STRING,str);
    heapAdd(h,BIGDATA,bigdata);
    heapAdd(h,LAMBDA,lambda);
    heapAdd(h,INT,inn);
    heapAdd(h,RANGE,range);
    heapAdd(h,DATA,data);
    heapAdd(h,SOFT,soft);
    heapAdd(h,BIGDATA,bigdata);
    heapAdd(h,PHANTOM,phantom);

    return t;
}
예제 #23
0
int main(int argc, char *argv[]){

	char path[20];
	char buf[0];
	char flake;
	int fd;
	int n;
	stackNode *top;
	stackCreate(&top);

	if(!argv[1])
		strcpy(path,"data");
	else
		strcpy(path,argv[1]);

	fd = open(path, O_RDONLY, S_IRWXU);
	while((n = read(fd, buf, BUFFER_SIZE)) > 0){
		flake = buf[0];
		stackPush(&top,flake);					
	}
	//stackDisplay(&top);
	parse(&top);
	//	if(write(1, buf, n) != n )
	//		printf("Write Error");
	if(n < 0)
		printf("Read Error \n");








return 0;
}
예제 #24
0
#include "../Catch/include/catch.hpp"
#include "stack.h"
#include "Macro.h"

TEST_CASE("Stack test", "[stack]")
{
    typedef long type_for_test_t;
    type_for_test_t testElements[] = { -1, 30, 60, 120, -50 };

    // Test "create"
    auto stack = stackCreate(sizeof(type_for_test_t));
    REQUIRE(stack);

    // Test "push"
    for (auto &testElement : testElements) {
        bool status = false;
        CHECK_NOTHROW(status = stackPush(stack, &testElement));
        CHECK(status);
    }

    // Check "size"
    CHECK(stackSize(stack) == STATIC_ARRAY_ITEMS_COUNT(testElements));

    // Test "pop" and "top"
    for (int i = STATIC_ARRAY_ITEMS_COUNT(testElements) - 1; i >= 0; -- i) {
        CHECK(*static_cast<type_for_test_t *>(stackTop(stack)) == testElements[i]);
        bool status = false;
        CHECK_NOTHROW(status = stackPop(stack));
        CHECK(status);
    }
예제 #25
0
파일: lab24_var18.c 프로젝트: BlagoProg/MAI
int main(void)
{
	int action;
	char expr[255];
	Node *root = NULL, *root2 = NULL;
	Stack stPost;

	while (1)
	{
		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("%s", expr);

				treeDestroy(&root);
				treeDestroy(&root2);
				stackCreate(&stPost);
				postOrder(expr, &stPost);
				treeBuild(&root, &stPost);
				stackDestroy(&stPost);
				
				root2 = treeCopy(&root);
				
				treeMoveMinus(&root2);

				break;
			}

			case 2:
			{
				printf("Исходное выражение: %s\n", expr);

				break;
			}

			case 3:
			{
				LKP(&root2);
				printf("\n");

				break;
			}

			case 4:
			{
				if (root != NULL)
				{
					printf("Дерево исходного выражения\n");
					PKL(&root, 0);
				}
				else
					printf("Дерево исходного выражения пусто\n");

				break;
			}

			case 5:
			{
				if (root2 != NULL)
				{
					printf("Дерево преобразованного выражения\n");
					PKL(&root2, 0);
				}
				else
					printf("Дерево преобразованного выражения пусто\n");

				break;
			}

			case 6: break;

			default:
			{
				printf("Ошибка. Такого пункта меню не существует\n");

				break;
			}
		}

		if (action == 6)
			break;
	}

	treeDestroy(&root);
	treeDestroy(&root2);

	return 0;	
}
예제 #26
0
파일: lab24_var18.c 프로젝트: BlagoProg/MAI
void postOrder(const char *str, Stack *st)
{
	int i = 0, isBracket = 0;
	char tmpCh;
	Token tk;
	Stack stOp;

	stackCreate(&stOp);

	tk._varOp = '\0';
	tk._num = 0;

	while (str[i] != '\0')
	{
		if (isLetter(str[i]))
		{
			tk._varOp = str[i];

			stackPush(st, tk);
		}
		else if (isNumber(str[i]))
		{
			tk._varOp = '\0';
			tk._num = tk._num * 10 + str[i] - '0';

			if (str[i + 1] != '.' && !isNumber(str[i + 1]))
			{
				stackPush(st, tk);

				tk._num = 0;
			}
		}
		else if (isOp(str[i]))
		{
			tk._varOp = str[i];

			if (str[i] == ')')
				isBracket = 1;
			else if (str[i] == '-' && (i == 0 || str[i - 1] == '('))
			{
				tmpCh = tk._varOp;
				tk._varOp = '\0';
				tk._num = 0;

				stackPush(st, tk);

				tk._varOp = tmpCh;
			}

			while (!stackEmpty(&stOp) && (isOpHigh(stackTop(&stOp)._varOp, str[i]) || isBracket))
			{
				if (stackTop(&stOp)._varOp == '(')
					isBracket = 0;
				else
					stackPush(st, stackTop(&stOp));

				stackPop(&stOp);
			}

			if (str[i] != ')')
				stackPush(&stOp, tk);
		}

		i++;
	}

	while (!stackEmpty(&stOp))
	{
		stackPush(st, stackTop(&stOp));
		stackPop(&stOp);
	}

	stackDestroy(&stOp);
}
예제 #27
0
파일: heap.c 프로젝트: lborwell/gc
/*
* Create heaps
*/
heap* initHeaps(){
    dataConsCreate();
    bigdataHeapCreate();
    bigdataindex = stackCreate();
    return heapCreate();
}
예제 #28
0
void
test_create_stack() {
	stack *stack = stackCreate();
	CU_ASSERT_PTR_NOT_NULL(stack);
}
예제 #29
0
파일: testgc.c 프로젝트: lborwell/gc
Test* createTest(){
    Test* t = malloc(sizeof(Test));
    t->h = initHeaps();
    t->s = stackCreate();
    return t;
}
예제 #30
0
파일: backup.c 프로젝트: TyPetrochko/cs323
int dcommand(int argc, char * argv[]){

    struct stack * log = stackCreate();
#ifdef DEBUG
    printf("dcommand\n");
#endif
    // Get archive name from command line
    char * arkName = argv[2];

    // File descriptor for existing archive
    int arkiv;

    // Make sure 'open' is working
    if(!strcmp(arkName, "-")){
	// If archive name is '-' then read from std_in
	arkiv = STDIN_FILENO;
    } else if ((arkiv = open(arkName, O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)) == -1){
	snprintf(errDesc, ERR_STATUS_LENGTH, "opening initial archive %s", arkName);
	return -1;
    }
    
    /* Make new archive (temporary) to copy to
     * ... if it succeeds, we will keep temp archive
     * else we will unlink it. */
    int newArkiv;
    char tmpName [PATH_MAX];
    if(!strcmp(arkName, "-")){
	newArkiv = STDOUT_FILENO;
    }else{
	snprintf(tmpName, PATH_MAX, "%sXXXXXX", arkName);
	if ((newArkiv = mkstemp(tmpName)) == -1){
	    snprintf(errDesc, ERR_STATUS_LENGTH, 
		    "making new tmp archive with name %s", tmpName);
	    return -1;
	}
    }
    
    // Variable to store filesize of current archive
    off_t fileSize;

    // Read through archive 'arkiv'
    // For each file, filesize is stored, then file's name, terminated by null char
#ifdef DEBUG
    printf("    scanning through archive\n");
#endif
dreadloop:
    while(read(arkiv, &fileSize, sizeof(off_t)) > 0){
	// File's name
	char nameBuffer[PATH_MAX];
	// Read into nameBuffer until null char
	int posInNameBuff = 0;
	while(read(arkiv, nameBuffer + posInNameBuff, 1) == 1 
		&& nameBuffer[posInNameBuff++] != '\0');

	// Do we have a valid file?
	if(strlen(nameBuffer) < 1){
	    // Abort mission. Roll back.
	    snprintf(errDesc, ERR_STATUS_LENGTH, 
		    "reading file '%s' with name less than one char from archive %s", nameBuffer, arkName);
	    return -1;
	}
	
	// Check if this file is in command line
	for(int i = 3; i < argc; i++){
	    // If 'zoo' is in command line, also check for 'zoo/'
	    char asDirectoryName[PATH_MAX];
	    strcpy(asDirectoryName, argv[i]);
	    if(asDirectoryName[strlen(asDirectoryName) - 1] != '/') strcat(asDirectoryName, "/");
	    if(!strcmp(nameBuffer, argv[i]) 
		    || !strcmp(nameBuffer, asDirectoryName)
		    || checkIfParentDirectory(asDirectoryName, nameBuffer)){
#ifdef DEBUG
		printf("        it is listed in command line args, so skip it\n");
#endif
		// Skip ahead to next file
		if(lseek(arkiv, fileSize, SEEK_CUR) == -1){
		    // Couldn't skip ahead in file. Rollback.
		    return -1;
		}
		stackAddFile(log, nameBuffer);
		goto dreadloop;
	    }
	}

	// Not listed - so copy to new file

	// Add file size and name to archive
	if(archiveFileSizeAndName(nameBuffer, newArkiv, fileSize) == -1){
	    return -1;
	}
       
	// Add rest of file
	if(copyBytes(nameBuffer, arkiv, newArkiv, fileSize) == -1){
	    return -1;
	}
	    
    }
    
    // Make sure that all the arg commands were deleted
    for (int i = 3; i < argc; i++){
	if(!stackContainsChild(log, argv[i])){
	    fprintf(stderr, "Far: cannot find %s\n", argv[i]);
	}
    }

    // Done! Destory stack and switch files
    stackDestroy(log);
    char tmpBackupName[PATH_MAX];
    snprintf(tmpBackupName, PATH_MAX, "%s.bak", arkName);
    if(arkiv != STDIN_FILENO && rename(arkName, tmpBackupName) == -1){
	// Can't rename first file with .bak. Rollback.
	snprintf(errDesc, ERR_STATUS_LENGTH, 
		"first step switching archives, renaming %s to %s", arkName, tmpBackupName);
	unlink(tmpName);
	return -1;
    }
    if(arkiv != STDIN_FILENO && rename(tmpName, arkName) == -1){
	// Can't make tmpfile permanent. Rollback.
	snprintf(errDesc, ERR_STATUS_LENGTH, 
		"second step switching archives, renaming %s to %s", tmpName, arkName);
	rename(tmpBackupName, arkName);
	if(arkiv != STDIN_FILENO) unlink(tmpName);
	return -1;
    }
    if(arkiv != STDIN_FILENO && close(arkiv) == -1){
	// Can't close original archive.
	snprintf(errDesc, ERR_STATUS_LENGTH, "closing old archive file %s", arkName);
	return -1;
    }
    if(arkiv != STDIN_FILENO && close(newArkiv) == -1){
	// Can't close original archive.
	snprintf(errDesc, ERR_STATUS_LENGTH, "closing archive file %s", tmpName);
	return -1;
    }
    if(arkiv != STDIN_FILENO && unlink(tmpBackupName) == -1){
	snprintf(errDesc, ERR_STATUS_LENGTH, 
		"unlinking original archive, renamed %s", tmpBackupName);
    }

    return 0;
}