Declare ptr char array.
Declare temp buffer: char temp[SIZE];
Declare counter for the temp.
Declare counter for the array (where we put temp after we come to a space).

Loop for the size of the command line:
if current character is NOT a space
    place into temp at temp's counter: ie: temp[temp_counter] = command_line[command_line_counter];
else
    place temp into the array
    increment array counter
    reset temp's counter to zero
    zero out temp with '\0'

#include "stdio.h"
#include "stdlib.h"

#include <string.h>
#include <unistd.h>
#include <sys/types.h>


int mainLoop();
void getCommandLineInput();
void loadCommands();
void executeCommand(char* command, char* commandLine);
void executeCommand2(char* command, char* commandLine);

const int MAX_BUF = 30;
const int MAX_ARGUMENTS = 5;

char commandLineInput[MAX_BUF];


int main()
{
        return mainLoop();
}

int mainLoop()
{
        int exitFlag = 0;
        bool run = true;

        while(run)
        {
		printf("Type in a string to be parsed. Type exit to quit.\n");
                getCommandLineInput();


                //We need to break the input up to isolate the exact command.
                //Iterate until a space is located.
                char command[MAX_BUF];
                char arguments[MAX_BUF];
                bool writeCommand = true;
                int arg_counter = 0;

                for(int i = 0;i<MAX_BUF;i++)
                {
                        arguments[i] = '\0';
                        command[i] = '\0';

                        if(writeCommand == true && commandLineInput[i] != ' ')
                                command[i] = commandLineInput[i];
                        else
                        {
                                if(writeCommand)
                                        writeCommand = false;
                                else
                                {
                                        arguments[arg_counter] = commandLineInput[i];
                                        arg_counter++;
                                }
                        }
                }

                printf("The command is: %s\n", command);
                printf("The arguments are: %s\n", arguments);

                if(!strcmp(commandLineInput, "exit"))
                {
                        printf("Exiting\n");
                        break;
                }


                executeCommand(command, arguments);
        }


        return exitFlag;
}

//Gets the input from stdin and puts it into the global variable.
void getCommandLineInput()
{

        gets(commandLineInput);

        //printf("%s\n", commandLineInput);

}

void executeCommand(char *command, char* commandLineInput)
{
        char *arglist[MAX_ARGUMENTS];

        int size = strlen(commandLineInput);
        char temp[size];
        int i;
        for(i = 0;i<size;i++)
                temp[i] = '\0';
        for(i = 0;i<MAX_ARGUMENTS;i++)
                arglist[i] = new char;

        arglist[0] = command;
        int temp_counter = 0;
        int arg_counter = 1;

        bool quote = false;
        for(i = 0;i<size;i++)
        {
		//Put the characters in the temp buffer if its not a space or if we are in a quote
                if(commandLineInput[i] != ' ' || quote == true)
                {
                        printf("looking at: %c\n", commandLineInput[i]);
                        temp[temp_counter] = commandLineInput[i];
                        temp_counter++;

			//ok reached either the beginning or the end so negate it.
                        if(commandLineInput[i] == '\"')
                                quote = !quote;
                }
                else
                {
                        int j;

			//horrible code - i really can't figure this out.
			//i've tried strdup, sprintf, strcpy, strncpy, and manually copying the contents over but it still gives me problems.

                        temp[temp_counter] = '\0';
                        char *temp2 = strdup(temp);

			//display the results and add in terminators.
                        for(j=temp_counter;j<size;j++)
                        {
                                temp[temp_counter] = '\0';
                                printf("temp[%d]: %c\n", j, temp[j]);
                        }


			//set the temp2 to the arglist. temp2 is not referenced to the other items in the arglist array.
                        arglist[arg_counter] = temp2;

			//display some debug information
                        printf("temp2: %s\n", temp2);
                        printf("temp: %s\n", temp);
                        printf("arglist: %s\n", arglist[arg_counter]);

			//result the counters
                        arg_counter++;
                        temp_counter = 0;

                        //zero out temp
                        for(j = 0;j<size;j++)
                                temp[j] = '\0';
                }
        }


	//since the loop terminates before it puts in the last item, we manually do it here.
        printf("temp: %s\n", temp);
        arglist[arg_counter] = temp;
        arg_counter++;

	//display the contents
        for(i =0;i<arg_counter;i++)
        {
                printf("arg: %s\n", arglist[i]);
        }


	//copy it to a new arg list because exec will exec the commands the number of times according to the size of arglist.
	//so with the way this currently works, we dont know the size of the commands before we allocate the arglist var above.


        //new arg list.
        char * arglist2[arg_counter+1];

	//reset the memory locations
        for(i = 0;i<(arg_counter+1);i++)
                arglist2[i] = new char;

	//display some debug info
        printf("arg counter +1: %d\n", (arg_counter+1));

	//copy the contents over.
        for(i = 0;i<(arg_counter+1);i++)
        {
                arglist2[i]=arglist[i];
                printf("arg2: %s\n", arglist2[i]);
        }

        printf("Command: %s\n", command);


	return;

	//execute the command
	pid_t pid;

        pid = fork();

        if (pid < 0)
        {
                fprintf(stderr, "Fork failed.\n");
                exit(2);

        }
        if (pid == 0)
        {
              if( execvp(command, arglist) == -1)
                {
                        fprintf(stderr, "Execl Failed\n");
                        exit(3);

                }
        }
        printf("Parent(shell) continues.\n");
	
}

arglist[0] = pointer to arg1 string
arglist[1] = pointer to arg2 string
arglist[2] = pointer to arg3 string
arglist[3] = NULL (literally set it to NULL)
arglist[4+] = invalid and ignored

// gets user input from stdin and puts it into global buffer.  returns 1 on success, and 0 on failure.
int getCommandLineInput()
{
  printf("> ");  // CLI input prompt
  fflush(stdout);  // flush the stream to force output of the prompt
  if(fgets(commandLineInput, MAX_BUF, stdin) != NULL)
    return 1;  // success
  else
    return 0;  // failure
}

#include <stdio.h>

char **arrayOfCharPointers(void);

int main(void)
{
  char **array = arrayOfCharPointers();
  while(*array != NULL)
    puts(*(array++));
  system("pause");
  return 0;
}

char **arrayOfCharPointers(void)
{
  static char *array[5] = {"one", "two", "three", "four", NULL};
  return array;
}