#include "cgc_planetParsers.h"
int cgc_planetMenu( pPlanet pl )
{
	int choice = 0;
	char selection[30];
	cgc_size_t length = 0;
	pCountry pc = NULL;
	if ( pl == NULL ) {
		return 0;
	}
	while ( 1 ) {
		cgc_bzero(selection, 30);
		cgc_printf("\nPlanet: @s\n", pl->name);
		cgc_printf("1) Display planet information\n");
		cgc_printf("2) Set Period\n");
		cgc_printf("3) Set Orbit Speed\n");
		cgc_printf("4) Set Aphelion\n");
		cgc_printf("5) Set Perihelion\n");
		cgc_printf("6) Set Mean Radius\n");
		cgc_printf("7) Set Equatorial Radius\n");
		cgc_printf("8) Set Mass\n");
		cgc_printf("9) Set Gravity\n");
		cgc_printf("10) Set population\n");
		cgc_printf("11) Add Country\n");
		cgc_printf("12) Select country\n");
		cgc_printf("13) Delete Planet and exit menu\n");
		cgc_printf("14) Exit menu\n");
		cgc_printf("Selection: ");
		cgc_receive_until(selection, '\n', 3);
		choice = cgc_atoi( selection );
		switch ( choice ) {
			case 1:
				{cgc_printPlanetInfo( pl );}
				break;
			case 2:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->period = cgc_atof(selection);
				break;
			case 3:
				{cgc_printf("\n-> ");}
				cgc_receive_until(selection, '\n', 10);
				pl->orbitspeed = cgc_atof(selection);
				break;
			case 4:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->aphelion = cgc_atof(selection);
				break;
			case 5:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->perihelion = cgc_atof(selection);
				break;
			case 6:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->radius = cgc_atof(selection);
				break;
			case 7:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->eradius = cgc_atof(selection);
				break;
			case 8:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->mass = cgc_atof(selection);
				break;
			case 9:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->gravity = cgc_atof(selection);
				break;
			case 10:
				{cgc_printf("\n-> ");}
				cgc_receive_until( selection, '\n', 10);
				pl->population = cgc_atoi(selection);
				break;
			case 11:
				{if ( pl->country_count >= COUNTRYMAX ) {
					cgc_printf("Too many countries\n");
					continue;
				}}
				cgc_printf("\nNew Name: ");
				cgc_receive_until(selection, '\n', 19);
				choice = 0;
				while ( choice < COUNTRYMAX ) {
					if ( pl->countries[choice] == NULL ) {
						break;
					}
					choice++;
				}
				if ( choice == COUNTRYMAX ) {
					cgc_printf("!!No country slots\n");
					continue;
				}
				if ( cgc_allocate( sizeof(Country), 0, (void**)(&pc) ) != 0 ) {
					cgc_printf("!!Failed to allocate structure\n");
					continue;
				}
				cgc_initCountry( pc );
				pl->countries[choice] = pc;
				length = 0;
	
				while ( cgc_isalnum( selection[length] ) ) {
					pc->name[length] = selection[length];
					length++;
				}
				pc->name[length] = '\x00';
				pl->country_count++;
				break;
			case 12:
				{cgc_printf("\nCountries:\n");}
				for ( choice = 0; choice < pl->country_count; choice++ ) {
					if ( pl->countries[choice] != NULL ) {
						cgc_printf("@d) @s\n", choice + 1, pl->countries[choice]);
					}
				}
				cgc_bzero(selection, 30);
				cgc_printf("\n-> ");
				cgc_receive_until( selection, '\n', 3 );
				choice = cgc_atoi(selection);
				if ( choice < 1 || choice > COUNTRYMAX) {
					cgc_printf("Invalid choice...\n");
					continue;
				} else {if ( pl->countries[ choice-1] == NULL ) {
					cgc_printf("Invalid choice...\n");
					continue;
				}}
				if ( cgc_countryMenu( pl->countries[choice-1]) == 0 ) {
					pl->countries[choice-1] = NULL;
					pl->country_count--;
				}
				break;
			case 13:
				{cgc_freePlanet( pl );}
				return 0;
				break;
			case 14:
				{return 1;}
				break;
			default:
				{cgc_printf("Invalid...\n");}
				break;
		};
	}
end:
	return 1;
}
void cgc_freePlanet( pPlanet pl )
{
	int index = 0;
	if ( pl == NULL ) {
		return;
	}
	/// Free all of the associated countries
	while ( index < COUNTRYMAX ) {
		if ( pl->countries[ index] != NULL ) {
			/// This function also frees the pointer so freePlanet does not have to.
			cgc_freeCountry( pl->countries[index] );
			pl->countries[index] = NULL;
		}
		index++;
	}
	
	cgc_deallocate( pl, sizeof(Planet) );
	return;
}
void cgc_printPlanetInfo( pPlanet pl )
{
        int index = 0;
        if ( pl == NULL ) {
                return;
        }
        if ( pl->name[0] == '\x00' ) {
                cgc_printf("Name: Unknown\n");
        } else {
                cgc_printf("Name: @s\n", pl->name );
        }
        if ( pl->population >= 0 ) {
                cgc_printf("\tPopulation: @d\n", pl->population);
        }
        if ( pl->period >= 0.0 ) {
                cgc_printf("\tPeriod: @f\n", pl->period);
        }
        if ( pl->orbitspeed >= 0.0 ) {
                cgc_printf("\tOrbit Speed: @f\n", pl->orbitspeed);
        }
        if ( pl->aphelion >= 0.0 ) {
                cgc_printf("\tAphelion: @f\n", pl->aphelion);
        }
        if ( pl->perihelion >= 0.0 ) {
                cgc_printf("\tPerihelion: @f\n", pl->perihelion);
        }
        if ( pl->radius >= 0.0 ) {
                cgc_printf("\tRadius: @f\n", pl->radius);
        }
        if ( pl->eradius >= 0.0 ) {
                cgc_printf("\tERadius: @f\n", pl->eradius);
        }
        if ( pl->mass >= 0.0 ) {
                cgc_printf("\tMass: @f\n", pl->mass);
        }
	
	if ( pl->gravity >= 0.0 ) {
		cgc_printf("\tGravity: @f\n", pl->gravity);
	}
	/// Print each country's information
        while ( index < COUNTRYMAX ) {
                if ( pl->countries[ index ] != NULL ) {
                        cgc_printCountryInfo( pl->countries[index] );
                }
                index++;
        }
        return;
}
void cgc_initPlanet( pPlanet pl )
{
        register int index = 0;
        if ( pl == NULL ) {
                return;
        }
        cgc_bzero( pl->name, 20 );
        pl->period = -1.0;
        pl->orbitspeed = -1.0;
        pl->aphelion = -1.0;
        pl->perihelion = -1.0;
        pl->radius = -1.0;
        pl->eradius = -1.0;
        pl->mass = -1.0;
        pl->gravity = -1.0;
        pl->population = -1.0;
        pl->country_count = 0;
        while ( index < COUNTRYMAX ) {
                pl->countries[index] = NULL;
                index++;
        }
        return;
}
pPlanet cgc_planetTopLevel( pstring topLevel )
{
	int endIndex = 0;
        int temp_index = 0;
        pPlanet newPlanet = NULL;
        element el;
        char *fl = NULL;
        int lastGood = 0;
        if ( topLevel == NULL ) {
                goto end;
        }
        /// Skip any leading spaces
        cgc_skipWhiteSpace( topLevel );
	lastGood = topLevel->index;
	if ( topLevel->maxlength < 9 ) {
		goto end;
	}
	char *c = "{Planet}";
	for ( int i = 0; i < 8; i++ ) {
		if ( topLevel->buffer[ topLevel->index + i ] != c[i] ) {
			goto end;
		}
	}
        /// Skip 8 bytes of top level then any whitespace
        topLevel->index += 8;
	cgc_skipWhiteSpace( topLevel );
        /// Allocate a new planet structure
        if ( cgc_allocate( sizeof(Planet), 0, (void**)&newPlanet) != 0 ) {
                goto end;
        }
        cgc_initPlanet( newPlanet );
        /// Extract the next element name
        fl = cgc_pullNextElementName( topLevel );
        cgc_getIndex( topLevel, &lastGood);
        while ( fl != NULL ) {
                /// Convert the element name
                el = cgc_elementNameToEnum( fl );
                /// The name is no longer needed so free it
                cgc_deallocate( fl, cgc_strlen(fl) + 1 );
                switch (el) {
                        case name:
                                {fl = cgc_extractName( topLevel );}
                                if ( fl == NULL ) {
                                        goto error;
                                }
				cgc_bzero( newPlanet->name, 20 );
                                cgc_strncpy( newPlanet->name, fl, 19 );
                                cgc_deallocate(fl, cgc_strlen(fl) + 1 );
                                fl = NULL;
                                break;
                        case population:
                                {newPlanet->population = cgc_extractPopulation( topLevel );}
                                if ( newPlanet->population < 0 ) {
                                        goto error;
                                }
                                break;
                        case period:
                                /// Extract period and check result
                                {newPlanet->period = cgc_extractPeriod( topLevel );}
                                if ( newPlanet->period < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case orbitspeed:
                                {newPlanet->orbitspeed = cgc_extractOrbitSpeed( topLevel );}
                                if ( newPlanet->orbitspeed < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case aphelion:
                                {newPlanet->aphelion = cgc_extractAphelion( topLevel );}
                                if ( newPlanet->aphelion < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case perihelion:
                                {newPlanet->perihelion = cgc_extractPerihelion( topLevel );}
                                if ( newPlanet->perihelion < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case radius:
                                {newPlanet->radius = cgc_extractRadius( topLevel );}
                                if ( newPlanet->radius < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case eradius:
                                {newPlanet->eradius = cgc_extractERadius( topLevel );}
                                if ( newPlanet->eradius < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case mass:
                                {newPlanet->mass = cgc_extractMass( topLevel );}
                                if ( newPlanet->mass < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case gravity:
                                {newPlanet->gravity = cgc_extractGravity( topLevel );}
                                if ( newPlanet->gravity < 0.0 ) {
                                        goto error;
                                }
                                break;
                        case country:
                                {if ( newPlanet->country_count >= COUNTRYMAX ) {
                                        cgc_printf("!!Only @d countries allowed\n", COUNTRYMAX);
                                        goto error;
                                }}
                                newPlanet->countries[ newPlanet->country_count] = cgc_countryTopLevel(topLevel);
                                if (newPlanet->countries[ newPlanet->country_count ] == NULL ) {
                                        goto error;
                                }
                                newPlanet->country_count++;
                                break;
                        default:
                                {cgc_printf("Not allowed under Planet\n", fl);}
                                goto error;
                                break;
                };
                cgc_getIndex( topLevel, &lastGood );
                fl = cgc_pullNextElementName( topLevel );
        }
        /// Since no more valid elements need to be parsed, check the closing element
        cgc_skipWhiteSpace( topLevel );
        if ( !cgc_atChar( topLevel, '{' ) ) {
                cgc_printf("!!Closing value failed for Planet\n");
                goto error;
        }
        /// Skip the open brace
        if ( cgc_incChar( topLevel ) < 0 ) {
                goto error;
        }
        cgc_skipWhiteSpace( topLevel );
        if ( !cgc_atChar( topLevel, '#' ) ) {
                cgc_printf("!!Malformed closing element\n");
                goto error;
        }
        /// Skip past #
        if ( cgc_incChar( topLevel ) == -1 ) {
                goto error;
        }
        cgc_getIndex( topLevel, &temp_index );
        endIndex = cgc_skipAlpha( topLevel );
        if ( endIndex == -1 ) {
                endIndex = 0;
                goto error;
        }
        if ( temp_index == endIndex ) {
                goto error;
        }
        fl = cgc_copyData( topLevel, temp_index, endIndex );
        if ( fl == NULL ) {
                goto error;
        }
        if ( cgc_strcmp( fl, "Planet") != 0 ) {
                cgc_printf("!!Closing element malformed\n");
                cgc_deallocate( fl, (endIndex-temp_index) + 1 );
                goto error;
        }
        cgc_deallocate(fl, (endIndex-temp_index) + 1 );
        cgc_skipWhiteSpace( topLevel );
        if ( !cgc_atChar( topLevel, '}' ) ) {
                cgc_printf("!!Failed to find final closing brace\n");
                goto error;
        }
        cgc_incChar(topLevel);
	
        goto end;
error:
        topLevel->index = lastGood;
        cgc_printf("!!Error at: @s\n", topLevel->buffer + topLevel->index);
	if ( newPlanet != NULL ) {
		cgc_freePlanet( newPlanet );
		newPlanet = NULL;
	}
end:
        return newPlanet;
}
double cgc_extractPeriod( pstring str )
{
	char *temp = NULL;
	double period = -1.0;
	int start = 0;
	int end = 0;
	/// These will be used specifically for the data
	int ps = 0;
	int pe = 0;
	if (str == NULL ) {
		return period;
	}
	cgc_skipWhiteSpace(str);
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		return period;
	}
	/// Skip past the curly brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return period;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		return period;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "Period" then this is the wrong function
	if ( cgc_strcmp( temp, "Period") != 0 ) {
		cgc_printf("!!Element id is not \"Period\"\n");
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		return period;
	}
	/// The buffer is no longer needed so free it
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		return -1.0;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		return period;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	cgc_getIndex( str, &ps );
	/// The period data must be a float
	pe = cgc_skipFloat( str );
	if ( pe == -1 ) {
		cgc_printf("!!Failed to locate the end of the period data\n");
		return end;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		return -1.0;
	}
	/// Skip past the brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		return period;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_skipLength( str, 1 );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		return period;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "Period") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return period;
	}
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		return -1.0;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the name element data
	temp = cgc_copyData( str, ps, pe );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy period data\n");
		return -1;
	}
	period = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	return period;
}
double cgc_extractOrbitSpeed( pstring str )
{
	char *temp = NULL;
	double speed = -1.0;
	register int start = 0;
	register int end = 0;
	int ss = 0;
	int se = 0;
	if (str == NULL ) {
		goto reterrvalue;	
	}
	start = cgc_skipWhiteSpace(str);
	if ( !(cgc_atChar( str, '{' ) & 1) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		goto reterrspeed;
	}
	/// Skip past the curly brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return speed;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		goto reterrvalue;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "OrbitSpeed" then this is the wrong function
	if ( cgc_strcmp( temp, "OrbitSpeed") != 0 ) {
		cgc_printf("!!Element id is not \"OrbitSpeed\"\n");
		cgc_bzero( temp, cgc_strlen(temp) );
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		goto reterrvalue;
	}
	/// The buffer is no longer needed so free it
	cgc_bzero( temp, cgc_strlen(temp) + 1 );
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		goto reterrspeed;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		goto retspeed;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	ss = str->index;
	/// The period data must be a float
	se = cgc_skipFloat( str );
	if (se == -1 ) {
		cgc_printf("!!Failed to locate the end of the period data\n");
		return -1.0;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		goto reterrvalue;
	}
	/// Skip past the brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		goto reterrspeed;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_skipLength( str, 1 );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		goto reterrvalue;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "OrbitSpeed") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_bzero(temp, cgc_strlen(temp) + 1 );
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return -1.0;
	}
	cgc_bzero( temp, cgc_strlen(temp) + 1 );
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		goto reterrspeed;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the name element data
	temp = cgc_copyData( str, ss, se );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy period data\n");
		goto retspeed;
	}
	speed = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	goto retspeed;
reterrvalue:
	return -1.0; 
reterrspeed:
	speed = -1.0;
	return speed;
retspeed:
	return speed;
}
double cgc_extractAphelion( pstring str )
{
	char *temp = NULL;
	double aphelion = -1.0;
	int start = 0;
	int end = 0;
	/// These will be used specifically for the data
	int ps = 0;
	int pe = 0;
	if (str == NULL ) {
		return -1.0;
	}
	start = cgc_skipWhiteSpace(str);
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		return aphelion;
	}
	/// Skip past the curly brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return aphelion;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		return aphelion;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "Aphelion" then this is the wrong function
	if ( cgc_strcmp( temp, "Aphelion") != 0 ) {
		cgc_printf("!!Element id is not \"Aphelion\"\n");
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		return aphelion;
	}
	/// The buffer is no longer needed so free it
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		return -1.0;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		return aphelion;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	cgc_getIndex( str, &ps );
	/// The period data must be a float
	pe = cgc_skipFloat( str );
	if ( pe == -1 ) {
		cgc_printf("!!Failed to locate the end of the period data\n");
		return aphelion;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		return -1.0;
	}
	/// Skip past the brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		return aphelion;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_skipLength( str, 1 );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		return aphelion;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "Aphelion") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return aphelion;
	}
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		return -1.0;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the name element data
	temp = cgc_copyData( str, ps, pe );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy period data\n");
		return -1;
	}
	aphelion = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	return aphelion;
}
double cgc_extractPerihelion( pstring str )
{
	char *temp = NULL;
	double perihelion = -1.0;
	int start = 0;
	int end = 0;
	/// These will be used specifically for the data
	int ps = 0;
	int pe = 0;
	if (str == NULL ) {
		return -1.0;
	}
	start = cgc_skipWhiteSpace(str);
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		return perihelion;
	}
	/// Skip past the curly brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return perihelion;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		return perihelion;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "Perihelion" then this is the wrong function
	if ( cgc_strcmp( temp, "Perihelion") != 0 ) {
		cgc_printf("!!Element id is not \"Perihelion\"\n");
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		return perihelion;
	}
	/// The buffer is no longer needed so free it
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		return -1.0;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		return perihelion;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	cgc_getIndex( str, &ps );
	/// The period data must be a float
	pe = cgc_skipFloat( str );
	if ( pe == -1 ) {
		cgc_printf("!!Failed to locate the end of the perihelion data\n");
		return perihelion;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		return -1.0;
	}
	/// Skip past the brace
	if ( cgc_incChar( str) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		return perihelion;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_skipLength( str, 1 );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		return perihelion;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "Perihelion") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return perihelion;
	}
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		return -1.0;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the name element data
	temp = cgc_copyData( str, ps, pe );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy perihelion data\n");
		return -1;
	}
	perihelion = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	return perihelion;
}
double cgc_extractRadius( pstring str )
{
	char *temp = NULL;
	double radius = -1.0;
	int start = 0;
	int end = 0;
	/// These will be used specifically for the data
	int rs = 0;
	int re = 0;
	if (str == NULL ) {
		return -1.0;
	}
	start = cgc_skipWhiteSpace(str);
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		return radius;
	}
	/// Skip past the curly brace
	if ( cgc_incChar( str ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return radius;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		return radius;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "Radius" then this is the wrong function
	if ( cgc_strcmp( temp, "Radius") != 0 ) {
		cgc_printf("!!Element id is not \"Radius\"\n");
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		return radius;
	}
	/// The buffer is no longer needed so free it
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		return -1.0;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_incChar( str) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		return radius;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	cgc_getIndex( str, &rs );
	/// The radius data must be a float
	re = cgc_skipFloat( str );
	if ( re == -1 ) {
		cgc_printf("!!Failed to locate the end of the radius data\n");
		return radius;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		return -1.0;
	}
	/// Skip past the brace
	if ( cgc_incChar( str) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		return radius;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_incChar( str );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		return radius;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "Radius") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return radius;
	}
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		return -1.0;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the name element data
	temp = cgc_copyData( str, rs, re );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy radius data\n");
		return -1.0;
	}
	radius = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	return radius;
}
double cgc_extractERadius( pstring str )
{
	char *temp = NULL;
	double eradius = -1.0;
	int start = 0;
	int end = 0;
	/// These will be used specifically for the data
	int es = 0;
	int ee = 0;
	if (str == NULL ) {
		return -1.0;
	}
	start = cgc_skipWhiteSpace(str);
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		return eradius;
	}
	/// Skip past the curly brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return eradius;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		return eradius;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "ERadius" then this is the wrong function
	if ( cgc_strcmp( temp, "ERadius") != 0 ) {
		cgc_printf("!!Element id is not \"ERadius\"\n");
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		return eradius;
	}
	/// The buffer is no longer needed so free it
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		return -1.0;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		return eradius;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	cgc_getIndex( str, &es );
	/// The eradius data must be a float
	ee = cgc_skipFloat( str );
	if ( ee == -1 ) {
		cgc_printf("!!Failed to locate the end of the eradius data\n");
		return eradius;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		return -1.0;
	}
	/// Skip past the brace
	if ( cgc_incChar( str) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		return eradius;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_skipLength( str, 1 );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		return eradius;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "ERadius") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return eradius;
	}
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		return -1.0;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the eradius element data
	temp = cgc_copyData( str, es, ee );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy eradius data\n");
		return -1;
	}
	eradius = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	return eradius;
}
double cgc_extractMass( pstring str )
{
	char *temp = NULL;
	double mass = -1.0;
	int start = 0;
	int end = 0;
	/// These will be used specifically for the data
	int es = 0;
	int ee = 0;
	if (str == NULL ) {
		return -1.0;
	}
	start = cgc_skipWhiteSpace(str);
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		return mass;
	}
	/// Skip past the curly brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return mass;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		return mass;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "Mass" then this is the wrong function
	if ( cgc_strcmp( temp, "Mass") != 0 ) {
		cgc_printf("!!Element id is not \"Mass\"\n");
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		return mass;
	}
	/// The buffer is no longer needed so free it
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		return -1.0;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		return mass;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	cgc_getIndex( str, &es );
	/// The mass data must be a float
	ee = cgc_skipFloat( str );
	if ( ee == -1 ) {
		cgc_printf("!!Failed to locate the end of the mass data\n");
		return mass;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		return -1.0;
	}
	/// Skip past the brace
	if ( cgc_incChar( str) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		return mass;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_skipLength( str, 1 );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		return mass;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "Mass") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return mass;
	}
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		return -1.0;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the mass element data
	temp = cgc_copyData( str, es, ee );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy mass data\n");
		return -1;
	}
	mass = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	return mass;
}
double cgc_extractGravity( pstring str )
{
	char *temp = NULL;
	double gravity = -1.0;
	int start = 0;
	int end = 0;
	/// These will be used specifically for the data
	int es = 0;
	int ee = 0;
	if (str == NULL ) {
		return -1.0;
	}
	start = cgc_skipWhiteSpace(str);
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate opening brace\n");
		return gravity;
	}
	/// Skip past the curly brace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip opening brace\n");
		return gravity;
	}
	/// Skip any additional whitespace
	start = cgc_skipWhiteSpace(str);
	/// This should skip any to either whitespace or a closing '}'
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the element id\n");
		return gravity;
	}
	/// Copy the element id from the string
	temp = cgc_copyData( str, start, end );
	if ( temp == NULL ) {
		cgc_printf("!!Copy from @d to @d failed\n", start, end);
		return -1.0;
	}
	/// If the element id is not "Gravity" then this is the wrong function
	if ( cgc_strcmp( temp, "Gravity") != 0 ) {
		cgc_printf("!!Element id is not \"Gravity\"\n");
		cgc_deallocate( temp, cgc_strlen(temp) + 1 );
		temp = NULL;
		return gravity;
	}
	/// The buffer is no longer needed so free it
	cgc_deallocate(temp, cgc_strlen(temp) + 1);
	/// Skip to the end of the element id
	cgc_skipWhiteSpace( str );
	/// If it is not a closing brace then this is improperly formatted.
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate initial closing brace\n");
		return -1.0;
	}
	/// Skip the closing brace as well as any whitespace
	if ( cgc_skipLength( str, 1 ) == -1 ) {
		cgc_printf("!!Failed to skip initial closing brace\n");
		return gravity;
	}
	cgc_skipWhiteSpace( str );
	/// Copy the start index to store the data
	cgc_getIndex( str, &es );
	/// The gravity data must be a float
	ee = cgc_skipFloat( str );
	if ( ee == -1 ) {
		cgc_printf("!!Failed to locate the end of the gravity data\n");
		return gravity;
	}
	/// The rest of this code is a check to ensure proper formatting except for the copy data
	cgc_skipWhiteSpace( str );
	/// If this is not an opening curly brace then fail
	if ( !cgc_atChar( str, '{' ) ) {
		cgc_printf("!!Failed to locate the final opening brace\n");
		return -1.0;
	}
	/// Skip past the brace
	if ( cgc_incChar( str) == -1 ) {
		cgc_printf("!!Failed to skip the final opening brace\n");
		return gravity;
	}
	
	cgc_skipWhiteSpace(str);
	/// If this is not a # indicating the closing brace then fail
	if ( !cgc_atChar( str, '#' ) ) {
		cgc_printf("!!Failed to locate the closing mark\n");		
		return -1.0;
	}
	/// Skip past the # but save the start
	start = cgc_skipLength( str, 1 );
	if ( start == -1 ) {
		cgc_printf("!!Failed to skip closing mark\n");
		return gravity;
	}
	end = cgc_skipToNonAlphaNum( str );
	if ( end == -1 ) {
		cgc_printf("!!Failed to locate the end of the closing element id\n");
		return -1.0;
	}
	
	temp = cgc_copyData( str, start, end );
	if ( cgc_strcmp( temp, "Gravity") != 0 ) {
		cgc_printf("!!Invalid closing element id: @s\n", temp);
		cgc_deallocate(temp, cgc_strlen(temp)+1);
		return gravity;
	}
	cgc_deallocate(temp, cgc_strlen(temp)+1);
	cgc_skipWhiteSpace( str );
	/// Check the final curly brace
	if ( !cgc_atChar( str, '}' ) ) {
		cgc_printf("!!Failed to locate final closing brace\n");
		return -1.0;
	}
	/// Skip past the closing brace
	cgc_skipLength( str, 1 );
		
	/// Copy the gravity element data
	temp = cgc_copyData( str, es, ee );
	if ( temp == NULL ) {
		cgc_printf("!!Failed to copy gravity data\n");
		return -1;
	}
	gravity = cgc_atof( temp );
	cgc_deallocate( temp, cgc_strlen(temp) + 1 );
	return gravity;
}