/* virtual */ void av::tools::Tool::evaluate()
{
av::FieldContainer::evaluate();
const MFTargetHolder::ContainerType& targets = Targets.getValue();
for(MFTargetHolder::ContainerType::const_iterator last_holder = mLastTargets.begin(); last_holder != mLastTargets.end(); ++last_holder)
{
if(!hasTarget(targets, (*last_holder)->Target.getValue()))
evaluateRemovedTarget(**last_holder);
}
for(MFTargetHolder::ContainerType::const_iterator holder = targets.begin(); holder != targets.end(); ++holder)
{
evaluateTarget(**holder);
if(hasTarget(mLastTargets, (*holder)->Target.getValue()))
evaluateKeptTarget(**holder);
else
evaluateAddedTarget(**holder);
}
mLastTargets = targets;
}
int main(int argc, char *const argv[])
{
puts("");
argF = 0; // -f argument: file - use file as a makefile
argK = 0; // -k argument: keep going - Continue as much as possible after error
argN = 0; // -n argument: Just print - print the commands that would be executed, don't execute
argQ = 0; // -q argument: question - don't run commands
hasChanged = 0;
bool hasTarget = 0; // whether or not a target is specified from command line
char *makeFile; // filename for the makefile being used.
char *target; // target to be used
FILE *myFile; // file to be used for reading
int c; // used for getopt loop
while((c = getopt(argc, argv, "f:knq")) != -1) // Collect command arguments
{
if(c == 'k') argK = 1; // set K
if(c == 'f' && argF == 0) // set F (only if it has not been set before)
{
argF = 1;
makeFile = (char*)calloc(1, strlen(optarg) + 1); // extract filename
strcpy(makeFile, optarg);
}
if(c == 'n') argN = 1; // set N
if(c == 'q') argQ = 1; // set Q
}
if(!argF)
{
struct stat fileBuf;
if(stat("GNUmakefile", &fileBuf) == 0)
makeFile = "GNUmakefile";
else if(stat("makefile", &fileBuf) == 0)
makeFile = "makefile";
else if(stat("Makefile", &fileBuf) == 0)
makeFile = "Makefile";
else
{
printf("Could not find a default makefile. Program terminating...\n");
exit(0);
}
}
if(argc > optind) // if there are still arguments after the command options,
{ // extract the target command from the argument list
hasTarget = 1;
target = calloc(1, strlen(argv[optind]) + 1);
strcpy(target, argv[optind]);
originalTarget = target;
}
myFile = fopen(makeFile, "r");
char line[MACROSIZE];
char *makeString[MACROSIZE];
int counter = 0;
if( myFile != NULL)
{
while(fgets (line, sizeof line, myFile) != NULL)
{
makeString[counter] = calloc(1, strlen(line) + 1);
strcpy(makeString[counter], line);
// puts(makeString[counter]);
counter ++;
}
fclose(myFile);
}
macI *firstMacro = calloc(1, sizeof(macI));
firstMacro = createList(firstMacro, makeString, counter);
for(int i = 0; i < counter; i++)
{
char *temp = subMacros(makeString[i], firstMacro);
makeString[i] = realloc(makeString[i], strlen(temp) + 1);
strcpy(makeString[i], temp);
RemoveNewLines(makeString[i]);
makeString[i] = RemoveStartSpaces(makeString[i]);
}
tItem *firstTarget = calloc(1, sizeof(tItem));
firstTarget = insertTarget(firstTarget, FIRSTTARGET);
switch(evaluateTarget(makeString, target, counter, hasTarget, firstTarget))
{
case 3:
// puts("1");
return 1;
break;
case 4:
// puts("0");
return 0;
break;
default:
break;
}
// ****************************************** FREE MEMORY *************************************
// ****************************************** FREE MEMORY *************************************
// ****************************************** FREE MEMORY *************************************
if(hasChanged == 0) printf("mymake: `%s' is up to date.\n", originalTarget);
if(argF) free(makeFile);
if(hasTarget) free(target);
for(int i = 0; i < counter; i ++)
free(makeString[counter]);
freeTargets(firstTarget);
freeMacros(firstMacro);
}
int evaluateTarget(char *makeString[], char *target, int counter, bool hasTarget, tItem *firstTar)
{
bool mustRun = false;
bool hasError = false;
struct stat targetBuf;
struct stat dependBuf;
time_t tarTime;
time_t depTime;
char *tarLine = findTarget(makeString, target, counter, hasTarget);
if(tarLine != NULL)
{
target = malloc(strlen(tarLine));
int i = 0;
for(i = 0; tarLine[i] != ':' ; i++)
target[i] = tarLine[i];
target[i] = '\0';
if(originalTarget == NULL)
{
originalTarget = malloc(strlen(target));
strcpy(originalTarget, target);
}
}
if(tarLine == NULL)
{
hasError = true;
printf("make: *** No rule to make target `%s'.", target);
hasChanged = 1;
if(argK) printf("\n");
else
{
printf(" Stop.\n");
exit(0);
}
return 2;
}
if(targetDone(target, firstTar) == 1)
return 0;
tItem *newTar;
newTar = insertTarget(firstTar, target);
char *dependencies[MACROSIZE];
bool hasDeps = parseDepen(tarLine, dependencies);
if(!hasDeps) // Does the target line have dependencies? NO
{
mustRun = true;
}
else // Does the target line have dependencies? YES
{
if(stat(target, &targetBuf) == 0) // Does the target exist? YES
{
tarTime = targetBuf.st_mtime;
for(int i = 0; dependencies[i] != NULL; i ++) // Loop through the dependencies
{
if(findTarget(makeString, dependencies[i], counter, hasTarget) != NULL) // does the depend target line exist? YES
{
switch(evaluateTarget(makeString, dependencies[i], counter, true, firstTar))
{
case 1:
mustRun = true;
break;
case 2:
mustRun = false;
hasError = true;
break;
case 3:
mustRun = true;
break;
default:
break;
}
}
else // Does the depend target line exist? NO
{
if(stat(dependencies[i], &dependBuf) != 0) // Does the file exist in the directory? NO
{
hasError = true;
printf("make: *** No rule to make target `%s'.", dependencies[i]);
hasChanged = 1;
if(argK) printf("\n");
else
{
printf(" Stop.\n");
exit(0);
}
return 2;
// ERROR! .c or .h file does not exist!
}
else
{
depTime = dependBuf.st_mtime;
if(depTime > tarTime) // is the dependency file newer than the target file? YES
mustRun = true;
}
}
}
}
else // Does the Target exist in the directory? NO
{
mustRun = true;
// printf("%s does not exist in directory, mustRun = true\n", target);
for(int i = 0; dependencies[i] != NULL; i++)
{
if(findTarget(makeString, dependencies[i], counter, hasTarget) != NULL) // Does the depend target line exist? YES
{
if(evaluateTarget(makeString, dependencies[i], counter, true, firstTar) == 2)
mustRun = false;
}
else
{
if(stat(dependencies[i], &dependBuf) != 0) // Does the dependency file exist in the directory? NO
{
mustRun = false;
hasError = true;
printf("make: *** No rule to make target `%s'.", dependencies[i]);
hasChanged = 1;
if(argK) printf("\n");
else
{
printf(" Stop.\n");
exit(0);
}
return 2;
// ERROR! .c or .h file does not exist!
}
}
}
}
}
if(mustRun == true && hasError == false && argQ == false)
{
puts(findCommands(makeString, target, counter));
hasChanged = 1;
return 1;
}
else if(mustRun == true && hasError == false && argQ == true)
return 3;
else if(mustRun == false && hasError == false && argQ == true)
return 4;
else if(hasError == 1)
return 2;
return 0;
}
