int main()
{
int input;
PrintGreeting();
/*Unless 4 is selected, restart program Does this work?*/
do
{
DisplayMainMenu();
input = GetValidInt(1, 4);
/*Main Menu Options select*/
switch (input)
{
case 1:
ConvertTime();
break;
case 2:
ConvertCurrency();
break;
case 3:
ConvertTemp();
break;
default:
break;
}
}while(input !=4);
return 0;
}
void setup_Rmainloop(void)
{
volatile int doneit;
volatile SEXP baseEnv;
SEXP cmd;
char deferred_warnings[11][250];
volatile int ndeferred_warnings = 0;
/* In case this is a silly limit: 2^32 -3 has been seen and
* casting to intptr_r relies on this being smaller than 2^31 on a
* 32-bit platform. */
if(R_CStackLimit > 100000000U)
R_CStackLimit = (uintptr_t)-1;
/* make sure we have enough head room to handle errors */
if(R_CStackLimit != -1)
R_CStackLimit = (uintptr_t)(0.95 * R_CStackLimit);
InitConnections(); /* needed to get any output at all */
/* Initialize the interpreter's internal structures. */
#ifdef HAVE_LOCALE_H
#ifdef Win32
{
char *p, Rlocale[1000]; /* Windows' locales can be very long */
p = getenv("LC_ALL");
strncpy(Rlocale, p ? p : "", 1000);
Rlocale[1000 - 1] = '\0';
if(!(p = getenv("LC_CTYPE"))) p = Rlocale;
/* We'd like to use warning, but need to defer.
Also cannot translate. */
if(!setlocale(LC_CTYPE, p))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_CTYPE=%s failed\n", p);
if((p = getenv("LC_COLLATE"))) {
if(!setlocale(LC_COLLATE, p))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_COLLATE=%s failed\n", p);
} else setlocale(LC_COLLATE, Rlocale);
if((p = getenv("LC_TIME"))) {
if(!setlocale(LC_TIME, p))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_TIME=%s failed\n", p);
} else setlocale(LC_TIME, Rlocale);
if((p = getenv("LC_MONETARY"))) {
if(!setlocale(LC_MONETARY, p))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_MONETARY=%s failed\n", p);
} else setlocale(LC_MONETARY, Rlocale);
/* Windows does not have LC_MESSAGES */
/* We set R_ARCH here: Unix does it in the shell front-end */
char Rarch[30];
strcpy(Rarch, "R_ARCH=/");
strcat(Rarch, R_ARCH);
putenv(Rarch);
}
#else /* not Win32 */
if(!setlocale(LC_CTYPE, ""))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_CTYPE failed, using \"C\"\n");
if(!setlocale(LC_COLLATE, ""))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_COLLATE failed, using \"C\"\n");
if(!setlocale(LC_TIME, ""))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_TIME failed, using \"C\"\n");
#ifdef ENABLE_NLS
if(!setlocale(LC_MESSAGES, ""))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_MESSAGES failed, using \"C\"\n");
#endif
/* NB: we do not set LC_NUMERIC */
#ifdef LC_MONETARY
if(!setlocale(LC_MONETARY, ""))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_MONETARY failed, using \"C\"\n");
#endif
#ifdef LC_PAPER
if(!setlocale(LC_PAPER, ""))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_PAPER failed, using \"C\"\n");
#endif
#ifdef LC_MEASUREMENT
if(!setlocale(LC_MEASUREMENT, ""))
snprintf(deferred_warnings[ndeferred_warnings++], 250,
"Setting LC_MEASUREMENT failed, using \"C\"\n");
#endif
#endif /* not Win32 */
#endif
/* make sure srand is called before R_tmpnam, PR#14381 */
srand(TimeToSeed());
InitArithmetic();
InitParser();
InitTempDir(); /* must be before InitEd */
InitMemory();
InitStringHash(); /* must be before InitNames */
InitNames();
InitBaseEnv();
InitGlobalEnv();
InitDynload();
InitOptions();
InitEd();
InitGraphics();
InitTypeTables(); /* must be before InitS3DefaultTypes */
InitS3DefaultTypes();
R_Is_Running = 1;
R_check_locale();
/* Initialize the global context for error handling. */
/* This provides a target for any non-local gotos */
/* which occur during error handling */
R_Toplevel.nextcontext = NULL;
R_Toplevel.callflag = CTXT_TOPLEVEL;
R_Toplevel.cstacktop = 0;
R_Toplevel.promargs = R_NilValue;
R_Toplevel.callfun = R_NilValue;
R_Toplevel.call = R_NilValue;
R_Toplevel.cloenv = R_BaseEnv;
R_Toplevel.sysparent = R_BaseEnv;
R_Toplevel.conexit = R_NilValue;
R_Toplevel.vmax = NULL;
R_Toplevel.nodestack = R_BCNodeStackTop;
#ifdef BC_INT_STACK
R_Toplevel.intstack = R_BCIntStackTop;
#endif
R_Toplevel.cend = NULL;
R_Toplevel.intsusp = FALSE;
R_Toplevel.handlerstack = R_HandlerStack;
R_Toplevel.restartstack = R_RestartStack;
R_Toplevel.srcref = R_NilValue;
R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
R_ExitContext = NULL;
R_Warnings = R_NilValue;
/* This is the same as R_BaseEnv, but this marks the environment
of functions as the namespace and not the package. */
baseEnv = R_BaseNamespace;
/* Set up some global variables */
Init_R_Variables(baseEnv);
/* On initial entry we open the base language package and begin by
running the repl on it.
If there is an error we pass on to the repl.
Perhaps it makes more sense to quit gracefully?
*/
#ifdef RMIN_ONLY
/* This is intended to support a minimal build for experimentation. */
if (R_SignalHandlers) init_signal_handlers();
#else
FILE *fp = R_OpenLibraryFile("base");
if (fp == NULL)
R_Suicide(_("unable to open the base package\n"));
doneit = 0;
SETJMP(R_Toplevel.cjmpbuf);
R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
if (R_SignalHandlers) init_signal_handlers();
if (!doneit) {
doneit = 1;
R_ReplFile(fp, baseEnv);
}
fclose(fp);
#endif
/* This is where we source the system-wide, the site's and the
user's profile (in that order). If there is an error, we
drop through to further processing.
*/
R_IoBufferInit(&R_ConsoleIob);
R_LoadProfile(R_OpenSysInitFile(), baseEnv);
/* These are the same bindings, so only lock them once */
R_LockEnvironment(R_BaseNamespace, TRUE);
#ifdef NOTYET
/* methods package needs to trample here */
R_LockEnvironment(R_BaseEnv, TRUE);
#endif
/* At least temporarily unlock some bindings used in graphics */
R_unLockBinding(R_DeviceSymbol, R_BaseEnv);
R_unLockBinding(R_DevicesSymbol, R_BaseEnv);
R_unLockBinding(install(".Library.site"), R_BaseEnv);
/* require(methods) if it is in the default packages */
doneit = 0;
SETJMP(R_Toplevel.cjmpbuf);
R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
if (!doneit) {
doneit = 1;
PROTECT(cmd = install(".OptRequireMethods"));
R_CurrentExpr = findVar(cmd, R_GlobalEnv);
if (R_CurrentExpr != R_UnboundValue &&
TYPEOF(R_CurrentExpr) == CLOSXP) {
PROTECT(R_CurrentExpr = lang1(cmd));
R_CurrentExpr = eval(R_CurrentExpr, R_GlobalEnv);
UNPROTECT(1);
}
UNPROTECT(1);
}
if (strcmp(R_GUIType, "Tk") == 0) {
char buf[PATH_MAX];
snprintf(buf, PATH_MAX, "%s/library/tcltk/exec/Tk-frontend.R", R_Home);
R_LoadProfile(R_fopen(buf, "r"), R_GlobalEnv);
}
/* Print a platform and version dependent greeting and a pointer to
* the copyleft.
*/
if(!R_Quiet) PrintGreeting();
R_LoadProfile(R_OpenSiteFile(), baseEnv);
R_LockBinding(install(".Library.site"), R_BaseEnv);
R_LoadProfile(R_OpenInitFile(), R_GlobalEnv);
/* This is where we try to load a user's saved data.
The right thing to do here is very platform dependent.
E.g. under Unix we look in a special hidden file and on the Mac
we look in any documents which might have been double clicked on
or dropped on the application.
*/
doneit = 0;
SETJMP(R_Toplevel.cjmpbuf);
R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
if (!doneit) {
doneit = 1;
R_InitialData();
}
else {
if (! SETJMP(R_Toplevel.cjmpbuf)) {
warning(_("unable to restore saved data in %s\n"), get_workspace_name());
}
}
/* Initial Loading is done.
At this point we try to invoke the .First Function.
If there is an error we continue. */
doneit = 0;
SETJMP(R_Toplevel.cjmpbuf);
R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
if (!doneit) {
doneit = 1;
PROTECT(cmd = install(".First"));
R_CurrentExpr = findVar(cmd, R_GlobalEnv);
if (R_CurrentExpr != R_UnboundValue &&
TYPEOF(R_CurrentExpr) == CLOSXP) {
PROTECT(R_CurrentExpr = lang1(cmd));
R_CurrentExpr = eval(R_CurrentExpr, R_GlobalEnv);
UNPROTECT(1);
}
UNPROTECT(1);
}
/* Try to invoke the .First.sys function, which loads the default packages.
If there is an error we continue. */
doneit = 0;
SETJMP(R_Toplevel.cjmpbuf);
R_GlobalContext = R_ToplevelContext = R_SessionContext = &R_Toplevel;
if (!doneit) {
doneit = 1;
PROTECT(cmd = install(".First.sys"));
R_CurrentExpr = findVar(cmd, baseEnv);
if (R_CurrentExpr != R_UnboundValue &&
TYPEOF(R_CurrentExpr) == CLOSXP) {
PROTECT(R_CurrentExpr = lang1(cmd));
R_CurrentExpr = eval(R_CurrentExpr, R_GlobalEnv);
UNPROTECT(1);
}
UNPROTECT(1);
}
{
int i;
for(i = 0 ; i < ndeferred_warnings; i++)
warning(deferred_warnings[i]);
}
if (R_CollectWarnings) {
REprintf(_("During startup - "));
PrintWarnings();
}
/* trying to do this earlier seems to run into bootstrapping issues. */
R_init_jit_enabled();
R_Is_Running = 2;
}
int main(int argc, char *argv[])
{
NODEPTR headBone = NULL, tailBone = NULL;
NODEPTR headUser = NULL, tailUser = NULL;
NODEPTR headSystem = NULL, tailSystem = NULL;
NODEPTR headTrain = NULL, tailTrain = NULL;
NODEPTR curr = NULL, choice = NULL;
LIST *boneyard, *user, *system, *train;
FILE *ifp;
int numDom, menu, turn = CONTINUE, status;
int player = CONTINUE;
/* check for correct number of arguments */
if(argc != 3)
{
/* print message to standard error */
fprintf(stderr, "incorrect number of arguments.\n");
fprintf(stderr, "enter a.out, name of file, and number of starting\n");
fprintf(stderr, "dominoes.\n");
exit(-1);
}
int handSize = atoi(argv[2]);
char *fileName = argv[1];
ifp = fopen(fileName, "r");
/* check if the file opened correctly */
if(ifp == NULL)
{
fprintf(stderr, "%s is incorrect\n", fileName);
exit (-2);
}
/* makes sure num dominoes is positive */
if(atoi(argv[2]) <= 0)
{
/* print message to standard error */
fprintf(stderr, "number of dominoes must be positive\n");
exit(-3);
}
/* gather necessary memory for the LIST structs */
boneyard = (LIST *) malloc(sizeof(LIST));
if(boneyard == NULL)
{
fprintf(stderr, "Out of Memory - boneyard\n");
exit(-6);
}
user = (LIST *) malloc(sizeof(LIST));
if(user == NULL)
{
fprintf(stderr, "Out of Memory - user\n");
exit(-7);
}
system = (LIST *) malloc(sizeof(LIST));
if(system == NULL)
{
fprintf(stderr, "Out of Memory - system\n");
exit(-8);
}
train = (LIST *) malloc(sizeof(LIST));
if(train == NULL)
{
fprintf(stderr, "Out of Memory - train\n");
exit(-9);
}
/* point the head and tail to the list struct */
boneyard->head = headBone;
boneyard->tail = tailBone;
boneyard->nrNodes = 0;
user->head = headUser;
user->tail = tailUser;
headUser = user->head;
tailUser = user->head;
user->nrNodes = 0;
system->head = headSystem;
system->tail = tailSystem;
system->nrNodes = 0;
train->head = headTrain;
train->tail = tailTrain;
train->nrNodes = 0;
/* Creates the boneyard which holds all dominoes in the beginning */
numDom = CreateBoneyard(boneyard, ifp);
/* calculates max hand size for game of dominoes */
if(handSize >= (numDom - 1) / 2)
{
fprintf(stderr, "%d is too large for number of dominoes\n", handSize);
fprintf(stderr, "largest number of dominoes is %d\n", (numDom - 1) / 2);
exit(-4);
}
/* prints greeting to the user */
PrintGreeting();
/* prints program instructions */
PrintInstructions();
/* gives the user a linked list of dominoes */
DealUser(boneyard, user, handSize);
/* gives the system a linked list of dominoes */
DealSystem(boneyard, system, handSize);
/* takes the first node from the boneyard to be used as the train */
curr = boneyard->head;
boneyard->head = boneyard->head->next;
InsertLeft(train, curr);
/* prints the menu for user interface */
PrintMenu();
/* Game Loop */
while(player == CONTINUE)
{
/* player turn loop */
while(turn != OVER)
{
printf("The train (%d): ", train->nrNodes);
PrintList(train->head);
printf("\n\n");
printf("Your turn...(enter six for menu)\n");
menu = GetValidInt(); /* int used for menu nav */
switch(menu)
{
case PRINTDOMINO:
printf("Your Dominoes: ");
PrintList(user->head);
printf("\n");
turn = CONTINUE; /* print domino doesnt use up your turn */
break;
case INSERTLEFT:
/* selects a domino to play */
choice = SelectDominoLeft(train, user);
if(choice != NULL)
{
InsertLeft(train, choice);
turn = OVER;
} else {
turn = CONTINUE; /* if can't play, turn isnt lost */
}
break;
case INSERTRIGHT:
/* selects a domino to play */
choice = SelectDominoRight(train, user);
if(choice != NULL)
{
choice->next = NULL;
InsertRight(train, choice);
turn = OVER;
} else {
turn = CONTINUE;
}
break;
case DRAWDOMINO:
/* checks if boneyard is empty */
if(IsEmpty(boneyard->head) == FALSE)
{
status = CheckDomino(train, user, USER);
if(status == TRUE)
{
DrawDomino(user, boneyard);
turn = OVER;
} else {
printf("\nYou had a domino to play\n\n");
turn = CONTINUE;
}
} else {
printf("Boneyard is empty\n");
}
break;
case PASSTURN:
/* checks if you can play a domino and for empty boneyard */
if(CheckDomino(train, user, USER) == TRUE &&
IsEmpty(boneyard->head) == TRUE)
{
printf("\nuser passes his turn\n");
turn = OVER;
} else
if(IsEmpty(boneyard->head) == FALSE)
{
printf("\nCant pass, you can draw from the boneyard\n\n");
turn = CONTINUE;
} else {
printf("Can't pass you still have a domino to play");
}
break;
case PRINTMENU:
PrintMenu();
turn = CONTINUE;
break;
case QUIT:
turn = OVER;
player = QUIT;
break;
default:
printf("Dios Mios!!, esta numero no existan!!!\n");
break;
}
/* checks if player ran out of dominoes */
if(IsEmpty(user->head) == TRUE)
{
player = WIN;
}
}
turn = CONTINUE;
printf("The Train: ");
PrintList(train->head);
printf("\n");
/* computers turn */
if(player == CONTINUE)
{
printf("System's Hand: ");
PrintList(system->head);
printf("\n");
printf("\nSystem's turn...");
/* tries to play a domino for the system */
if(CheckDomino(train, system, SYSTEM) == FALSE)
{
system->nrNodes--;
printf("System has %d dominoes left\n\n", system->nrNodes);
} else
if(IsEmpty(boneyard->head) == FALSE) /* tries to draw domino */
{
DrawDomino(system, boneyard);
printf("System drew a domino from the boneyard\n");
printf("System has %d dominoes left\n\n", system->nrNodes);
} else {
/* last passes if can do neither of the above */
printf("System has passed this turn\n");
printf("System has %d dominoes left\n\n", system->nrNodes);
}
/* checks for empty hand */
if(IsEmpty(system->head) == TRUE)
{
player = LOSE;
}
}
}
if(player == WIN)
{
printf("Player Wins!\n");
/* destroys all linked lists */
DestroyList(user);
DestroyList(boneyard);
DestroyList(system);
DestroyList(train);
} else
if(player == LOSE)
{
/* destroys all linked lists */
printf("System Wins! You Lose!");
DestroyList(user);
DestroyList(boneyard);
DestroyList(system);
DestroyList(train);
} else {
/* destroys all linked lists */
printf("Hope you had a good game, Play again soon!\n");
DestroyList(user);
DestroyList(boneyard);
DestroyList(system);
DestroyList(train);
}
return 0;
}
int main (void)
{
int length = 0;
int width = 0;
int i = 0;
int rectangleList[NUMRECTANGLES][NUMATTRIBUTES];
PrintGreeting();
/* Get input from user */
printf("Please enter the length and width of ");
printf("%d", NUMRECTANGLES);
printf(" rectangles\n");
printf("in the form of length, width (number comma number)\n");
printf("- one pair on each line\n\n");
/* Read in the length and width values for each rectangle */
/* Store each value in an element of a 2-dimensional array */
for (i = 0; i < NUMRECTANGLES; i++)
{
/* Read length and width and store in array */
scanf ("%d,%d", &length, &width);
rectangleList[i][LENGTH] = length;
rectangleList[i][WIDTH] = width;
/******************** STEP 3 ***********************
* Write a couple lines of code to calculate the *
* perimeter and area of the current rectangle, *
* and store the perimeter and area in elements 2 *
* and 3 of the second dimension of the array. *
* *
* Use the CalculatePerimeter and CalculateArea *
* functions from geometry.h *
***************************************************/
rectangleList[i][PERIMETER] = CalculatePerimeter(length, width);
rectangleList[i][AREA] = CalculateArea(length, width);
}
printf("\nThe properties of the rectangle(s) are:\n\n");
/* The header for a results table */
PrintTableHeader();
/* Print out the length, width, perimeter and area of each rectangle */
/* Print one per line */
/******************* STEP 2 ***************************
* Uncomment the following statement to call the *
* function which actually print out a table based on *
* the values in our array. *
* *
* Note that we are PASSING the array here! *
*****************************************************/
PrintRectangleTable( rectangleList, NUMRECTANGLES );
printf("\n");
return 0;
}
