Lab46 Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
======Part 2======

=====Entries=====

====October 3, 2011====
I updated my linked list development, and committed it to the Subversion repository.\\
There is an
<cli>
lab46:~/src/data$ svn commit -m "Updated linkedLinst1-jr.c to include delete node, append, ans insert. Thes functions need work as they do not handle the end  node or the  next to end node correctly -jr"
Sending    data/linkedList1-jr.c
Transmitting file data .
Committed revision 10.
</cli>
====October 6, 2011====
After verifying my linked list library, I then added the linkedListLibrary directory and its files to the Subversion repository.\\
<cli>
lab46:~/src/data$ svn add linkedListLibrary
A         linkedListLibrary
A         linkedListLibrary/linkedListLib.c
A         linkedListLibrary/linkedList-jr.c
A         linkedListLibrary/linkedListLib.h
A         linkedListLibrary/linkedListTest.c
A  (bin)  linkedListLibrary/linkedListTest
lab46:~/src/data$
</cli>
After adding the linked list library files to the Subversion repository, I committed them as well.\\
<cli>
lab46:~/src/data$ svn commit -m "linked list library, linkedListLib.a, contains the following functions: createList, destroyListHead, destroyListTail, listSizeHead, listSizeTail, printIntDataHead, insert, append, deleteNode, void loadListData, loadNode, createNode, copyList, findData, which have all been verified -John Rine"                                                                                                                                                          Sending        data/linkedList1-jr.c
Adding         data/linkedListLibrary
Adding         data/linkedListLibrary/linkedList-jr.c
Adding         data/linkedListLibrary/linkedListLib.c
Adding         data/linkedListLibrary/linkedListLib.h
Adding  (bin)  data/linkedListLibrary/linkedListTest
Adding         data/linkedListLibrary/linkedListTest.c
Transmitting file data ......
Committed revision 11.
lab46:~/src/data$
</cli>
I am now finalizing my linked list project page which is at:\\
http://lab46.corning-cc.edu/user/jr018429/portfolio/libdll .\\
====October 12, 2011====
I learned to use a single .h file to prototye all of my functions and the node structure for all of my library files. Below is a record of the steps I went through to get there.\\
I successfully created and used a static linked list library, or so I thought, when I finalized my linked list project. However, when it came to implementing a static library of stack routines and associated data type, I had a horrible time. every library file wanted a node structure in it however when I linked the library files together, I got error messages! I had to figure out a way to have only one node struct reference that I could share with the library files. I appealed to the instructor for help! 
<cli>
Date: Wed, 12 Oct 2011 19:54:26 -0400 (EDT)
From: John Rine <jr018429@lab46.corning-cc.edu>
To: wedge@lab46.corning-cc.edu, haas@corning-cc.edu
Subject: static library HELP!!!!!

I am trying to finish my stack library and mange all the crap going on in my personal life and it ain't going very good.
I think I got lucky compiling and linking the linked List library.
I am having a time with the stack. I took a different approach with it.
I am having many library files with names describing the functions inside.
For example:
createFixedStack.c createFixedStack.h
listStackSize.c
listStackSize.h
destroyFixedStack.c
destroyFixedStack.h

I also have a test program named:
stackTest.c

please look closely at the #include "..." in the files, also look closely at the way I created the static library.
What am I doing wrong?????
I can't find any good examples on the Internet. My issues are compounded by having a struct. please look closely at how the struct is included in the includes.

I took copious notes. From you class, I got:
main
#include "mything.h"
how does "mything.h in the test program relate to multiple include files??
 I also got the following:
ar rcs libdll.a *.o
How does libdll relate to "mything.h" in the test program?
I am missing something!!!!

in stackTest.c I am declaring the individual .h files:
#include "createFixedStack.h"
#include "destroyFixedStack.h"
#include "listStackSize.h"

I successfully created .o files for these libraries using the following:
lab46:~/Stack$ gcc -c createFixedStack.c -o  createFixedStack.o
lab46:~/Stack$ gcc -c destroyFixedStack.c -o  destroyFixedStack.o
lab46:~/Stack$ gcc -c listStackSize.c -o  listStackSize.o

Then I can successfully create a static library using:
lab46:~/Stack$ ar rcs libStackJRdll.a *.o


Code and includes


//createFixedStack.h
//John T. Rine
//October 12, 2011

#ifndef _CREATEFIXEDSTACK_JR_H
#define _CREATEFIXEDSTACK_JR_H

#include<stdio.h>
#include<stdlib.h>

struct Node
{
       int data;
       struct Node * prev;
       struct Node * next;
};

typedef struct Node node;


void createFiixedStackList(node **, node **, int);

#endif


//createFixedStack.c
//John T. Rine
//October 12, 2011

#include<stdlib.h>
#include<stdio.h>
#include"createFixedStack.h"



void createFixedStack(node **head, node **tail, int elements)
{
       int i;
       node *new;
       new = NULL;
       *head = *tail = NULL;

       for(i = 1; i<=elements; i++)
       {
               if (*head == NULL)
               {
                       *head = (node *) malloc(sizeof(node));
                       *tail = *head;
                       (*head)->prev = NULL;
                       (*head)->next = NULL;
               }
               else
               {
                       new = (node *) malloc(sizeof(node));
                       new->prev = *tail;
                       new->next = NULL;
                       (*tail)->next = new;
                       *tail = new;
               }
       }
}




//destroyFixedStack.h
//John T. Rine
//October 12, 2011

#ifndef _DESTROYFIXEDSTACK_JR_H
#define _DESTROYFIXEDSTACK_JR_H

#include<stdio.h>
#include<stdlib.h>

struct Node
{
       int data;
       struct Node * prev;
       struct Node * next;
};

typedef struct Node node;


void destroyFixedStackHead(node *);
void destroyFixedStackTail(node *);

#endif



//destroyFixedStack.c
//John T. Rine
//October 12, 2011

#include<stdlib.h>
#include<stdio.h>
#include "destroyFixedStack.h"

void destroyFixedStackHead(node *head)
{
       node *temp;
       node *temp2;
       temp = NULL;
       temp2 = NULL;
       temp = head;
       while(temp != NULL)
       {
               temp2 = temp->next;
               if (temp->prev != NULL) temp->prev = NULL;
               if (temp->next != NULL) temp->next = NULL;
               free(temp);
               temp = temp2;
       }
}

void destroyFixedStackTail(node *tail)
{
       node *temp;
       node *temp2;
       temp = NULL;
       temp2 = NULL;
       temp = tail;
       while(temp != NULL)
       {
               temp2 = temp->prev;
               if (temp->prev != NULL) temp->prev = NULL;
               if (temp->next != NULL) temp->next = NULL;
               free(temp);
               temp = temp2;

       }
}



//listStackSize.h
//John T. Rine
//October 12, 2011

#ifndef _LISTSTACKSIZE_JR_H
#define _LISTSTACKSIZE_JR_H

#include<stdio.h>
#include<stdlib.h>

struct Node
{
       int data;
       struct Node * prev;
       struct Node * next;
};

typedef struct Node node;

int listStackSizeHead(node *);
int listStackSizeTail(node *);

#endif


//listrStackSize.c
//John T. Rine
//October 12, 2011


#include<stdlib.h>
#include<stdio.h>
#include"listStackSize.h"

int listStackSizeHead(node *head)
{
       int size = 0;
       while (head != NULL)
       {
               head = head->next;
               size++;
       }
       return size;
}

int listStackSizeTail(node *tail)
{
       int size = 0;
       while (tail != NULL)
       {
               tail = tail->prev;
               size++;
       }
       return size;
}



//stackTest.c
//Author: John T. Rine
//Date: October 12, 2011


#include "createFixedStack.h"
#include "destroyFixedStack.h"
#include "listStackSize.h"

int main(int argc, char **argv)
{

       node *head, *tail;
       head = tail = NULL;

       printf("Creating a list of 10 nodes...\n");
       createFixedStack(&head, &tail, 10);
       getchar(); //Holds the console window open on a Windows machine
}






However when I try to create the test executable, it bombs-HELP!!!

John T. Rine

Graduate Electrical Technology-Electronics
Graduate General Studies
---
 Lab46: Penguin Powered
</cli>
====October 13, 2011====
I finally figured that I could create a struct .h file to define the node structure and then include that .h file in my lother library files. Sure enough, it worked!
<cli>
Date: Thu, 13 Oct 2011 10:40:10 -0400
From: Matthew Haas <wedge@lab46.corning-cc.edu>
To: John Rine <jr018429@lab46.corning-cc.edu>
Subject: Re: static library HELP!!!!! (fwd)
On Oct 12, 2011, at 11:34 PM, John Rine wrote:


      I got it.
      The issue is that the structure used as a node is shared throughout all of the functions. When you break them up, you can't include the structure in
      every .h file, so what you do is to creat e a structure.h file and include that in the broken up files. Its seems you also need it in the test file as
      well. Man did that was driving me crazy.</cli>
</cli>
My instructor pointed out, however, that I could have simply made one .h file for all of my library files! Why didn't I think of that?
<cli>
Date: Thu, 13 Oct 2011 10:40:10 -0400
From: Matthew Haas <wedge@lab46.corning-cc.edu>
To: John Rine <jr018429@lab46.corning-cc.edu>
Subject: Re: static library HELP!!!!! (fwd)
Parts/Attachments:
   1   OK    ~61 lines  Text
   2 Shown   ~62 lines  Text
----------------------------------------


On Oct 12, 2011, at 11:34 PM, John Rine wrote:


      I got it.
      The issue is that the structure used as a node is shared throughout all of the functions. When you break them up, you can't include the structure in
      every .h file, so what you do is to creat e a structure.h file and include that in the broken up files. Its seems you also need it in the test file as
      well. Man did that was driving me crazy.


John,

 You may have appeared to resolve the issue, but I think the situation is still inordinately complex and can be simplified.

 For your stack library, you should be able to get away with just 1 header file, let's call it: stack.h

 stack.h can look as follows:

-------------------------------------
#ifndef _STACK_H
#define _STACK_H

#include "linkedlist.h"

struct stack {
struct list *data;
struct node *top;
};
typedef struct stack Stack;

Node *pop(Stack *);
int push(Stack *, Node *);
Node *peek(Stack *);
int isEmpty(Stack *);

#endif
-------------------------------------

All your .c files can just #include "stack.h", which will take care of all the function prototypes, struct definition, and even pull in the linked list stuff for
you (the linkedlist.h file will similarly have #ifndef _LINKED_LIST_H guards).

With so many header files, the way you seem to be approaching it might be creating a lot more managerial work for yourself... let the preprocessor take care of it
for you.

Is this code on Lab46? I took a quick peek and couldn't find it.

-Matthew
--
Matthew Haas
Lab46 System Administrator
Instructor of Computer & Information Science
http://lab46.corning-cc.edu/haas/home/ [lab46.corning-cc.edu]
</cli>
====October 14, 2011====
I finally finished my doubly linked stack library project :) !!!
It is available at:\\
http://lab46.corning-cc.edu/user/jr018429/portfolio/stack \\
I learned about implementing stacks using doubly linked structure
node structures. I also learned how to use a single .h file for
all library function prototypes and the library node structure definition.
I also learned that another more complicated way of implementing the library would
be to create a strucure .h file which defines the node structure and then
including that in the other library files, assuming one is using a .h
file per library .c file. Yet another way might be to include the node
structure definition in each .h file but wrap it in a #ifndef, #define,
#endif block as follows:\\
<code>
#ifndef _NODESTRUCT_H
#define _NODESTRUCT_H
struct Node
{
        int data;
        node *next;
        node *prev;
}
#endif
</code>
====October 19, 2011====
State machines are ubiquitous in programming and in hardware design-synchronous digital logic design. I found a very good tutorial on statemachine design at: http://johnsantic.com/comp/state.html .
I shared this link and what I know about state-machines with my Data Structures and Systems Programming classes.\\ 
<cli>
Date: Wed, 19 Oct 2011 23:06:46 -0400 (EDT)
From: John Rine <jr018429@lab46.corning-cc.edu>
To: data@lab46.corning-cc.edu, sys@lab46.corning-cc.edu
Subject: State Machines in Programming

Check out this link on state machines:
http://johnsantic.com/comp/state.html

State machines are a very import concept in both hardware and software design.
Stae machines  are either, in the case of hardware, clock driven or in software, loop, or interrupt driven. State machines store their last state and then compare
this last state to input and if defined in their design, will change state when triggered by a clock, loop, or interrupt.
State machines implemented in software can be used to perform hardware control, for example machine tool and robotics software. Soft state machines can be used in
game design such that game flow changes based on the game's previous state and input from the player. One way to implement state machines in software by combining
loop and  selecttion structures.

In hardware they are implemented using a register (flip-flops) and decoding logic. Why even discuss a hardware implement here? Well as we learned last sememmster in
Computer Organizations, hardware can be simulated in software! The decoding logic of a hardware defined state machine decodes the outputs of the state register
(output and state storage) and input and caauses the state register's state to change when the output state and inputs change to some value defined by the design.
Even though a synchronous counter is not considered to be a state machine, it may be helpful as an analogy to understanding them. A synchronous counter is reset
when firat powered up. The decoding circuitry sees 0 on the out put of the counter and decodes this value to be 1 on the input. On the next clock pulse, the counter
changes to 1 on its output. now the decoding circuitry sees 1 on the output and decodes this to 2 on the input. When the next clock tick occurs, the output changes
to 3 and so on... To get to a state machine from a synchronous counter, simply add inouts from the outside to the ddecoding circuitry. Now consider a hardware state
machine, on power up the state machine's outputs are set to 0. Now if a sensor on an input changes state, when the next clock pulse occurs and if the decoding
circuitry is designed to do so, a state machine output will change in response to the sensor's input. This output will maintain its state until the decoding logic
coupled with certain input states associate with the decoding design and a clock pulse causes it to change.
There are two types of hardware state machines:
1. Moore, and
2. Meally
At least one author has described the cpu as a state machine.
I am sure I have made the subject of state machines as clear as mud.

John T. Rine

Graduate Electrical Technology-Electronics
Graduate General Studies
---
 Lab46: Penguin Powered
</cli>
====October 23, 2011====
I added and committed my forkExample.c program to the Subversion repository.\\
<cli>
lab46:~/src/sysprog$ svn add forkExample.c
A         forkExample.c
lab46:~/src/sysprog$ svn commit -m "Added and commited a simple example of using fork -John Rine"
Adding         sysprog/forkExample.c
Transmitting file data .
Committed revision 16.
</cli>
I added and committed my useMalloc.c program to the Subversion repository.\\
<cli>
lab46:~/src/data$ svn add useMalloc.c
A         useMalloc.c
lab46:~/src/data$ svn commit -m "Added and committed useMalloc.c, an example program demonstrating dynamic memory allocation of structures and arrays -John Rine"
Sending        data/Stack/libdll.a
Adding         data/useMalloc.c
Transmitting file data ..
Committed revision 17.
lab46:~/src/data$
</cli>
====October 24, 2011====
I conducted and documented an experiment to determine if a string literal could be assigned to a pointer pointing to dynamically allocated memory and then be used in a program, then when the data is no longer needed, deallocate it.
The experiment is documented in Part II, experiment 1.\\
\\
====October 28, 2011====
I added and committed the code I wrote to implement an array-based stack data structure.\\
\\
<cli>
lab46:~/src/data$ svn add arrayStack.c
A         arrayStack.c
lab46:~/src/data$ svn commit -m "Added and committed an array-based stack program. -John Rine"
Adding         data/arrayStack.c
Sending        data/useMalloc.c
Transmitting file data ..
Committed revision 18.
lab46:~/src/data$
</cli>
\\
I added and committed the code I wrote to design and test doubly-linked list functions.\\
<cli>
lab46:~/src/data$ svn add linkedListDev.c
A         linkedListDev.c
lab46:~/src/data$ svn commit -m "Added and committed linkedListDev.c, a linked list development program -John Rine"
Adding         data/linkedListDev.c
Transmitting file data .
Committed revision 19.
lab46:~/src/data$
</cli>

====October 29, 2011====
I added and committed the code I wrote to learn about threads.\\
<cli>
lab46:~/src/sysprog$ svn add threadTest.c
A         threadTest.c
lab46:~/src/sysprog$ svn commit -m "Added and committed threadTest.c a program to illustrate thread creation and termination -John Rine"
Sending        sysprog/interface.c
Adding         sysprog/threadTest.c
Transmitting file data ..
Committed revision 20.
lab46:~/src/sysprog$
</cli>
\\
I added and committed the code I wrote to implement an array-based queue.\\
<cli>
lab46:~/src/data$ svn add queueTest.c
A         queueTest.c
lab46:~/src/data$ svn commit -m "Added and committed an array-based example of a queue -John T. Rine"
Adding         data/queueTest.c
Transmitting file data .
Committed revision 21.
lab46:~/src/data$
</cli>
====October 30, 2011====
I entered my part deux (II) course objectives for systems programming and data structures courses.
I also completed my third experiment for part II. I also wrote system programming topic information for the synchronization methods mutex, and barrier.  
=====data Topics=====

====malloc====
malloc is a c library function for dynamically allocating memory in the "heap".
dynamically allocated memory is memory that has been set aside for use during the execution of the program, also know as "run time".
malloc can be used to dynamically allocate variables as well as arrays, including multidimensional arrays and structures. The malloc function becomes available for use in a program after the stdlib.h header has been added to the program.\\
<file c useMalloc.c>
//useMalloc.c
//John T. Rine
//October 23, 2011

#include<stdlib.h>
#include<stdio.h>


struct Test
{
        char *message1;
        char *message2;
};

typedef struct Test test;

int main(int argc, char **argv)
{

        //malloc a struct
        test *testPTR;

        testPTR = (test *)malloc(sizeof(test));

        testPTR->message1 = "Hello ";
        testPTR->message2 = "world!";

        printf("Message1 = %s, message2 = %s\n", testPTR->message1, testPTR->message2);

        free(testPTR);


        //malloc a char array
        int i = 0;
        int ii = 0;
        char * inputString = "John T. Rine\0";
        char * string = NULL;

        printf("input string contains %s\n", inputString);
        while(*(inputString + i) != '\0') i++;
        printf("Character count = %d\n", i);
        string = (char *)malloc(sizeof(char) * (i + 1));
        for(ii = 0; ii <= (i + 1); ii++) *(string + ii) = *(inputString + ii);
        printf("Dynamically allocated array contains %s\n", string);

        free(string);

        return 0;
}

</file>
Compilation and execution of useMalloc.c were successful as seen below.\\
<cli>
lab46:~/src/data$ ./useMalloc
Message1 = Hello , message2 = world!
input string contains John T. Rine
Character count = 12
Dynamically allocated array contains John T. Rine
lab46:~/src/data$
</cli>
==References==
  - http://en.wikipedia.org/wiki/Malloc
  - http://www.cplusplus.com/reference/clibrary/cstdlib/malloc/
  - http://www.cs.bu.edu/teaching/c/alloc/intro/
  - http://en.wikipedia.org/wiki/C_dynamic_memory_allocation
  - http://randu.org/tutorials/c/dynamic.php
====Heap====
Since the data structures class is now making copious use of dynamically allocated memory using malloc and free to allocate and deallocate memory to make, manage, and destroy linked lists, stacks, quesues and so on, wouldn't it be a good idea to understand what the heap is, and how its used?\\
Dynamically allocated memory is usually allocated from a pool of unused memory known as the "heap" or "free store". Because the exact memory address of a dynamic memory allocation is not known in advance, dynamically allocated memory is accessed indirectly through the use of pointers.
The exact method used to organize the heap and allocate and deallocate parts of it is hidden behind an abstract interface.\\
==References==
  - http://en.wikipedia.org/wiki/Dynamic_memory_allocation
  - http://en.wikipedia.org/wiki/Memory_pool
  - http://en.wikipedia.org/wiki/C_dynamic_memory_allocation
====Stack====
The stack is a last in, first out (LIFO) data structure. A stack can have any data type, including structures as elements, but has only a few basic operations which can be performed on it: initialize or create, push, pop and peek. The initialize or create operation creates a stack and initializes it. The push operation adds a new item to the top of the stack. The pop operation removes an item from the top of the stack. The stack peek operation gets the data from the top of the stack without deleting it or changing the stack pointer.\\
\\
<file c arrayStack.c>
//arrayStack.c
//John T. Rine
//October 28, 2011

#include<stdio.h>
#include<stdlib.h>

struct Stack 
{
  char *array;
  int top;
  int size;
};

typedef struct Stack stack;

int cntChars(char *);
void createStack(stack *, int);
void push(stack *, char);
char pop(stack *);
int isEmpty(stack *);
int isFull(stack *);

int main(int argc, char **argv)
{
	int i;
	int count;
	stack newStack;
	char stringArray[200];

	printf("Enter a string: ");
	gets(stringArray); 
	count = cntChars(stringArray); 
	createStack(&newStack, count); 
	if(isEmpty(&newStack)) printf("Stack is empty\n");
	else printf("Stack is not empty\n");
	for(i = 0; i < count; i++)
	{
		push(&newStack,stringArray[i]);
                printf("The character going into tos is: %c\n", newStack.array[i]);
	}
        if(isEmpty(&newStack)) printf("Stack is empty\n");
        else printf("Stack is not empty\n");
	for(i = 0; i < count; i++) printf("The character in tos is: %c\n", pop(&newStack));
        for(i = 0; i < count; i++)
        {
                push(&newStack,stringArray[i]);
                printf("The character going into tos is: %c\n", newStack.array[i]);
        }
	push(&newStack,'H');

	return 0;
}

int cntChars(char *inputString)
{
	// returned value "count" does not include '\0'
	int count = 0;
	while(*(inputString + count) != '\0') ++count;
	return(count);
}

void createStack(stack *stackVar, int size)
{
	char *array;

	array = (char *)malloc(sizeof(char) * size);

  	if (array == NULL)
	{
    		fprintf(stderr, "Not enough memory to create the stack.\n");
    		exit(1);
  	}

	stackVar->array = array;
  	stackVar->size = size;
  	stackVar->top = -1;

}

int isEmpty(stack *stackVar)
{
  return stackVar->top < 0;
}

int isFull(stack *stackVar)
{
  return stackVar->top >= stackVar->size - 1;
}

void push(stack *stackVar, char  element)
{
	if (isFull(stackVar))
	{
		fprintf(stderr, "Can't push on the stack is full\n");
		exit(1);
	}
	stackVar->array[++stackVar->top] = element;
}


char pop(stack *stackVar)
{
	if (isEmpty(stackVar))
	{
		fprintf(stderr, "Can't pop from stack; stack is empty\n");
		exit(1);
	}
	return stackVar->array[stackVar->top--];
}
</file>
\\
Execution of the source code listed above with the string "Oh no! I have just been Rick rolled!" as input.\\
\\
<cli>
lab46:~/src/data$ gcc arrayStack.c -o arrayStack
/tmp/cczFb9N2.o: In function `main':
arrayStack.c:(.text+0x35): warning: the `gets' function is dangerous and should not be used.
lab46:~/src/data$ ./arrayStack
Enter a string: Oh no! I have just been Rick rolled!
Stack is empty
The character going into tos is: O
The character going into tos is: h
The character going into tos is:
The character going into tos is: n
The character going into tos is: o
The character going into tos is: !
The character going into tos is:
The character going into tos is: I
The character going into tos is:
The character going into tos is: h
The character going into tos is: a
The character going into tos is: v
The character going into tos is: e
The character going into tos is:
The character going into tos is: j
The character going into tos is: u
The character going into tos is: s
The character going into tos is: t
The character going into tos is:
The character going into tos is: b
The character going into tos is: e
The character going into tos is: e
The character going into tos is: n
The character going into tos is:
The character going into tos is: R
The character going into tos is: i
The character going into tos is: c
The character going into tos is: k
The character going into tos is:
The character going into tos is: r
The character going into tos is: o
The character going into tos is: l
The character going into tos is: l
The character going into tos is: e
The character going into tos is: d
The character going into tos is: !
Stack is not empty
The character in tos is: !
The character in tos is: d
The character in tos is: e
The character in tos is: l
The character in tos is: l
The character in tos is: o
The character in tos is: r
The character in tos is:
The character in tos is: k
The character in tos is: c
The character in tos is: i
The character in tos is: R
The character in tos is:
The character in tos is: n
The character in tos is: e
The character in tos is: e
The character in tos is: b
The character in tos is:
The character in tos is: t
The character in tos is: s
The character in tos is: u
The character in tos is: j
The character in tos is:
The character in tos is: e
The character in tos is: v
The character in tos is: a
The character in tos is: h
The character in tos is:
The character in tos is: I
The character in tos is:
The character in tos is: !
The character in tos is: o
The character in tos is: n
The character in tos is:
The character in tos is: h
The character in tos is: O
The character going into tos is: O
The character going into tos is: h
The character going into tos is:
The character going into tos is: n
The character going into tos is: o
The character going into tos is: !
The character going into tos is:
The character going into tos is: I
The character going into tos is:
The character going into tos is: h
The character going into tos is: a
The character going into tos is: v
The character going into tos is: e
The character going into tos is:
The character going into tos is: j
The character going into tos is: u
The character going into tos is: s
The character going into tos is: t
The character going into tos is:
The character going into tos is: b
The character going into tos is: e
The character going into tos is: e
The character going into tos is: n
The character going into tos is:
The character going into tos is: R
The character going into tos is: i
The character going into tos is: c
The character going into tos is: k
The character going into tos is:
The character going into tos is: r
The character going into tos is: o
The character going into tos is: l
The character going into tos is: l
The character going into tos is: e
The character going into tos is: d
The character going into tos is: !
Can't push on the stack is full
lab46:~/src/data$
</cli>
==References==
  - http://www.cs.bu.edu/teaching/c/stack/array/
  - <html><a href="http://en.wikipedia.org/wiki/Stack_(abstract_data_type)">http://en.wikipedia.org/wiki/Stack_(abstract_data_type)</a></html>

====Linked List====
A linked list is a data structure whose elements each contain pointers to other elements in the linked list. There are singly-linked lists whose pointers only point in one direction, and doubly-linked lists which has pointers pointing in the direction of head and pointers which point in the direction of the tail. The list is traversed using the pointers contained in the node.\\
For example, a list can be traversed from the head using the "next" pointer as follows:\\
\\
<code>
temp = head;
while(temp != NULL)                //while temp is not at the end of the list
{
	printf("%d ",temp->data); //printf the value of the data in the current node
	temp = temp->next;        //load temp with the address of the next node
}
</code>
\\
<file c linkedListDev.c>
//linkedListDev.c
//John T. Rine
//October 28, 2011


#include<stdio.h>
#include<stdlib.h>

struct Node
{
	int data;
	struct Node * prev;
	struct Node * next;
};

typedef struct Node node;

void createList(node **, node **, int);
void destroyListHead(node *);
void destroyListTail(node *);
int listSizeHead(node *);
int listSizeTail(node *);
void printIntDataHead(node *);
void insert(node **, node **, int, int);
void append(node **, node **, int, int);
void deleteNode(node **, node **, int);
void loadListData(node *);
void loadNode(node *, int, int);
void createNode(node*, node*);
void copyList(node *, node **, node **);
int findData(node *, int);

int main(int argc, char **argv)
{
	
	node *head, *tail, *copyHead, *copyTail, *temp;
	head = tail = copyHead = copyTail = NULL;

	int i = 1;

	printf("Creating a list of 4 nodes...\n");
	createList(&head, &tail, 4);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printf("Load list data\n");
	loadListData(head);
	printIntDataHead(head);
	printf("Inserting node 0 with data of 3200 before head node...\n");
	insert(&head, &tail, 0, 3200);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Inserting node with data of -3200 before tail node...\n");
	insert(&head, &tail, listSizeHead(head) - 1, -3200);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Appending node with data of 2300 after head node...\n");
	append(&head, &tail, 0, 2300);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Appending node with data of -2300 after tail node...\n");
	append(&head, &tail, listSizeHead(head) - 1, -2300);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Loading node 0 with data of 0...\n");
	loadNode(head, 0, 0);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Loading tail node with data of 255...\n");
	loadNode(head, listSizeHead(head) - 1, 255);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Deleting head node...\n");
	deleteNode(&head, &tail, 0);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Deleting tail node...\n");
	deleteNode(&head, &tail, listSizeHead(head) - 1);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	printf("Deleting node 2...\n");
	deleteNode(&head, &tail, 2);
	printf("Size of the list is: %d\n", listSizeHead(head));
	printIntDataHead(head);
	copyList(head, &copyHead, &copyTail);
	printf("Size of the list is: %d\n", listSizeHead(copyHead));
	printIntDataHead(copyHead);
	printf("The node location of 3 is %d\n", findData(copyHead, 3));

	destroyListHead(head);
	return 0;
}

void createList(node **headd, node **taill, int elements)
{
	int i;
	node *new, *head, *tail;
	new = head  = tail = NULL;

	for(i = 1; i<=elements; i++)
	{
		if (head == NULL)
		{
			head = (node *) malloc(sizeof(node));
			tail = head;
			head->prev = NULL;
			head->next = NULL;
		}
		else
		{
			new = (node *) malloc(sizeof(node));
			new->prev = tail;
			new->next = NULL;
			tail->next = new;
			tail = new;
		}
	}
	*headd = head;
	*taill = tail;
}

void destroyListHead(node *head)
{
	node *temp;
	node *temp2;
	temp = NULL;
	temp2 = NULL;
	temp = head;
	while(temp != NULL)
	{
		temp2 = temp->next;
		if (temp->prev != NULL) temp->prev = NULL;
		if (temp->next != NULL) temp->next = NULL;
		free(temp);
		temp = temp2;	
	}
}

void destroyListTail(node *tail)
{
	node *temp;
	node *temp2;
	temp = NULL;
	temp2 = NULL;
	temp = tail;
	while(temp != NULL)
	{
		temp2 = temp->prev;
		if (temp->prev != NULL) temp->prev = NULL;
		if (temp->next != NULL) temp->next = NULL;
		free(temp);
		temp = temp2;	
	}
}

int listSizeHead(node *head)
{
	int size = 0;
	while (head != NULL)
	{	
		head = head->next;
		size++;
	}
	return size;
}

int listSizeTail(node *tail)
{
        int size = 0;
        while (tail != NULL)
        {
                tail = tail->prev;
                size++;
        }
        return size;
}

void printIntDataHead(node * head)
{
	node * temp = NULL;
	
	temp = head;
	while(temp != NULL)
	{
		printf("%d ",temp->data);
		temp = temp->next;
	}
	printf("\n");
}

void insert(node ** head, node ** tail, int position, int data)
{
	int i;
	node *temp, *temp2;
	temp = temp2 = NULL;

	temp = *head;
	for(i = 0; i < position; i++)
	{
		temp = temp -> next;
	}

		if (*head == NULL)
		{
			*head = (node *) malloc(sizeof(node));
			*tail = *head;
			(*head)->prev = NULL;
			(*head)->next = NULL;
			(*head)->data = data;
		}
		else if (*head == temp)
		{
			temp2 = (node *) malloc (sizeof(node));
			temp2->next = *head;
			(*head)->prev = temp2;
			*head = (*head)->prev;
			(*head)->prev = NULL;
			(*head)->data = data;
		}
		else
		{
			temp2 = (node *) malloc (sizeof(node));	
			temp2->next = temp;
			temp2->prev = temp->prev;
			temp->prev->next = temp2;
			temp->prev = temp2;
			temp2->data = data;
		}
}

void append(node **head, node **tail, int position, int data)
{
	int i;
	node *temp, *temp2;
	temp = temp2 = NULL;

	temp = *head;
	for(i = 0; i < position; i++)
	{
		temp = temp -> next;
	}

		if (*head == NULL)
		{
			*head = (node *) malloc(sizeof(node));
			*tail = *head;
			(*head)->prev = NULL;
			(*head)->next = NULL;
			(*head)->data = data;
		}
		else if (*tail == temp)
		{
			temp2 = (node *) malloc (sizeof(node));
			temp2->prev = *tail;
			temp2->next = NULL;
			(*tail)->next = temp2;
			*tail = temp2;
			(*tail)->data = data;
		}
		else
		{
			temp2 = (node *) malloc (sizeof(node));
			temp2->prev = temp;
			temp2->next = temp->next;
			temp->next->prev = temp2;
			temp->next = temp2;
			temp2->data = data;
			
		}

}

void deleteNode(node **head, node **tail, int position)
{
	int i;
	node * temp = NULL;

	temp = *head;
	for(i = 0; i < position; i++)
	{
		temp = temp->next;
	}
	if(temp != *head && temp != *tail)
	{
		temp->next->prev = temp->prev;
		temp->prev->next = temp->next;
		temp->prev = NULL;
		temp->next = NULL;
	}
	else if (temp == *head)
	{
		temp->next->prev = NULL;
		*head = temp->next;
		temp->next = NULL;
	}
	else
	{
		temp->prev->next = NULL;
		*tail = temp->prev;
		temp->prev = NULL;
	}
	free(temp);
}

void loadListData(node *head)
{
	int i = 0;
	node *temp = NULL;
	temp = head;
	printf("Enter a value or -1 to quit: ");
	scanf("%d", &i);
	while(i != -1)
	{
		temp->data = i;
		temp = temp->next;
		if(temp == NULL)
		{
			printf("List is full of data!\n");
			break;
		}
		printf("Enter a value or -1 to quit: ");
		scanf("%d", &i);
	}

}


void loadNode(node *head, int position, int value)
{
	int i;
	node *temp = NULL;
	temp = head;

	temp = head;
	for(i = 0; i < position; i++)
	{
		temp = temp->next;
	}
	temp->data = value;
}

void createNode(node* head, node* tail)
{
	head = (node *) malloc(sizeof(node));
	tail = head;
	head->prev = NULL;
	head->next = NULL;
}

void copyList(node *head, node **copyHead, node **copyTail)
{
	node *new, *temp;
	new = *copyHead = *copyTail = temp = NULL;
	temp = head;
	while(temp != NULL)
	{
		if (*copyHead == NULL)
		{
			*copyHead = (node *) malloc(sizeof(node));
			*copyTail = *copyHead;
			(*copyHead)->prev = NULL;
			(*copyHead)->next = NULL;
			(*copyHead)->data = temp->data;
		}
		else
		{
			new = (node *) malloc(sizeof(node));
			new->prev = *copyTail;
			new->next = NULL;
			(*copyTail)->next = new;
			*copyTail = new;
			(*copyTail)->data = temp->data;
		}
		temp = temp->next;
	}
}

int findData(node *head, int data)
{
	int counter = 0;
	while(head != NULL)
	{
		if(head->data == data) break;
		counter++;
		head = head->next;
	}
	return counter;
}

</file>
\\
<cli>
lab46:~/src/data$ ./linkedListDev
Creating a list of 4 nodes...
Size of the list is: 4
Load list data
Enter a value or -1 to quit: 1
Enter a value or -1 to quit: 2
Enter a value or -1 to quit: 3
Enter a value or -1 to quit: 4
List is full of data!
1 2 3 4
Inserting node 0 with data of 3200 before head node...
Size of the list is: 5
3200 1 2 3 4
Inserting node with data of -3200 before tail node...
Size of the list is: 6
3200 1 2 3 -3200 4
Appending node with data of 2300 after head node...
Size of the list is: 7
3200 2300 1 2 3 -3200 4
Appending node with data of -2300 after tail node...
Size of the list is: 8
3200 2300 1 2 3 -3200 4 -2300
Loading node 0 with data of 0...
Size of the list is: 8
0 2300 1 2 3 -3200 4 -2300
Loading tail node with data of 255...
Size of the list is: 8
0 2300 1 2 3 -3200 4 255
Deleting head node...
Size of the list is: 7
2300 1 2 3 -3200 4 255
Deleting tail node...
Size of the list is: 6
2300 1 2 3 -3200 4
Deleting node 2...
Size of the list is: 5
2300 1 3 -3200 4
Size of the list is: 5
2300 1 3 -3200 4
The node location of 3 is 2
lab46:~/src/data$
</cli>
\\
==References==
  - http://en.wikipedia.org/wiki/Linked_list
  - http://www.cprogramming.com/tutorial/lesson15.html
  - http://cslibrary.stanford.edu/103/LinkedListBasics.pdf
  - http://www.dreamincode.net/code/snippet82.htm
  - http://www.youtube.com/watch?v=oiW79L8VYXk
  - http://xlinux.nist.gov/dads/HTML/linkedList.html
====Top====
The element of the stack data structure which is available for stack operations (see the data structures topic "Stack" for details of stack operations) is known as the top of TOS (top of stack).
The stack position top may have data "pushed" (see the data topic "Pushing" for details of the stack operation push) into it at which point the stack pointer, a pointer pointing to the stack element which is available for stack operations, is incremented so as to expose the next stack element for stack operations.
The stack position top may also have data "popped" (see the data topic "Popping" for details of the stack operation pop) from it at which point the stack pointer, is decremented to expose the next stack element for stack operations.\\
\\
==References==
  - <html><a href="http://en.wikipedia.org/wiki/Stack_(abstract_data_type)">http://en.wikipedia.org/wiki/Stack_(abstract_data_type)</a></html>
  - http://www.i-programmer.info/babbages-bag/357-advanced-data-structures.html
  - http://www.cs.bu.edu/teaching/c/stack/array/
  - http://www.cs.bu.edu/teaching/c/stack/linked-list/
====Overflow Condition====
If, a data structure such as a stack is full and cannot accept (store) anymore data, it is considered to be in an overflow state.
==References==
  - http://wiki.answers.com/Q/Overflow_and_underflow_conditions_in_data_structures
  - <html><a href="http://en.wikipedia.org/wiki/Stack_(abstract_data_type)">http://en.wikipedia.org/wiki/Stack_(abstract_data_type)</a></html>
====Underflow Condition====
If, a data structure, such as a stack, is empty, no more data can be taken from it; it cannot be "popped" again as the data retreived would be erroneous, and the data structure position pointer, the stack pointer in the case of stacks, would be manipulated to point to some memory location which is no longer part of the data structure; this is considered to be the "underflow" state.
==References==
  - http://wiki.answers.com/Q/Overflow_and_underflow_conditions_in_data_structures 
  -  <html><a href="http://en.wikipedia.org/wiki/Stack_(abstract_data_type)">http://en.wikipedia.org/wiki/Stack_(abstract_data_type)</a></html>

====Free====
The function free, is used to release heap (see the data topic "Heap" for details) memory which was previously allocated dynamically, that is at run time, through the use of one of the memory allocation functions.
free takes a single pointer argument; it releases the memory pointed to by its argument.
==References==
  - http://en.wikipedia.org/wiki/Memory_management
  - http://en.wikipedia.org/wiki/C_dynamic_memory_allocation
  - http://www.yolinux.com/TUTORIALS/Cpp-DynamicMemory.html
  - http://linux.die.net/man/3/malloc 
  - http://www.cprogramming.com/tutorial/virtual_memory_and_heaps.html
  - http://stackoverflow.com/questions/1350819/c-free-store-vs-heap
  - http://msdn.microsoft.com/en-us/library/ms810603.aspx
====Structure====
A structure or record is a collection of variables grouped together under a single identifier. The data are related somehow, that is the point of a structure or record. A classic example of a structure or record is that of an employee. Character array or string members of an employee structure or record might be the employee's first and last names, street, address, city, and state of residence. Integer members of the employee structure or record might be employee number, age, etc. The structure data type, also known as an abstract data type, provides an elegant and powerful way for keeping related data together. 
==References==
  - http://en.wikipedia.org/wiki/Record_(computer_science)
  - http://www.roseindia.net/c-tutorials/c-structure.shtml 

====Queue====
A queue is a FIFO (see the data topic "FILO/FIFO" for details) type data structure. That is, data is taken from the queue in the same order that it was placed into it.
Enqueuing
Dequeue
The following program demonstrates an array-based queue.\\
<file c queueTest.c>
//queueTest.c
//John T. Rine
//October 29, 2011

#include<stdio.h>
#include<stdlib.h>

struct Queue
{
	char *queueArray;
	int count;
	int size;
	int startIndex;
};

typedef  struct Queue queue;


void createQueue(queue *, int);
void destroyQueue(queue *);
void enqueue(queue *, char);
void printQueue(queue *);
int queueCount(queue *);
char dequeue(queue *);

int main(int argc, char **argv)
{
	queue newQueue;
	
	createQueue(&newQueue, 25);
	destroyQueue(&newQueue);
	enqueue(&newQueue, 'J');
        enqueue(&newQueue, 'o');
        enqueue(&newQueue, 'h');
        enqueue(&newQueue, 'n');
	printf("Calling printQueue(&newQueue)...\n");
        printQueue(&newQueue);
	printf("Calling and printing return value from dequeue...\n");
	printf("%c, ", dequeue(&newQueue));
        printf("%c, ", dequeue(&newQueue));
	printf("\n");
	printf("Calling printQueue(&newQueue)...\n");
	printQueue(&newQueue);

	return 0;
}

void createQueue(queue *queuePTR, int size)
{
	char *queueArrayPTR = NULL;
	queueArrayPTR = (char *)malloc(sizeof(char) * size);
	queuePTR->queueArray = queueArrayPTR;
	queuePTR->size = size;
	queuePTR->count = 0;
	queuePTR->startIndex = 0;
}

void destroyQueue(queue *queuePTR)
{
	free(queuePTR->queueArray);
}

void enqueue(queue *queuePTR, char data)
{
	int queueArrayIndex;
	if(queuePTR->count < queuePTR->size)
	{
		queueArrayIndex = queuePTR->startIndex + queuePTR->count;
		queuePTR->queueArray[queueArrayIndex] = data;
		queuePTR->count++;
	}
	else printf("Queue is full!\n");  
}

void printQueue(queue *queuePTR)
{
	int i;
	for(i = 0; i < queuePTR->count; i++) printf("%c, ",queuePTR->queueArray[(queuePTR->startIndex + i)%queuePTR->size]);
	printf("\n");
}


int queueCount(queue *queuePTR)
{
	return queuePTR->count;
}

char dequeue(queue *queuePTR)
{
	char ret;
	if(queuePTR->count == 0)
	{
		 printf("queue is empty!\n");
		exit(1);
	}
	ret = queuePTR->queueArray[queuePTR->startIndex];
    	queuePTR->count--;
    	queuePTR->startIndex = (queuePTR->startIndex + 1)%queuePTR->size;
    	return ret;
}
</file>
\\
This is the output of the queueTest.c program:\\
<cli>
lab46:~/src/data$ gcc queueTest.c -o queueTest
lab46:~/src/data$ ./queueTest
Calling printQueue(&newQueue)...
J, o, h, n,
Calling and printing return value from dequeue...
J, o,
Calling printQueue(&newQueue)...
h, n,
lab46:~/src/data$
</cli>
==References==
  - http://www.cs.bu.edu/teaching/c/queue/array/types.html
  - http://technical-interview.com/Implement_a_Queue_using_an_Array.aspx
  - <html><a href="http://en.wikipedia.org/wiki/Queue_(abstract_data_type)">http://en.wikipedia.org/wiki/Queue_(abstract_data_type)</a></html> 

====Array====
An array is a set of similar data type data stored in a contiguous section of memory. Since data contained in a array is packaged in similar sized memory blocks and stored in contiguous memory locations, it becomes possible to simply add an array element offset to the base address of the array to access data at a specific element withing the array. The following program illustrates the use off an index to access elements of an array.\\
\\
<file c arrayTest.c>
//arrayTest.c
//John T. Rine
//October 29, 2011

#include<stdio.h>

int main(int argc, char **argv)
{
        char array[26] = {0};
        int i;
        printf("Enter a string (<= 25 character) to place into a character array\n");
        gets(array);
        printf("array contains %s\n", array);
        i = 0;
        while(array[i] != '\0')
        {
                printf("array[%d] = %c\n", i, array[i]);
                printf("*(array + %d) = %c\n", i, *(array + i));
                i++;
        }

        return 0;
}
</file>
This is the output of the arrayTest.c program listed above.\\
<cli>
lab46:~/src/data$ ./arrayTest
Enter a string (<= 25 character) to place into a character array
John T. Rine
array contains John T. Rine
array[0] = J
*(array + 0) = J
array[1] = o
*(array + 1) = o
array[2] = h
*(array + 2) = h
array[3] = n
*(array + 3) = n
array[4] =
*(array + 4) =
array[5] = T
*(array + 5) = T
array[6] = .
*(array + 6) = .
array[7] =
*(array + 7) =
array[8] = R
*(array + 8) = R
array[9] = i
*(array + 9) = i
array[10] = n
*(array + 10) = n
array[11] = e
*(array + 11) = e
lab46:~/src/data$
</cli>
==References==
  - http://rajkishor09.hubpages.com/hub/Array-in-C-programming--Programmers-view 
  - http://guy-lecky-thompson.suite101.com/introduction-to-arrays-a25228

====LIFO/FIFO====
LIFO is an acronym for "**L**ast **I**n, **F**irst **O**ut"; FIFO is an acronym for "**F**irst **I**n, **F**irst **O**ut". The stack is a last in, first out or LIFO data structure whereas the queue is a first in, first out or FIFO data structure.
Due to the nature of the stack, one use is to reverse the order of data items. The data items to be reveresed are pushed onto the stack, and then to reverse them, they are popped off.
==References==
  - http://en.wikipedia.org/wiki/FIFO
  - <html><a href="http://en.wikipedia.org/wiki/LIFO_(computing)">http://en.wikipedia.org/wiki/LIFO_(computing)</a></html> 
  - http://introcs.cs.princeton.edu/java/43stack/
=====hpc1 Topics=====

====Keyword 1====
\\
==References==

====Keyword 2====
Identification and definition of the chosen keyword.

If you want to demonstrate something on the command-line, you can do so as follows:

<cli>
lab46:~$ cd src
lab46:~/src$ gcc -o hello hello.c
lab46:~/src$ ./hello
Hello, World!
lab46:~/src$ 
</cli>

====Keyword 3====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you wish to aid your definition with a code sample, you can do so by using a wiki **code** block, an example follows:

<code c>
/*
 * Sample code block
 */
#include <stdio.h>

int main()
{
    return(0);
}
</code>

====Keyword 4====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you want to demonstrate something on the command-line, you can do so as follows:

<cli>
lab46:~$ cd src
lab46:~/src$ gcc -o hello hello.c
lab46:~/src$ ./hello
Hello, World!
lab46:~/src$ 
</cli>


====Keyword 5====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you wish to aid your definition with a code sample, you can do so by using a wiki **code** block, an example follows:

<code c>
/*
 * Sample code block
 */
#include <stdio.h>

int main()
{
    return(0);
}
</code>


====Keyword 6====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you want to demonstrate something on the command-line, you can do so as follows:

<cli>
lab46:~$ cd src
lab46:~/src$ gcc -o hello hello.c
lab46:~/src$ ./hello
Hello, World!
lab46:~/src$ 
</cli>


====Keyword 7====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you wish to aid your definition with a code sample, you can do so by using a wiki **code** block, an example follows:

<code c>
/*
 * Sample code block
 */
#include <stdio.h>

int main()
{
    return(0);
}
</code>

====Keyword 8====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you want to demonstrate something on the command-line, you can do so as follows:

<cli>
lab46:~$ cd src
lab46:~/src$ gcc -o hello hello.c
lab46:~/src$ ./hello
Hello, World!
lab46:~/src$ 
</cli>


====Keyword 9====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you wish to aid your definition with a code sample, you can do so by using a wiki **code** block, an example follows:

<code c>
/*
 * Sample code block
 */
#include <stdio.h>

int main()
{
    return(0);
}
</code>


====Keyword 10====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you want to demonstrate something on the command-line, you can do so as follows:

<cli>
lab46:~$ cd src
lab46:~/src$ gcc -o hello hello.c
lab46:~/src$ ./hello
Hello, World!
lab46:~/src$ 
</cli>


====Keyword 11====
Identification and definition of the chosen keyword. Substitute "keyword" with the actual keyword.

If you wish to aid your definition with a code sample, you can do so by using a wiki **code** block, an example follows:

<code c>
/*
 * Sample code block
 */
#include <stdio.h>

int main()
{
    return(0);
}
</code>



=====sysprog Topics=====

====fork====
The fork() system call takes no arguments and returns a process ID.
fork() is used to create new processes which are child processes of the caller. Once a child process has been created both processes will execute the next instruction following the fork call. The returned PID value is the only way to distinguish between the child and the parent.
If calling fork is successfully executed, Unix/Linux will make two identical copies of address spaces, one for the parent and the other for the child. 
Both processes will start their execution at the next statement following fork.\\ 
Regarding fork's return value, the man page says the following:
<code>
from man fork:
RETURN VALUE
On success, the PID of the child process is returned in the parent, and
0 is returned in the child.  On failure, -1 is returned in the  parent,
no child process is created, and errno is set appropriately.
</code>
The following code asks the user to enter the number of iterations that the parent and child processes should execute. Next, fork is called with fork assigning its return value of type pid_t to pid. Once fork is called, fork's return value is used to determine whether what is being printed currently is the child or the parent. If the return value is 0, then its the child, if its some positive value greater than 0, then its the parent.
<file c forkExample.c>
//forkExample.c
//John T. Rine
//October 23, 2011

#include <sys/types.h>
#include <stdlib.h>
#include<stdio.h>

#define CHILD 0

int globalTestVar = 0;

char *child(int *);
char *parent();
char *error();



int main(int argc, char **argv)
{
        char * procID = '\0';
        int localTestVar = 0;
        int *localTestVarPTR = NULL;
        localTestVarPTR = &localTestVar;

        pid_t pid;

        printf("Enter a global variable value\n");
        scanf("%d", &globalTestVar);

        printf("Enter a local variable value\n");
        scanf("%d", &localTestVar);


        pid = fork();

        //Error, failed to fork
        if (pid < CHILD) procID = error();
        //child
        else if (pid == CHILD) procID = child(localTestVarPTR);
        //parent
        else procID = parent();

        //Executed by both parent and child.
        printf("procID = %s\n", procID);
        printf("Global variable = %d\n", globalTestVar);
        printf("Local variable = %d\n", localTestVar);

}

char *child(int *localTestVarPtr)
{
        char *procID;
        procID = "Child Process: ";
        ++*localTestVarPtr;
        ++globalTestVar;
        return procID;
}

char *parent()
{
        char *procID;
        procID = "Parent Process:";
        return procID;
}

char *error()
{
        char *procID;
        procID = "Failed to fork";
        return procID;
}
</file> 
Execution of forkExample.c
<cli>
lab46:~/src/sysprog$ ./forkExample
Enter a global variable value
2
Enter a local variable value
3
procID = Parent Process:
Global variable = 2
Local variable = 3
procID = Child Process:
Global variable = 3
Local variable = 4
lab46:~/src/sysprog$
</cli>

==References==
  - http://www.csl.mtu.edu/cs4411/www/NOTES/process/fork/create.html
  - http://linux.die.net/man/2/fork
  - Understanding Unix/Linux System Programming by Bruce Molay
  - http://www.yolinux.com/TUTORIALS/ForkExecProcesses.html
====Threads-part deux (instructor's permission)====
The main comprises a single, default thread. All other threads must be explicitly created by the programmer. 
The function pthread_create creates a new thread and makes it executable. This routine can be called any number of times from anywhere within your code. The maximum number of threads that may be created by a process is implementation dependent.
For example, the code below uses the number of arguments other than the file name (argc - 1) to create a given number of threads in the program.\\
There are many ways in which a thread may be terminated. The thread returns normally from its starting routine. It's work is done. The thread makes a call to the pthread_exit whether its work is done or not. The thread is canceled by another thread via the pthread_cancel routine. The entire process is terminated due to making a call to either the exec() or exit(). If main() finishes first, without calling pthread_exit explicitly itself.\\ 
\\
The program below uses the following pthread library functions:
\\
==int pthread_create(pthread_t * thread, const pthread_attr_t * attr, void * (*start_routine)(void *), void *arg)== 
  * thread: An opaque, unique identifier for the new thread returned by the subroutine. 
  * attr: An opaque attribute object that may be used to set thread attributes. You can specify a thread attributes object, or NULL for the default values. 
  * start_routine: the C routine that the thread will execute once it is created. 
  * arg: A single argument that may be passed to start_routine. It must be passed by reference as a pointer cast of type void. NULL may be used if no argument is to be passed. 
\\
==pthread_exit()==
pthread_exit() enables the programmer to specify an optional termination status parameter. This optional parameter is typically returned to threads "joining" the terminated thread.\\ 
Regarding the calling of pthread_exit from main, there is a problem if main finishes before the threads it created if pthread_exit() isn't called explicitly. All of the threads it created will terminate because main is done and no longer exists to support the threads. 
By having main explicitly call pthread_exit as the last thing it does, main will kept alive to support the threads it created until they are done.\\ 

\\
<file c threadTest.c>
//threadTest.c
//John T. Rine
//October 29, 2011

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void *PrintMessage(void *message)
{
   printf("%s\n", message);
   pthread_exit(NULL);
}

int main(int argc, char **argv)
{
        if(argc == 1)
        {
                printf("No threads specified, exiting...\n");
                exit(1);
        }
        pthread_t threads[argc - 1];
        int rc, t;
        for(t=0;t<argc - 1;t++)
        {
                printf("In main: creating thread %ld\n", t);
                rc = pthread_create(&threads[t], NULL, PrintMessage, *(argv + t + 1));
                if (rc)
                {
                        printf("ERROR; return code from pthread_create() is %d\n", rc);
                        exit(-1);
                }
        }
        pthread_exit(NULL);
}
</file>
\\
Compilation, linking, and execution of the code listed above:\\
<cli>
lab46:~/src/sysprog$ gcc threadTest.c -o threadTest -lpthread
lab46:~/src/sysprog$ ./threadTest
No threads specified, exiting...
lab46:~/src/sysprog$ ./threadTest John
In main: creating thread 0
John
lab46:~/src/sysprog$ ./threadTest John Thomas
In main: creating thread 0
In main: creating thread 1
John
Thomas
lab46:~/src/sysprog$ ./threadTest John Thomas Rine
In main: creating thread 0
In main: creating thread 1
John
In main: creating thread 2
Thomas
Rine
lab46:~/src/sysprog$
</cli>
==References==
  - http://softpixel.com/~cwright/programming/threads/threads.c.php
  - Understanding Unix/Linux System Programming-A Guide to Theory and Practice, Bruce Molay
  - https://computing.llnl.gov/tutorials/parallel_comp/
  - https://computing.llnl.gov/tutorials/pthreads/
  - http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html
  - http://www.cs.cf.ac.uk/Dave/C/node29.html
  - http://softpixel.com/~cwright/programming/threads/threads.c.php
  - http://www.csc.villanova.edu/~mdamian/threads/posixsem.html

====POSIX====
POSIX is an acronym for "**P**ortable **O**perating **S**ystem **I**nterface for Uni**X**". POSIX is the name of a set of related standards specified by the IEEE to define the application programming interface (API), along with shell and utilities interfaces, for software compatible with variants of the Unix operating system, although the standard can apply to any operating system. POSIX support guarantees code is portable from system to system and it is increasingly becoming a requirement that applications conform to POSIX standards. For example, the USA's Joint Technical Architecture—Army (JTA-A) standards set specifies that conformance to the POSIX standard is critical to support software interoperability.
<code>
Wikipedia (http://en.wikipedia.org/wiki/POSIX) lists items addressed in the various versions of POSIX:
Parts before 1997, POSIX comprised several standards:

POSIX.1, Core Services (incorporates Standard ANSI C) (IEEE Std 1003.1-1988) 
  * Process Creation and Control
  * Signals
  * Floating Point Exceptions
  * Segmentation / Memory Violations
  * Illegal Instructions
  * Bus Errors
  * Timers
  * File and Directory Operations
  * Pipes
  * C Library (Standard C)
  * I/O Port Interface and Control
  * Process Triggers

POSIX.1b, Real-time extensions (IEEE Std 1003.1b-1993) 
  * Priority Scheduling
  * Real-Time Signals
  * Clocks and Timers
  * Semaphores
  * Message Passing
  * Shared Memory
  * Asynch and Synch I/O
  * Memory Locking Interface

POSIX.1c, Threads extensions (IEEE Std 1003.1c-1995) 
  * Thread Creation, Control, and Cleanup
  * Thread Scheduling
  * Thread Synchronization
  * Signal Handling

POSIX.2, Shell and Utilities (IEEE Std 1003.2-1992) 
  * Command Interpreter
  * Utility Programs

Versions after 1997, the Austin Group developed the POSIX revisions. The specifications are known under the name Single UNIX Specification, before they become a POSIX standard when formally approved by the ISO.

POSIX:2001 or IEEE Std 1003.1-2001 equates to the Single UNIX Specification version 3[5]

This standard consisted of:
  * the Base Definitions, Issue 6,
  * the System Interfaces and Headers, Issue 6,
  * the Commands and Utilities, Issue 6.

POSIX:2004 or IEEE Std 1003.1-2004 involved a minor update of POSIX:2001. It incorporated two technical corrigenda.[6] Its contents are available on the web.[7]

POSIX:2008
As of 2009[update] POSIX:2008 or IEEE Std 1003.1-2008 represents the current version.[8][9] A free online copy is available.[10]
This standard consists of:
  * the Base Definitions, Issue 7,
  * the System Interfaces and Headers, Issue 7,
  * the Commands and Utilities, Issue 7.
</code>

==References==
  - http://en.wikipedia.org/wiki/POSIX
  - http://www.lynuxworks.com/products/posix/posix.php3
  - http://technet.microsoft.com/en-us/library/bb463220.aspx
  - http://stephesblog.blogs.com/papers/acm-posix.pdf

====Semaphores Revisited (instructor's consent)====
The semaphore is a synchronization method. A semaphore is a kernel variable that is accessible by all of the processes currently executing on the system.
Processes use semaphores to coordinate access to shared system resources between them. A semaphore is a counter; when it is zero, the semaphore can block a thread’s execution using sem_wait until another thread increments the counter using sem_post. 
The following example code came from http://pages.cs.wisc.edu/~travitch/pthreads_primer.html
This is the result of compiling, linking and then executing the example code listed above:\\
<code>
#include <semaphore.h>
#include <pthread.h>
#include <stdio.h>

#define THREADS 20

sem_t OKToBuyMilk;
int milkAvailable;

void* buyer(void *);

int main(int argc, char **argv)
{
	int i;
	pthread_t threads[THREADS];

	milkAvailable = 0;

	// Initialize the semaphore with a value of 1.
	// Note the second argument: passing zero denotes
	// that the semaphore is shared between threads (and
	// not processes).
	if(sem_init(&OKToBuyMilk, 0, 1))
	{
		printf("Could not initialize a semaphore\n");
		return -1;
	}

	for(i = 0; i < THREADS; ++i)
	{
		if(pthread_create(&threads[i], NULL, &buyer, NULL))
		{
			printf("Could not create thread %d\n", i);
			return -1;
		}
	}	

	for(i = 0; i < THREADS; ++i)
	{
		if(pthread_join(threads[i], NULL))
		{
			printf("Could not join thread %d\n", i);	
			return -1;
		}
	}

	sem_destroy(&OKToBuyMilk);

	// Make sure we don't have too much milk.
	printf("Total milk: %d\n", milkAvailable);

	return 0;
}

void* buyer(void *arg)
{
	// P()
	sem_wait(&OKToBuyMilk);
	if(!milkAvailable)
	{
		// Buy some milk
		++milkAvailable;
	}
	// V()
	sem_post(&OKToBuyMilk);

	return NULL;
}

</code>
<cli>
lab46:~/src/sysprog$ gcc testSemaphore.c -o testSemaphore -lpthread
lab46:~/src/sysprog$ ./testSemaphore
Total milk: 1
lab46:~/src/sysprog$
</cli>
==References==
  - http://pages.cs.wisc.edu/~travitch/pthreads_primer.html
  - http://www.cs.cf.ac.uk/Dave/C/node31.html
  - http://publib.boulder.ibm.com/infocenter/iseries/v5r3/index.jsp?topic=%2Frzahw%2Frzahwsemco.htm
  - http://www.csc.villanova.edu/~mdamian/threads/posixsem.html
====Mutexes (Mutual Exclusion)====
The mutex is a synchronization method. The word mutex means mutual exclusion (between threads in this usage) and is a combination of the two words as follows: **MUT**ual **EX**clusion. A mutex is used cooperatively between threads to guarantee that only one of the threads is allowed to access shared memory or run certain application code at a time.

 

==References==
  - http://pages.cs.wisc.edu/~travitch/pthreads_primer.html
  - http://www.cs.cf.ac.uk/Dave/C/node31.html
  - http://publib.boulder.ibm.com/infocenter/iseries/v5r3/index.jsp?topic=%2Frzahw%2Frzahwmutco.htm
====Barriers====
The barrier is a synchronization method. A barrier for a set of threads or processes makes any thread or process stop at mutex and cannot continue until the remaining threads or processes reach this barrier.
==References==
  - http://pages.cs.wisc.edu/~travitch/pthreads_primer.html
  - <html><a href="http://en.wikipedia.org/wiki/Barrier_(computer_science)">http://en.wikipedia.org/wiki/Barrier_(computer_science)</a></html>
====File Locks====
File locking is a device that controls access to a file by allowing only one process to access it at one time.
==References==
  - http://en.wikipedia.org/wiki/File_locking
  - http://windowsxp.mvps.org/processlock.htm (File locks and Windows)
====Asynchronous Input====
Asynchronous input, is a non-blocking type of I/O that allows other processing to continue while input is being received. 
\\
==References==
  - http://en.wikipedia.org/wiki/Asynchronous_I/O
  - http://www.answers.com/topic/asynchronous-input-output
====File Access====
First, Linux utilizes permissions bits to control file access. There are three types of access: read, write, and execute.
Also there is file locking which is a device that controls access to a file by allowing only one process to access it at one time.
\\
==References==
  - http://www.comptechdoc.org/os/linux/usersguide/linux_ugfilesp.html
  - http://en.wikipedia.org/wiki/File_locking
  - http://windowsxp.mvps.org/processlock.htm (File locks and Windows)
====System Calls====
Kernel space is protected, nothing contained in it can be used in a program (called) directly. There are therefore services which are provided to act as interfaces between applications in user space and the kernel. A system call is the only way a programmer may use these services.
==References==
  - http://en.wikipedia.org/wiki/System_call
  - http://www.gnu.org/s/hello/manual/libc/System-Calls.html
  - http://www.ibm.com/developerworks/linux/library/l-system-calls/
  - http://www.softpanorama.org/Internals/unix_system_calls.shtml 

====Bit Sets and Masks====
Individual bits within a larger data package, a byte for instance, can be used to represent something.
So rather than having a variable hold a value that represents only one thing, each bit within the variable can represent something.
One example of the use of bit sets would be using chmod to set file permissions.
Bit masks are used to manipulate only certain bits within a larger data package. Bit masking of data is carried out using two things, a bit mask, and a bitwise logical operation.
Bit masks are used to either select or deselect which bits are set or changed; bitwise operations actually change the data based on the bit mask value.
For example, data bits can be set using the bitwise or:\\
<code>
data = 00000000
mask = 01010101
data = data | bit mask
data = 01010101
</code>
\\
Data bits can be reset using bitwise and:
<code>
data = 11111111
mask = 01010101
data = data & bit mask
data = 01010101
</code>
\\
Other bitwise operations which can be used to bit mask and bit set repectively are exclusive or and complement.\\
==References==
  - http://www.somacon.com/p125.php
  - http://en.wikipedia.org/wiki/Bit_array 
  - http://en.wikipedia.org/wiki/Bitwise_operation
  - http://www.gamedev.net/page/resources/_/technical/general-programming/bitwise-operations-in-c-r1563
  - <html><a href="http://en.wikipedia.org/wiki/Mask_(computing">http://en.wikipedia.org/wiki/Mask_(computing)</a></html>


====Signals====
A signal is a software interrupt delivered to a process when an event occurs.\\  
The code below was taken from http://www.c.happycodings.com/Gnu-Linux/code18.html and is used to demonstrate how signals work in a program.\\
\\
<code>
//http://www.c.happycodings.com/Gnu-Linux/code18.html
//Signal, catch Ctrl-C

#include <stdio.h>
#include <unistd.h>  /* sleep(1) */
#include <signal.h>

void ex_program(int sig);

int main(void) {
 (void) signal(SIGINT, ex_program);

 while(1)
  printf("sleeping .. ZZZzzzz ....\n"), sleep(1);

 return 0;
}

void ex_program(int sig) {
 printf("Wake up call ... !!! - Catched signal: %d ... !!\n", sig);
 (void) signal(SIGINT, SIG_DFL);
}
</code>
\\
Executing the code listed above produces the following output:\\
<cli>
lab46:~/src/sysprog$ gcc sigTest.c -o sigTest
lab46:~/src/sysprog$ ./sigTest
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
^CWake up call ... !!! - Catched signal: 2 ... !!
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
sleeping .. ZZZzzzz ....
^C
lab46:~/src/sysprog$
</cli>
==References==
  - http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_21.html
  - http://publications.gbdirect.co.uk/c_book/chapter9/signal_handling.html
  - http://www.c.happycodings.com/Gnu-Linux/code18.html
  - http://www.cs.cf.ac.uk/Dave/C/node24.html
 

=====data Objective=====
====Objective-Data Structures in Applications====
I would like to become more familiar with the various data structures, specific uses for each and be able to use them in applications.

===Method===
I will learn more about linked-lists, stacks, queues, graphs and trees 
by:
  * Searching the Internet of information as well a code snippets.
  * Reading the Systems Programming text book and experimenting with the code.
  * Writing experimental code of my own.
  * Using the scientific method while performing experiments
\\
===Measurement===
Research and analysis of experimental results: see "Pushing" and "Popping" Part I Data Structures topics, also see "Overflow", "Underflow", "Linked list", "Queues", "malloc", "free" Part II Data Structures topics for details. 
\\
===Analysis===
I have written linked list and stack libraries using linked nodes. I have also written array-based stacks and queues, each have dynamically-sized arrays all which compiled, linked, and executed successfully.led, linked and executed successfully. 
=====hpc1 Objective=====
====Objective====
State the course objective; define what that objective entails.

===Method===
State the method you will use for measuring successful academic/intellectual achievement of this objective.

===Measurement===
Follow your method and obtain a measurement. Document the results here.

===Analysis===
Reflect upon your results of the measurement to ascertain your achievement of the particular course objective.

  * How did you do?
  * Room for improvement?
  * Could the measurement process be enhanced to be more effective?
  * Do you think this enhancement would be efficient to employ?
  * Could the course objective be altered to be more applicable? How would you alter it?
=====sysprog Objective=====
====Objective-Parallel Computing====
I would like to understand fork, what its purpose for being is and about spawning child processes in more detail.
I would also like to understand mutltithreading, thread synchronization in more detail. I would like to understand more about parallel computing and how fork and multithreading play a part 
\\
===Method===
I will learn more about concurrency, fork, child processes, multithreading, and thread synchronization 
by:
  * Searching the Internet of information as well a code snippets.
  * Reading the Systems Programming text book and experimenting with the code.
  * Writing experimental code of my own.
  * Using the scientific method while performing experiments
\\
===Measurement===
Research and analysis of experimental results: see "Threads", ""Multithreading", and "Semaphore" under Part I of the System programming topics, also see "Threads part deux", "Semiphores" and "Mutexes" Part II Systeme programming topics for details. 
\\
===Analysis===
I wrote a simple mulithreaded application which compiled, linked and executed successfully. Regarding semaphores, I experimented with code which I found on the Internet.
I was able, after modifying it, to compile, link and execute it. I worked with functions from both pthreads.h and semaphore.h.
=====Experiments=====
====Experiment 1-String Literals and pointers to Dynamically Allocated Memory====

===Question===
Is it possible to assign a string literal (using double-quotation marks), to a block of memory that has been dynamically allocated but has not had data yet assigned to it?

===Resources===
==References==
  - <html><a href="http://msdn.microsoft.com/en-us/library/8kc54dd5(v=vs.80).aspx">http://msdn.microsoft.com/en-us/library/8kc54dd5(v=vs.80).aspx</a></html>
  - http://ubuntuforums.org/showthread.php?t=357869
  - http://www.c-faq.com/decl/strlitinit.html
 
===Hypothesis===
Since it is possible to assign a string literal to a character pointer and then use it in a program (i.e.print out the data it points to), it should be possible to assign a string literal to pointer, pointing to a dynamically-allocated block of memory which hasn't yet been assigned data and then when the data is no longer needed, free it.\\
For example:\\
<file c testStringLiteral.c>
//testStringLiteral.c
//John T. Rine
//October 24, 2011

#include<stdio.h>

int main(int argc, char **argv)
{
        char * nameStringPTR = NULL;

        nameStringPTR = "John T. Rine";
        printf("nameStringPTR points to: %s\n:", nameStringPTR);
        return 0;
}
</file>
And the execution:\\
<cli>
lab46:~/src/data$ gcc testStringLiteral.c -o testStringLiteral
lab46:~/src/data$ ./testStringLiteral
nameStringPTR points to: John T. Rine
lab46:~/src/data$
</cli>
===Experiment===
This version of the testMalloc.c program corresponds to the first set of program output in the data section below.\\
<file c useMalloc.c>
//testMalloc.c
//John T. Rine
//October 24, 2011

#include<stdlib.h>
#include<stdio.h>


int main(int argc, char **argv)
{

        //malloc a char array
        char *arrayPTR = NULL;
        arrayPTR = malloc(sizeof(char) * 10);
        arrayPTR = "John Rine\0";
        printf("My name is: %s\n", arrayPTR);

        free(arrayPTR);

        return 0;
}
</file>
This version of the testMalloc.c program, with free commented out, corresponds to the second set of program output listed in the data section below.\\
<file c testMalloc.c>
//testMalloc.c
//John T. Rine
//October 24, 2011

#include<stdlib.h>
#include<stdio.h>


int main(int argc, char **argv)
{

        //malloc a char array
        char *arrayPTR = NULL;
        arrayPTR = malloc(sizeof(char) * 10);
        arrayPTR = "John Rine\0";
        printf("My name is: %s\n", arrayPTR);

        //free(arrayPTR);

        return 0;
}
</file>
This version of the testMalloc.c program, also with free commented out, corresponds to the third set of program output listed in the data section below. Note that printf function calls have been added to check the address contained in arrayPTR before and after assigning the string to the character pointer.\\
<file c testMalloc.c>
//testMalloc.c
//John T. Rine
//October 24, 2011

#include<stdlib.h>
#include<stdio.h>


int main(int argc, char **argv)
{

        //malloc a char array
        char *arrayPTR = NULL;
        arrayPTR = malloc(sizeof(char) * 10);
printf("The address contained in arrayPTR before assigning a string is: 0x%x\n", arrayPTR);
        arrayPTR = "John Rine\0";
printf("The address contained in arrayPTR before assigning a string is: 0x%x\n", arrayPTR);
        printf("My name is: %s\n", arrayPTR);

        //free(arrayPTR);

        return 0;
}
</file>
This last version of testMalloc.c assigns the individual characters in the string to the character-sized memory locations pointed to by the character pointer assigned to point to the dynamically allocated memory.
<file c testMalloc.c>
//testMalloc.c
//John T. Rine
//October 23, 2011

#include<stdlib.h>
#include<stdio.h>


int main(int argc, char **argv)
{

        //malloc a char array
        int i = 0;
        int ii = 0;
        char * inputString = "John T. Rine\0";
        char * string = NULL;

        printf("input string contains %s\n", inputString);
        while(*(inputString + i) != '\0') i++;
        printf("Character count = %d\n", i);
        string = (char *)malloc(sizeof(char) * (i + 1));
        for(ii = 0; ii <= (i + 1); ii++) *(string + ii) = *(inputString + ii);
        printf("Dynamically allocated array contains %s\n", string);

        free(string);

        return 0;
}
</file>
===Data===
Program output after assigning a string to a character pointer which points to a set of dynamically allocated character sized memory locations, printing out the contents pointed to, and then the freeing the memory. This output was created by the first version of the testMalloc.c program listed in the Experiment section listed above.\\
<cli>
lab46:~/src/data$ gcc testMalloc.c -o testMalloc
lab46:~/src/data$ ./testMalloc
My name is: John Rine
*** glibc detected *** ./testMalloc: free(): invalid pointer: 0x00000000004006cc ***
======= Backtrace: =========
/lib/libc.so.6(+0x71ad6)[0x7f9874d51ad6]
/lib/libc.so.6(cfree+0x6c)[0x7f9874d5684c]
./testMalloc[0x4005d6]
/lib/libc.so.6(__libc_start_main+0xfd)[0x7f9874cfec4d]
./testMalloc[0x4004c9]
======= Memory map: ========
00400000-00401000 r-xp 00000000 00:11 2147645911                         /home/jr018429/src/data/testMalloc
00600000-00601000 rw-p 00000000 00:11 2147645911                         /home/jr018429/src/data/testMalloc
01f1e000-01f3f000 rw-p 00000000 00:00 0                                  [heap]
7f9870000000-7f9870021000 rw-p 00000000 00:00 0
7f9870021000-7f9874000000 ---p 00000000 00:00 0
7f9874aca000-7f9874ae0000 r-xp 00000000 ca:01 57346                      /lib/libgcc_s.so.1
7f9874ae0000-7f9874cdf000 ---p 00016000 ca:01 57346                      /lib/libgcc_s.so.1
7f9874cdf000-7f9874ce0000 rw-p 00015000 ca:01 57346                      /lib/libgcc_s.so.1
7f9874ce0000-7f9874e38000 r-xp 00000000 ca:01 57396                      /lib/libc-2.11.2.so
7f9874e38000-7f9875037000 ---p 00158000 ca:01 57396                      /lib/libc-2.11.2.so
7f9875037000-7f987503b000 r--p 00157000 ca:01 57396                      /lib/libc-2.11.2.so
7f987503b000-7f987503c000 rw-p 0015b000 ca:01 57396                      /lib/libc-2.11.2.so
7f987503c000-7f9875041000 rw-p 00000000 00:00 0
7f9875041000-7f987505f000 r-xp 00000000 ca:01 57564                      /lib/ld-2.11.2.so
7f987524c000-7f987524f000 rw-p 00000000 00:00 0
7f987525b000-7f987525e000 rw-p 00000000 00:00 0
7f987525e000-7f987525f000 r--p 0001d000 ca:01 57564                      /lib/ld-2.11.2.so
7f987525f000-7f9875260000 rw-p 0001e000 ca:01 57564                      /lib/ld-2.11.2.so
7f9875260000-7f9875261000 rw-p 00000000 00:00 0
7fffca6cc000-7fffca6e1000 rw-p 00000000 00:00 0                          [stack]
7fffca6f3000-7fffca6f4000 r-xp 00000000 00:00 0                          [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
Aborted
lab46:~/src/data$
</cli>
Program output with free commented out. This output was created by the second version of the testMalloc.c program listed in the experiment section above.\\
<cli>
lab46:~/src/data$ ./testMalloc
My name is: John Rine
lab46:~/src/data$
</cli>
Program output with free commented out and with printf function calls to print out the address contained in arrayPTR before and after assigning the string to the character pointer. This program output was created by the third version of the testMalloc program listed in the experiment section above.\\
<cli>
lab46:~/src/data$ gcc testMalloc.c -o testMalloc
lab46:~/src/data$ ./testMalloc
The address contained in arrayPTR before assigning a string is: 0x86d010
The address contained in arrayPTR before assigning a string is: 0x4006f6
My name is: John Rine
lab46:~/src/data$
</cli>
This last set of program output corresponds the the last incarnation of the testMalloc.c program listed above in the experiment section.
<cli>
lab46:~/src/data$ gcc testMalloc.c -o testMalloc
lab46:~/src/data$ ./testMalloc
input string contains John T. Rine
Character count = 12
Dynamically allocated array contains John T. Rine
lab46:~/src/data$
</cli>
===Analysis===
Based on the data collected, my hypothesis was proven to not be correct.
The first verision of the testMalloc.c program crashed when free executed which seemed to indicate that the issue seemed to be misuse of the free function.
The second version of the program, in which free was commented out, ran flawlessly reinforcing the notion that the issue has to do with free.
The third version of the program introduced printf calls to print out the address of arrayPTR before and after the assignment of the string literal to it. This version of the program demonstrates that assigning a string literal to a pointer pointing to newly allocated and not yet used memory causes the address stored in the pointer to no longer point to the dynamically llocated memory, but to the beginning address of the string literal. Therefore, when free attempted to free memory no longer being pointed to, it caused an exception to be thrown.
The fourth and final version of the testMalloc.c program demonstrates that the proper way to assign a string to dynamically allocated memory in C is to do it character by character.\\ 
===Conclusions===
In C, even though it is possible to assign a string literal to a pointer and then use it, it is not possible to assign a string literal directly to a pointer pointing to dynamically allocated memory. This is because assigning a string literal to it changes the address stored in it so that when the memory is later freed, an exception is thrown because the pointer no longer points to the dynamically allocated memory.
====Experiment 2-Curses Library, Function (F) Keys, and Terminal and Keyboard Settings====
===Question===
Is it possible to use curses library input functions to handle and/or get function (F) keys in the same way that other key characters are handledretrieved?
\\
===Resources===
Currently, for my system programming projects, I am developing a GUI (**G**raphical **U**ser **I**nterface) interface, with which to program and display the results of operations (register values), for the 8085 CPU project begun in Computer Organization last sememster.\\
The GUI is to be developed using curses. I started with a function to read keyboardin input, however, the curses input function, getch, could not recognize the function (F) keys for some reason.
<cli>
Date: Sun, 18 Sep 2011 21:25:29 -0400 (EDT)
From: John Rine <jr018429@lab46.corning-cc.edu>
Reply-To: "\\\"Systems\\\" Classes Discussion List" <sys@lab46.corning-cc.edu>
To: sys@lab46.corning-cc.edu
Subject: [SYS] Trouble with Curses recognizing F keys and other keyboard keys

All,
I am having trouble with curses recognizing function keys and the escape key.
I am using code like this:
#include<curses.h>

int main()
{
    int c;
    initscr();
    keypad(stdscr,TRUE);
    noecho();
    move(0,0);
    c=getch();
    while(c != KEY_F(1) && c != 'q')
    {
        move(0,0);
        printw("%c\n",c);
        refresh();
        c=getch();
    }
    endwin();
    return 0;
}
it will exit with 'q' but not KEY_F(1) or the F1 key. Also, the esc key is not recognized when using the KEY_EXIT constant. Anyone have any ideas as to how to get
function keys and the escape key to work with curses?

thanks,

John T. Rine

---
 Lab46: Penguin Powered
</cli>
\\
The instructor stated that he didn't have experience with curses and functions keys, but that this question could be the basis for an experiment; he challenged me to, using the scientific method, put together a hypothesis and a set of experiments whose outcome would help me answer the question posed.\\ 
<cli>
Date: Mon, 19 Sep 2011 08:43:07 -0400
From: Matthew Haas <wedge@lab46.corning-cc.edu>
Reply-To: "\\\"Systems\\\" Classes Discussion List" <sys@lab46.corning-cc.edu>
To: sys@lab46.corning-cc.edu
Subject: Re: [SYS] Trouble with Curses recognizing F keys and other keyboard keys

On 09/18/2011 09:25 PM, John Rine wrote:
>
> I am having trouble with curses recognizing function keys and the escape key.
> I am using code like this:
> #include<curses.h>
>
> int main()
> {
>     int c;
>     initscr();
>     keypad(stdscr,TRUE);
>     noecho();
>     move(0,0);
>     c=getch();
>     while(c != KEY_F(1) && c != 'q')
>     {
>         move(0,0);
>         printw("%c\n",c);
>         refresh();
>         c=getch();
>     }
>     endwin();
>     return 0;
> }
> it will exit with 'q' but not KEY_F(1) or the F1 key. Also, the esc key is not recognized when using the KEY_EXIT constant. Anyone have any ideas as to how to get
> function keys and the escape key to work with curses?

I've never played with the function keys... so that would take some experimenting.
Escape, even though there may not be a #define for it (all the keys available to you are #define'd in /usr/include/curses.h, check it out), has a value.
The trick is, what is it? Hmm... this could be another experiment.
If you know that pretty much every key on the keyboard has a value (which ones do not have a direct value?), how could we figure out what the values of keys are?
What is the data type of the 'c' variable in the program above?
What type of data are we displaying in the printw() function call above?
Could you perhaps CHANGE the format specifier to match the actual data type of the 'c' variable? What would happen then?
If you then compile and run the program and start pressing keys, what happens? What do you see when you press 'a', 'A', spacebar? Do you know what these values
correspond to?
What do you think happens when you start pressing some keys that do not directly have printable characters associated with them, like... escape. What does it
display?

-Matthew
--
 Matthew Haas
 Lab46 System Administrator
 Instructor of Computer&  Information Science
 http://lab46.corning-cc.edu/haas/home/

_______________________________________________
SYS mailing list
SYS@lab46.corning-cc.edu
http://lab46.corning-cc.edu/mailman/listinfo/sys
</cli>
\\
==References==
  - http://fixunix.com/bsd/88211-ncurses-function-keys.html
  - http://www.cplusplus.com/forum/unices/670/
  - http://stackoverflow.com/questions/3468851/gnu-compiler-key-f-not-detecting-function-keys
  - http://linux.die.net/man/3/getch
  - http://osr600doc.sco.com/en/man/html.CURSES/getnstr.CURSES.html

===Hypothesis===
Based on what I've read, it should be possible to uses curses library functions to handle function key input.
\\
===Experiment===
Since I was having trouble getting curses functions to recognize function (F) keys, I designed a simple program to read keyboard input using a curses function and then printed out the results. The program has the minium required to read and verify keyboard input.
\\
<code>
//curseskeys.c
//John T. Rine
//October 29, 2011

#include <ncurses.h>

int main()
{       int ch;

        initscr();
        raw();
        keypad(stdscr, TRUE);
        noecho();

        printw("Type any character\n");
        ch = getch();
        if(ch == KEY_F(1))
                printw("F1 Key pressed");
         else
        {       printw("The pressed key is ");
                printw("%c", ch);
        }
        refresh(); 
        getch();
        endwin();
        return 0;
}
</code>
\\
Since the F keys were not being recognized by the curses getch function, I wrote a program that gets keyboard input from stdin and stores it in an array. I then print out the characters stored in the array.\\  
\\
<code>
//getFkeys.c
//John T. Rine
//October 29, 2011

#include<stdio.h>

int main(int argc, char **argv)
{
        char array[10] = { 0 };
        int i;
        char c;
        fgets(array,9,stdin);
        for (i = 0; i < 10; i++) printf("Array[%d] = %d\n", i, array[i]);

        return 0;
}
</code>
\\
===Data===
curseskeys.c execution with puTTY keyboard function and keyboard keys set to ESC[n~.\\
{{:opus:fall2011:jr018429:puttykeyboard1jpg.jpg?200|}}\\
Result of entering the character 'a':\\
<cli>
Type any character
The pressed key is a
</cli>
\\
Result of entering the F1 key:\\
<cli>
lab46:~/src/sysprog$ ./curseskeys
lab46:~/src/sysprog$ ~
</cli>
\\
\\
curseskeys.c execution with puTTY keyboard function and keyboard keys set to VT100+.\\
{{:opus:fall2011:jr018429:puttykeyboard2jpg.jpg?200|}}\\
Result of entering the 'a' key:\\
<cli>
Type any character
The pressed key is a
</cli>
\\
Result of entering the F1 key:\\
<cli>
Type any character
F1 Key pressed
</cli>
\\
\\
getFkeys.c execution with puTTY keyboard function and keyboard keys set to ESC[n~.\\
{{:opus:fall2011:jr018429:puttykeyboard1jpg.jpg?200|}}\\
Result of entering the character 'a':\\
<cli>
lab46:~/src/sysprog$ ./getFkeys
a
Array[0] = 97
Array[1] = 10
Array[2] = 0
Array[3] = 0
Array[4] = 0
Array[5] = 0
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
</cli>
\\
Result of entering the F1 key:\\
<cli>
lab46:~/src/sysprog$ ./getFkeys
^[[11~
Array[0] = 27
Array[1] = 91
Array[2] = 49
Array[3] = 49
Array[4] = 126
Array[5] = 10
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
lab46:~/src/sysprog$
</cli>
\\
getFkeys.c execution with puTTY keyboard function and keyboard keys set to VT100+.\\
{{:opus:fall2011:jr018429:puttykeyboard2jpg.jpg?200|}}\\
Result of entering the character 'a':\\
<cli>
lab46:~/src/sysprog$ ./getFkeys
a
Array[0] = 97
Array[1] = 10
Array[2] = 0
Array[3] = 0
Array[4] = 0
Array[5] = 0
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
lab46:~/src/sysprog$
</cli>
\\
Result of entering the F1 key:\\
<cli>
lab46:~/src/sysprog$ ./getFkeys
^[OP
Array[0] = 27
Array[1] = 79
Array[2] = 80
Array[3] = 10
Array[4] = 0
Array[5] = 0
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
lab46:~/src/sysprog$
</cli>
\\
===Analysis===
The data (program output from curseskeys.c) indicates that in order to use the curses getch function to get function (F) key input, the keyboard setting in puTTY must be set to something other than ESC[n~. The program executions that were able to read function (F) key input in this experiment were performed with the keyboad setting st to VT100+. 
The data collected from the the program output of getFkeys.c indicates that the keyboard/terminal settings do infact influence what is returned from a function (F) key keypress.
With the puTTY keyboard/function key setting set to ESC[n~, the output of getFkeys.c with a character input of 'a' is:
<code>
a
Array[0] = 97
Array[1] = 10
Array[2] = 0
Array[3] = 0
Array[4] = 0
Array[5] = 0
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
</code>
\\
whereas the output with the puTTY keyboard/function key setting set as above, the output of getFkeys.c with a keyboard input of F1 is:
<code>
^[[11~
Array[0] = 27
Array[1] = 91
Array[2] = 49
Array[3] = 49
Array[4] = 126
Array[5] = 10
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
</code>
\\
\\
With the puTTY keyboard/function key setting set to VT100+, the output of getFkeys.c with a character input of 'a' is:
<code>
a
Array[0] = 97
Array[1] = 10
Array[2] = 0
Array[3] = 0
Array[4] = 0
Array[5] = 0
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
</code>
\\
whereas the output with the puTTY keyboard/function key setting set as above, the output of getFkeys.c with a keyboard input of F1 is:
<code>
^[OP
Array[0] = 27
Array[1] = 79
Array[2] = 80
Array[3] = 10
Array[4] = 0
Array[5] = 0
Array[6] = 0
Array[7] = 0
Array[8] = 0
Array[9] = 0
</code>
indicating that the keyboard/terminal settings do NOT influence what is returned when a character key is pressed, but do influence what is returned when a function (F) key is pressed.
\\
===Conclusions===
Since it appears that the terminal keyboard/function key setting does influence what is returned when a function (F) key is pressed, it would be a good idea to guarantee termminal settings before an applications, using function keys, executes. This could, or should be able to be accomplished either through the use of a shell script, modifying a system configuration file, or through the use of a programming library. 
====Experiment 3-Header Files, Compiling, and Linking====

===Question===
If the library header file for functions used in a program is included in a source file, shouldn't compiling the source file alone cause the creation of an executable (that is linking is automatic, after all, the header file for the library was included in the source file)?

===Resources===
==References==
  - http://www.network-theory.co.uk/docs/gccintro/gccintro_17.html 
  - http://www.cs.duke.edu/~ola/courses/programming/libraries.html
===Hypothesis===
Based on what I've read it should not link successfuly because standard c libraries are located in libc.so, while the math library is located in libm.so. The standard c libraries are linked by default, whereas the math library is not. 
===Experiment===
I used the following program to collect data for the experiment. This file has math.h and stdio.h headers file included in the source file.\\
<code>
//mathTest.c
///John T. Rine
//October 30, 2011

#include <math.h>
#include <stdio.h>

int main (int argc, char **argv)
{
        double x = 0;
        printf("Enter a value to takes its square root\n");
        scanf("%lf", &x);
        printf ("The square root of %lf is %lf\n", x, sqrt(x));
        return 0;
}
</code>
===Data===
These are the results of the first attempt at compiling mathTest.c; the exact invocation of the gcc compiler uses was: gcc mathTest.c -o mathTest
<cli>
lab46:~/src/sysprog$ gcc mathTest.c -o mathTest
/tmp/ccJHwf08.o: In function `main':
mathTest.c:(.text+0x51): undefined reference to `sqrt'
collect2: ld returned 1 exit status
lab46:~/src/sysprog$
</cli>
\\
These are the results of the second attempt at compiling mathTest.c; the exact invocation of the gcc compiler used was: gcc mathTest.c -o mathTest -lm
<cli>
lab46:~/src/sysprog$ gcc mathTest.c -o mathTest -lm
lab46:~/src/sysprog$
</cli>
\\
This are the results of executing the program after successfully compiling and linking it.\\
<cli>
lab46:~/src/sysprog$ ./mathTest
Enter a value to takes its square root
144
The square root of 144.000000 is 12.000000
lab46:~/src/sysprog$
</cli>
===Analysis===
My hypothesis was correct as can be seen from the data collected from the experiment. If the math library is not linked, no executable is created, however, if the math library is linked, them the executable is created successfully.
===Conclusions===
If a library is not part of the C standard library, when the program is being compiled and linked there must be something to indicate what should be linked.\\
Since curses is not part of the C standard library, what happened while compiling and linking the math library will also occur when a curses program is compiled and linked.\\ 
For example compiling and linking a curses program without indicating what should be linked:\\
<cli>
lab46:~/src/sysprog$ gcc curseskeys.c -o curseskeys
/tmp/cco3mJn0.o: In function `main':
curseskeys.c:(.text+0x9): undefined reference to `initscr'
curseskeys.c:(.text+0xe): undefined reference to `raw'
curseskeys.c:(.text+0x15): undefined reference to `stdscr'
curseskeys.c:(.text+0x22): undefined reference to `keypad'
curseskeys.c:(.text+0x27): undefined reference to `noecho'
curseskeys.c:(.text+0x36): undefined reference to `printw'
curseskeys.c:(.text+0x3d): undefined reference to `stdscr'
curseskeys.c:(.text+0x45): undefined reference to `wgetch'
curseskeys.c:(.text+0x60): undefined reference to `printw'
curseskeys.c:(.text+0x71): undefined reference to `printw'
curseskeys.c:(.text+0x85): undefined reference to `printw'
curseskeys.c:(.text+0x8c): undefined reference to `stdscr'
curseskeys.c:(.text+0x94): undefined reference to `wrefresh'
curseskeys.c:(.text+0x9b): undefined reference to `stdscr'
curseskeys.c:(.text+0xa3): undefined reference to `wgetch'
curseskeys.c:(.text+0xa8): undefined reference to `endwin'
collect2: ld returned 1 exit status
lab46:~/src/sysprog$
</cli>
Compiling and linking a curses program with an indication of what should be linked:\\
<cli>
lab46:~/src/sysprog$ gcc curseskeys.c -o curseskeys -lcurses
lab46:~/src/sysprog$
</cli>
\\
It is an interesting observation that the math library is linked as -lm and its dynamic library file name is libm.so. The curses library is linked as -lcurses; this implies that the curses dynamic library file name should be libcurses.so.
Since the math library is included in a source file as #include<math.h>, and since the curses library is included in a source file as #include<curses.h>, then these dynamic libraries should be in the same path and also be in the same path as the c standard library (libc.so). A search for libcurses.so, therefore, int the c library path should be successful; there should be a dynamic library file by the name of libcurses.so in the c library path.
Lab46 Wiki

User Tools

Site Tools

Page Tools
