608 lines
No EOL
21 KiB
C
608 lines
No EOL
21 KiB
C
#include "configops.h"
|
|
#include "StandardConstants.h"
|
|
#include "StringUtils.h"
|
|
|
|
/*
|
|
Name: clearConfigData
|
|
Process: frees dynamically allocated config data structure
|
|
if it has not already been freed
|
|
Function Input/Parameters: pointer to config data structure (ConfigDataType *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: NULL (ConfigDataType *)
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: free
|
|
*/
|
|
ConfigDataType *clearConfigData(ConfigDataType *configData)
|
|
{
|
|
// initialize function and variables
|
|
// check that config data pointer is not null
|
|
if(configData != NULL)
|
|
{
|
|
// free data structure memory
|
|
// fct: free
|
|
free(configData);
|
|
// set config pointer to NULL
|
|
configData = NULL;
|
|
}
|
|
// set config data pointer to null
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
Name: configCodeToString
|
|
Process: utility fct converts configuration code numbers to string they represent
|
|
Function Input/Parameters: configuration code (int)
|
|
Function Output/Parameters: resulting output string (char *)
|
|
Function Output/Returned: none
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: copyString
|
|
*/
|
|
void configCodeToString(int code, char *outString)
|
|
{
|
|
// define array with eight items, and short (10) lengths
|
|
char displayStrings[8][10] = {"SJF-N","SRTF-P","FCFS-P","RR-P",
|
|
"FCFS-N","Monitor", "File", "Both"};
|
|
// copy string to return parameter
|
|
// fct: copyString
|
|
copyString(outString, displayStrings[code]);
|
|
// void function, no return.
|
|
}
|
|
|
|
/*
|
|
Name: displayConfigData
|
|
Process: screen dump/display of all config data
|
|
Function Input/Parameters: pointer to config data structure (ConfigDataType *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: none
|
|
Device Input/Device: none
|
|
Device Output/Monitor: displayed as spec'd
|
|
Dependencies: configCodeToString, printf
|
|
*/
|
|
void displayConfigData(ConfigDataType *configData)
|
|
{
|
|
// initialize function and variables
|
|
char displayString[STD_STR_LEN];
|
|
// print lines of display for all member values
|
|
// fct: printf, codeToString
|
|
printf("Config File Display\n");
|
|
printf("-------------------\n");
|
|
printf("Version : %3.2f\n", configData->version);
|
|
printf("Program File Name : %s\n", configData->metaDataFileName);
|
|
configCodeToString(configData->cpuSchedCode, displayString);
|
|
printf("CPU Schedule Selection: %s\n", displayString);
|
|
printf("Quantum Time : %d\n", configData->quantumCycles);
|
|
printf("Memory Display : ");
|
|
if(configData->memDisplay)
|
|
{
|
|
printf("On\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Off\n");
|
|
}
|
|
printf("Memory Available : %d\n", configData->memAvailable);
|
|
printf("Process Cycle Rate : %d\n", configData->procCycleRate);
|
|
printf("I/O Cycle Rate : %d\n", configData->ioCycleRate);
|
|
configCodeToString(configData->logToCode, displayString);
|
|
printf("Log to Selection : %s\n", displayString);
|
|
printf("Log File Name : %s\n\n", configData->logToFileName);
|
|
// void function, no return.
|
|
}
|
|
|
|
/*
|
|
Name: getConfigData
|
|
Process: driver function for capturing config data from config file
|
|
Function Input/Parameters: file name (const char *)
|
|
Function Output/Parameters: pointer to config data pointer (ConfigDataType **)
|
|
end/result state message pointer (char *)
|
|
Function Output/Returned: Boolean result of data access operation (bool)
|
|
Device Input/File: config data uploaded
|
|
Device Output/Device: none
|
|
Dependencies: copyString, fopen, getStringToDelimiter, compareString, fclose,
|
|
malloc, free, stripTrailingSpaces, getDataLineCode, fscanf,
|
|
strToLowerCase, valueInRange, getCpuSchedCode, getLogToCode
|
|
*/
|
|
bool getConfigData(const char *fileName,
|
|
ConfigDataType **configData, char *endStateMsg)
|
|
{
|
|
// initialize function and variables
|
|
// set constant number of data lines
|
|
const int NUM_DATA_LINES = 10;
|
|
// set read only constant
|
|
const char READ_ONLY_FLAG[] = "r";
|
|
// create pointer for data input
|
|
ConfigDataType *tempData;
|
|
// declare other variables
|
|
FILE *fileAccessPtr;
|
|
char dataBuffer[MAX_STR_LEN], lowerCaseDataBuffer[MAX_STR_LEN];
|
|
int intData, dataLineCode, lineCtr = 0;
|
|
double doubleData;
|
|
// set endStateMsg to success
|
|
// fct: copyString
|
|
char testMsg[] = "Configuration file upload successful";
|
|
copyString(endStateMsg, testMsg);
|
|
// initialize config data pointer in case of return error
|
|
*configData = NULL;
|
|
// open file
|
|
// fct: fopen
|
|
fileAccessPtr = fopen(fileName, READ_ONLY_FLAG);
|
|
// check for file open failure
|
|
if(fileAccessPtr == NULL)
|
|
{
|
|
// set end state message to config file access error
|
|
// fct: copyString
|
|
char testMsg[] = "Configuration file access error";
|
|
copyString(endStateMsg, testMsg);
|
|
// return file access error
|
|
return false;
|
|
}
|
|
// get first line, check for failure
|
|
// fct: getStringToDelimiter, compareString
|
|
if(!getStringToDelimiter(fileAccessPtr, COLON, dataBuffer)
|
|
|| compareString(dataBuffer, "Start Simulator Configuration File") != 0)
|
|
{
|
|
// close file access
|
|
// fct: fclose
|
|
fclose(fileAccessPtr);
|
|
// set end state message to corrupt leader line error
|
|
// fct: copyString
|
|
copyString(endStateMsg, "Corrupt configuration leader line error");
|
|
// return corrupt file data
|
|
return false;
|
|
}
|
|
// create temporary pointer to configuration data structure
|
|
// fct: malloc
|
|
tempData = (ConfigDataType *) malloc(sizeof(ConfigDataType));
|
|
// loop to end of config data items
|
|
while(lineCtr < NUM_DATA_LINES)
|
|
{
|
|
// get line leader, check for failure
|
|
// fct: getStringToDelimiter
|
|
if(!getStringToDelimiter(fileAccessPtr, COLON, dataBuffer))
|
|
{
|
|
// free temp struct memory
|
|
// fct: free
|
|
free(tempData);
|
|
// close file access
|
|
// fct: fclose
|
|
fclose(fileAccessPtr);
|
|
// set end state message to line capture failure
|
|
// fct: copyString
|
|
copyString(endStateMsg,
|
|
"Configuration data leader line capture error");
|
|
// return incomplete file error
|
|
return false;
|
|
}
|
|
// strip trailing spaces of config leader lines
|
|
// for use in other fcts
|
|
// fct: stripTrailingSpaces
|
|
stripTrailingSpaces(dataBuffer);
|
|
// find correct data line code number from string
|
|
// fct: getDataLineCode
|
|
dataLineCode = getDataLineCode(dataBuffer);
|
|
// check for data line found
|
|
if(dataLineCode != CFG_CORRUPT_PROMPT_ERR)
|
|
{
|
|
// get data value
|
|
// check for version number (double value)
|
|
if(dataLineCode == CFG_VERSION_CODE)
|
|
{
|
|
// get version number
|
|
// fct: fscanf
|
|
fscanf(fileAccessPtr, "%lf", &doubleData);
|
|
}
|
|
// otherwise, check for metaData, fileNames,
|
|
// CPU Scheduling names, or memory display setting (strings)
|
|
else if(dataLineCode == CFG_MD_FILE_NAME_CODE ||
|
|
dataLineCode == CFG_LOG_FILE_NAME_CODE ||
|
|
dataLineCode == CFG_CPU_SCHED_CODE ||
|
|
dataLineCode == CFG_LOG_TO_CODE ||
|
|
dataLineCode == CFG_MEM_DISPLAY_CODE)
|
|
{
|
|
// get string input
|
|
// fct: fscanf
|
|
fscanf(fileAccessPtr, "%s", dataBuffer);
|
|
// set string to lower case for testing in valueInRange
|
|
// fct: strToLowerCase
|
|
strToLowerCase(lowerCaseDataBuffer, dataBuffer);
|
|
}
|
|
// otherwise, assume integer data
|
|
else
|
|
{
|
|
// get integer input
|
|
// fct: fscanf
|
|
fscanf(fileAccessPtr, "%d", &intData);
|
|
}
|
|
// check for data value in range
|
|
// fct: valueInRange
|
|
if(valueInRange(dataLineCode, intData,
|
|
doubleData, lowerCaseDataBuffer))
|
|
{
|
|
// assign to data pointer depending on config item
|
|
// (all config line possibilities)
|
|
// fct: copyString, getCpuSchedCode,
|
|
// compareString, getLogToCode, as needed
|
|
switch(dataLineCode)
|
|
{
|
|
case CFG_VERSION_CODE:
|
|
tempData->version = doubleData;
|
|
break;
|
|
case CFG_MD_FILE_NAME_CODE:
|
|
copyString(tempData->metaDataFileName, dataBuffer);
|
|
break;
|
|
case CFG_CPU_SCHED_CODE:
|
|
tempData->cpuSchedCode =
|
|
getCpuSchedCode(lowerCaseDataBuffer);
|
|
break;
|
|
case CFG_QUANT_CYCLES_CODE:
|
|
tempData->quantumCycles = intData;
|
|
break;
|
|
case CFG_MEM_DISPLAY_CODE:
|
|
tempData->memDisplay =
|
|
compareString(lowerCaseDataBuffer, "on") == 0;
|
|
break;
|
|
case CFG_MEM_AVAILABLE_CODE:
|
|
tempData->memAvailable = intData;
|
|
break;
|
|
case CFG_PROC_CYCLES_CODE:
|
|
tempData->procCycleRate = intData;
|
|
break;
|
|
case CFG_IO_CYCLES_CODE:
|
|
tempData->ioCycleRate = intData;
|
|
break;
|
|
case CFG_LOG_TO_CODE:
|
|
tempData->logToCode = getLogToCode(lowerCaseDataBuffer);
|
|
break;
|
|
case CFG_LOG_FILE_NAME_CODE:
|
|
copyString(tempData->logToFileName, dataBuffer);
|
|
break;
|
|
}
|
|
}
|
|
// otherwise, assume data value not in range
|
|
else
|
|
{
|
|
// free temp struct memory
|
|
// fct: free
|
|
free(tempData);
|
|
// close file access
|
|
// fct: fclose
|
|
fclose(fileAccessPtr);
|
|
// set end state message to configuration data out of range
|
|
// fct: copyString
|
|
copyString(endStateMsg, "Configuration item out of range");
|
|
// return data out of range
|
|
return false;
|
|
}
|
|
}
|
|
// otherwise, check for data line not found
|
|
else
|
|
{
|
|
// free temp struct memory
|
|
// fct: free
|
|
free(tempData);
|
|
// close file access
|
|
// fct: fclose
|
|
fclose(fileAccessPtr);
|
|
// set end state message to configuration corrupt prompt error
|
|
// fct: copyString
|
|
copyString(endStateMsg, "Corrupted configuration prompt");
|
|
// return corrupt config file code
|
|
return false;
|
|
}
|
|
// increment line counter
|
|
lineCtr = lineCtr + 1;
|
|
}
|
|
// end loop to end of config data items
|
|
// acquire end of sim config string
|
|
// fct: getStringToDelimiter, compareString
|
|
if(!getStringToDelimiter(fileAccessPtr, PERIOD, dataBuffer) ||
|
|
compareString(dataBuffer, "End Simulator Configuration File") != 0)
|
|
{
|
|
// free temp struct memory
|
|
// fct: free
|
|
free(tempData);
|
|
// close file access
|
|
// fct: fclose
|
|
fclose(fileAccessPtr);
|
|
// set end state message to corrupt configuration end line
|
|
// fct: copyString
|
|
copyString(endStateMsg, "Configuration end line capture error");
|
|
// return corrupt file data
|
|
return false;
|
|
}
|
|
// test for "file only" output so memory diagnostics do not display
|
|
tempData->memDisplay = tempData->memDisplay &&
|
|
tempData->logToCode != LOGTO_FILE_CODE;
|
|
// assign temp ptr to parameter return ptr
|
|
*configData = tempData;
|
|
// close file access
|
|
// fct: fclose
|
|
fclose(fileAccessPtr);
|
|
// return no error code
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Name: getCpuSchedCode
|
|
Process: converts cpu schedule string to code (all scheduling possibilities)
|
|
Function Input/Parameters: lower case code string (const char *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: cpu schedule code (ConfigDataCodes)
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: compareString
|
|
*/
|
|
ConfigDataCodes getCpuSchedCode(const char *lowerCaseCodeStr)
|
|
{
|
|
// iniitalize function and variables
|
|
// set default return to FCFS-N
|
|
ConfigDataCodes returnVal = CPU_SCHED_FCFS_N_CODE;
|
|
// check for SJF-N
|
|
// fct: compareString
|
|
if(compareString(lowerCaseCodeStr, "sjf-n") == 0)
|
|
{
|
|
// set SJF-N code
|
|
returnVal = CPU_SCHED_SJF_N_CODE;
|
|
}
|
|
// check for SRTF-P
|
|
// fct: compareString
|
|
if(compareString(lowerCaseCodeStr, "srtf-p") == 0)
|
|
{
|
|
// set SRTF-P code
|
|
returnVal = CPU_SCHED_SRTF_P_CODE;
|
|
}
|
|
// check for FCFS-P
|
|
// fct: compareString
|
|
if(compareString(lowerCaseCodeStr, "fcfs-p") == 0)
|
|
{
|
|
// set FCFS-P code
|
|
returnVal = CPU_SCHED_FCFS_P_CODE;
|
|
}
|
|
// check for RR-P
|
|
// fct: compareString
|
|
if(compareString(lowerCaseCodeStr, "rr-p") == 0)
|
|
{
|
|
// set RR-P code
|
|
returnVal = CPU_SCHED_RR_P_CODE;
|
|
}
|
|
return returnVal;
|
|
}
|
|
|
|
/*
|
|
Name: getDataLineCode
|
|
Process: converts leader line string to configuration code value
|
|
(processes all config file leader lines)
|
|
Function Input/Parameters: config leader line string (const char *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: configuration code value (ConfigCodeMessages)
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: compareString
|
|
*/
|
|
ConfigCodeMessages getDataLineCode(const char *dataBuffer)
|
|
{
|
|
// iniitalize function and variables
|
|
// return appropriate code depending on prompt string provided
|
|
// fct: compareString
|
|
if(compareString(dataBuffer, "Version/Phase") == 0)
|
|
{
|
|
return CFG_VERSION_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "File Path") == 0)
|
|
{
|
|
return CFG_MD_FILE_NAME_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "CPU Scheduling Code") == 0)
|
|
{
|
|
return CFG_CPU_SCHED_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "Quantum Time (cycles)") == 0)
|
|
{
|
|
return CFG_QUANT_CYCLES_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "Memory Display (On/Off)") == 0)
|
|
{
|
|
return CFG_MEM_DISPLAY_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "Memory Available (KB)") == 0)
|
|
{
|
|
return CFG_MEM_AVAILABLE_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "Processor Cycle Time (msec)") == 0)
|
|
{
|
|
return CFG_PROC_CYCLES_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "I/O Cycle Time (msec)") == 0)
|
|
{
|
|
return CFG_IO_CYCLES_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "Log To") == 0)
|
|
{
|
|
return CFG_LOG_TO_CODE;
|
|
}
|
|
if(compareString(dataBuffer, "Log File Path") == 0)
|
|
{
|
|
return CFG_LOG_FILE_NAME_CODE;
|
|
}
|
|
// return corrupt leader line error code
|
|
return CFG_CORRUPT_PROMPT_ERR;
|
|
}
|
|
|
|
/*
|
|
Name: getLogToCode
|
|
Process: converts "log to" text to
|
|
configuration data code (three log to strings)
|
|
Function Input/Parameters: lower case log to string (const char *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: configuration data code value
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: compareString
|
|
*/
|
|
ConfigDataCodes getLogToCode(const char *lowerCaseLogToStr)
|
|
{
|
|
// initialize function and variables
|
|
// set default to log to monitor
|
|
ConfigDataCodes returnVal = LOGTO_MONITOR_CODE;
|
|
// check for BOTH
|
|
// fct: compareString
|
|
if(compareString(lowerCaseLogToStr, "both") == 0)
|
|
{
|
|
// set return value to both code
|
|
returnVal = LOGTO_BOTH_CODE;
|
|
}
|
|
// check for FILE
|
|
// fct: compareString
|
|
if(compareString(lowerCaseLogToStr, "file") == 0)
|
|
{
|
|
// set return value to file code
|
|
returnVal = LOGTO_FILE_CODE;
|
|
}
|
|
// return selected code
|
|
return returnVal;
|
|
}
|
|
|
|
/*
|
|
Name: stripTrailingSpaces
|
|
Process: removes trailing spaces from input config leader lines
|
|
Function Input/Parameters: config leader line string (char *)
|
|
Function Output/Parameters: updates config leader line string (char *)
|
|
Function Output/Returned: none
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: getStringLength
|
|
*/
|
|
void stripTrailingSpaces(char *str)
|
|
{
|
|
// initialize index to length of string - 1 to get highest array index
|
|
int index = getStringLength(str) - 1;
|
|
// loop while space is found at the end of string
|
|
while(str[index] == SPACE)
|
|
{
|
|
// set element to NULL_CHAR
|
|
str[index] = NULL_CHAR;
|
|
// decrement index
|
|
index = index - 1;
|
|
}
|
|
// end loop from end of string
|
|
// void function, no return.
|
|
}
|
|
|
|
/*
|
|
Name: valueInRange
|
|
Process: checks for config data values in range, including str values
|
|
Function Input/Parameters: line code number for specific config value (int),
|
|
integer value, as needed (int),
|
|
double value, as needed (double),
|
|
string value, as needed (const char *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: Boolean result of the range test (bool)
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: compareString
|
|
*/
|
|
bool valueInRange(int lineCode, int intVal, double doubleVal,
|
|
const char *lowerCaseStringVal)
|
|
{
|
|
// initialize function and variables
|
|
// set result to true, all tests are to find false
|
|
bool result = true;
|
|
// use line code to identify prompt line
|
|
switch(lineCode)
|
|
{
|
|
// for version code
|
|
case CFG_VERSION_CODE:
|
|
// check if limits of version code are exceeded
|
|
if(doubleVal < 0.00 || doubleVal > 10.00)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
// for cpu scheduling code
|
|
case CFG_CPU_SCHED_CODE:
|
|
// check for not finding one of the scheduling strings
|
|
// fct: compareString
|
|
if(compareString(lowerCaseStringVal, "fcfs-n") != 0 &&
|
|
compareString(lowerCaseStringVal, "sjf-n") != 0 &&
|
|
compareString(lowerCaseStringVal, "srtf-p") != 0 &&
|
|
compareString(lowerCaseStringVal, "fcfs-p") != 0 &&
|
|
compareString(lowerCaseStringVal, "rr-p") != 0)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
// for quantum cycles
|
|
case CFG_QUANT_CYCLES_CODE:
|
|
// check for quantum cycles limits exceeded
|
|
if(intVal < 0 || intVal > 100)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
// for memory display
|
|
case CFG_MEM_DISPLAY_CODE:
|
|
// check for not finding either on or off
|
|
// fct: compareString
|
|
if(compareString(lowerCaseStringVal, "on") != 0 &&
|
|
compareString(lowerCaseStringVal, "off") != 0)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
// for memory available
|
|
case CFG_MEM_AVAILABLE_CODE:
|
|
// check for memory limits exceeded
|
|
if(intVal < 1024 || intVal > 102400)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
// check for process cycles
|
|
case CFG_PROC_CYCLES_CODE:
|
|
// check for process cycles limits exceeded
|
|
if(intVal < 1 || intVal > 100)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
// check for process cycles
|
|
case CFG_IO_CYCLES_CODE:
|
|
// check for process cycles limits exceeded
|
|
if(intVal < 1 || intVal > 1000)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
// check for log to operation
|
|
case CFG_LOG_TO_CODE:
|
|
// check for not finding one of the log to strings
|
|
// fct: compareString
|
|
if(compareString(lowerCaseStringVal, "both") != 0 &&
|
|
compareString(lowerCaseStringVal, "monitor") != 0 &&
|
|
compareString(lowerCaseStringVal, "file") != 0)
|
|
{
|
|
// set bool to false
|
|
result = false;
|
|
}
|
|
// break
|
|
break;
|
|
}
|
|
// return result of limits analysis
|
|
return result;
|
|
} |