int main(int argc, char** argv) { if (argc > 1 && !strcmp(argv[1], "-v")) { g_verbose = true; ++argv; --argc; } if (argc > 1 && !strcmp(argv[1], "-r")) { g_recursive = true; ++argv; --argc; } if (argc != 3) { fprintf(stderr, "Usage: treecat treeLocation boxcode\n"); exit(1); } char* boxcode = argv[2]; g_treeLocation = argv[1]; char fileboxcode[1000]; strcpy(fileboxcode, boxcode); FILE* fp = 0; int fileBoxLength; for (fileBoxLength = strlen(boxcode); fileBoxLength >= 0; --fileBoxLength) { fileboxcode[fileBoxLength] = '\0'; fp = openBox(fileboxcode); if (fp) break; } boxcode += fileBoxLength; char fullboxcode[1000]; strcpy(fullboxcode, fileboxcode); strcat(fullboxcode, boxcode); char buf[10000]; while (*boxcode && fgets(buf, sizeof(buf), fp)) { if (buf[0] != 'X') { *boxcode = '\0'; fprintf(stderr, "box = %s\n", argv[2]); fputs(buf, stdout); exit(0); } if (*boxcode == '1') processTree(fp, false, boxcode); ++boxcode; } processTree(fp, true, fullboxcode); }
void doit(char *filename) { startup(); FILE *fp = NULL; __try { char filepath[257]; sprintf(filepath, "%s\\gdi_trial.phashc", filename); fopen_s(&fp, filepath, "w+"); fprintf(fp, "%s\n", filename); processTree("", filename, fp); fclose(fp); } __finally { shutdown(); if (fp != NULL) { fflush(fp); fclose(fp); } } }
/* * processes call tree. * runs if command, if successful run commands in then block otherwise * runs commands in else block. * calls itself if command is nested_if block * parameters: IFBLOCK* ifBlock - processes tree rooted at ifBlock * returns : 0 if success otherwise 1 */ static int processTree(IFBLOCK* ifBlock) { int result;//result of processing COMMSEQ* node;//for linked list iteration IFBLOCK* currIfBlock;//poiner to nested if block char* command,**arglist;//for convenience result = execCommand(ifBlock->commandargs + 1);//result of if commad node = (result == 0) ? ifBlock->thenComSeq : ifBlock->elseComSeq;//which block to execute while(node != NULL) { if(node->type == COMMAND){//executable command command = (char*)node->cmd; arglist = splitline(command);//get command args result = execCommand(arglist);//execute command } else{//nested_if block currIfBlock = (IFBLOCK*)node->cmd; result = processTree(currIfBlock);//recursively process nested if } node = node->next;//go to next node } return result; }
/* * public function: * calls private function processTree() to process call tree * calls clearCallTree() to destroy the tree * returns : 0 if success otherwise 1 */ int processCallTree() { int ret; ret = processTree(the_if_block);//process tree clearCallTree();//destroy tree return ret; }
// Process a directory tree: for each jpg file, calculate the phash, // and write the hash value and file string to the output file. void processTree(const char *path, char *basepath, FILE *fp) { std::list<std::string> folders; std::vector<std::string> files; char thispath[257]; char apath[257]; sprintf(thispath, "%s%s", basepath, path); struct dirent *dent; DIR *srcdir = opendir(thispath); if (srcdir == NULL) return; while ((dent = readdir(srcdir)) != NULL) { struct stat st; if (dent->d_name[0] == '.') continue; if (strlen(thispath) + strlen(dent->d_name) > 256) { printf("Path too long:%s", dent->d_name); continue; } sprintf(apath, "%s\\%s", thispath, dent->d_name); stat(apath, &st); if (st.st_mode & _S_IFDIR) // recurse into subdirectories { sprintf(apath, "%s\\%s", path, dent->d_name); folders.push_back(apath); // processTree(apath, basepath, fp); } else { files.push_back(apath); // processFile(apath, basepath, fp); } } closedir(srcdir); int max = files.size(); #pragma omp parallel for for (int dex = 0; dex < max; dex++) { processFile((char *)(files[dex].c_str()), basepath, fp); } for (std::list<std::string>::iterator it = folders.begin(); it != folders.end(); ++it) { processTree((*it).c_str(), basepath, fp); } }
/* * Class: java_awt_KeyboardFocusManager * Method: clearGlobalFocusOwner * Signature: ()V */ JNIEXPORT void JNICALL Java_java_awt_KeyboardFocusManager__1clearGlobalFocusOwner (JNIEnv *env, jobject self) { /* Redirect focus to the focus proxy of the active Window. The effect we want is for the active Window to remain active, but for none of its children to be the focus owner. AWT maintains state to know that any key events delivered after this call (but before focus is re-established elsewhere) get ignored. */ jobject activeWindow; Widget proxy; if ((*env)->EnsureLocalCapacity(env, 1) < 0) { return; } AWT_LOCK(); activeWindow = (*env)->CallStaticObjectMethod (env, keyboardFocusManagerIDs.keyboardFocusManagerCls, keyboardFocusManagerIDs.markClearGlobalFocusOwnerMID); if (activeWindow != NULL) { // Setting focus owner to proxy will be equivalent haveing // null focus owner in Java layer while we will still be // able to receive key events. proxy = findWindowsProxy(activeWindow, env); if (proxy != NULL) { Widget curFocusWidget = XmGetFocusWidget(proxy); if (curFocusWidget != NULL) { callFocusHandler(curFocusWidget, FocusOut); } // Disable all but proxy widgets processTree(curFocusWidget, proxy, False); XmProcessTraversal(proxy, XmTRAVERSE_CURRENT); } } AWT_UNLOCK(); }
void processTree(Node* root, int noOfCodeWords, bool firstCode, vector<codeWords>& store) { int unique = noOfCodeWords/2; int rDepth = rightmostDepth(root); for(int i = 1;i < rDepth; i++) { Node* rootCopy = copy(root); Node* newRoot = rotate(NULL, rootCopy, rightmostAtDepth(rootCopy, i)); codeWords temp = codeWordsFromTree(newRoot, noOfCodeWords, firstCode); show(temp); store.push_back(temp); processTree(newRoot, noOfCodeWords, firstCode, store); destoryTree(newRoot); } }
void processTree(FILE* fp, bool print, char* boxcode) { int boxdepth = strlen(boxcode); char buf[10000]; int depth = 0; while (fgets(buf, sizeof(buf), fp)) { bool filledHole = false; if (g_recursive && print && buf[0] == 'H') { boxcode[boxdepth + depth] = '\0'; FILE* fpH = openBox(boxcode); if (fpH) { processTree(fpH, print, boxcode); fclose(fpH); filledHole = true; } else { fprintf(stderr, "missing %s\n", boxcode); } } if (print && !filledHole) fputs(buf, stdout); if (buf[0] == 'X') { boxcode[boxdepth + depth] = '0'; ++depth; } else { for (; depth > 0 && boxcode[boxdepth + depth-1] == '1'; --depth) { } if (depth > 0) { boxcode[boxdepth + depth-1] = '1'; } else { boxcode[boxdepth] = '\0'; return; } } } boxcode[boxdepth + depth] = '\0'; fprintf(stderr, "premature EOF at %s\n", boxcode); }
bool processTree(FILE* fp, FILE* out, bool printTree, bool printHoles, char* boxcode) { int boxdepth = strlen(boxcode); char buf[10000]; char fileName[10000]; int depth = 0; while (fgets(buf, sizeof(buf), fp)) { bool filledHole = false; // Open HOLE file if exists. If no printing is set, we don't need to traverse HOLEs if (g_recursive && buf[0] == 'H' && depth > 0) { bool nbd_var_box = (strchr(buf,'V') != NULL); FILE* fpH = openBox(boxcode, fileName); if (fpH) { FILE* outH = tmpfile(); if (outH) { bool success = processTree(fpH, outH, printTree, printHoles, boxcode); fclose(fpH); if (!success) { fclose(outH); // The tree is incomplete, so we rename the boxfile to mark as incomplete // TODO: Not sure if treecat should have the power to rename files if (g_mark_incomplete) if (!mark(fileName,".incomplete")) fprintf(stderr, "failed to mark %s as incomplete\n", fileName); } else { // If the HOLE subtree is complete, print it to the output stream rewind(outH); bool success = putStream(out,outH); fclose(outH); if (!success) { fprintf(stderr, "failed to print HOLE %s subtree\n", boxcode); break; } else { filledHole = true; } } } } if (printHoles && !filledHole && ! nbd_var_box) fprintf(out, "%s\n", boxcode); // Print the missing boxcode to stdout } if (printTree && !filledHole) { fputs(buf, out); // Print the buffer if we are printing out the filled tree } if (buf[0] == 'X') { boxcode[boxdepth + depth] = '0'; // Descend via left branch ++depth; boxcode[boxdepth + depth] = '\0'; } else { // Go up as many nodes as necessary for (; depth > 0 && boxcode[boxdepth + depth-1] == '1'; --depth) {} if (depth > 0) { boxcode[boxdepth + depth-1] = '1'; // Jump from left to right node boxcode[boxdepth + depth] = '\0'; // Truncate to keep box current } else { boxcode[boxdepth] = '\0'; // Truncate to keep box current return true; } } } // If we get to this point, the tree is incomplete // TODO: This may be unnecssary code as we rename incomplete trees if (printHoles) { // Print the box we "should" be at as missing fprintf(out, "%s\n", boxcode); // Print the missing boxcode to stdout // We list all other missing boxes for (int i = depth; i > 0; --i) { if (boxcode[boxdepth + i-1] != '1') { boxcode[boxdepth + i-1] = '1'; // Jump from left to right node boxcode[boxdepth + i] = '\0'; // Truncate to keep box current fprintf(out, "%s\n", boxcode); // Print the missing boxcode to stdout } else { boxcode[boxdepth + i] = '\0'; // Truncate to keep box current } } } return false; }
int main(int argc, char** argv) { bool printTree = true; bool printHoles = false; if (argc > 1 && strcmp(argv[1], "--holes") == 0) { printTree = false; printHoles = true; ++argv; --argc; } if (argc > 1 && strcmp(argv[1], "--mark") == 0) { g_mark_incomplete = true; ++argv; --argc; } if (argc > 1 && strcmp(argv[1], "-s") == 0) { printTree = false; printHoles = false; ++argv; --argc; } if (argc > 1 && strcmp(argv[1], "-v") == 0) { g_verbose = true; ++argv; --argc; } if (argc > 1 && strcmp(argv[1], "-r") == 0) { g_recursive = true; ++argv; --argc; } if (argc != 3) { fprintf(stderr, "Usage: treecat [--holes] [--mark] [-s] [-v] [-r] treeLocation boxcode\n"); fprintf(stderr, "holes : do not print the tree but print the holes\n"); fprintf(stderr, "mark : rename incomplete (sub)tree file(s) containing given boxcode (sub if -r)\n"); fprintf(stderr, "s : silent, don't print trees or holes\n"); fprintf(stderr, "v : verbose\n"); fprintf(stderr, "r : recur over all subtree files to prince full subtree of boxcode\n"); fprintf(stderr, "WARNING: If all --mark -r are set and boxcode is root or '', then mark any foreign tree files\n"); exit(1); } // The fullboxcode parameter can specify the fileName and sequetial boxcode // A boxcode is just a sequence of zeros and ones giving a posiiton in a binary tree depth-first traversal // The treeFile will also be in pre-order depth-first char fullboxcode[10000]; char fileboxcode[10000]; strncpy(fullboxcode, argv[2], 10000); strncpy(fileboxcode, argv[2], 10000); g_treeLocation = argv[1]; char fileName[10000]; int fileBoxLength = strlen(fullboxcode); if ((fileBoxLength == 0) || (strncmp(fullboxcode, "root", fileBoxLength) == 0)) { g_start_is_root = true; } // TODO: Taging of foreign files may be dangerous if (g_start_is_root && g_mark_incomplete && g_recursive) { DIR * dirp = opendir(g_treeLocation); struct dirent * dp; while ((dp = readdir(dirp)) != NULL) { if (ends_with(dp->d_name,"out")) { sprintf(fileName, "%s/%s", g_treeLocation, dp->d_name); unopened_out_files.push_back(std::string(fileName)); } } } // See if a file with the tree for a prefix of the box exists FILE* fp = 0; while (fileBoxLength >= 0) { fileboxcode[fileBoxLength] = '\0'; fp = openBox(fileboxcode, fileName); if (fp) { break; } --fileBoxLength; } if (!fp) exit(1); char * boxcode_const = (char *)calloc(10000, sizeof(char)); strncpy(boxcode_const, fullboxcode+fileBoxLength, 10000); char * boxcode = boxcode_const; char buf[10000]; // If the boxcode is still not empty, we traverse down the tree and print only // once we get to the proper node. We terminate early if the node does not exist while (*boxcode && fgets(buf, sizeof(buf), fp)) { if (buf[0] != 'X') { // If not a splitting, print the test failed by the truncated box *boxcode = '\0'; fprintf(stderr, "terminal box = %s%s\n", fileboxcode, boxcode_const); if (printTree) fputs(buf, stdout); free(boxcode_const); fclose(fp); exit(0); } if (*boxcode == '1') { // Actually have to process the tree if we go right at any point in the boxcode int success = processTree(fp, NULL, false, false, boxcode); if (!success) exit(1); // Incomplete tree or boxcode not found } ++boxcode; // Keeps going left in the tree as *boxcode == 0 } free(boxcode_const); FILE* out = tmpfile(); if (!out) exit(1); bool success = processTree(fp, out, printTree, printHoles, fullboxcode); fclose(fp); if (g_start_is_root && g_mark_incomplete && g_recursive) { for (std::vector<std::string>::iterator it = unopened_out_files.begin() ; it != unopened_out_files.end(); ++it) { fprintf(stderr, "unopened/foreign out file = %s\n", it->c_str()); // TODO: Not sure if treecat should have the power to rename files if (!mark(it->c_str(),".foreign")) fprintf(stderr, "failed to mark %s as foreign\n", it->c_str()); } } if (!success) { fclose(out); // The tree is incomplete, so we rename the boxfile to mark as incomplete // TODO: Not sure if treecat should have the power to rename files if (g_mark_incomplete) { if (!mark(fileName,".incomplete")) fprintf(stderr, "failed to mark %s as incomplete\n", fileName); } exit(1); } else { rewind(out); bool putSuccess = putStream(stdout, out); fclose(out); if (!putSuccess) exit(1); else exit(0); } }