| /* |
| * Copyright 2009, The Android Open Source Project |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <map> |
| #include <string> |
| #include <vector> |
| #include <cstdio> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| using namespace std; |
| |
| string WEBKITLIB = "external/webkit"; |
| |
| string oldBaseStr; |
| string oldCmdStr; |
| string newBaseStr; |
| string newCmdStr; |
| string sandboxBaseStr; |
| string sandboxCmdStr; |
| string outputDir; |
| string scratchDir; |
| |
| const char* oldBase; |
| const char* oldCmd; |
| const char* newBase; |
| const char* newCmd; |
| const char* sandboxBase; |
| const char* sandboxCmd; |
| |
| bool assert_debug; |
| |
| #define myassert(a) do { \ |
| if (!(a)) { \ |
| fprintf(stderr, "%s %d %s\n", __FUNCTION__, __LINE__, #a); \ |
| fflush(stderr); \ |
| if (assert_debug) for(;;); else exit(0); \ |
| } \ |
| } while(false) |
| |
| class Options { |
| public: |
| Options() : emitGitCommands(false), emitPerforceCommands(false), |
| mergeMake(true), copyOther(true), mergeCore(true), |
| removeEmptyDirs(true), removeSVNDirs(true), debug(false), |
| execute(false), verbose(false), cleared(false) |
| { |
| } |
| |
| bool finish(); |
| void clearOnce() |
| { |
| if (cleared) |
| return; |
| mergeMake = copyOther = mergeCore = removeEmptyDirs = removeSVNDirs = false; |
| cleared = true; |
| } |
| string androidWebKit; |
| string baseWebKit; |
| string newWebKit; |
| bool emitGitCommands; |
| bool emitPerforceCommands; |
| bool mergeMake; |
| bool copyOther; |
| bool mergeCore; |
| bool removeEmptyDirs; |
| bool removeSVNDirs; |
| bool debug; |
| bool execute; |
| bool verbose; |
| private: |
| bool cleared; |
| }; |
| |
| Options options; |
| |
| char* GetFile(string fileNameStr, size_t* sizePtr = NULL, int* lines = NULL) |
| { |
| const char* fileName = fileNameStr.c_str(); |
| FILE* file = fopen(fileName, "r"); |
| if (file == NULL) |
| { |
| fprintf(stderr, "can't read %s\n", fileName); |
| myassert(0); |
| return 0; |
| } |
| fseek(file, 0, SEEK_END); |
| size_t size = ftell(file); |
| if (sizePtr) |
| *sizePtr = size; |
| fseek(file, 0, SEEK_SET); |
| char* buffer = new char[size + 2]; |
| fread(buffer, size, 1, file); |
| buffer[size] = buffer[size + 1] = '\0'; |
| int lineCount = 0; |
| for (size_t index = 0; index < size; index++) { |
| if (buffer[index] == '\n') { |
| buffer[index] = '\0'; |
| lineCount++; |
| } |
| } |
| if (lines) |
| *lines = lineCount; |
| fclose(file); |
| return buffer; |
| } |
| |
| bool Options::finish() |
| { |
| ::assert_debug = options.debug; |
| if (androidWebKit.size() == 0) { |
| fprintf(stderr, "missing --android parameter"); |
| return false; |
| } |
| if (baseWebKit.size() == 0) { |
| fprintf(stderr, "missing --basewebkit parameter"); |
| return false; |
| } |
| if (newWebKit.size() == 0) { |
| fprintf(stderr, "missing --newwebkit parameter"); |
| return false; |
| } |
| sandboxBaseStr = androidWebKit + "/" + WEBKITLIB; |
| sandboxCmdStr = sandboxBaseStr; |
| int err = system("pwd > pwd.txt"); |
| myassert(err != -1); |
| outputDir = string(GetFile("pwd.txt")); |
| system("rm pwd.txt"); |
| myassert(outputDir.size() > 0); |
| scratchDir = outputDir; |
| outputDir += "/scripts/"; |
| string outputMkdir = "test -d " + outputDir + " || mkdir " + outputDir; |
| system(outputMkdir.c_str()); |
| scratchDir += "/scratch/"; |
| string scratchMkdir = "test -d " + scratchDir + " || mkdir " + scratchDir; |
| system(scratchMkdir.c_str()); |
| oldBaseStr = baseWebKit; |
| oldCmdStr = oldBaseStr; |
| newBaseStr = newWebKit; |
| newCmdStr = newBaseStr; |
| oldBase = oldBaseStr.c_str(); |
| oldCmd = oldCmdStr.c_str(); |
| newBase = newBaseStr.c_str(); |
| newCmd = newCmdStr.c_str(); |
| sandboxBase = sandboxBaseStr.c_str(); |
| sandboxCmd = sandboxCmdStr.c_str(); |
| return true; |
| } |
| |
| // scratch files |
| string ScratchFile(const char* name) |
| { |
| return scratchDir + name + ".txt"; |
| } |
| |
| FILE* commandFile; |
| FILE* copyDirFile; |
| FILE* oopsFile; |
| |
| string SedEscape(const char* str) |
| { |
| string result; |
| char ch; |
| while ((ch = *str++) != '\0') { |
| if (ch == '/' || ch == '\\' || ch == '$') |
| result += '\\'; |
| result += ch; |
| } |
| return result; |
| } |
| |
| char* List(const char* base, char* name, const char* workingDir) |
| { |
| string listStr = "ls -F \""; |
| listStr += string(base) + "/" + workingDir + "\" > " + ScratchFile(name); |
| int err = system(listStr.c_str()); |
| myassert(err == 0); |
| return GetFile(ScratchFile(name)); |
| } |
| |
| bool Merge(const char* oldDir, const char* oldFile, const char* newDir, const char* newFile, |
| const char* outFile) |
| { |
| char scratch[2048]; |
| |
| sprintf(scratch, "merge -p -q \"%s/%s/%s\" \"%s/%s/%s\" \"%s/%s/%s\" > %s", |
| sandboxBase, oldDir, oldFile, oldBase, oldDir, oldFile, newBase, newDir, newFile, outFile); |
| int err = system(scratch); |
| myassert(err == 0 || err ==1 || err == 256); |
| return err == 0; |
| } |
| |
| bool Merge(const char* dir, const char* file) |
| { |
| return Merge(dir, file, dir, file, "/dev/null"); |
| } |
| |
| /* |
| static const char* skipNonSpace(char** linePtr) { |
| char* line = *linePtr; |
| while (line[0] && isspace(line[0]) == false) |
| line++; |
| *linePtr = line; |
| return line; |
| } |
| */ |
| |
| static bool endsWith(const char* str, const char* end) { |
| size_t endLen = strlen(end); |
| const char* endStr = str + strlen(str) - endLen; |
| return endStr >= str && strcmp(endStr, end) == 0; |
| } |
| |
| static void skipSpace(char** linePtr) { |
| char* line = *linePtr; |
| while (isspace(line[0])) |
| line++; |
| *linePtr = line; |
| } |
| |
| /* |
| static void setTrimmed(string& str, char* loc, int len) { |
| char* start = loc; |
| skipSpace(&loc); |
| len -= loc - start; |
| while (len > 0 && isspace(loc[len - 1])) |
| len--; |
| str = string(loc, len); |
| } |
| */ |
| |
| static bool skipText(char** linePtr, const char* text) { |
| skipSpace(linePtr); |
| size_t length = strlen(text); |
| bool result = strncmp(*linePtr, text, length) == 0; |
| if (result) |
| *linePtr += length; |
| skipSpace(linePtr); |
| return result; |
| } |
| |
| static bool isTokenChar(char ch) { |
| return isalnum(ch) || ch == '_'; |
| } |
| |
| struct Pair { |
| char* name; |
| int brace; |
| }; |
| |
| class Parse { |
| public: |
| char* m_text; |
| bool m_inComment; |
| bool m_inFunction; |
| bool m_inFindFunctionType; |
| vector<Pair> m_classes; |
| vector<Pair> m_namespaces; |
| vector<Pair> m_preprocessorConditions; |
| string m_functionName; |
| string m_functionDeclaration; |
| string m_classDeclaration; |
| int m_braceLevel; |
| int m_functionBrace; |
| |
| Parse(char* text) : m_text(text), m_inComment(false), m_inFunction(false), m_inFindFunctionType(false), |
| m_braceLevel(0), m_functionBrace(0) {} |
| |
| int CheckForBrace() |
| { |
| int indent = 0; |
| // don't count braces in strings, chars, comments |
| do { |
| char* openBrace = strchr(m_text, '{'); |
| char* closeBrace = strchr(m_text, '}'); |
| if (openBrace == NULL && closeBrace == NULL) |
| break; |
| char* brace = openBrace == NULL ? closeBrace : closeBrace == NULL ? openBrace : |
| openBrace < closeBrace ? openBrace : closeBrace; |
| char* doubleQ = strchr(m_text, '"'); |
| char* singleQ = strchr(m_text, '\''); |
| char* quote = doubleQ == NULL ? singleQ : singleQ == NULL ? doubleQ : |
| doubleQ < singleQ ? doubleQ : singleQ; |
| char quoteMark = quote == doubleQ ? '"' : '\''; |
| if (quote && quote < brace) { |
| myassert(quote[-1] != '\\'); |
| do { |
| quote = strchr(quote + 1, quoteMark); |
| myassert(doubleQ); |
| } while (quote[-1] == '\\'); |
| m_text = quote + 1; |
| continue; |
| } |
| indent += openBrace != NULL ? 1 : -1; |
| m_text = openBrace + 1; |
| } while (m_text[0] != '\0'); |
| return indent; |
| } |
| |
| int ParseLine() |
| { |
| size_t textLen = strlen(m_text); |
| char* lineStart = m_text; |
| char* commentStart; |
| if (m_text[0] == '\0') |
| goto nextLine; |
| if (m_inComment == false && m_text[0] == '/') { |
| m_inComment = m_text[1] == '*'; |
| if (m_text[1] == '/' || m_text[1] == '*') |
| goto nextLine; |
| } |
| commentStart = m_text; // before anything else, turn embedded comments into their own lines |
| if (m_inComment == false && skipText(&commentStart, "//")) { |
| if (commentStart < lineStart + textLen) |
| commentStart[0] = '/'; |
| else |
| commentStart[-1] = ' '; |
| commentStart -= 2; |
| commentStart[0] = '\0'; |
| textLen = commentStart - lineStart; |
| goto nextLine; |
| } |
| if (m_inComment || skipText(&commentStart, "/*")) { |
| char* commentEnd = commentStart; |
| if (skipText(&commentEnd, "*/")) { |
| if (commentEnd < lineStart + textLen) { |
| commentEnd[-1] = '\0'; |
| textLen = commentEnd - lineStart - 2; |
| } |
| if (m_inComment) { |
| m_inComment = false; |
| goto nextLine; |
| } |
| } |
| if (m_inComment) |
| goto nextLine; |
| memcpy(commentStart - 2, "\0/*", 3); |
| textLen = commentStart - lineStart - 2; |
| } |
| if (skipText(&m_text, "#include")) |
| goto nextLine; |
| if (skipText(&m_text, "#if") || skipText(&m_text, "#else")) { |
| Pair condition = { lineStart, m_braceLevel }; |
| m_preprocessorConditions.push_back(condition); |
| goto nextLine; |
| } |
| { |
| bool is_endif = false; |
| if (skipText(&m_text, "#elif") || (is_endif = skipText(&m_text, "#endif")) != false) { // pop prior elif, if |
| char* lastText; |
| do { |
| int last = m_preprocessorConditions.size() - 1; |
| myassert(last >= 0); |
| lastText = m_preprocessorConditions[last].name; |
| m_preprocessorConditions.pop_back(); |
| } while (is_endif && skipText(&lastText, "#else") == true); |
| goto nextLine; |
| } |
| } |
| if (skipText(&m_text, "namespace")) { |
| Pair space = { lineStart, m_braceLevel }; |
| m_namespaces.push_back(space); |
| goto checkForBrace; |
| } |
| if (m_inFunction) |
| goto checkForBrace; |
| // detect functions by looking for token preceding open-paren. |
| if (m_inFindFunctionType == false) { |
| char* openParen = strchr(m_text, '('); |
| if (openParen) { |
| char* last = openParen; |
| while (last > m_text && isspace(last[-1])) |
| --last; |
| while (last > m_text && ((isTokenChar(last[-1]) || last[-1] == ':') && last[-2] == ':')) |
| --last; |
| myassert(isdigit(last[0]) == false); |
| if (isTokenChar(last[0])) { |
| m_inFindFunctionType = true; |
| m_functionName = string(last); |
| } |
| } |
| } |
| { |
| char* openBrace = strchr(m_text, '{'); |
| char* semiColon = strchr(m_text, ';'); |
| if (semiColon != NULL && semiColon < openBrace) |
| openBrace = NULL; |
| // functions are of the form: type (class::)*function(parameter-list) { |
| // all of which may be on separate lines |
| // so keep track of returntype, class, function, paramlist, openbrace separately |
| if (m_inFindFunctionType == true) { // look ahead to see which comes first, a semicolon or an open brace |
| if (openBrace) { |
| m_functionBrace = ++m_braceLevel; |
| m_inFunction = true; |
| m_inFindFunctionType = false; |
| m_text = openBrace + 1; |
| goto checkForBrace; |
| } |
| if (semiColon != NULL) { // a function declaration |
| m_inFindFunctionType = false; |
| m_functionDeclaration = m_functionName; |
| m_functionName.erase(0, m_functionName.length()); |
| } else |
| goto nextLine; |
| } |
| // FIXME what if class line has neither brace nor semi? |
| if (skipText(&m_text, "class")) { |
| if (openBrace > m_text) { |
| Pair _class = { lineStart, m_braceLevel }; |
| m_classes.push_back(_class); |
| } else if (semiColon != NULL) { |
| m_classDeclaration = lineStart; // !!! FIXME should have function form as above |
| } |
| } |
| } |
| checkForBrace: |
| m_braceLevel += CheckForBrace(); |
| if (m_functionBrace > 0 && m_braceLevel <= m_functionBrace) { |
| m_functionName.erase(0, m_functionName.length()); |
| m_functionBrace = 0; |
| } |
| nextLine: |
| return textLen; |
| } |
| |
| }; |
| |
| char* const GetAndroidDiffs(const char* dir, const char* filename) |
| { |
| char scratch[2048]; |
| string diffsFile = ScratchFile(__FUNCTION__); |
| sprintf(scratch, "diff \"%s/%s/%s\" \"%s/%s/%s\" > %s", sandboxBase, dir, |
| filename, oldBase, dir, filename, diffsFile.c_str()); |
| int err = system(scratch); |
| myassert(err == 0 || err == 256); |
| char* const diffs = GetFile(diffsFile); |
| return diffs; |
| } |
| |
| void CheckForExec(const char* base1, const char* dir1, const char* file1, |
| const char* base2, const char* dir2, const char* file2, bool* ex1, bool* ex2) |
| { |
| size_t file1Len = strlen(file1); |
| size_t file2Len = strlen(file2); |
| bool file1Ex = file1[file1Len - 1] == '*'; |
| bool file2Ex = file2[file2Len - 1] == '*'; |
| if (file1Ex != file2Ex) { |
| fprintf(stderr, "warning: %s/%s/%s has %sexec bit set while" |
| " %s/%s/%s has %sexec bit set\n", |
| base1, dir1, file1, file1Ex ? "" : "no ", |
| base2, dir2, file2, file2Ex ? "" : "no "); |
| } |
| if (ex1) *ex1 = file1Ex; |
| if (ex2) *ex2 = file2Ex; |
| } |
| |
| bool CompareFiles(const char* base1, const char* dir1, const char* file1, |
| const char* base2, const char* dir2, const char* file2) |
| { |
| char scratch[2048]; |
| bool file1Ex, file2Ex; |
| string compareFileStr = ScratchFile(__FUNCTION__); |
| CheckForExec(base1, dir1, file1, base2, dir2, file2, &file1Ex, &file2Ex); |
| sprintf(scratch, "diff --brief \"%s/%s/%.*s\" \"%s/%s/%.*s\" > %s", |
| base1, dir1, (int) strlen(file1) - (int) file1Ex, file1, |
| base2, dir2, (int) strlen(file2) - (int) file2Ex, file2, |
| compareFileStr.c_str()); |
| int err = system(scratch); |
| myassert(err == 0 || err == 256); |
| char* scratchText = GetFile(compareFileStr); |
| size_t len = strlen(scratchText); |
| delete[] scratchText; |
| return len > 0; |
| } |
| |
| bool CompareFiles(const char* base1, const char* base2, const char* dir, const char* file) |
| { |
| return CompareFiles(base1, dir, file, base2, dir, file); |
| } |
| |
| int Compare(char* one, size_t len1, char* two, size_t len2) |
| { |
| char* o_end = one + len1; |
| char* t_end = two + len2; |
| do { |
| if (one == o_end) |
| return two == t_end ? 0 : 1; |
| if (two == t_end) |
| return -1; |
| char o = *one++; |
| char t = *two++; |
| if (o == t) |
| continue; |
| if (o == '/') |
| return -1; |
| if (t == '/') |
| return 1; |
| return o < t ? -1 : 1; |
| } while (true); |
| myassert(0); |
| return 0; |
| } |
| |
| string Find(const char* oldList) |
| { |
| string result; |
| char scratch[2048]; |
| // look in WebCore and JavaScriptCore |
| string findWebCore = ScratchFile("FindWebCore"); |
| sprintf(scratch, "cd %s%s ; find . -name \"%s\" > %s", |
| newBase, "/WebCore", oldList, findWebCore.c_str()); |
| int err = system(scratch); |
| myassert(err == 0 || err == 256); |
| int webCount; |
| char* foundInWebCore = GetFile(findWebCore, NULL, &webCount); |
| char* originalFoundInWebCore = foundInWebCore; |
| string findJavaScriptCore = ScratchFile("FindJavaScriptCore"); |
| sprintf(scratch, "cd %s%s ; find . -name \"%s\" > %s", |
| newBase, "/JavaScriptCore", oldList, findJavaScriptCore.c_str()); |
| err = system(scratch); |
| myassert(err == 0 || err == 256); |
| int javaScriptCount; |
| char* foundInJavaScriptCore = GetFile(findJavaScriptCore, NULL, &javaScriptCount); |
| char* originalFoundInJavaScriptCore = foundInJavaScriptCore; |
| if (webCount == 1 && javaScriptCount == 0) { |
| result = "WebCore/" + string(&foundInWebCore[2]); |
| } else if (webCount == 0 && javaScriptCount == 1) { |
| result = "JavaScriptCore/" + string(&foundInJavaScriptCore[2]); |
| } else if (webCount == 1 && javaScriptCount == 1 && |
| strncmp(&foundInWebCore[2], "ForwardingHeaders/", 18) == 0) { |
| result = "JavaScriptCore/" + string(&foundInJavaScriptCore[2]); |
| } else if (webCount == 1 && javaScriptCount == 1 && |
| strncmp(&foundInJavaScriptCore[2], "API/tests/", 10) == 0) { |
| result = "JavaScriptCore/" + string(&foundInJavaScriptCore[2]); |
| } else if (webCount + javaScriptCount > 0) { |
| fprintf(stderr, "deleted file \"%s\" has more than one possible rename:\n", oldList); |
| int index; |
| for (index = 0; index < webCount; index++) { |
| fprintf(stderr, "WebCore/%s\n", &foundInWebCore[2]); |
| foundInWebCore += strlen(foundInWebCore) + 1; |
| } |
| for (index = 0; index < javaScriptCount; index++) { |
| fprintf(stderr, "JavaScriptCore/%s\n", &foundInJavaScriptCore[2]); |
| foundInJavaScriptCore += strlen(foundInJavaScriptCore) + 1; |
| } |
| } |
| delete[] originalFoundInWebCore; |
| delete[] originalFoundInJavaScriptCore; |
| return result; |
| } |
| |
| char* GetMakeAndExceptions(const char* dir, const char* filename, size_t* makeSize, |
| string* excludedFilesPtr, string* excludedGeneratedPtr, |
| string* excludedDirsPtr, string* androidFilesPtr, |
| char** startPtr, char** localStartPtr) |
| { |
| char scratch[1024]; |
| sprintf(scratch, "%s/%s/%s", sandboxBase, dir, filename); |
| char* makeFile = GetFile(scratch, makeSize); |
| char* start = makeFile; |
| do { // find first filename in makefile |
| if (strncmp(start, "# LOCAL_SRC_FILES_EXCLUDED := \\", 30) == 0) |
| break; |
| start += strlen(start) + 1; |
| } while (start < makeFile + *makeSize); |
| myassert(start[0] != '\0'); |
| start += strlen(start) + 1; |
| // construct one very large regular expression that looks like: |
| // echo '%s' | grep -v -E 'DerivedSources.cpp|WebCorePrefix.cpp...' |
| // to filter out matches that aren't allowed |
| // wildcards '*' in the original need to be expanded to '.*' |
| string excludedFiles = "grep -v -E '"; |
| while (strncmp(start, "#\t", 2) == 0) { |
| start += 2; |
| char ch; |
| while ((ch = *start++) != ' ') { |
| if (ch == '*') |
| excludedFiles += '.'; |
| else if (ch == '.') |
| excludedFiles += '\\'; |
| excludedFiles += ch; |
| } |
| excludedFiles += "|"; |
| myassert(*start == '\\'); |
| start += 2; |
| } |
| excludedFiles[excludedFiles.size() - 1] = '\''; |
| *excludedFilesPtr = excludedFiles; |
| do { |
| if (strncmp(start, "# LOCAL_GENERATED_FILES_EXCLUDED := \\", 37) == 0 || |
| strncmp(start, "# LOCAL_DIR_WILDCARD_EXCLUDED := \\", 34) == 0) |
| break; |
| start += strlen(start) + 1; |
| } while (start < makeFile + *makeSize); |
| if (strncmp(start, "# LOCAL_GENERATED_FILES_EXCLUDED := \\", 37) == 0) { |
| string excludedGenerated = "grep -v -E '"; |
| start += strlen(start) + 1; |
| while (strncmp(start, "#\t", 2) == 0) { |
| start += 2; |
| char ch; |
| while ((ch = *start++) != ' ') { |
| if (ch == '*') |
| excludedGenerated += '.'; |
| else if (ch == '.') |
| excludedGenerated += '\\'; |
| excludedGenerated += ch; |
| } |
| excludedGenerated += "|"; |
| myassert(*start == '\\'); |
| start += 2; |
| } |
| myassert(excludedGeneratedPtr); |
| excludedGenerated[excludedGenerated.size() - 1] = '\''; |
| *excludedGeneratedPtr = excludedGenerated; |
| } |
| do { // find first filename in makefile |
| if (strncmp(start, "# LOCAL_DIR_WILDCARD_EXCLUDED := \\", 34) == 0) |
| break; |
| start += strlen(start) + 1; |
| } while (start < makeFile + *makeSize); |
| if (start[0] != '\0') { |
| string excludedDirs = "-e '/\\.vcproj\\// d' -e '/\\.svn\\// d' "; |
| do { |
| start += strlen(start) + 1; |
| char* exceptionDirStart = start; |
| if (strncmp(exceptionDirStart, "#\t", 2) != 0) { |
| myassert(exceptionDirStart[0] == '\0'); |
| break; |
| } |
| exceptionDirStart += 2; |
| char* exceptionDirEnd = exceptionDirStart; |
| do { |
| exceptionDirEnd = strchr(exceptionDirEnd, '\\'); |
| } while (exceptionDirEnd && *++exceptionDirEnd == '/'); |
| myassert(exceptionDirEnd); |
| --exceptionDirEnd; |
| myassert(exceptionDirEnd[-1] == ' '); |
| myassert(exceptionDirEnd[-2] == '*'); |
| myassert(exceptionDirEnd[-3] == '/'); |
| exceptionDirEnd[-3] = '\0'; |
| excludedDirs += "-e '/"; |
| if (exceptionDirStart[0] == '/') |
| excludedDirs += "\\"; |
| excludedDirs += exceptionDirStart; |
| excludedDirs += "\\// d' "; |
| start = exceptionDirEnd; |
| } while (true); |
| *excludedDirsPtr = excludedDirs; |
| } |
| *startPtr = start; |
| // optionally look for android-specific files |
| char* makeEnd = makeFile + *makeSize; |
| do { // find first filename in makefile |
| if (strcmp(start, "# LOCAL_ANDROID_SRC_FILES_INCLUDED := \\") == 0) |
| break; |
| } while ((start += strlen(start) + 1), start < makeEnd); |
| if (start >= makeEnd) |
| return makeFile; |
| start += strlen(start) + 1; |
| string androidFiles = "grep -v -E '"; |
| do { |
| myassert(strncmp(start, "#\t", 2) == 0); |
| start += 2; |
| char ch; |
| bool isIdl = strstr(start, "idl \\") != 0; |
| char* lastSlash = strrchr(start, '/') + 1; |
| while ((ch = *start++) != ' ') { |
| if (ch == '*') |
| androidFiles += '.'; |
| else if (ch == '.') |
| androidFiles += '\\'; |
| androidFiles += ch; |
| if (!isIdl) |
| continue; |
| if (ch == '/' && start == lastSlash) |
| androidFiles += "JS"; |
| if (ch == '.') { |
| myassert(strcmp(start, "idl \\") == 0); |
| start += 4; |
| androidFiles += 'h'; |
| break; |
| } |
| } |
| androidFiles += "|"; |
| myassert(*start == '\\'); |
| start += 2; |
| } while (start[0] == '#'); |
| androidFiles[androidFiles.size() - 1] = '\''; |
| *androidFilesPtr = androidFiles; |
| return makeFile; |
| } |
| |
| vector<char*> GetDerivedSourcesMake(const char* dir) |
| { |
| vector<char*> result; |
| char scratch[1024]; |
| sprintf(scratch, "%s/%s/%s", newBase, dir, "DerivedSources.make"); |
| size_t fileSize; |
| char* file = GetFile(scratch, &fileSize); |
| char* fileEnd = file + fileSize; |
| myassert(file); |
| size_t len; |
| do { // find first filename in makefile |
| len = strlen(file); |
| if (strcmp(file, "all : \\") == 0) |
| break; |
| file += len + 1; |
| } while (file < fileEnd); |
| myassert(strcmp(file, "all : \\") == 0); |
| file += len + 1; |
| while (file[0] != '#') { |
| len = strlen(file); |
| char* st = file; |
| skipSpace(&st); |
| if (st[0] != '\\' && st[0] != '$') |
| result.push_back(st); |
| file += len + 1; |
| } |
| return result; |
| } |
| |
| bool MarkDerivedFound(vector<char*>& derived, char* check, size_t len) |
| { |
| bool found = false; |
| for (unsigned index = 0; index < derived.size(); index++) { |
| char* der = derived[index]; |
| if (strncmp(der, check, len) == 0) { |
| der[0] = '\0'; |
| found = true; |
| } |
| } |
| return found; |
| } |
| |
| void UpdateDerivedMake() |
| { |
| const char* dir = "WebCore"; |
| int err; |
| vector<char*> derived = GetDerivedSourcesMake(dir); |
| size_t makeSize; |
| char* start, * localStart; |
| string excludedDirs, excludedFiles, excludedGenerated, androidFiles; |
| char* makeFile = GetMakeAndExceptions(dir, "Android.derived.mk", &makeSize, |
| &excludedFiles, &excludedGenerated, &excludedDirs, &androidFiles, |
| &start, &localStart); |
| if (options.emitPerforceCommands) |
| fprintf(commandFile, "p4 edit %s/%s/%s\n", sandboxCmd, dir, "Android.derived.mk"); |
| fprintf(commandFile, "cat %s/%s/%s | sed \\\n", sandboxCmd, dir, "Android.derived.mk"); |
| string updateDerivedMake = ScratchFile(__FUNCTION__); |
| string filelist = string("cd ") + newBase + "/" + dir + |
| " ; find . -name '*.idl' | " + excludedFiles + |
| " | sed -e 's/.\\///' " + excludedDirs + |
| " | sed 's@\\(.*\\)/\\(.*\\)\\.idl@ $(intermediates)/\\1/JS\\2.h@' " |
| " | sort -o " + updateDerivedMake; |
| err = system(filelist.c_str()); |
| myassert(err == 0 || err == 256); |
| char* bindings = GetFile(updateDerivedMake); |
| bool inGen = false; |
| char* fileEnd = makeFile + makeSize; |
| char* nextStart; |
| do { |
| size_t startLen = strlen(start); |
| nextStart = start + startLen + 1; |
| bool onGen = false; |
| char* st = start; |
| if (inGen == false) { |
| if (strncmp(st, "GEN", 3) != 0) |
| continue; |
| st += 3; |
| skipSpace(&st); |
| if (strncmp(st, ":=", 2) != 0) |
| continue; |
| st += 2; |
| onGen = true; |
| } |
| skipSpace(&st); |
| inGen = start[startLen - 1] == '\\'; |
| if (inGen) { |
| if (st[0] == '\\' && st[1] == '\0') |
| continue; |
| if (strcmp(st, "$(addprefix $(intermediates)/, \\") == 0) |
| continue; |
| } else if (st[0] == ')' && st[1] == '\0') |
| continue; |
| static const char bindHead[] = "bindings/js/"; |
| const size_t bindLen = sizeof(bindHead) - 1; |
| string escaped; |
| if (strncmp(st, bindHead, bindLen) == 0) { |
| st += bindLen; |
| if (MarkDerivedFound(derived, st, strlen(st)) == false) { |
| fprintf(stderr, "*** webkit removed js binding: %s" |
| " (must be removed manually)\n", st); |
| escaped = SedEscape(st); |
| fprintf(commandFile, "-e '/%s/ d' ", escaped.c_str()); |
| } |
| continue; |
| } |
| myassert(strncmp(st, "$(intermediates)", 16) == 0); |
| if (onGen && inGen == false) { // no continuation |
| char* lastSlash; |
| myassert(strrchr(st, '/') != NULL); |
| while ((lastSlash = strrchr(st, '/')) != NULL) { |
| char* lastEnd = strchr(lastSlash, ' '); |
| if (lastEnd == NULL) |
| lastEnd = lastSlash + strlen(lastSlash); |
| myassert(lastSlash != 0); |
| lastSlash++; |
| size_t lastLen = lastEnd - lastSlash; |
| if (MarkDerivedFound(derived, lastSlash, lastLen) == false) { |
| fprintf(stderr, "*** webkit removed generated file:" |
| " %.*s (must be removed manually)\n", (int) lastLen, |
| lastSlash); |
| // escaped = SedEscape(st); |
| // fprintf(commandFile, "-e '/%s/ d' \\\n", escaped.c_str()); |
| } |
| char* priorDollar = strrchr(st, '$'); |
| myassert(priorDollar != NULL); |
| char* nextDollar = strchr(st, '$'); |
| if (nextDollar == priorDollar) |
| break; |
| priorDollar[0] = '\0'; |
| } |
| continue; |
| } |
| char* nextSt = nextStart; |
| skipSpace(&nextSt); |
| myassert(strncmp(nextSt, "$(intermediates)", 16) != 0 || strcmp(st, nextSt) < 0); |
| // do { |
| char* bind = bindings; |
| myassert(bind); |
| skipSpace(&bind); |
| int compare = strncmp(bind, st, strlen(bind) - 2); |
| if (compare < 0) { // add a file |
| escaped = SedEscape(st); |
| char* filename = strrchr(bindings, '/'); |
| myassert(filename); |
| filename += 3; |
| // FIX ME: exclude items in DerivedSources.make all : $(filter-out ... |
| char* bi = bindings; |
| skipSpace(&bi); |
| char* bindName = strrchr(bi, '/'); |
| myassert(bindName != NULL); |
| bindName++; |
| string biStr = SedEscape(bi); |
| fprintf(commandFile, "-e '/%s/ i\\\n_TAB_%s \\\\\n' ", |
| escaped.c_str(), biStr.c_str()); |
| MarkDerivedFound(derived, bindName, strlen(bindName)); |
| nextStart = start; |
| bindings += strlen(bindings) + 1; |
| inGen = true; |
| } else if (compare > 0) { |
| // if file to be deleted is locally added by android, leave it alone |
| myassert(strncmp(st, "$(intermediates)/", 17) == 0); |
| string subst = string(st).substr(17, strlen(st) - 17 - (inGen ? 2 : 0)); |
| string localDerivedStr = ScratchFile("LocalDerived"); |
| string filter = string("echo '") + subst + "' | " + androidFiles + |
| " > " + localDerivedStr; |
| if (options.debug) |
| fprintf(stderr, "LocalDerived.txt : %s\n", filter.c_str()); |
| err = system(filter.c_str()); |
| myassert(err == 0 || err == 256); |
| char* localDerived = GetFile(localDerivedStr); |
| if (localDerived[0] != '\0') { |
| escaped = SedEscape(st); |
| fprintf(commandFile, "-e '/%s/ d' ", escaped.c_str()); |
| } |
| } else { |
| char* stName = strrchr(st, '/'); |
| myassert(stName); |
| stName++; |
| MarkDerivedFound(derived, stName, strlen(stName)); |
| bindings += strlen(bindings) + 1; |
| } |
| // } while (strstr(start, "$(intermediates)") != NULL); |
| // if changing directories, add any new files to the end of this directory first |
| if (bindings[0] != '\0' && strstr(nextStart, "$(intermediates)") == NULL) { |
| st = start; |
| skipSpace(&st); |
| escaped = SedEscape(st); |
| st = strchr(st, '/'); |
| char* stDirEnd = strchr(st + 1, '/'); |
| do { |
| bind = strchr(bindings, '/'); |
| if (!bind) |
| break; |
| char* bindEnd = strchr(bind + 1, '/'); |
| if (!bindEnd) |
| break; |
| if (bindEnd - bind != stDirEnd - st) |
| break; |
| if (strncmp(st, bind, stDirEnd - st) != 0) |
| break; |
| if (inGen == false) |
| fprintf(commandFile, "-e '/%s/ s/$/ \\\\/' ", escaped.c_str()); |
| char* bi = bindings; |
| skipSpace(&bi); |
| string biStr = SedEscape(bi); |
| fprintf(commandFile, "-e '/%s/ a\\\n_TAB_%s\n' ", |
| escaped.c_str(), biStr.c_str()); |
| MarkDerivedFound(derived, bindEnd + 1, strlen(bindEnd + 1)); |
| escaped = biStr; |
| inGen = false; |
| bindings += strlen(bindings) + 1; |
| } while (true); |
| } |
| } while (start = nextStart, start < fileEnd); |
| for (unsigned index = 0; index < derived.size(); index++) { |
| char* der = derived[index]; |
| if (der[0] == '\0') |
| continue; |
| string excludedGeneratedStr = ScratchFile("ExcludedGenerated"); |
| string filter = string("echo '") + der + "' | " + excludedGenerated + |
| " > " + excludedGeneratedStr; |
| err = system(filter.c_str()); |
| myassert(err == 0 || err == 256); |
| char* excluded = GetFile(excludedGeneratedStr); |
| if (excluded[0] != '\0') |
| fprintf(stderr, "*** missing rule to generate %s\n", der); |
| } |
| fprintf(commandFile, " | sed 's/^_TAB_/\t/' > %s/%s/%s\n", sandboxCmd, dir, "xAndroid.derived.mk"); |
| fprintf(commandFile, "mv %s/%s/%s %s/%s/%s\n", |
| sandboxCmd, dir, "xAndroid.derived.mk", sandboxCmd, dir, "Android.derived.mk"); |
| if (options.emitGitCommands) |
| fprintf(commandFile, "git add %s/%s\n", dir, "Android.derived.mk"); |
| } |
| |
| int MatchLen(const char* one, const char* two, size_t len) |
| { |
| bool svgIn1 = strstr(one, "svg") || strstr(one, "SVG"); |
| bool svgIn2 = strstr(two, "svg") || strstr(two, "SVG"); |
| if (svgIn1 != svgIn2) |
| return 0; |
| int signedLen = (int) len; |
| int original = signedLen; |
| while (*one++ == *two++ && --signedLen >= 0) |
| ; |
| return original - signedLen; |
| } |
| |
| // create the list of sed commands to update the WebCore Make file |
| void UpdateMake(const char* dir) |
| { |
| // read in the makefile |
| size_t makeSize; |
| char* start, * localStart = NULL; |
| string excludedDirs, excludedFiles, androidFiles; |
| char* makeFile = GetMakeAndExceptions(dir, "Android.mk", &makeSize, |
| &excludedFiles, NULL, &excludedDirs, &androidFiles, &start, &localStart); |
| char* lastFileName = NULL; |
| size_t lastFileNameLen = 0; |
| int lastLineNumber = -1; |
| // get the actual list of files |
| string updateMakeStr = ScratchFile(__FUNCTION__); |
| string filelist = string("cd ") + newBase + "/" + dir + " ;" |
| " find . -name '*.cpp' -or -name '*.c' -or -name '*.y' | " + |
| excludedFiles + " | sed -e 's/.\\///' " + excludedDirs + |
| " | sort -o " + updateMakeStr; |
| if (options.debug) |
| fprintf(stderr, "make %s/%s filter: %s\n", dir, "Android.mk", filelist.c_str()); |
| int err = system(filelist.c_str()); |
| myassert(err == 0 || err == 256); |
| char* newList = GetFile(updateMakeStr); |
| do { // find first filename in makefile |
| if (strncmp(start, "LOCAL_SRC_FILES := \\", 20) == 0) |
| break; |
| start += strlen(start) + 1; |
| } while (start < makeFile + makeSize); |
| myassert(start[0] != '\0'); |
| if (options.emitPerforceCommands) |
| fprintf(commandFile, "p4 edit %s/%s/%s\n", sandboxCmd, dir, "Android.mk"); |
| fprintf(commandFile, "cat %s/%s/%s | sed ", sandboxCmd, dir, "Android.mk"); |
| int lineNumber = 0; |
| do { |
| start += strlen(start) + 1; |
| lineNumber++; |
| if (start - makeFile >= makeSize || start[0] == '$') |
| break; |
| if (start[0] == '\0' || !isspace(start[0])) |
| continue; |
| skipSpace(&start); |
| if (start[0] == '\0' || start[0] == '\\') |
| continue; |
| size_t startLen = strlen(start); |
| if (start[startLen - 1] == '\\') |
| --startLen; |
| while (isspace(start[startLen - 1])) |
| --startLen; |
| size_t newListLen = strlen(newList); |
| if (lastFileName != NULL) { |
| myassert(strncmp(start, lastFileName, startLen) > 0 || |
| startLen > lastFileNameLen); |
| } |
| if (strstr(start, "android") != NULL || strstr(start, "Android") != NULL) { |
| if (startLen == newListLen && strncmp(newList, start, startLen) == 0) |
| newList += newListLen + 1; |
| lastFileName = start; |
| lastFileNameLen = startLen; |
| lastLineNumber = lineNumber; |
| continue; |
| } |
| int compare; |
| bool backslash = lastFileName && |
| lastFileName[strlen(lastFileName) - 1] == '\\'; |
| do { |
| compare = strncmp(newList, start, startLen); |
| if (compare == 0 && startLen != newListLen) |
| compare = newListLen < startLen ? -1 : 1; |
| if (newList[0] == '\0' || compare >= 0) |
| break; |
| // add a file |
| if (lastFileName && lineNumber - lastLineNumber > 1 && |
| MatchLen(lastFileName, newList, lastFileNameLen) > |
| MatchLen(start, newList, startLen)) { |
| string escaped = SedEscape(lastFileName); |
| if (!backslash) |
| fprintf(commandFile, "-e '/%s/ s/$/ \\\\/' ", escaped.c_str()); |
| fprintf(commandFile, "-e '/%s/ a\\\n_TAB_%s%s\n' ", |
| SedEscape(lastFileName).c_str(), newList, |
| backslash ? " \\\\" : ""); |
| lastFileName = newList; |
| lastFileNameLen = newListLen; |
| } else { |
| fprintf(commandFile, "-e '/%s/ i\\\n_TAB_%s \\\\\n' ", |
| SedEscape(start).c_str(), newList); |
| } |
| newList += newListLen + 1; |
| newListLen = strlen(newList); |
| } while (true); |
| if (newList[0] == '\0' || compare > 0) { |
| // don't delete files added by Android |
| string localMakeStr = ScratchFile("LocalMake"); |
| string filter = "echo '" + string(start).substr(0, startLen) + |
| "' | " + androidFiles + " > " + localMakeStr; |
| int err = system(filter.c_str()); |
| myassert(err == 0 || err == 256); |
| char* localMake = GetFile(localMakeStr); |
| if (localMake[0] != '\0') { |
| string escaped = SedEscape(start); |
| fprintf(commandFile, "-e '/%s/ d' ", escaped.c_str()); |
| } |
| } else |
| newList += newListLen + 1; |
| lastFileName = start; |
| lastFileNameLen = startLen; |
| lastLineNumber = lineNumber; |
| } while (true); |
| fprintf(commandFile, " | sed 's/^_TAB_/\t/' > %s/%s/%s\n", sandboxCmd, dir, "xAndroid.mk"); |
| fprintf(commandFile, "mv %s/%s/%s %s/%s/%s\n", |
| sandboxCmd, dir, "xAndroid.mk", sandboxCmd, dir, "Android.mk"); |
| if (options.emitGitCommands) |
| fprintf(commandFile, "git add %s/%s\n", dir, "Android.mk"); |
| } |
| |
| static bool emptyDirectory(const char* base, const char* work, const char* dir) { |
| string findEmptyStr = "find \""; |
| string emptyDirStr = ScratchFile("emptyDirectory"); |
| if (base[0] != '\0') |
| findEmptyStr += string(base) + "/" + work + "/" + dir + "\""; |
| else |
| findEmptyStr += string(work) + "/" + dir + "\""; |
| findEmptyStr += " -type f -print > " + emptyDirStr; |
| int err = system(findEmptyStr.c_str()); |
| if (err != 0) |
| return true; |
| FILE* file = fopen(emptyDirStr.c_str(), "r"); |
| if (file == NULL) |
| { |
| fprintf(stderr, "can't read %s\n", emptyDirStr.c_str()); |
| myassert(0); |
| return true; |
| } |
| fseek(file, 0, SEEK_END); |
| size_t size = ftell(file); |
| fclose(file); |
| return size == 0; |
| } |
| |
| static bool emptyDirectory(const char* work, const char* dir) { |
| return emptyDirectory("", work, dir); |
| } |
| |
| void CompareDirs(const char* workingDir, bool renamePass) |
| { |
| map<string, string> renameMap; |
| char* oldList = List(oldBase, "old", workingDir); |
| char* newList = List(newBase, "new", workingDir); |
| char* sandList = List(sandboxBase, "sandbox", workingDir); |
| char* oldMem = oldList; |
| char* newMem = newList; |
| char* sandboxMem = sandList; |
| // identify files to be added, removed by comparing old, new lists |
| do { |
| size_t oldLen = strlen(oldList); |
| size_t newLen = strlen(newList); |
| size_t sandLen = strlen(sandList); |
| if (oldLen == 0 && newLen == 0 && sandLen == 0) |
| break; |
| bool oldDir = false; |
| bool oldExecutable = false; |
| if (oldLen > 0) { |
| char last = oldList[oldLen - 1]; |
| oldDir = last == '/'; |
| oldExecutable = last == '*'; |
| if (oldDir || oldExecutable) |
| --oldLen; |
| } |
| bool newDir = false; |
| bool newExecutable = false; |
| if (newLen > 0) { |
| char last = newList[newLen - 1]; |
| newDir = last == '/'; |
| newExecutable = last == '*'; |
| if (newDir || newExecutable) |
| --newLen; |
| } |
| bool sandDir = false; |
| bool sandExecutable = false; |
| if (sandLen > 0) { |
| char last = sandList[sandLen - 1]; |
| sandDir = last == '/'; |
| sandExecutable = last == '*'; |
| if (sandDir || sandExecutable) |
| --sandLen; |
| } |
| string oldFileStr = string(oldList).substr(0, oldLen); |
| const char* oldFile = oldFileStr.c_str(); |
| string newFileStr = string(newList).substr(0, newLen); |
| const char* newFile = newFileStr.c_str(); |
| string sandFileStr = string(sandList).substr(0, sandLen); |
| const char* sandFile = sandFileStr.c_str(); |
| int order = Compare(oldList, oldLen, newList, newLen); |
| int sandOrder = 0; |
| if ((oldLen > 0 || sandLen > 0) && order <= 0) { |
| sandOrder = Compare(sandList, sandLen, oldList, oldLen); |
| if (sandOrder > 0 && renamePass == false) |
| fprintf(stderr, "error: file in old webkit missing from sandbox: %s/%s\n", |
| workingDir, oldFile); |
| if (sandOrder < 0 && renamePass == false) { |
| // file added by android -- should always have name 'android?' |
| const char* android = strstr(sandFile, "ndroid"); |
| if (android == NULL) |
| fprintf(stderr, "warning: expect added %s to contain 'android': %s/%s\n", |
| sandDir ? "directory" : "file" , workingDir, sandFile); |
| } |
| if (sandOrder == 0) { |
| myassert(oldDir == sandDir); |
| if (oldExecutable != sandExecutable) |
| CheckForExec(oldBase, workingDir, oldList, |
| sandboxBase, workingDir, sandList, 0, 0); |
| } |
| if (sandOrder <= 0) |
| sandList += strlen(sandList) + 1; |
| if (sandOrder < 0) |
| continue; |
| } |
| if (order < 0) { // file in old list is not in new |
| // check to see if file is read only ; if so, call p4 delete -- otherwise, just call delete |
| if (oldDir == false) { |
| bool modifiedFile = false; |
| // check to see if android modified deleted file |
| if (sandOrder == 0) { |
| string rename(workingDir); |
| rename.append("/"); |
| rename.append(oldFile); |
| if (renamePass) { |
| string newName = Find(oldFile); |
| if (newName.length() > 0) { |
| map<string, string>::iterator iter = renameMap.find(rename); |
| myassert(iter == renameMap.end()); // if I see the same file twice, must be a bug |
| renameMap[rename] = newName; |
| myassert(rename != newName); |
| if (options.debug) |
| fprintf(stderr, "map %s to %s\n", rename.c_str(), newName.c_str()); |
| } |
| } |
| if (renamePass == false) { |
| bool oldSandboxDiff = CompareFiles(oldBase, sandboxBase, workingDir, oldList); |
| const char* renamedDir = workingDir; |
| map<string, string>::iterator iter = renameMap.find(rename); |
| if (iter != renameMap.end()) { |
| string newName = renameMap[rename]; |
| renamedDir = newName.c_str(); |
| char* renamed = (char*) strrchr(renamedDir, '/'); |
| *renamed++ = '\0'; // splits rename into two strings |
| if (options.emitPerforceCommands) { |
| fprintf(commandFile, "p4 integrate \"%s/%s/%s\" \"%s/%s/%s\"\n", sandboxCmd, workingDir, oldFile, |
| sandboxCmd, renamedDir, renamed); |
| fprintf(commandFile, "p4 resolve \"%s/%s/%s\"\n", sandboxCmd, renamedDir, renamed); |
| } else if (options.emitGitCommands) { |
| fprintf(commandFile, "git mv \"%s/%s\" \"%s/%s\"\n", workingDir, oldFile, |
| renamedDir, renamed); |
| } |
| if (oldSandboxDiff) { |
| if (options.emitPerforceCommands) |
| fprintf(commandFile, "p4 open \"%s/%s/%s\"\n", sandboxCmd, renamedDir, renamed); |
| fprintf(commandFile, "merge -q \"%s/%s/%s\" \"%s/%s/%s\" \"%s/%s/%s\"\n", |
| sandboxCmd, renamedDir, renamed, oldCmd, workingDir, oldFile, newCmd, renamedDir, renamed); |
| bool success = Merge(workingDir, oldFile, renamedDir, renamed, "/dev/null"); |
| if (success == false) { |
| fprintf(stderr, "*** Manual merge required: %s/%s\n", renamedDir, renamed); |
| fprintf(commandFile, "cat \"%s/%s/%s\" | sed -e 's/^<<<<<<<.*$/#ifdef MANUAL_MERGE_REQUIRED/' " |
| "-e 's/^=======$/#else \\/\\/ MANUAL_MERGE_REQUIRED/' " |
| "-e 's/^>>>>>>>.*$/#endif \\/\\/ MANUAL_MERGE_REQUIRED/' > \"%s/%s/x%s\"\n", |
| sandboxCmd, renamedDir, renamed, sandboxCmd, renamedDir, renamed); |
| fprintf(commandFile, "mv \"%s/%s/x%s\" \"%s/%s/%s\"\n", |
| sandboxCmd, renamedDir, renamed, sandboxCmd, renamedDir, renamed); |
| } |
| if (options.emitGitCommands) |
| fprintf(commandFile, "git add \"%s/%s\"\n", renamedDir, renamed); |
| } else { |
| bool oldNewDiff = CompareFiles(oldBase, workingDir, oldList, newBase, renamedDir, renamed); |
| if (oldNewDiff) { |
| if (options.emitPerforceCommands) |
| fprintf(oopsFile, "p4 open \"%s/%s/%s\"\n", sandboxCmd, renamedDir, renamed); |
| fprintf(oopsFile, "cp \"%s/%s/%s\" \"%s/%s/%s\"\n", |
| newCmd, renamedDir, renamed, sandboxCmd, renamedDir, renamed); |
| if (options.emitGitCommands) |
| fprintf(oopsFile, "git add \"%s/%s\"\n", renamedDir, renamed); |
| } |
| } |
| } else if (oldSandboxDiff) { |
| modifiedFile = true; |
| fprintf(stderr, "*** Modified file deleted: %s/%s\n", workingDir, oldFile); |
| // FindDeletedAndroidChanges(workingDir, oldFile); |
| } |
| } // if renamePass == false |
| } // if sandOrder == 0 |
| if (modifiedFile) { |
| fprintf(commandFile, "cat \"%s/%s/%s\" | sed -e '1 i\\\n#ifdef MANUAL_MERGE_REQUIRED\n' " |
| "-e '$ a\\\n#endif \\/\\/ MANUAL_MERGE_REQUIRED\n' > \"%s/%s/x%s\"\n", |
| sandboxCmd, workingDir, oldFile, sandboxCmd, workingDir, oldFile); |
| fprintf(commandFile, "mv \"%s/%s/x%s\" \"%s/%s/%s\"\n", |
| sandboxCmd, workingDir, oldFile, sandboxCmd, workingDir, oldFile); |
| } else if (options.emitPerforceCommands) |
| fprintf(commandFile, "p4 delete \"%s/%s/%s\"\n", sandboxCmd, workingDir, oldFile); |
| else if (options.emitGitCommands) |
| fprintf(commandFile, "git rm \"%s/%s\"\n", workingDir, oldFile); |
| else |
| fprintf(commandFile, "rm \"%s/%s/%s\"\n", sandboxCmd, workingDir, oldFile); |
| } else { // if oldDir != false |
| // !!! FIXME start here; |
| // check to see if old directory is empty ... (e.g., WebCore/doc) |
| // ... and/or isn't in sandbox anyway (e.g., WebCore/LayoutTests) |
| // if old directory is in sandbox (e.g. WebCore/kcanvas) that should work |
| if (options.emitPerforceCommands) |
| fprintf(commandFile, "p4 delete \"%s/%s/%s/...\"\n", sandboxCmd, workingDir, oldFile); |
| else if (options.emitGitCommands) |
| fprintf(commandFile, "git rm \"%s/%s/...\"\n", workingDir, oldFile); |
| else |
| fprintf(commandFile, "rm \"%s/%s/%s/...\"\n", sandboxCmd, workingDir, oldFile); |
| if (renamePass == false) |
| fprintf(stderr, "*** Directory deleted: %s/%s\n", workingDir, oldFile); |
| } |
| oldList += strlen(oldList) + 1; |
| continue; |
| } |
| if (order > 0) { |
| if (renamePass == false) { |
| string rename(workingDir); |
| rename.append("/"); |
| rename.append(newFile); |
| bool skip = false; |
| for (map<string, string>::iterator iter = renameMap.begin(); iter != renameMap.end(); iter++) { |
| if (iter->second == rename) { |
| skip = true; |
| break; |
| } |
| } |
| if (skip == false) { |
| if (newDir) { |
| if (strcmp(sandFile, newFile) != 0 && |
| emptyDirectory(newBase, workingDir, newFile) == false) { |
| fprintf(copyDirFile, "find \"%s/%s/%s\" -type d -print | " |
| "sed 's@%s/\\(.*\\)@mkdir %s/\\1@' | bash -s\n", |
| newCmd, workingDir, newFile, newCmd, sandboxCmd); |
| fprintf(copyDirFile, "find \"%s/%s/%s\" -type f -print | " |
| "sed 's@%s/\\(.*\\)@cp %s/\\1 %s/\\1@' | bash -s\n", |
| newCmd, workingDir, newFile, newCmd, newCmd, sandboxCmd); |
| if (options.emitPerforceCommands) |
| fprintf(copyDirFile, "find \"%s/%s/%s\" -type f -print | " |
| "p4 -x - add\n", |
| sandboxCmd, workingDir, newFile); |
| else if (options.emitGitCommands) |
| fprintf(copyDirFile, "git add \"%s/%s\"\n", |
| workingDir, newFile); |
| } |
| } else { |
| // if (emptyDirectory(sandboxBase, workingDir)) { |
| // fprintf(commandFile, "mkdir \"%s/%s\"\n", sandboxCmd, workingDir); |
| // } |
| bool edit = false; |
| size_t newLen1 = strlen(newFile); |
| for (map<string, string>::iterator iter = renameMap.begin(); iter != renameMap.end(); iter++) { |
| if (strcmp(iter->second.c_str(), workingDir) == 0) { |
| const char* first = iter->first.c_str(); |
| size_t firstLen = strlen(first); |
| if (firstLen > newLen1 && strcmp(newFile, |
| &first[firstLen - newLen1]) == 0) { |
| edit = true; |
| break; |
| } |
| } |
| } |
| if (edit == false) { |
| fprintf(commandFile, "cp \"%s/%s/%s\" \"%s/%s/%s\"\n", |
| newCmd, workingDir, newFile, sandboxCmd, workingDir, newFile); |
| if (options.emitPerforceCommands) |
| fprintf(commandFile, "p4 add \"%s/%s/%s\"\n", sandboxCmd, workingDir, newFile); |
| else if (options.emitGitCommands) |
| fprintf(commandFile, "git add \"%s/%s\"\n", workingDir, newFile); |
| } |
| } |
| } |
| } |
| newList += strlen(newList) + 1; |
| continue; |
| } |
| if (oldDir) { |
| myassert(newDir); |
| size_t newLen1 = strlen(workingDir) + strlen(oldList); |
| char* newFile = new char[newLen1 + 1]; |
| sprintf(newFile, "%s/%.*s", workingDir, (int) strlen(oldList) - 1, |
| oldList); |
| if (sandOrder > 0) { // file is on old and new but not sandbox |
| if (emptyDirectory(newBase, newFile) == false) { |
| fprintf(copyDirFile, "find \"%s/%s\" -type d -print | " |
| "sed 's@%s/\\(.*\\)@mkdir %s/\\1@' | bash -s\n", |
| newCmd, newFile, newCmd, sandboxCmd); |
| fprintf(copyDirFile, "find \"%s/%s\" -type f -print | " |
| "sed 's@%s/\\(.*\\)@cp %s/\\1 %s/\\1@' | bash -s\n", |
| newCmd, newFile, newCmd, newCmd, sandboxCmd); |
| if (options.emitPerforceCommands) |
| fprintf(copyDirFile, "find \"%s/%s\" -type f -print | " |
| "p4 -x - add\n", |
| sandboxCmd, newFile); |
| else if (options.emitGitCommands) |
| fprintf(copyDirFile, "git add \"%s\"", newFile); |
| } |
| } else |
| CompareDirs(newFile, renamePass); |
| delete[] newFile; |
| } else { |
| // at this point, the file is in both old and new webkits; see if it changed |
| // ignore executables, different or not (or always copy, or do text compare? or find binary compare? ) |
| if (oldExecutable != newExecutable) |
| fprintf(stderr, "*** %s/%s differs in the execute bit (may cause problems for perforce)\n", workingDir, oldFile); |
| // myassert(sandOrder != 0 || sandFile[sandLen - 1] == '*'); |
| // Diff(oldBase, sandboxBase, workingDir, oldFile); |
| bool oldNewDiff = CompareFiles(oldBase, newBase, workingDir, oldList); |
| if (oldNewDiff && sandOrder == 0 && renamePass == false) { // if it changed, see if android also changed it |
| if (options.emitPerforceCommands) |
| fprintf(commandFile, "p4 edit \"%s/%s/%s\"\n", sandboxCmd, workingDir, oldFile); |
| bool oldSandboxDiff = CompareFiles(oldBase, sandboxBase, workingDir, oldFile); |
| if (oldSandboxDiff) { |
| fprintf(commandFile, "merge -q \"%s/%s/%s\" \"%s/%s/%s\" \"%s/%s/%s\"\n", |
| sandboxCmd, workingDir, oldFile, oldCmd, workingDir, oldFile, newCmd, workingDir, oldFile); |
| bool success = Merge(workingDir, oldFile); |
| if (success == false) { |
| fprintf(stderr, "*** Manual merge required: %s/%s\n", workingDir, oldFile); |
| fprintf(commandFile, "cat \"%s/%s/%s\" | sed -e 's/^<<<<<<<.*$/#ifdef MANUAL_MERGE_REQUIRED/' " |
| "-e 's/^=======$/#else \\/\\/ MANUAL_MERGE_REQUIRED/' -e 's/^>>>>>>>.*$/#endif \\/\\/ MANUAL_MERGE_REQUIRED/' > \"%s/%s/x%s\"\n", |
| sandboxCmd, workingDir, oldFile, sandboxCmd, workingDir, oldFile); |
| fprintf(commandFile, "mv \"%s/%s/x%s\" \"%s/%s/%s\"\n", |
| sandboxCmd, workingDir, oldFile, sandboxCmd, workingDir, oldFile); |
| } |
| } else fprintf(commandFile, "cp \"%s/%s/%s\" \"%s/%s/%s\"\n", newCmd, workingDir, oldFile , |
| sandboxCmd, workingDir, oldFile); |
| if (options.emitGitCommands) |
| fprintf(commandFile, "git add \"%s/%s\"\n", workingDir, oldFile); |
| } |
| } |
| myassert(oldLen == newLen); |
| newList += strlen(newList) + 1; |
| oldList += strlen(oldList) + 1; |
| } while (true); |
| delete[] oldMem; |
| delete[] newMem; |
| delete[] sandboxMem; |
| } |
| |
| bool Ignore(char* fileName, size_t len) |
| { |
| if (len == 0) |
| return true; |
| if (fileName[len - 1] =='/') |
| return true; |
| if (strcmp(fileName, ".DS_Store") == 0) |
| return true; |
| if (strcmp(fileName, ".ignoreSVN") == 0) |
| return true; |
| return false; |
| } |
| |
| void FixStar(char* fileName, size_t len) |
| { |
| if (fileName[len - 1] =='*') |
| fileName[len - 1] = '\0'; |
| } |
| |
| void FixColon(char** fileNamePtr, size_t* lenPtr) |
| { |
| char* fileName = *fileNamePtr; |
| size_t len = *lenPtr; |
| if (fileName[len - 1] !=':') |
| return; |
| fileName[len - 1] = '\0'; |
| if (strncmp(fileName ,"./", 2) != 0) |
| return; |
| fileName += 2; |
| *fileNamePtr = fileName; |
| len -= 2; |
| *lenPtr = len; |
| } |
| |
| bool IgnoreDirectory(const char* dir, const char** dirList) |
| { |
| if (dirList == NULL) |
| return false; |
| const char* test; |
| while ((test = *dirList++) != NULL) { |
| if (strncmp(dir, test, strlen(test)) == 0) |
| return true; |
| } |
| return false; |
| } |
| |
| static void doSystem(char* scratch) |
| { |
| if (false) printf("%s\n", scratch); |
| int err = system(scratch); |
| myassert(err == 0); |
| } |
| |
| static void copyToCommand(char* scratch, string file) |
| { |
| doSystem(scratch); |
| char* diff = GetFile(file.c_str()); |
| while (*diff) { |
| fprintf(commandFile, "%s\n", diff); |
| diff += strlen(diff) + 1; |
| } |
| } |
| |
| #define WEBKIT_EXCLUDED_DIRECTORIES \ |
| "-not -path \"*Tests\" " /* includes LayoutTests, PageLoadTests */ \ |
| "-not -path \"*Tests/*\" " /* includes LayoutTests, PageLoadTests */ \ |
| "-not -path \"*Site\" " /* includes BugsSite, WebKitSite */ \ |
| "-not -path \"*Site/*\" " /* includes BugsSite, WebKitSite */ \ |
| "-not -path \"./PlanetWebKit/*\" " \ |
| "-not -path \"./PlanetWebKit\" " |
| |
| #define ANDROID_EXCLUDED_FILES \ |
| "-e '/^Files .* differ/ d' " \ |
| "-e '/^Only in .*/ d' " \ |
| "-e '/Android.mk/ d' " \ |
| "-e '/android$/ d' " |
| |
| #define ANDROID_EXCLUDED_DIRS \ |
| "-e '/\\/JavaScriptCore\\// d' " \ |
| "-e '/\\/WebCore\\// d' " |
| |
| #define ANDROID_EXCLUDED_DIRS_GIT \ |
| "-e '/ JavaScriptCore\\// d' " \ |
| "-e '/ WebCore\\// d' " |
| |
| void CopyOther() |
| { |
| string excludedFiles = ANDROID_EXCLUDED_FILES; |
| if (options.emitGitCommands) |
| excludedFiles += ANDROID_EXCLUDED_DIRS_GIT; |
| else |
| excludedFiles += ANDROID_EXCLUDED_DIRS; |
| char scratch[1024]; |
| // directories to ignore in webkit |
| string copyOtherWebKit = ScratchFile("CopyOtherWebKit"); |
| sprintf(scratch, "cd %s ; find . -type d -not -empty " |
| WEBKIT_EXCLUDED_DIRECTORIES |
| " > %s", newBase, copyOtherWebKit.c_str()); |
| doSystem(scratch); |
| // directories to ignore in android |
| string copyOtherAndroid = ScratchFile("CopyOtherAndroid"); |
| sprintf(scratch, "cd %s ; find . -type d -not -empty " |
| "-not -path \"*.git*\" " |
| "-not -path \"*android*\" " |
| " > %s", sandboxBase, copyOtherAndroid.c_str()); |
| doSystem(scratch); |
| if (0) { |
| string copyOtherMkDir = ScratchFile("CopyOtherMkDir"); |
| sprintf(scratch, "diff %s %s | sed -e 's@< \\./\\(.*\\)$" |
| "@mkdir %s/\\1@' " |
| "-e '/^[0-9].*/ d' " |
| "-e '/>.*/ d' " |
| "-e '/---/ d' " |
| "-e '/\\/JavaScriptCore\\// d' " |
| "-e '/\\/WebCore\\// d' " |
| "> %s", copyOtherWebKit.c_str(), copyOtherAndroid.c_str(), sandboxCmd, |
| copyOtherMkDir.c_str()); |
| if (options.debug) |
| fprintf(stderr, "%s\n", scratch); |
| copyToCommand(scratch, copyOtherMkDir); |
| } |
| string copyOtherDiff = ScratchFile("CopyOtherDiff"); |
| int scratchLen = sprintf(scratch, "diff %s %s | sed -e 's@< \\./\\(.*\\)$" |
| "@mkdir -p -v %s/\\1 ; find %s/\\1 -type f -depth 1 -exec cp {} %s/\\1 \";\"", |
| copyOtherWebKit.c_str(), copyOtherAndroid.c_str(), sandboxCmd, newCmd, |
| sandboxCmd); |
| if (options.emitGitCommands) |
| scratchLen += sprintf(&scratch[scratchLen], " ; cd %s ; find ", sandboxCmd); |
| else |
| scratchLen += sprintf(&scratch[scratchLen], " ; find %s/", sandboxCmd); |
| scratchLen += sprintf(&scratch[scratchLen], "\\1 -type f -depth 1 | "); |
| if (options.emitPerforceCommands) |
| scratchLen += sprintf(&scratch[scratchLen], "p4 -x - add "); |
| else if (options.emitGitCommands) |
| scratchLen += sprintf(&scratch[scratchLen], "xargs git add "); |
| scratchLen += sprintf(&scratch[scratchLen], |
| "@' -e '/^[0-9].*/ d' " |
| "-e '/>.*/ d' " |
| "-e '/---/ d' " |
| "-e '/\\/JavaScriptCore\\// d' " |
| "-e '/\\/WebCore\\// d' " |
| "> %s", copyOtherDiff.c_str()); |
| if (options.debug) |
| fprintf(stderr, "%s\n", scratch); |
| copyToCommand(scratch, copyOtherDiff); |
| string deleteOtherDiff = ScratchFile("DeleteOtherDiff"); |
| scratchLen = sprintf(scratch, "diff -r -q %s %s | sed -e " |
| "'s@Only in %s/\\(.*\\)\\: \\(.*\\)@", |
| newBase, sandboxBase, sandboxBase); |
| if (options.emitPerforceCommands) |
| scratchLen += sprintf(&scratch[scratchLen], "p4 delete %s/", sandboxCmd); |
| else if (options.emitGitCommands) |
| scratchLen += sprintf(&scratch[scratchLen], "git rm "); |
| else |
| scratchLen += sprintf(&scratch[scratchLen], "rm %s/", sandboxCmd); |
| scratchLen += sprintf(&scratch[scratchLen], "\\1/\\2@' %s > %s", |
| excludedFiles.c_str(), deleteOtherDiff.c_str()); |
| if (options.debug) |
| fprintf(stderr, "%s\n", scratch); |
| copyToCommand(scratch, deleteOtherDiff); |
| string addOtherDiff = ScratchFile("AddOtherDiff"); |
| scratchLen = sprintf(scratch, "diff -r -q %s %s | sed -e " |
| "'s@Only in %s/\\(.*\\)\\: \\(.*\\)" |
| "@mkdir -p -v %s/\\1 ; cp %s/\\1/\\2 %s/\\1/\\2 ; ", |
| newBase, sandboxBase, newBase, sandboxCmd, newCmd, sandboxCmd); |
| if (options.emitPerforceCommands) |
| scratchLen += sprintf(&scratch[scratchLen], |
| "p4 add %s/\\1/\\2", sandboxCmd); |
| else if (options.emitGitCommands) |
| scratchLen += sprintf(&scratch[scratchLen], |
| "git add \\1/\\2"); |
| scratchLen += sprintf(&scratch[scratchLen], "@' %s > %s", |
| excludedFiles.c_str(), addOtherDiff.c_str()); |
| if (options.debug) |
| fprintf(stderr, "%s\n", scratch); |
| copyToCommand(scratch, addOtherDiff); |
| string editOtherDiff = ScratchFile("EditOtherDiff"); |
| scratchLen = sprintf(scratch, "diff -r -q %s %s | sed -e " |
| "'s@Files %s/\\(.*\\) and %s/\\(.*\\) differ@", |
| newBase, sandboxBase, newBase, sandboxBase); |
| if (options.emitPerforceCommands) |
| scratchLen += sprintf(&scratch[scratchLen], |
| "p4 edit %s/\\2 ; ", sandboxCmd); |
| scratchLen += sprintf(&scratch[scratchLen], "cp %s/\\1 %s/\\2 ", |
| newCmd, sandboxCmd); |
| if (options.emitGitCommands) |
| scratchLen += sprintf(&scratch[scratchLen], |
| " ; git add \\2"); |
| scratchLen += sprintf(&scratch[scratchLen], "@' %s > %s", |
| excludedFiles.c_str(), editOtherDiff.c_str()); |
| if (options.debug) |
| fprintf(stderr, "%s\n", scratch); |
| copyToCommand(scratch, editOtherDiff); |
| } |
| |
| void MakeExecutable(const string& filename) |
| { |
| string makeExScript = "chmod +x "; |
| makeExScript += filename; |
| int err = system(makeExScript.c_str()); |
| myassert(err == 0); |
| } |
| |
| bool ReadArgs(char* const args[], int argCount) |
| { |
| int index = 0; |
| const char* toolpath = args[index++]; |
| // first arg is path to this executable |
| // use this to build default paths |
| |
| for (; index < argCount; index++) { |
| const char* arg = args[index]; |
| if (strncmp(arg, "-a", 2) == 0 || strcmp(arg, "--android") == 0) { |
| index++; |
| options.androidWebKit = args[index]; |
| continue; |
| } |
| if (strncmp(arg, "-b", 2) == 0 || strcmp(arg, "--basewebkit") == 0) { |
| index++; |
| options.baseWebKit = args[index]; |
| continue; |
| } |
| if (strncmp(arg, "-c", 2) == 0 || strcmp(arg, "--mergecore") == 0) { |
| options.clearOnce(); |
| options.mergeCore = true; |
| continue; |
| } |
| if (strncmp(arg, "-d", 2) == 0 || strcmp(arg, "--debug") == 0) { |
| options.debug = true; |
| continue; |
| } |
| if (strncmp(arg, "-e", 2) == 0 || strcmp(arg, "--emptydirs") == 0) { |
| options.clearOnce(); |
| options.removeEmptyDirs = true; |
| continue; |
| } |
| if (strncmp(arg, "-g", 2) == 0 || strcmp(arg, "--git") == 0) { |
| options.emitGitCommands = true; |
| if (options.emitPerforceCommands == false) |
| continue; |
| } |
| if (strncmp(arg, "-m", 2) == 0 || strcmp(arg, "--mergemake") == 0) { |
| options.clearOnce(); |
| options.mergeMake = true; |
| continue; |
| } |
| if (strncmp(arg, "-n", 2) == 0 || strcmp(arg, "--newwebkit") == 0) { |
| index++; |
| options.newWebKit = args[index]; |
| continue; |
| } |
| if (strncmp(arg, "-o", 2) == 0 || strcmp(arg, "--copyother") == 0) { |
| options.clearOnce(); |
| options.copyOther = true; |
| continue; |
| } |
| if (strncmp(arg, "-p", 2) == 0 || strcmp(arg, "--perforce") == 0) { |
| options.emitPerforceCommands = true; |
| if (options.emitGitCommands == false) |
| continue; |
| } |
| if (strncmp(arg, "-s", 2) == 0 || strcmp(arg, "--removesvn") == 0) { |
| options.clearOnce(); |
| options.removeSVNDirs = true; |
| continue; |
| } |
| if (strncmp(arg, "-v", 2) == 0 || strcmp(arg, "--verbose") == 0) { |
| options.verbose = true; |
| fprintf(stderr, "path: %s\n", toolpath); |
| int err = system("pwd > pwd.txt"); |
| myassert(err != -1); |
| fprintf(stderr, "pwd: %s\n", GetFile("pwd.txt")); |
| system("rm pwd.txt"); |
| continue; |
| } |
| if (strncmp(arg, "-x", 2) == 0 || strcmp(arg, "--execute") == 0) { |
| options.execute = true; |
| continue; |
| } |
| if (options.emitGitCommands && options.emitPerforceCommands) |
| printf("choose one of --git and --perforce\n"); |
| else if (strncmp(arg, "-h", 2) != 0 && strcmp(arg, "--help") != 0 && strcmp(arg, "-?") != 0) |
| printf("%s not understood\n", args[index]); |
| printf( |
| "WebKit Merge for Android version 1.1\n" |
| "Usage: webkitmerge -a path -b path -n path [-g or -p] [-c -d -e -m -o -s -v -x]\n" |
| "Options -c -e -m -o -s are set unless one or more are passed.\n" |
| "Leave -g and -p unset to copy, merge, and delete files outside of source control.\n" |
| "-a --android path Set the Android webkit path to merge to.\n" |
| "-b --basewebkit path Set the common base for Android and the newer webkit.\n" |
| "-c --mergecore Create merge scripts for WebCore, JavaScriptCore .h .cpp.\n" |
| "-d --debug Show debugging printfs; loop forever on internal assert.\n" |
| "-e --emptydirs Remove empty directories from webkit trees.\n" |
| "-g --git Emit git commands.\n" |
| "-h --help Show this help.\n" |
| "-m --mergemake Create merge scripts for WebCore/Android.mk,\n" |
| " WebCore/Android.derived.mk, and JavaScriptCore/Android.mk.\n" |
| "-n --newwebkit path Set the webkit to merge from.\n" |
| "-o --copyother Create script to copy other webkit directories.\n" |
| "-p --perforce Emit perforce commands.\n" |
| "-s --removesvn Remove svn directories from webkit trees.\n" |
| "-v --verbose Show status printfs.\n" |
| "-x --execute Execute the merge scripts.\n" |
| ); |
| return false; |
| } |
| return options.finish(); |
| } |
| |
| int main (int argCount, char* const args[]) |
| { |
| if (ReadArgs(args, argCount) == false) |
| return 0; |
| int err; |
| // First remove all .svn directories |
| if (options.removeSVNDirs) { |
| if (options.verbose) |
| fprintf(stderr, "removing svn directories from %s\n", newBase); |
| string removeSVNStr = string("find ") + newBase + |
| " -type d -name \".svn\" -print0 | xargs -0 rm -rf"; |
| err = system(removeSVNStr.c_str()); |
| myassert(err == 0); |
| } |
| // Remove all empty directories |
| if (options.removeEmptyDirs) { |
| if (options.verbose) |
| fprintf(stderr, "removing empty directories from %s, %s\n", |
| oldBase, newBase); |
| string removeEmpty = string("find ") + oldBase + " " + newBase + |
| " -type d -empty -delete"; |
| err = system(removeEmpty.c_str()); |
| myassert(err == 0); |
| } |
| if (options.mergeCore /* || options.mergeMake */) { |
| if (options.verbose) |
| fprintf(stderr, "building rename map\n"); |
| commandFile = fopen("/dev/null", "w"); |
| copyDirFile = fopen("/dev/null", "w"); |
| CompareDirs("WebCore", true); // build rename map |
| CompareDirs("JavaScriptCore", true); |
| fclose(copyDirFile); |
| fclose(commandFile); |
| } |
| if (options.mergeMake) { |
| if (options.verbose) |
| fprintf(stderr, "building make.sh\n"); |
| string makeShell = outputDir + "make.sh"; |
| commandFile = fopen(makeShell.c_str(), "w"); |
| if (options.emitGitCommands || options.emitPerforceCommands) |
| fprintf(commandFile, "cd %s\n", sandboxCmd); |
| UpdateMake("WebCore"); |
| UpdateMake("JavaScriptCore"); |
| UpdateDerivedMake(); |
| fclose(commandFile); |
| MakeExecutable(makeShell); |
| } |
| if (options.copyOther) { |
| if (options.verbose) |
| fprintf(stderr, "building copyOther.sh\n"); |
| string copyOtherShell = outputDir + "copyOther.sh"; |
| commandFile = fopen(copyOtherShell.c_str(), "w"); |
| if (options.emitGitCommands || options.emitPerforceCommands) |
| fprintf(commandFile, "cd %s\n", sandboxCmd); |
| CopyOther(); |
| fclose(commandFile); |
| MakeExecutable(copyOtherShell); |
| } |
| if (options.mergeCore) { |
| if (options.verbose) |
| fprintf(stderr, "building command.sh copyDir.sh oops.sh\n"); |
| string commandShell = outputDir + "command.sh"; |
| commandFile = fopen(commandShell.c_str(), "w"); |
| if (options.emitGitCommands || options.emitPerforceCommands) |
| fprintf(commandFile, "cd %s\n", sandboxCmd); |
| string copyDirShell = outputDir + "copyDir.sh"; |
| copyDirFile = fopen(copyDirShell.c_str(), "w"); |
| if (options.emitGitCommands || options.emitPerforceCommands) |
| fprintf(copyDirFile, "cd %s\n", sandboxCmd); |
| string oopsShell = outputDir + "oops.sh"; |
| oopsFile = fopen(oopsShell.c_str(), "w"); |
| if (options.emitGitCommands || options.emitPerforceCommands) |
| fprintf(oopsFile, "cd %s\n", sandboxCmd); |
| CompareDirs("WebCore", false); // generate command script |
| CompareDirs("JavaScriptCore", false); |
| fclose(oopsFile); |
| fclose(copyDirFile); |
| fclose(commandFile); |
| MakeExecutable(oopsShell); |
| MakeExecutable(copyDirShell); |
| MakeExecutable(commandShell); |
| } |
| if (options.execute) { |
| if (options.mergeCore) { |
| if (options.verbose) |
| fprintf(stderr, "executing command.sh\n"); |
| string execCommand = "cd " + options.androidWebKit + "; . " + outputDir + "command.sh"; |
| err = system(execCommand.c_str()); |
| myassert(err == 0); |
| if (options.verbose) |
| fprintf(stderr, "executing copyDir.sh\n"); |
| string execCopy = "cd " + options.androidWebKit + "; . " + outputDir + "copyDir.sh"; |
| err = system(execCopy.c_str()); |
| myassert(err == 0); |
| } |
| if (options.mergeMake) { |
| if (options.verbose) |
| fprintf(stderr, "executing make.sh\n"); |
| string execMake = "cd " + options.androidWebKit + "; . " + outputDir + "make.sh"; |
| err = system(execMake.c_str()); |
| myassert(err == 0); |
| } |
| if (options.copyOther) { |
| if (options.verbose) |
| fprintf(stderr, "executing copyOther.sh\n"); |
| string execCopyOther = "cd " + options.androidWebKit + "; . " + outputDir + "copyOther.sh"; |
| err = system(execCopyOther.c_str()); |
| myassert(err == 0); |
| } |
| } |
| if (options.verbose) |
| fprintf(stderr, "done!\n"); |
| else { |
| string rmAllCmd = "rm " + scratchDir + "* ; rmdir " + scratchDir; |
| err = system(rmAllCmd.c_str()); |
| myassert(err == 0); |
| } |
| return 0; |
| } |
| |
| /* things to do: |
| when inserting MANUAL_MERGE_REQUIRED, if contents is #preprocessor, balance first? |
| */ |
