void links(char * path1, char * path2) {
int path1_len = str_len(path1);
path1[path1_len - 1] = '\0';
int path2_len, i, index_file_name, quant_chars;
char * directory_path;
char * name;
iNode * path1_inode = current;
path1_inode = parser_path(path1, path1_inode);
if (path1_inode == NULL) {
printf("Wrong name or path\n");
}
// Search for the first / from right to left, to get the path and the
//filename.
path2_len = str_len(path2);
for (i = path2_len; i >= 0; i--) {
if (path2[i] == '/') {
index_file_name = i;
break;
}
}
//if I find one
if (i >= 0) {
quant_chars = path2_len - (path2_len - index_file_name) + 1;
directory_path = malloc(quant_chars);
name = malloc(path2_len - quant_chars);
memcpy(directory_path, path2, quant_chars);
memcpy(name, path2 + quant_chars, path2_len - quant_chars);
name[path2_len - quant_chars] = '\0';
directory_path[quant_chars - 1] = '\0';
iNode * path2_inode = current;
path2_inode = parser_path(directory_path, path2_inode);
iNode * link_node = insert_file(name, 777, path2_inode);
copy_link_inode(path1_inode, link_node);
} else {
/*printf("ENTRO");*/
iNode * path2_inode = current;
iNode * link_node = insert_file(path2, 2, path2_inode);
copy_link_inode(path1_inode, link_node);
/*printf("ID:%d\n",link_node->identifier);*/
fs_insert_inode(link_node);
}
return;
}
int add_files(const struct sockaddr_in *peer_addr, const char *pck_data, int data_len) {
int i, j;
char tmp[1024];
unsigned char md5[MD5_DIGEST_LENGTH];
char op;
j = 0;
for (i = 0; i < data_len; i ++) {
if (pck_data[i] != '+' && pck_data[i] != '-') {
fprintf(stderr, "add_files error - bad packet format\n");
return -1;
}
op = pck_data[i];
memcpy(md5, pck_data + i + 1, MD5_DIGEST_LENGTH);
for (i += MD5_DIGEST_LENGTH + 1 ; i < data_len; i ++) {
if (pck_data[i] != '\n') {
tmp[j] = pck_data[i];
j ++;
} else {
tmp[j] = 0;
j = 0;
if (op == '+') {
insert_file(tmp, md5, peer_addr->sin_addr.s_addr, peer_addr->sin_port);
} else {
remove_file(peer_addr->sin_addr.s_addr, peer_addr->sin_port, tmp, md5);
}
break;
}
}
}
return 0;
}
void
new_mail_widget::create_actions()
{
m_action_send_msg = new QAction(FT_MAKE_ICON(FT_ICON16_SEND),
tr("Send mail"), this);
connect(m_action_send_msg, SIGNAL(activated()), this, SLOT(send()));
m_action_attach_file = new QAction(FT_MAKE_ICON(FT_ICON16_ATTACH),
tr("Attach file"), this);
connect(m_action_attach_file, SIGNAL(activated()), this, SLOT(attach_files()));
m_action_insert_file = new QAction(FT_MAKE_ICON(FT_ICON16_OPENFILE),
tr("Insert text file"), this);
connect(m_action_insert_file, SIGNAL(activated()), this, SLOT(insert_file()));
m_action_edit_note = new QAction(FT_MAKE_ICON(FT_ICON16_EDIT_NOTE),
tr("Edit note"), this);
connect(m_action_edit_note, SIGNAL(activated()), this, SLOT(edit_note()));
m_action_add_header = new QAction(FT_MAKE_ICON(ICON16_HEADER),
tr("Add header field"), this);
connect(m_action_add_header, SIGNAL(activated()), this, SLOT(add_field_editor()));
m_action_open_notepad = new QAction(FT_MAKE_ICON(ICON16_NOTEPAD),
tr("Open global notepad"), this);
connect(m_action_open_notepad, SIGNAL(activated()), this, SLOT(open_global_notepad()));
}
int
insert_file(const char * filename, class Properties& p){
FILE * f = fopen(filename, "r");
int res = insert_file(f, p);
if(f) fclose(f);
return res;
}
FileStore::FileStore()
{
//run command to return /n delimited list of files in the current directory
FILE* pipe = popen(config->find_cmd.c_str(), "r");
if(!pipe)
return;
char *line = NULL;
size_t size = 0;
size_t root_path_length = config->cwd_path.length() + 1;
while(!feof(pipe))
{
if(getline(&line, &size, pipe) != -1)
{
std::string path = std::string(line);
//pop the ending newline
path.pop_back();
//remove root working directory
path = path.substr(root_path_length, std::string::npos);
//create a new File object, and save it in the vector
insert_file(new File(path));
}
}
pclose(pipe);
}
int do_creat(char * filename, int mode) {
int i;
iNode * ret;
if ((ret = insert_file(filename, mode, current)) == NULL) {
return -1;
}
int fd = insert_fd(ret->iNode_number);
return fd;
}
/****************************************************************************************************************************************
* FUNCTION NAME : main.c
*
* DESCRIPTION : main function for implementing bst
*
* RETURN VALUE : SUCCESS
*
**************************************************************************************************************************************/
int main(int argc, char *argv[])
{
if(NULL == argv[1])
{
printf("please enter input file name\n");
exit(FAILURE);
}
if(NULL == argv[2])
{
printf("please enter output file name\n");
exit(FAILURE);
}
FILE *fp1; //file pointer for input file
FILE *fp2; //file pointer for output file
file_open(&fp1, argv[1], "r");//opening input file in read mode
file_open(&fp2, argv[2], "w");//opening output file in write mode
char input[MAX]; //for storing input file names
node *root = NULL; //root node of tree
int count = 0; //name count
int duplicates = 0;
while(1)
{
memset(input, 0, MAX * sizeof(char));//initializing input
/*reading from the file*/
fgets(input, (MAX-1)*sizeof(char), fp1);
if(feof(fp1))
{
break;
}
insert_bst(&root, input, &duplicates);
count++;
}
printf("\n\n**********File contents in level order***********\n\n");
fprintf(fp2, "Total names present in the input file is %d\n", count);
fprintf(fp2, "Total number of duplicate names present in the input file is %d\n\n", duplicates);
fprintf(fp2, "\n\n**********File contents in level order***********\n\n");
insert_file(&root, &fp2);
file_close(&fp1); //closing input file
file_close(&fp2); //closing output file
free_bst(&root);
return SUCCESS;
}
void cp_file(char * filename, iNode * origin, iNode * path_inode)
{
iNode * ret, * aux;
char * buff;
int fd;
aux = current;
if ( (ret = insert_file(filename, 777, path_inode)) == NULL)
return ;
insert_fd(ret->iNode_number);
current = origin;
fd = do_open(filename, 1, 2);
buff = malloc(getsize(fd));
read(fd, buff, -1);
//printf("\nhasta ahora todo va bien. filename:%s. buffer:%s", filename, buff);
//while(1);
current = path_inode;
fd = do_open(filename, 1, 777);
write(fd, buff, str_len(buff));
current = aux;
}
/*
* Insert diversion number DIVNUM into the current output file. The
* diversion is NOT placed on the expansion obstack, because it must not
* be rescanned. When the file is closed, it is deleted by the system.
*/
void
insert_diversion (int divnum)
{
FILE *div;
if (divnum < 0 || divnum >= ndiversion)
return;
div = divtab[divnum];
if (div == NULL || div == output)
return;
if (output != NULL)
{
rewind (div);
insert_file (div);
output_current_line = -1;
}
fclose (div);
divtab[divnum] = NULL;
}
BOOL CSoliDire::add_file()
{
CFileDialog dlgAdd(TRUE, (LPCTSTR)"*.*|*.*||", NULL, OFN_OVERWRITEPROMPT, (LPCTSTR)"*.*|*.*||", NULL);
UINT iRet = dlgAdd.DoModal(),
nCount = 0;
if (iRet == IDOK)
{
POSITION pos = dlgAdd.GetStartPosition();
while (pos)
{
insert_file(dlgAdd.GetNextPathName(pos));
nCount++;
}
CString msg;
printf("%d file(s) sucessfully added.\n", nCount);
return TRUE;
}
return FALSE;
}
bool implicit_report(bip_context* c)
{
/* Create report file */
FILE* report = fopen("reports/implicit.tex", "w");
if(report == NULL) {
return false;
}
/* Write preamble */
bool success = insert_file("latex/header.tex", report);
if(!success) {
return false;
}
fprintf(report, "\n");
/* Write header */
fprintf(report, "\\section{%s}\n\n", "Implicit Enumeration");
fprintf(report, "\\noindent{\\huge %s.} \\\\[0.4cm]\n",
"Binary Integer Programming");
fprintf(report, "{\\LARGE %s.}\\\\[0.4cm]\n", "Operation Research");
fprintf(report, "\\HRule \\\\[0.5cm]\n");
/* Write description */
fprintf(report, "\\indent ");
success = insert_file("latex/preamble.tex", report);
if(!success) {
return false;
}
/* Write first section */
fprintf(report, "\\\\[0.5cm]\n\\noindent{\\Large Details:}\n");
fprintf(report, "\\begin{compactitem}\n");
fprintf(report, "\\item %s : \\textsc{%s}. \n",
"Executed on", get_current_time());
fprintf(report, "\\item %s : \\textsc{%lf %s}. \n",
"Execution time", c->execution_time,
"seconds");
fprintf(report, "\\item %s : \\textsc{%i %s}. \n",
"Memory required", c->memory_required,
"bytes");
fprintf(report, "\\end{compactitem}\n");
fprintf(report, "\n");
/* TOC */
fprintf(report, "\\newpage\n");
fprintf(report, "\\tableofcontents\n");
fprintf(report, "\\newpage\n");
fprintf(report, "\n");
/* Model */
fprintf(report, "\\section{%s}\n", "Model");
fprintf(report, "\n");
imp_model(report, c);
fprintf(report, "\\end{adjustwidth}\n");
fprintf(report, "\\newpage\n");
fprintf(report, "\n");
/* Write execution */
fprintf(report, "\\section{%s}\n", "Resolution");
success = copy_streams(c->report_buffer, report);
if(!success) {
return false;
}
/* End document */
fprintf(report, "\\end{document}\n");
fprintf(report, "\n");
/* Save & swap buffers */
int success_file = fflush(report);
if(success_file == EOF) {
return false;
}
success_file = fclose(c->report_buffer);
if(success_file == EOF) {
return false;
}
c->report_buffer = report;
return true;
}
static void
insert_diversion_helper (m4_diversion *diversion)
{
/* Effectively undivert only if an output stream is active. */
if (output_diversion)
{
if (diversion->size)
{
if (!output_diversion->u.file)
{
/* Transferring diversion metadata is faster than
copying contents. */
assert (!output_diversion->used && output_diversion != &div0
&& !output_file);
output_diversion->u.buffer = diversion->u.buffer;
output_diversion->size = diversion->size;
output_cursor = diversion->u.buffer + diversion->used;
output_unused = diversion->size - diversion->used;
diversion->u.buffer = NULL;
}
else
{
/* Avoid double-charging the total in-memory size when
transferring from one in-memory diversion to
another. */
total_buffer_size -= diversion->size;
output_text (diversion->u.buffer, diversion->used);
}
}
else if (!output_diversion->u.file)
{
/* Transferring diversion metadata is faster than copying
contents. */
assert (!output_diversion->used && output_diversion != &div0
&& !output_file);
output_diversion->u.file = m4_tmprename (diversion->divnum,
output_diversion->divnum);
output_diversion->used = 1;
output_file = output_diversion->u.file;
diversion->u.file = NULL;
diversion->size = 1;
}
else
{
if (!diversion->u.file)
diversion->u.file = m4_tmpopen (diversion->divnum, true);
insert_file (diversion->u.file);
}
output_current_line = -1;
}
/* Return all space used by the diversion. */
if (diversion->size)
{
if (!output_diversion)
total_buffer_size -= diversion->size;
free (diversion->u.buffer);
diversion->size = 0;
}
else
{
if (diversion->u.file)
{
FILE *file = diversion->u.file;
diversion->u.file = NULL;
if (m4_tmpclose (file, diversion->divnum) != 0)
m4_error (0, errno,
_("cannot clean temporary file for diversion"));
}
if (m4_tmpremove (diversion->divnum) != 0)
M4ERROR ((0, errno, "cannot clean temporary file for diversion"));
}
diversion->used = 0;
gl_oset_remove (diversion_table, diversion);
diversion->u.next = free_list;
free_list = diversion;
}
/***********************************************************************************************************************************************
* FUNCTION NAME : main.c
*
* DESCRIPTION : contains main function swhich call other functions for implementing the given problem statement
*
* RETURN VALUE : SUCCESS
*
**************************************************************************************************************************************************/
int main(int argc, char *argv[])
{
/*error handling for command line arguments*/
if(NULL == argv[1])
{
printf("Please provide first input file name\n");
exit(FAILURE);
}
if(NULL == argv[2])
{
printf("Please provide second input file name\n");
exit(FAILURE);
}
if(NULL == argv[3])
{
printf("Please provide output file name\n");
exit(FAILURE);
}
FILE *fp1; //file pointer for first input file
FILE *fp2; //file pointer for second input file
FILE *fp3; //file pointer for output file
int index; //array index
char string[MAX];//for storing strings
memset(string,0,MAX*sizeof(char));//initializing input to null
char *arr[MAX]; //array for storing names
/*initializing array of pointers to null*/
for (index=0; index<MAX-1; index++)
{
arr[index] = NULL;
}
file_open(&fp1, argv[1], "r");//opening first input file in read only mode
file_open(&fp2, argv[2], "r");//opening second input file in read only mode
file_open(&fp3,argv[3], "w");//opening output file in write only mode
index = 0;
/*reading from first input file & storing it in array*/
while(1)
{
fgets(string, (MAX-1)*sizeof(char), fp1); //reading from the first input file
/*error handling for end of file*/
if(feof(fp1))
{
break;
}
insert_array(arr, string, index);
++index;
}
/*reading from second input file and storing it in array*/
while(1)
{
fgets(string, (MAX-1)*sizeof(char), fp2); //reading from the second input file
/*error handling for end of file*/
if(feof(fp2))
{
break;
}
insert_array(arr, string, index);
++index;
}
printf("\n");
printf("***************array before sorting*************************\n");
display_array(arr, index);
printf("\n\n");
quicksort(arr, 0, index-1);//sorting the array
printf("*******************array after sorting****************************\n");
display_array(arr, index);
printf("\n\n");
insert_file(arr, index, &fp3);//read from the ds and store it in output file
file_close(&fp1); //closing first input file
file_close(&fp2); //closing second input file
file_close(&fp3); //closing output file
free_array(arr, index); //free the link list
return SUCCESS;
}
int main(int argc, char *argv[])
{
char filename[STRING_LENGTH];
char *include_path;
/* Command line parameters */
if (argc < 2) {
include_path = (char *) malloc(sizeof(char)*2);
strcpy(include_path, ".");
}
else {
include_path = (char *) malloc(sizeof(char)*strlen(argv[1]));
strcpy(include_path, argv[1]);
}
/* User code at top of file */
sprintf(filename, "%s/%s", include_path, "user_code_top.metaflex");
insert_file(filename);
/* Definitions */
sprintf(filename, "%s/%s", include_path, "roman_numbers.metaflex");
insert_file(filename);
/* Separator */
printf("\n%%%%\n");
/* Rules */
/* - Wordlist rules */
sprintf(filename, "%s/%s", include_path, "article.wordlist");
rules_from_file(filename, "ARTICLE");
sprintf(filename, "%s/%s", include_path, "be.wordlist");
rules_from_file(filename, "BE");
sprintf(filename, "%s/%s", include_path, "character.wordlist");
rules_from_file(filename, "CHARACTER");
sprintf(filename, "%s/%s", include_path, "first_person.wordlist");
rules_from_file(filename, "FIRST_PERSON");
sprintf(filename, "%s/%s", include_path, "first_person_possessive.wordlist");
rules_from_file(filename, "FIRST_PERSON_POSSESSIVE");
sprintf(filename, "%s/%s", include_path, "first_person_reflexive.wordlist");
rules_from_file(filename, "FIRST_PERSON_REFLEXIVE");
sprintf(filename, "%s/%s", include_path, "negative_adjective.wordlist");
rules_from_file(filename, "NEGATIVE_ADJECTIVE");
sprintf(filename, "%s/%s", include_path, "negative_comparative.wordlist");
rules_from_file(filename, "NEGATIVE_COMPARATIVE");
sprintf(filename, "%s/%s", include_path, "negative_noun.wordlist");
rules_from_file(filename, "NEGATIVE_NOUN");
sprintf(filename, "%s/%s", include_path, "neutral_adjective.wordlist");
rules_from_file(filename, "NEUTRAL_ADJECTIVE");
sprintf(filename, "%s/%s", include_path, "neutral_noun.wordlist");
rules_from_file(filename, "NEUTRAL_NOUN");
sprintf(filename, "%s/%s", include_path, "nothing.wordlist");
rules_from_file(filename, "NOTHING");
sprintf(filename, "%s/%s", include_path, "positive_adjective.wordlist");
rules_from_file(filename, "POSITIVE_ADJECTIVE");
sprintf(filename, "%s/%s", include_path, "positive_comparative.wordlist");
rules_from_file(filename, "POSITIVE_COMPARATIVE");
sprintf(filename, "%s/%s", include_path, "positive_noun.wordlist");
rules_from_file(filename, "POSITIVE_NOUN");
sprintf(filename, "%s/%s", include_path, "second_person.wordlist");
rules_from_file(filename, "SECOND_PERSON");
sprintf(filename, "%s/%s", include_path, "second_person_possessive.wordlist");
rules_from_file(filename, "SECOND_PERSON_POSSESSIVE");
sprintf(filename, "%s/%s", include_path, "second_person_reflexive.wordlist");
rules_from_file(filename, "SECOND_PERSON_REFLEXIVE");
sprintf(filename, "%s/%s", include_path, "third_person_possessive.wordlist");
rules_from_file(filename, "THIRD_PERSON_POSSESSIVE");
/* - Single word rules */
printf("\n /* single word rules */\n");
rule_for_word("and", "AND");
rule_for_word("as", "AS");
rule_for_word("enter", "ENTER");
rule_for_word("exeunt", "EXEUNT");
rule_for_word("exit", "EXIT");
rule_for_word("heart", "HEART");
rule_for_word("if not", "IF_NOT");
rule_for_word("if so", "IF_SO");
rule_for_word("less", "LESS");
rule_for_word("let us", "LET_US");
rule_for_word("listen to", "LISTEN_TO");
rule_for_word("mind", "MIND");
rule_for_word("more", "MORE");
rule_for_word("not", "NOT");
rule_for_word("open", "OPEN");
rule_for_word("proceed to", "PROCEED_TO");
rule_for_word("recall", "RECALL");
rule_for_word("remember", "REMEMBER");
rule_for_word("return to", "RETURN_TO");
rule_for_word("speak", "SPEAK");
rule_for_word("than", "THAN");
rule_for_word("the cube of", "THE_CUBE_OF");
rule_for_word("the difference between", "THE_DIFFERENCE_BETWEEN");
rule_for_word("the factorial of", "THE_FACTORIAL_OF");
rule_for_word("the product of", "THE_PRODUCT_OF");
rule_for_word("the quotient between", "THE_QUOTIENT_BETWEEN");
rule_for_word("the remainder of the quotient between", "THE_REMAINDER_OF_THE_QUOTIENT_BETWEEN");
rule_for_word("the square of", "THE_SQUARE_OF");
rule_for_word("the square root of", "THE_SQUARE_ROOT_OF");
rule_for_word("the sum of", "THE_SUM_OF");
rule_for_word("twice", "TWICE");
rule_for_word("we must", "WE_MUST");
rule_for_word("we shall", "WE_SHALL");
/* - Other rules */
sprintf(filename, "%s/%s", include_path, "terminals.metaflex");
printf("\n /* rules for terminals from file %s */", filename);
insert_file(filename);
/* Separator */
printf("\n%%%%\n");
/* User code */
sprintf(filename, "%s/%s", include_path, "user_code_bottom.metaflex");
insert_file(filename);
/* We did it, no problemas */
free(include_path);
return 0;
}
void mv(char * filename, char * path)
{
int i, name_length, type;
filename[str_len(filename) - 1] = 0;
iNode * path_inode = current;
path_inode = parser_path(path, path_inode);
iNode * filename_inode = current;
filename_inode = parser_path(filename, filename_inode);
if(filename_inode->gid < currentUsr.group)
{
printf("\nCan not move '%s'. Permission denied.", filename);
return ;
}
if(filename_inode == NULL)
{
printf("\nCan not move '%s'. File doesn't exist.", filename);
return ;
}
if(path_inode == NULL)
{
name_length = str_len(path);
for(i = 0; i < name_length; i++)
if(path[i] == '/')
{
printf("\nCan not move '%s' to '%s'. Directory doesn't exist.", filename, path);
return;
}
rename_file(filename_inode->iNode_number, path);
return ;
}
int init_block = current->data.direct_blocks[0];
directoryEntry * dr = (directoryEntry*)calloc(64 * 96, 1);
read_disk(0, init_block, dr, (BLOCK_SIZE * 12), 0);
for(i = 1; i < 96; i++){
if( strcmp(filename, dr[i].name) == 1){
type = dr[i].type;
break;
}
}
if(type == DIRECTORY)
{
insert_directory_entry(filename_inode, path_inode, filename);
int inode_number = filename_inode->iNode_number;
init_block = current->data.direct_blocks[0];
directoryEntry * dr = (directoryEntry*)calloc(sizeof(directoryEntry),96);
read_disk(0,init_block,dr,BLOCK_SIZE*12,0);
iNode * parent = fs_get_inode(dr[1].inode);
int father_init_block = current->data.direct_blocks[0];
directoryEntry * father_dr = (directoryEntry*)calloc(sizeof(directoryEntry),96);
read_disk(0,father_init_block,father_dr,BLOCK_SIZE*12,0);
for ( i = 2; i < 96; i++){
if ( father_dr[i].inode == inode_number){
dr[i].type = 0;
dr[i].inode = 0;
dr[i].lenght = 0;
strcopy(dr[i].name,"\0",1 );
break;
}
}
write_disk(0,init_block,dr,BLOCK_SIZE*12,0);
}
else if( type == FILE)
{
insert_file(filename, 777, path_inode);
rmDir(filename);
}
return ;
}
int main()
{
printf("main\n");
node * root = create_Tree();
char fname[30];
char * word = (char *)malloc(sizeof(char)*MAXLENGTH);
int i;
char k[3];
do
{
printf("\n1. Check a file for spelling errors.\n2. Word lookup.\n3. Add a word to dictionary.\n4. Exit.\nEnter your choice: ");
scanf("%d",&i);
if (i==1)
{
printf("Enter the name of the file you wish to run spell check on : ");
scanf("%s", fname);
spell_Check(fname, root);
}
else if (i==2)
{
printf("Enter the word you wish to look up : ");
scanf("%s",word);
if (search(root,word))
{
printf("The word is correctly spelled.\n");
}
else
{
printf("The word is misspelt.\n");
printf("Word correction suggestions:\n");
fix(word, root);
printf("Would you like to add your word to the dictionary? Type y/n: ");
scanf("%s", k);
if (k[0] == 'y')
{
insert(root,word);
printf("Word added\n");
}
}
}
else if (i==3)
{
printf("Enter the word to be added\n");
char str[100];
scanf("%s",str);
if(search(root,str) == 0)
{
insert(root,str);
insert_file(str);
printf("Word added\n");
}
else
printf("Already exists in dictionary\n");
}
if (i > 4 || i < 1)
printf("Invalid choice. Enter again.\n");
}while (i != 4);
deleteTree(root);
return 0;
}
