int main(int argc, char *argv[]) { int quit = 0; bst *address_book = NULL; char *curr_file = (char *)malloc(0); fprintf(stdout,"Welcome to adrbook!\n\n"); fflush(stdout); if (argc == 2) { free(curr_file); curr_file = strdup(argv[1]); address_book = addr_book_from_file(curr_file); printf("Read file %s.\n", curr_file); putchar('\n'); fflush(stdout); } char buf[BUF_SZ]; /* interactive i/o loop */ help_text(); short_prompt(); while (1) { char *cmd; cmd = fgets(buf, BUF_SZ, stdin); cmd = trim_newline(cmd); /* printf("cmd=%s\n", cmd); */ putchar('\n'); if (!process_cmd(&curr_file, cmd, &address_book, &quit)) fprintf(stdout, "unknown command: \"%s\"\n", cmd); free(cmd); if (quit) break; short_prompt(); } return 0; }
/// Extracts the result reason from the input file. /// /// \pre This can only be called for those result types that require a reason. /// /// \param [in,out] input The file from which to read. /// \param first_line The first line of the reason. Because this is part of the /// same line in which the result status is printed, this line has already /// been read by the caller and thus must be provided here. /// \param [out] output Buffer to which to write the full reason. /// \param output_size Size of the output buffer. /// /// \return An error if there was no reason in the input or if there is a /// problem reading it. static kyua_error_t read_reason(FILE* input, const char* first_line, char* output, size_t output_size) { if (first_line == NULL || *first_line == '\0') return kyua_generic_error_new("Test case should have reported a " "failure reason but didn't"); snprintf(output, output_size, "%s", first_line); advance(&output, &output_size); bool had_newline = true; while (!is_really_eof(input)) { if (had_newline) { snprintf(output, output_size, "<<NEWLINE>>"); advance(&output, &output_size); } if (fgets(output, output_size, input) == NULL) { assert(ferror(input)); return kyua_libc_error_new(errno, "Failed to read reason from " "result file"); } had_newline = trim_newline(output); advance(&output, &output_size); } return kyua_error_ok(); }
void handle_user_input(connection_info *connection) { char input[255]; fgets(input, 255, stdin); trim_newline(input); // message msg; SBCP_message msg = initSBCP( SEND ); // msg.type = PUBLIC_MESSAGE; pushAttr(&msg, Username, connection->username); // strncpy(msg.username, connection->username, 20); //clear_stdin_buffer(); if(strlen(input) == 0) { return; } // strncpy(msg.data, input, 255); pushAttr(&msg, Message, input ); //Send some data if(send(connection->socket, &msg, sizeof(msg), 0) < 0) { perror("Send failed"); exit(1); } }
/* * read_string() * * Ask the user a question and prompt for a string answer * max = size of "answer" including NULL terminating character * Note: The answer parameter is MODIFIED by the function */ void read_string(char prompt[], char answer[], int max) { fputs(prompt, stdout); fflush(stdin); fgets(answer, max, stdin); trim_newline(answer); }
/// Parses a results file written by an ATF test case. /// /// \param input_name Path to the result file to parse. /// \param [out] status Type of result. /// \param [out] status_arg Optional integral argument to the status. /// \param [out] reason Textual explanation of the result, if any. /// \param reason_size Length of the reason output buffer. /// /// \return An error if the input_name file has an invalid syntax; OK otherwise. static kyua_error_t read_atf_result(const char* input_name, enum atf_status* status, int* status_arg, char* const reason, const size_t reason_size) { kyua_error_t error = kyua_error_ok(); FILE* input = fopen(input_name, "r"); if (input == NULL) { error = kyua_generic_error_new("Premature exit"); goto out; } char line[1024]; if (fgets(line, sizeof(line), input) == NULL) { if (ferror(input)) { error = kyua_libc_error_new(errno, "Failed to read result from " "file %s", input_name); goto out_input; } else { assert(feof(input)); error = kyua_generic_error_new("Empty result file %s", input_name); goto out_input; } } if (!trim_newline(line)) { error = kyua_generic_error_new("Missing newline in result file"); goto out_input; } char* reason_start = strstr(line, ": "); if (reason_start != NULL) { *reason_start = '\0'; *(reason_start + 1) = '\0'; reason_start += 2; } bool need_reason = false; // Initialize to shut up gcc warning. error = parse_status(line, status, status_arg, &need_reason); if (kyua_error_is_set(error)) goto out_input; if (need_reason) { error = read_reason(input, reason_start, reason, reason_size); } else { if (reason_start != NULL || !is_really_eof(input)) { error = kyua_generic_error_new("Found unexpected reason in passed " "test result"); goto out_input; } reason[0] = '\0'; } out_input: fclose(input); out: return error; }
void handle_user_input(connection_info clients[]) { char input[255]; fgets(input, sizeof(input), stdin); trim_newline(input); if(input[0] == 'q') { stop_server(clients); } }
static char * find_obppath (const char *sysfs_path_orig) { char *sysfs_path, *path; size_t path_size = strlen (sysfs_path_orig) + sizeof ("/obppath"); sysfs_path = xstrdup (sysfs_path_orig); path = xmalloc (path_size); while (1) { int fd; char *of_path; struct stat st; size_t size; snprintf(path, path_size, "%s/obppath", sysfs_path); #if 0 printf("Trying %s\n", path); #endif fd = open(path, O_RDONLY); if (fd < 0 || fstat (fd, &st) < 0) { snprintf(path, path_size, "%s/devspec", sysfs_path); fd = open(path, O_RDONLY); } if (fd < 0 || fstat (fd, &st) < 0) { kill_trailing_dir(sysfs_path); if (!strcmp(sysfs_path, "/sys")) { grub_util_info (_("`obppath' not found in parent dirs of `%s'," " no IEEE1275 name discovery"), sysfs_path_orig); free (path); free (sysfs_path); return NULL; } continue; } size = st.st_size; of_path = xmalloc (size + MAX_DISK_CAT + 1); memset(of_path, 0, size + MAX_DISK_CAT + 1); read(fd, of_path, size); close(fd); trim_newline(of_path); free (path); free (sysfs_path); return of_path; } }
/* Reads a value from the text table. Exits with non-zero status if the table is erroneous in some way. */ int read_value(unsigned int *outval, FILE*file) { char *res = 0; unsigned long lval; char *strout = 0; boolean bBlankLine = TRUE; ++linecount; *outval = 0; while (bBlankLine) { res = fgets(line_in, sizeof(line_in), file); if (res == 0) { if (ferror(file)) { fprintf(stderr, "tag_attr: Error reading table, %d lines read\n", linecount); exit(FAILED); } if (feof(file)) { return IS_EOF; } /* Impossible */ fprintf(stderr, "tag_attr: Impossible error reading table, " "%d lines read\n", linecount); exit(FAILED); } bBlankLine = is_skippable_line(line_in); } trim_newline(line_in, sizeof(line_in)); errno = 0; lval = strtoul(line_in, &strout, 0); if (strout == line_in) { bad_line_input("bad number input!"); } if (errno != 0) { int myerr = errno; fprintf(stderr, "tag_attr errno %d\n", myerr); bad_line_input("invalid number on line"); } *outval = (int) lval; return NOT_EOF; }
/* * read_dyn_string() * * Ask the user a question and prompt for a string answer * The string is dynamically allocated (and so should be freed) * The absolute maximum size that a string can ever be is given by * the #define MAX */ char *read_dyn_string(char prompt[]) { char buffer[MAX]; fputs(prompt, stdout); fflush(stdin); fgets(buffer, sizeof buffer, stdin); trim_newline(buffer); return strdup(buffer); }
int main(void) { printf("*****testing hash table*****\n\n"); htbl* t = ht_new(&good_hash, 10); FILE* cnets2015 = fopen("cnets2015", "r"); while (!feof(cnets2015)) { char* s = alloc_str(256); fgets(s, 256, cnets2015); char* l = trim_newline(s); free(s); if (strlen(l) > 0) { ht_ins(l, t); } free(l); } fclose(cnets2015); ht_show(t); printf("The hash table has %u buckets with %u entries (load factor %lg).\n\n", t->n_buckets, ht_n_entries(t), ht_load_factor(t)); printf("The bucket with the most items in it contains %u items.\n\n", ht_max_bucket(t)); printf("ht_member:\n"); printf("membership of cnet \"aardvark\" : %i\n", ht_member("aardvark", t)); printf("membership of cnet \"borja\" : %i\n", ht_member("borja", t)); printf("\n"); // resize printf("***now resizing***\n"); ht_resize(&t); printf("***resizing complete***\n\n"); // do everything again ht_show(t); printf("The hash table has %u buckets with %u entries (load factor %lg).\n\n", t->n_buckets, ht_n_entries(t), ht_load_factor(t)); printf("The bucket with the most items in it contains %u items.\n\n", ht_max_bucket(t)); printf("ht_member:\n"); printf("membership of cnet \"aardvark\" : %i\n", ht_member("aardvark", t)); printf("membership of cnet \"borja\" : %i\n", ht_member("borja", t)); printf("\n"); ht_free(t); return 0; }
// output in human-readable form // char* short_jd_string(double jd) { static char buf[256]; time_t tmptime; #ifdef USE_MANUAL_CALLSTACK call_stack.enter("short_jd_string()"); #endif /* USE_MANUAL_CALLSTACK */ if ( jd > JD0) { tmptime=jd_to_time_t(jd); strlcpy(buf, asctime(gmtime(&tmptime)),sizeof(buf)); trim_newline(buf); } else { strlcpy(buf,"Unknown",sizeof(buf)); } #ifdef USE_MANUAL_CALLSTACK call_stack.exit(); #endif /* USE_MANUAL_CALLSTACK */ return buf; }
char* jd_string(double jd) { static char buf[256], datestr[64]; time_t tmptime; #ifdef USE_MANUAL_CALLSTACK call_stack.enter("jd_string"); #endif /* USE_MANUAL_CALLSTACK */ if ( jd > JD0 ) { tmptime=jd_to_time_t(jd); strlcpy(datestr, asctime(gmtime(&tmptime)), sizeof(datestr)); trim_newline(datestr); sprintf(buf, "%14.5f (%s)", jd, datestr); } else { sprintf(buf,"%14.5f",jd); } #ifdef USE_MANUAL_CALLSTACK call_stack.exit(); #endif /* USE_MANUAL_CALLSTACK */ return buf; }
static void find_obppath(char *of_path, const char *sysfs_path_orig) { char *sysfs_path, *path; sysfs_path = xmalloc (PATH_MAX); path = xmalloc (PATH_MAX); strcpy(sysfs_path, sysfs_path_orig); while (1) { int fd; snprintf(path, PATH_MAX, "%s/obppath", sysfs_path); #if 0 printf("Trying %s\n", path); #endif fd = open(path, O_RDONLY); if (fd < 0) { kill_trailing_dir(sysfs_path); if (!strcmp(sysfs_path, "/sys")) grub_util_error("'obppath' not found in parent dirs of %s", sysfs_path_orig); continue; } memset(of_path, 0, OF_PATH_MAX); read(fd, of_path, OF_PATH_MAX); close(fd); trim_newline(of_path); break; } free (path); free (sysfs_path); }
zmqpp::message reader::Json::read() { zmqpp::message msg; msg << target; ::Json::Value value; ::Json::Reader reader; if (!reader.parse(Plain::read_input_str(), value)) { throw std::runtime_error(reader.getFormatedErrorMessages()); } if (!value.isArray()) { throw std::runtime_error("Must be array"); } for (size_t i = 0; i < value.size(); ++i) { auto val = value.get(i, ""); std::string param = (val.isString() ? val.asString() : val.toStyledString()); if (!val.isString()) { if (verbose) { std::cerr << "Item #" << i << " is not string!" << std::endl; } param = trim_newline(param); } msg << param; } return msg; }
/* Show any matching lines from 'in'. Return true on success. */ static int grep (const char *regexp, FILE *in, const char *opt_filename) { int found = 0; unsigned line_num = 0; char line[line_capacity]; char folded_regexp[line_capacity]; if (!matching_case) { if (line_capacity <= strlen (regexp)) panic ("regexp too long"); fold_case (folded_regexp, regexp); regexp = folded_regexp; } while (fgets (line, sizeof line, in)) { trim_newline (line, opt_filename); ++line_num; if (matching_positively == matches (regexp, line)) { found = 1; show (opt_filename, line_num, line); } } must_not_ferror (in, opt_filename ? opt_filename : "<stdin>"); return found; }
static int decode_file (idn_resconf_t conf1, idn_resconf_t conf2, FILE * fp, int flags) { idn_result_t r; idnconv_strbuf_t buf1, buf2; idn_action_t actions1, actions2; int nl_trimmed; int local_ace_hack, idn_ace_hack; idn_converter_t conv; /* * See if the input codeset is an ACE. */ conv = idn_resconf_getidnconverter (conf1); if (conv != NULL && idn_converter_isasciicompatible (conv) && (flags & FLAG_SELECTIVE)) idn_ace_hack = 1; else idn_ace_hack = 0; if (conv != NULL) idn_converter_destroy (conv); conv = idn_resconf_getlocalconverter (conf1); if (conv != NULL && idn_converter_isasciicompatible (conv) && (flags & FLAG_SELECTIVE)) local_ace_hack = 1; else local_ace_hack = 0; if (conv != NULL) idn_converter_destroy (conv); actions1 = IDN_IDNCONV; if (local_ace_hack) { actions2 = IDN_IDNCONV; if (flags & FLAG_MAP) actions2 |= IDN_MAP; if (flags & FLAG_NORMALIZE) actions2 |= IDN_NORMALIZE; if (flags & FLAG_PROHIBITCHECK) actions2 |= IDN_PROHCHECK; if (flags & FLAG_UNASSIGNCHECK) actions2 |= IDN_UNASCHECK; if (flags & FLAG_BIDICHECK) actions2 |= IDN_BIDICHECK; if (flags & FLAG_ASCIICHECK) actions2 |= IDN_ASCCHECK; if (flags & FLAG_LENGTHCHECK) actions2 |= IDN_LENCHECK; } else { actions2 = IDN_LOCALCONV; } if (flags & FLAG_DELIMMAP) actions1 |= IDN_DELIMMAP; if (flags & FLAG_MAP) actions1 |= IDN_MAP; if (flags & FLAG_NORMALIZE) actions1 |= IDN_NORMALIZE; if (flags & FLAG_NORMALIZE) actions1 |= IDN_NORMALIZE; if (flags & FLAG_PROHIBITCHECK) actions1 |= IDN_PROHCHECK; if (flags & FLAG_UNASSIGNCHECK) actions1 |= IDN_UNASCHECK; if (flags & FLAG_BIDICHECK) actions1 |= IDN_BIDICHECK; if (flags & FLAG_ASCIICHECK) actions1 |= IDN_ASCCHECK; if (flags & FLAG_ROUNDTRIPCHECK) actions1 |= IDN_RTCHECK; strbuf_init (&buf1); strbuf_init (&buf2); line_number = 1; while (strbuf_getline (&buf1, fp) != NULL) { /* * Trim newline at the end. This is needed for * those ascii-comatible encodings such as UTF-5 or RACE * not to try converting newlines, which will result * in `invalid encoding' error. */ nl_trimmed = trim_newline (&buf1); /* * Treat input line as the string encoded in local * encoding and convert it to UTF-8 encoded string. */ if (local_ace_hack) { if (strbuf_copy (&buf2, strbuf_get (&buf1)) == NULL) r = idn_nomemory; else r = idn_success; } else { r = convert_line (&buf1, &buf2, conf1, IDN_LOCALCONV, 0); } if (r != idn_success) { errormsg ("conversion failed at line %d: %s\n", line_number, idn_result_tostring (r)); goto error; } /* * Convert internationalized domain names in the line. */ if (idn_ace_hack) { r = convert_line (&buf2, &buf1, conf1, actions1, FLAG_REVERSE | FLAG_SELECTIVE); } else { r = convert_line (&buf2, &buf1, conf1, actions1, FLAG_REVERSE); } if (r != idn_success) { errormsg ("conversion failed at line %d: %s\n", line_number, idn_result_tostring (r)); goto error; } if (!idn_utf8_isvalidstring (strbuf_get (&buf1))) { errormsg ("conversion to utf-8 failed at line %d\n", line_number); goto error; } /* * Perform round trip check and convert to the output * codeset. */ if (local_ace_hack) { r = convert_line (&buf1, &buf2, conf2, actions2, FLAG_SELECTIVE); } else { r = convert_line (&buf1, &buf2, conf1, actions2, FLAG_REVERSE); } if (r != idn_success) { errormsg ("error in nameprep or output conversion " "at line %d: %s\n", line_number, idn_result_tostring (r)); goto error; } fputs (strbuf_get (&buf2), stdout); if (nl_trimmed) putc ('\n', stdout); if (flush_every_line) fflush (stdout); line_number++; } strbuf_reset (&buf1); strbuf_reset (&buf2); return (0); error: strbuf_reset (&buf1); strbuf_reset (&buf2); return (1); }
/* main: * read an optional size argument for hash table, * read in strings from standard input, * build hash table, * display hash table and a few statistics */ int main(int argc, char *argv[]) { htbl *t; int sz = DEFAULT_SIZE; int use_bad_hash = 0; char c; /* note: read about "getopt" to learn about command-line arg processing */ while ((c=getopt(argc,argv,"bs:"))!=-1) { switch (c) { case 'b': use_bad_hash = 1; break; case 's': sz = atoi(optarg); if (sz<1) { fprintf(stderr,"%s error: nonpositive table size %d\n",*argv,sz); exit(1); } break; case '?': usage(*argv); exit(1); } } /* build a new empty hash table */ t = htbl_new(use_bad_hash?&bad_hash:&good_hash,sz); /* read a line at a time from stdin, add non-empty strings to the table */ while (!feof(stdin)) { char *s = alloc_str(MAX_LINE_LEN); char *l; unsigned int n; fgets(s,MAX_LINE_LEN,stdin); l = trim_newline(s); free(s); if (strlen(l)>0) htbl_ins(l,t,&n); free(l); } /*unsigned int n = 0; char* s = "FORK"; htbl_ins(s, t, &n); */ htbl_show(stdout,t); printf("\nThe hash table has %i buckets with %i entries (load factor %lg).\n", t->n_buckets, htbl_num_entries(t), htbl_load_factor(t)); unsigned int max, max_index; htbl_max_bucket(t,&max,&max_index); printf("\nThe bucket with the most items in it contains %u items (bucket %u).\n", max,max_index); /* test hash table membership */ /* "aardvark" is not in the cnet file; "borja" is */ printf("\ntesting htbl_member:\n"); printf("membership of cnet \"aardvark\" (expecting 0): %i\n", htbl_member("aardvark",t)); printf("membership of cnet \"borja\" (expecting 1): %i\n", htbl_member("borja",t)); htbl_free(t); return 0; }
void handle_user_input(connection_info *connection) { char input[255]; fgets(input, 255, stdin); trim_newline(input); if (strcmp(input, "/q") == 0 || strmp(input, "/quit") == 0) { stop_client(connection); } else if (strcmp(input, "/l") == 0 || strcmp(input, "/quit") == 0) { message msg; msg.type = GET_USERS; if (send(connection->socket, &msg, sizeof(message), 0) < 0) { perror("Send failed"); exit(1); } } else if (strcmp(input, "/h") == 0 || strcmp(input, "/help") == 0) { puts("/quit or /q: Exit the program"); puts("/help or /h: Displays help information"); puts("/list or /l: Displays list of users in chatroom"); puts("/m <username> <message> Send a private message to <username>"); } else if (strcmp(input, "/m", 2) == 0) { message msg; msg.type = PRIVATE_MESSAGE; char * toUsername, *chatMsg; toUsername = strtok(input+3, " "); if (toUsername == NULL) { puts(KRED, "Format for private messages is: /, <username> <message" RESET); return; } if (toUsername == 0) { puts(KRED, "You must enter a username for a private message" RESET); return; } if (toUsername > 20) { puts(KRED, "The username must be between 1 and 20 characters" RESET); return; } chatMsg = strtok(NULL, ""); if (chatMsg == NULL) { puts(KRED, "You must enter a message to send to the specified user" RESET); return; } strncpy(msg.username, toUsername, 20); strncpy(msg.data, chatMsg, 255); if (send(connection->socket, $msg, sizeof(message), 0) < 0) { perror("Send failed"); exit(1); } } else { // Regular public message message msg; msg.type = PUBLIC_MESSAGE; strncpy(msg.username, connection->username, 20); if (strlen(input) == 0); // Send the data if (send(connection->socket, &msg, sizeof(message), 0) < 0) { perror("Send failed"); exit(1); } } }
/* Standart behaviour: if malformed or missing subtitle id - calculate, continue. if malformer or missing timing - skip event competely, text without timing is useless. if missing text - skip event, empty event also useless. */ bool parse_srt_file(FILE *infile, srt_file * const file) { char line[MAXLINE] = ""; char text_buf[MAXLINE] = ""; int s_len = 0; bool skip_event = false; uint16_t parsed = 0; /* num events parsed */ uint8_t t_detect = 3; /* number of first timing strings to analyze */ srt_event *event = (srt_event *) 0; srt_event **elist_tail = &file->events; if (!infile) return false; curr_line = unknown; while(!feof(infile)) { fgets(line, MAXLINE, infile); line_num++; /* unicode handle */ if (line_num == 1) charset_type = unicode_check(line, 0); prev_line = curr_line; curr_line = unknown; trim_newline(line); log_msg(raw, "%s", line); trim_spaces(line, LINE_START | LINE_END); s_len = strlen(line); if (s_len == 0) curr_line = blank; else if (strstr(line, "-->")) curr_line = timing; else if (prev_line == blank || prev_line == unknown) curr_line = id; /* at least, expected */ else /* prev_line == timing*/ curr_line = text; /* also expected */ if (feof(infile)) curr_line = blank; if (feof(infile) && s_len != 0) { log_msg(warn, MSG_F_UNEXPEOF, line_num); if (prev_line == text) append_string(text_buf, line, "\n", MAXLINE, 0); else strncpy(text_buf, line, MAXLINE); } log_msg(debug, "Line type: %i", curr_line); if (curr_line == id || (curr_line == timing && prev_line == blank)) { CALLOC(event, 1, sizeof(srt_event)); memset(text_buf, 0x0, MAXLINE); if (curr_line != id) { log_msg(warn, _("Missing subtitle id at line '%u'."), line_num); event->id = ++parsed; } } if (prev_line == timing && curr_line == blank) { log_msg(warn, _("Empty subtitle text at line %u. Event will be skipped."), line_num); skip_event = true; } if (prev_line == id && curr_line == blank) { log_msg(warn, _("Lonely subtitle id without timing or text. :-(")); skip_event = true; } switch (curr_line) { case id : /* See header for comments */ event->id = ++parsed; /* if ((event->id = atoi(line)) != 0) parsed++; */ break; case timing : if (t_detect-- && !(file->flags & SRT_E_STRICT)) analyze_srt_timing(line, &file->flags); skip_event = !parse_srt_timing(event, line, &file->flags); if (event->start > event->end) { log_msg(warn, _("Negative duration of event at line '%u'. Event will be skipped."), line_num); skip_event = true; } /*printf("%f --> %f\n", event->start, event->end);*/ break; case text : /* TODO: wrapping handling here */ if (prev_line == text) append_string(text_buf, line, "\n", MAXLINE, 0); else strncpy(text_buf, line, MAXLINE); break; case blank : if (!skip_event && prev_line != blank) { if ((event->text = strndup(text_buf, MAXLINE)) == NULL) log_msg(error, MSG_M_OOM); srt_event_append(&file->events, &elist_tail, event, opts.i_sort); memset(text_buf, 0, MAXLINE); } case unknown : default : continue; break; } if (skip_event) { /* clean parsed stuff & skip calloc() next time */ memset(event, 0, sizeof(srt_event)); memset(text_buf, 0, MAXLINE); parsed--; } } return true; /* if we reach this line, no error happens */ }
/* ** Read the git-fast-import format from pIn and insert the corresponding ** content into the database. */ static void git_fast_import(FILE *pIn){ ImportFile *pFile, *pNew; int i, mx; char *z; char *zUuid; char *zName; char *zPerm; char *zFrom; char *zTo; char zLine[1000]; gg.xFinish = finish_noop; while( fgets(zLine, sizeof(zLine), pIn) ){ if( zLine[0]=='\n' || zLine[0]=='#' ) continue; if( memcmp(zLine, "blob", 4)==0 ){ gg.xFinish(); gg.xFinish = finish_blob; }else if( memcmp(zLine, "commit ", 7)==0 ){ gg.xFinish(); gg.xFinish = finish_commit; trim_newline(&zLine[7]); z = &zLine[7]; /* The argument to the "commit" line might match either of these ** patterns: ** ** (A) refs/heads/BRANCHNAME ** (B) refs/tags/TAGNAME ** ** If pattern A is used, then the branchname used is as shown. ** Except, the "master" branch which is the default branch name in ** Git is changed to "trunk" which is the default name in Fossil. ** If the pattern is B, then the new commit should be on the same ** branch as its parent. And, we might need to add the TAGNAME ** tag to the new commit. However, if there are multiple instances ** of pattern B with the same TAGNAME, then only put the tag on the ** last commit that holds that tag. ** ** None of the above is explained in the git-fast-export ** documentation. We had to figure it out via trial and error. */ for(i=strlen(z)-1; i>=0 && z[i]!='/'; i--){} gg.tagCommit = memcmp(&z[i-4], "tags", 4)==0; /* True for pattern B */ if( z[i+1]!=0 ) z += i+1; if( fossil_strcmp(z, "master")==0 ) z = "trunk"; gg.zBranch = fossil_strdup(z); gg.fromLoaded = 0; }else if( memcmp(zLine, "tag ", 4)==0 ){ gg.xFinish(); gg.xFinish = finish_tag; trim_newline(&zLine[4]); gg.zTag = fossil_strdup(&zLine[4]); }else if( memcmp(zLine, "reset ", 4)==0 ){ gg.xFinish(); }else if( memcmp(zLine, "checkpoint", 10)==0 ){ gg.xFinish(); }else if( memcmp(zLine, "feature", 7)==0 ){ gg.xFinish(); }else if( memcmp(zLine, "option", 6)==0 ){ gg.xFinish(); }else if( memcmp(zLine, "progress ", 9)==0 ){ gg.xFinish(); trim_newline(&zLine[9]); fossil_print("%s\n", &zLine[9]); fflush(stdout); }else if( memcmp(zLine, "data ", 5)==0 ){ fossil_free(gg.aData); gg.aData = 0; gg.nData = atoi(&zLine[5]); if( gg.nData ){ int got; gg.aData = fossil_malloc( gg.nData+1 ); got = fread(gg.aData, 1, gg.nData, pIn); if( got!=gg.nData ){ fossil_fatal("short read: got %d of %d bytes", got, gg.nData); } gg.aData[got] = 0; if( gg.zComment==0 && gg.xFinish==finish_commit ){ gg.zComment = gg.aData; gg.aData = 0; gg.nData = 0; } } }else if( memcmp(zLine, "author ", 7)==0 ){ /* No-op */ }else if( memcmp(zLine, "mark ", 5)==0 ){ trim_newline(&zLine[5]); fossil_free(gg.zMark); gg.zMark = fossil_strdup(&zLine[5]); }else if( memcmp(zLine, "tagger ", 7)==0 || memcmp(zLine, "committer ",10)==0 ){ sqlite3_int64 secSince1970; for(i=0; zLine[i] && zLine[i]!='<'; i++){} if( zLine[i]==0 ) goto malformed_line; z = &zLine[i+1]; for(i=i+1; zLine[i] && zLine[i]!='>'; i++){} if( zLine[i]==0 ) goto malformed_line; zLine[i] = 0; fossil_free(gg.zUser); gg.zUser = fossil_strdup(z); secSince1970 = 0; for(i=i+2; fossil_isdigit(zLine[i]); i++){ secSince1970 = secSince1970*10 + zLine[i] - '0'; } fossil_free(gg.zDate); gg.zDate = db_text(0, "SELECT datetime(%lld, 'unixepoch')", secSince1970); gg.zDate[10] = 'T'; }else if( memcmp(zLine, "from ", 5)==0 ){ trim_newline(&zLine[5]); fossil_free(gg.zFromMark); gg.zFromMark = fossil_strdup(&zLine[5]); fossil_free(gg.zFrom); gg.zFrom = resolve_committish(&zLine[5]); }else if( memcmp(zLine, "merge ", 6)==0 ){ trim_newline(&zLine[6]); if( gg.nMerge>=gg.nMergeAlloc ){ gg.nMergeAlloc = gg.nMergeAlloc*2 + 10; gg.azMerge = fossil_realloc(gg.azMerge, gg.nMergeAlloc*sizeof(char*)); } gg.azMerge[gg.nMerge] = resolve_committish(&zLine[6]); if( gg.azMerge[gg.nMerge] ) gg.nMerge++; }else if( memcmp(zLine, "M ", 2)==0 ){ import_prior_files(); z = &zLine[2]; zPerm = next_token(&z); zUuid = next_token(&z); zName = rest_of_line(&z); dequote_git_filename(zName); i = 0; pFile = import_find_file(zName, &i, gg.nFile); if( pFile==0 ){ pFile = import_add_file(); pFile->zName = fossil_strdup(zName); } pFile->isExe = (fossil_strcmp(zPerm, "100755")==0); pFile->isLink = (fossil_strcmp(zPerm, "120000")==0); fossil_free(pFile->zUuid); pFile->zUuid = resolve_committish(zUuid); pFile->isFrom = 0; }else if( memcmp(zLine, "D ", 2)==0 ){ import_prior_files(); z = &zLine[2]; zName = rest_of_line(&z); dequote_git_filename(zName); i = 0; while( (pFile = import_find_file(zName, &i, gg.nFile))!=0 ){ if( pFile->isFrom==0 ) continue; fossil_free(pFile->zName); fossil_free(pFile->zPrior); fossil_free(pFile->zUuid); *pFile = gg.aFile[--gg.nFile]; i--; } }else if( memcmp(zLine, "C ", 2)==0 ){ int nFrom; import_prior_files(); z = &zLine[2]; zFrom = next_token(&z); zTo = rest_of_line(&z); i = 0; mx = gg.nFile; nFrom = strlen(zFrom); while( (pFile = import_find_file(zFrom, &i, mx))!=0 ){ if( pFile->isFrom==0 ) continue; pNew = import_add_file(); pFile = &gg.aFile[i-1]; if( strlen(pFile->zName)>nFrom ){ pNew->zName = mprintf("%s%s", zTo, pFile->zName[nFrom]); }else{ pNew->zName = fossil_strdup(pFile->zName); } pNew->isExe = pFile->isExe; pNew->isLink = pFile->isLink; pNew->zUuid = fossil_strdup(pFile->zUuid); pNew->isFrom = 0; } }else if( memcmp(zLine, "R ", 2)==0 ){ int nFrom; import_prior_files(); z = &zLine[2]; zFrom = next_token(&z); zTo = rest_of_line(&z); i = 0; nFrom = strlen(zFrom); while( (pFile = import_find_file(zFrom, &i, gg.nFile))!=0 ){ if( pFile->isFrom==0 ) continue; pNew = import_add_file(); pFile = &gg.aFile[i-1]; if( strlen(pFile->zName)>nFrom ){ pNew->zName = mprintf("%s%s", zTo, pFile->zName[nFrom]); }else{ pNew->zName = fossil_strdup(pFile->zName); } pNew->zPrior = pFile->zName; pNew->isExe = pFile->isExe; pNew->isLink = pFile->isLink; pNew->zUuid = pFile->zUuid; pNew->isFrom = 0; gg.nFile--; *pFile = *pNew; memset(pNew, 0, sizeof(*pNew)); } fossil_fatal("cannot handle R records, use --full-tree"); }else if( memcmp(zLine, "deleteall", 9)==0 ){ gg.fromLoaded = 1; }else if( memcmp(zLine, "N ", 2)==0 ){ /* No-op */ }else { goto malformed_line; } } gg.xFinish(); if( gg.hasLinks ){ db_set_int("allow-symlinks", 1, 0); } import_reset(1); return; malformed_line: trim_newline(zLine); fossil_fatal("bad fast-import line: [%s]", zLine); return; }