bst_t bst_remove(bst_t bst, index_t index) { if (bst_type(bst) == isNotEmpty) { switch (index_compare(index, bst)) { case EQ: switch (has_child(bst)) { case none: bst = bst_destroy(bst); break; case both: case justRigth: pair_destroy(bst->pair); bst->pair = pair_copy((bst->der)->pair); /*copia el par q le sigue (der) */ bst->der = bst_remove(bst->der, pair_fst((bst->der)->pair)); break; case justLeft: pair_destroy(bst->pair); bst->pair = pair_copy((bst->izq)->pair); /*copia el par q le sigue (der) */ bst->izq = bst_remove(bst->izq, pair_fst((bst->izq)->pair)); break; } break; case LT: bst->izq = bst_remove(bst->izq, index); break; case GT: bst->der = bst_remove(bst->der, index); break; } } return (bst); }
map_iterator_t map_insert(map_t* pt_map, const pair_t* cpt_pair) { pair_t t_elempair; map_iterator_t t_result; #ifdef CSTL_MAP_AVL_TREE avl_tree_result_pair_t t_avlresult; #else rb_tree_result_pair_t t_rbresult; #endif assert(pt_map != NULL && cpt_pair != NULL); assert(_same_map_pair_type(&pt_map->_t_pair, cpt_pair)); /* initialize the new pair */ t_elempair = _create_pair( pt_map->_t_pair._t_firsttypesize, pt_map->_t_pair._sz_firsttypename, pt_map->_t_pair._t_secondtypesize, pt_map->_t_pair._sz_secondtypename); pair_init(&t_elempair); memcpy(t_elempair.first, cpt_pair->first, t_elempair._t_firsttypesize); memcpy(t_elempair.second, cpt_pair->second, t_elempair._t_secondtypesize); /* insert pair into tree */ #ifdef CSTL_MAP_AVL_TREE t_avlresult = _avl_tree_insert_unique(_GET_MAP_AVL_TREE(pt_map), &t_elempair); if(t_avlresult._t_second._t_bool) { t_result = t_avlresult._t_first; } else { t_result = map_end(pt_map); pair_destroy(&t_elempair); } #else t_rbresult = _rb_tree_insert_unique(_GET_MAP_RB_TREE(pt_map), &t_elempair); if(t_rbresult._t_second._t_bool) { t_result = t_rbresult._t_first; } else { t_result = map_end(pt_map); pair_destroy(&t_elempair); } #endif _GET_CONTAINER(&t_result) = pt_map; _GET_MAP_CONTAINER_TYPE(&t_result) = _MAP_CONTAINER; _GET_MAP_ITERATOR_TYPE(&t_result) = _BIDIRECTIONAL_ITERATOR; return t_result; }
list_t list_remove(list_t list, index_t index) { list_t current = list,last=NULL; while(current != NULL && !index_is_equal(pair_fst(current->elem),index)) { last = current; current = current->next; } if(current!=NULL) { if(last==NULL) { list = current->next; } else { last->next = current->next; current->next = NULL; } current->elem = pair_destroy(current->elem); free(current); current = NULL; last = NULL; } return list; }
bst_t bst_destroy(bst_t bst) { switch (bst_type(bst)) { case isNull: break; case isEmpty: case isNotEmpty: if (bst->izq != NULL) { bst_destroy(bst->izq); /*Destruye subarbol izquierdo */ } if (bst->der != NULL) { bst_destroy(bst->der); /*Destruye subarbol derecho */ } bst->pair = pair_destroy(bst->pair); free(bst); bst = NULL; break; } return (bst); }
void multimap_destroy(multimap_t* pt_multimap) { assert(pt_multimap != NULL); /* destroy pair */ pair_destroy(&pt_multimap->_t_pair); /* destroy tree */ #ifdef CSTL_MULTIMAP_AVL_TREE _avl_tree_destroy(_GET_MULTIMAP_AVL_TREE(pt_multimap)); #else _rb_tree_destroy(_GET_MULTIMAP_RB_TREE(pt_multimap)); #endif }
list_t list_destroy(list_t list) { list_t current; while(list!= NULL) { current = list; list = list->next; current->elem = pair_destroy(current->elem); free(current); } current = NULL; return list; }
bst_t bst_remove(bst_t bst, index_t index) { bst_t current; if (bst != NULL) { if (index_is_less_than(index, pair_fst(bst->pair))) { bst->left = bst_remove(bst->left, index); } else if (index_is_equal(pair_fst(bst->pair), index) && bst->left == NULL) { current = bst->right; bst->pair = pair_destroy(bst->pair); free(bst); bst = current; } else if (index_is_equal(pair_fst(bst->pair), index) && bst->left != NULL) { bst->pair = pair_destroy(bst->pair); bst->pair = bst_max(bst->left); bst->left = delete_max(bst->left); } else { bst->right = bst_remove(bst->right, index); } } return (bst); }
bst_t delete_max(bst_t bst) { bst_t current; if (bst != NULL) { if (bst->right == NULL) { current = bst->left; /* Free the allocated resources */ bst->pair = pair_destroy(bst->pair); free(bst); bst = current; } else { bst->right = delete_max(bst->right); } } return (bst); }
void* _map_at_varg(map_t* pt_map, va_list val_elemlist) { pair_t t_elempair; bool_t t_result = false; void* pv_value = NULL; #ifdef CSTL_MAP_AVL_TREE avl_tree_result_pair_t t_avlresult; #else rb_tree_result_pair_t t_rbresult; #endif assert(pt_map != NULL); t_elempair = _create_pair( pt_map->_t_pair._t_firsttypesize, pt_map->_t_pair._sz_firsttypename, pt_map->_t_pair._t_secondtypesize, pt_map->_t_pair._sz_secondtypename); pair_init(&t_elempair); _get_varg_value( t_elempair.first, val_elemlist, t_elempair._t_firsttypesize, t_elempair._sz_firsttypename); memset(t_elempair.second, 0x00, t_elempair._t_secondtypesize); #ifdef CSTL_MAP_AVL_TREE t_avlresult = _avl_tree_insert_unique(_GET_MAP_AVL_TREE(pt_map), &t_elempair); pv_value = ((pair_t*)((avlnode_t*) _GET_AVL_TREE_COREPOS(&t_avlresult._t_first))->_pc_data)->second; t_result = t_avlresult._t_second._t_bool; #else t_rbresult = _rb_tree_insert_unique(_GET_MAP_RB_TREE(pt_map), &t_elempair); pv_value = ((pair_t*)((rbnode_t*) _GET_RB_TREE_COREPOS(&t_rbresult._t_first))->_pc_data)->second; t_result = t_rbresult._t_second._t_bool; #endif assert(pv_value != NULL); /* destroy the pair when inserting failed */ if(!t_result) { pair_destroy(&t_elempair); } return pv_value; }
bst_t bst_destroy(bst_t bst) { /* To destroy the current node, first we need to destroy its pair, * and its children if it have */ if (bst != NULL) { bst->pair = pair_destroy(bst->pair); if (bst->left != NULL) { bst->left = bst_destroy(bst->left); } if (bst->right != NULL) { bst->right = bst_destroy(bst->right); } /* Free the allocated resources */ free(bst); } bst = NULL; return (bst); }
static void _multimap_destroy_elem(void* pv_value) { assert(pv_value != NULL); pair_destroy((pair_t*)pv_value); }
/** * @brief main function for the copyright agent * * The copyright agent is used to automatically locate copyright statements * found in code. * * There are 3 ways to use the copyright agent: * 1. Command Line Analysis :: test a file from the command line * 2. Agent Based Analysis :: waits for commands from stdin * 3. Accuracy Test :: tests the accuracy of the copyright agent * * +-----------------------+ * | Command Line Analysis | * +-----------------------+ * * To analyze a file from the command line: * -C <filename> :: run copyright agent from command line * -d :: turn on debugging information * -T <Copyright Statements | URLs| Emails> :: Copyright Statements | URLs |Emails * * example: * $ ./copyright -C myfiletoscan * * +----------------------+ * | Agent Based Analysis | * +----------------------+ * * To run the copyright agent as an agent simply run with no command line args * -i :: initialize a connection to the database * -d :: turn on debugging information * * example: * $ upload_pk | ./copyright * * +---------------+ * | Accuracy Test | * +---------------+ * * To test the accuracy of the copyright agent run with a -t. Make sure to run the * accuracy tests in the source directory with the testdata directory: * -t :: run the accuracy analysis * * example: * $ ./copyright -t * * Running the tests will create 3 files: * 1. Matches: contains all of the matches found by the copyright agent, information * includes what file the match was found in, the dictionary element * that it matched, the name that it matched and the text that was found * 2. False_Positives: contains all of the false positives found by the agent, * information in the file includes the file the false positive was * in, the dictionary match, the name match, and the text * 3. Flase_Negatives: contains all of the false negatives found by the agent, * information in the file includes the file the false negative was * in, and the text of the false negative * * NOTE: -d will produces the exact same style of Matches file that the accuracy * testing does. Currently this is the only thing that -d will produce * * @param argc the number of command line arguments * @param argv the command line arguments * @return 0 on a successful program execution */ int main(int argc, char** argv) { /* primitives */ char sql[512]; // buffer for database access int c, i = -1; // temporary int containers int num_files = 0; // the number of rows in a job int ars_pk = 0; // the args primary key int user_pk = 0; long upload_pk = 0; // the upload primary key long agent_pk = 0; // the agents primary key char *SVN_REV = NULL; char *VERSION = NULL; char agent_rev[myBUFSIZ]; char copy_buf[FILENAME_MAX]; char name_buf[FILENAME_MAX]; int report_type = 7; // defaul as all. binary xxx 1st number as email, 2nd number as url, 3rd number as statement int cli_run = 0; // when run from command line, that mean -C option is set; 1: yes, 0: no /* Database structs */ PGconn* pgConn = NULL; // the connection to Database PGresult* pgResult = NULL; // result of a database access /* copyright structs */ copyright copy; // the work horse of the copyright agent pair curr; // pair to push into the file list /* verbose data */ FILE* mout = NULL; /* set the output streams */ cout = stdout; cerr = stdout; cin = stdin; /* connect to the scheduler */ fo_scheduler_connect(&argc, argv, &pgConn); /* initialize complex data strcutres */ memset(copy_buf, '\0', sizeof(copy_buf)); memset(name_buf, '\0', sizeof(copy_buf)); snprintf(copy_buf, sizeof(copy_buf), "%s/mods-enabled/copyright/agent/copyright.dic", sysconfigdir); snprintf(name_buf, sizeof(name_buf), "%s/mods-enabled/copyright/agent/names.dic", sysconfigdir); if(!copyright_init(©, copy_buf, name_buf)) { fprintf(cerr, "FATAL %s.%d: copyright initialization failed\n", __FILE__, __LINE__); fprintf(cerr, "FATAL %s\n", strerror(errno)); fflush(cerr); return 1; } /* parse the command line options */ while((c = getopt(argc, argv, "T:dc:C:tiVvh")) != -1) { switch(c) { case 'v': /* debugging */ mout = fopen("Matches", "w"); if(!mout) { fprintf(cerr, "ERROR could not open Matches for logging\n"); fflush(cerr); } else { verbose = 1; } break; case 'C': /* run from command line */ cli_run = 1; pair_init(&curr, string_function_registry(), int_function_registry()); pair_set_first(curr, optarg); pair_set_second(curr, &i); num_files++; break; case 'T': /* report type, Copyright Statements | URLs| Emails */ report_type = atoi(optarg); printf("report_type is:%d\n", report_type); break; case 't': /* run accuracy testing */ run_test_files(copy); copyright_destroy(copy); return 0; case 'i': /* initialize database connections */ copyright_destroy(copy); PQfinish(pgConn); return 0; case 'V': printf("%s", BuildVersion); copyright_destroy(copy); PQfinish(pgConn); return 0; default: /* error, print usage */ copyright_usage(argv[0]); return 3; } } /** run from command line */ if (1 == cli_run) { perform_analysis(pgConn, copy, curr, agent_pk, mout, report_type); pair_destroy(curr); } /* if there are no files in the file list then the agent is begin run from */ /* the scheduler, open the database and grab the files to be analyzed */ if(num_files == 0) { /* create the sql copy structure */ sqlcpy = fo_sqlCopyCreate(pgConn, "copyright", 32768, 7, "agent_fk", "pfile_fk", "copy_startbyte", "copy_endbyte", "content", "hash", "type"); /* book keeping */ pair_init(&curr, string_function_registry(), int_function_registry()); db_connected = 1; SVN_REV = fo_sysconfig("copyright", "SVN_REV"); VERSION = fo_sysconfig("copyright", "VERSION"); sprintf(agent_rev, "%s.%s", VERSION, SVN_REV); agent_pk = fo_GetAgentKey(pgConn, AGENT_NAME, 0, agent_rev, AGENT_DESC); /* make sure that we are connected to the database */ if(!check_copyright_table(pgConn)) { return 5; } user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */ /* enter the main agent loop */ while(fo_scheduler_next()) { upload_pk = atol(fo_scheduler_current()); /* Check Permissions */ if (GetUploadPerm(pgConn, upload_pk, user_pk) < PERM_WRITE) { LOG_ERROR("You have no update permissions on upload %ld", upload_pk); continue; } ars_pk = fo_WriteARS(pgConn, 0, upload_pk, agent_pk, AGENT_ARS, NULL, 0); sprintf(sql, fetch_pfile, upload_pk, agent_pk, agent_pk); pgResult = PQexec(pgConn, sql); num_files = PQntuples(pgResult); for(i = 0; i < num_files; i++) { c = atoi(PQgetvalue(pgResult, i, PQfnumber(pgResult, "pfile_pk"))); pair_set_first(curr, PQgetvalue(pgResult, i, PQfnumber(pgResult, "pfilename"))); pair_set_second(curr, &c); perform_analysis(pgConn, copy, curr, agent_pk, mout, REPORTALL); } fo_WriteARS(pgConn, ars_pk, upload_pk, agent_pk, AGENT_ARS, NULL, 1); PQclear(pgResult); } pair_destroy(curr); } if(db_connected) { fo_sqlCopyDestroy(sqlcpy, 1); PQfinish(pgConn); } if(verbose) { fclose(mout); } copyright_destroy(copy); fo_scheduler_disconnect(0); return 0; }
static void pair_free_object(zend_object *object) { Pair *pair = (Pair*) object; zend_object_std_dtor(&pair->std); pair_destroy(pair); }