/* 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; }