MVMint64 MVM_file_eof(MVMThreadContext *tc, MVMObject *oshandle) { MVMOSHandle *handle; verify_filehandle_type(tc, oshandle, &handle, "check eof"); return apr_file_eof(handle->body.file_handle) == APR_EOF ? 1 : 0; }
static apr_status_t restore_slotmem(void *ptr, const char *name, apr_size_t size, apr_pool_t *pool) { const char *storename; apr_file_t *fp; apr_size_t nbytes = size; apr_status_t rv = APR_SUCCESS; unsigned char digest[APR_MD5_DIGESTSIZE]; unsigned char digest2[APR_MD5_DIGESTSIZE]; storename = slotmem_filename(pool, name, 1); ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf, APLOGNO(02335) "restoring %s", storename); if (storename) { rv = apr_file_open(&fp, storename, APR_READ | APR_WRITE, APR_OS_DEFAULT, pool); if (rv == APR_SUCCESS) { rv = apr_file_read(fp, ptr, &nbytes); if ((rv == APR_SUCCESS || rv == APR_EOF) && nbytes == size) { rv = APR_SUCCESS; /* for successful return @ EOF */ /* * if at EOF, don't bother checking md5 * - backwards compatibility * */ if (apr_file_eof(fp) != APR_EOF) { apr_size_t ds = APR_MD5_DIGESTSIZE; rv = apr_file_read(fp, digest, &ds); if ((rv == APR_SUCCESS || rv == APR_EOF) && ds == APR_MD5_DIGESTSIZE) { rv = APR_SUCCESS; apr_md5(digest2, ptr, nbytes); if (memcmp(digest, digest2, APR_MD5_DIGESTSIZE)) { ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf, APLOGNO(02551) "bad md5 match"); rv = APR_EGENERAL; } } } else { ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf, APLOGNO(02552) "at EOF... bypassing md5 match check (old persist file?)"); } } else if (nbytes != size) { ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, ap_server_conf, APLOGNO(02553) "Expected %" APR_SIZE_T_FMT ": Read %" APR_SIZE_T_FMT, size, nbytes); rv = APR_EGENERAL; } apr_file_close(fp); } } return rv; }
static apt_bool_t test_file_process(apt_test_suite_t *suite, const char *file_path) { apr_file_t *file; char buffer[500]; apt_text_stream_t stream; rtsp_parser_t *parser; rtsp_generator_t *generator; apr_size_t length; apr_size_t offset; rtsp_message_t *message; apt_message_status_e msg_status; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Open File [%s]",file_path); if(apr_file_open(&file,file_path,APR_FOPEN_READ | APR_FOPEN_BINARY,APR_OS_DEFAULT,suite->pool) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open File"); return FALSE; } parser = rtsp_parser_create(suite->pool); generator = rtsp_generator_create(suite->pool); apt_text_stream_init(&stream,buffer,sizeof(buffer)-1); do { /* calculate offset remaining from the previous receive / if any */ offset = stream.pos - stream.text.buf; /* calculate available length */ length = sizeof(buffer) - 1 - offset; if(apr_file_read(file,stream.pos,&length) != APR_SUCCESS) { break; } /* calculate actual length of the stream */ stream.text.length = offset + length; stream.pos[length] = '\0'; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Parse RTSP Stream [%"APR_SIZE_T_FMT" bytes]\n%s",length,stream.pos); /* reset pos */ apt_text_stream_reset(&stream); do { msg_status = rtsp_parser_run(parser,&stream,&message); rtsp_message_handler(generator,message,msg_status); } while(apt_text_is_eos(&stream) == FALSE); /* scroll remaining stream */ apt_text_stream_scroll(&stream); } while(apr_file_eof(file) != APR_EOF); apr_file_close(file); return TRUE; }
static apt_bool_t test_file_process(apt_test_suite_t *suite, mrcp_resource_factory_t *factory, mrcp_version_e version, const char *file_path) { apr_file_t *file; char buffer[500]; apt_text_stream_t stream; mrcp_parser_t *parser; mrcp_generator_t *generator; apr_size_t length; apr_size_t offset; apt_str_t resource_name; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Open File [%s]",file_path); if(apr_file_open(&file,file_path,APR_FOPEN_READ | APR_FOPEN_BINARY,APR_OS_DEFAULT,suite->pool) != APR_SUCCESS) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Open File"); return FALSE; } parser = mrcp_parser_create(factory,suite->pool); generator = mrcp_generator_create(factory,suite->pool); apt_string_reset(&resource_name); if(version == MRCP_VERSION_1) { resource_name_read(file,parser); } apt_text_stream_init(&stream,buffer,sizeof(buffer)-1); do { /* init length of the stream */ stream.text.length = sizeof(buffer)-1; /* calculate offset remaining from the previous receive / if any */ offset = stream.pos - stream.text.buf; /* calculate available length */ length = stream.text.length - offset; if(apr_file_read(file,stream.pos,&length) != APR_SUCCESS) { break; } /* calculate actual length of the stream */ stream.text.length = offset + length; stream.pos[length] = '\0'; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Parse MRCP Stream [%lu bytes]\n%s",length,stream.pos); /* reset pos */ stream.pos = stream.text.buf; mrcp_stream_walk(parser,&stream,mrcp_message_handler,generator); } while(apr_file_eof(file) != APR_EOF); apr_file_close(file); return TRUE; }
int main(int argc,char **argv) { apr_initialize(); apr_pool_t *pool; apr_pool_create(&pool,NULL); apr_status_t st; char *filename; if(argc > 1) { filename=argv[1]; } else { filename="apr_md5.c"; } apr_md5_ctx_t md5; apr_md5_init(&md5); apr_file_t *file; st=apr_file_open(&file,filename,APR_READ,APR_REG,pool); if(st != APR_SUCCESS) { apr_err("apr_file_open()",st); return st; } apr_size_t n=1024; char *buf=apr_pcalloc(pool,n); while(APR_EOF != apr_file_eof(file)) { n=1024; st=apr_file_read(file,buf,&n); apr_md5_update(&md5,buf,n); } unsigned char result[APR_MD5_DIGESTSIZE]; apr_md5_final(result,&md5); for(int i=0;i<APR_MD5_DIGESTSIZE;i++) { printf("%02x",result[i]); } printf("\n"); apr_file_close(file); apr_pool_destroy(pool); apr_terminate(); return 0; }
static guint svn_cat_command_run (AnjutaCommand *command) { SvnCatCommand *self; SvnCommand *svn_command; svn_opt_revision_t revision; svn_opt_revision_t peg_revision; svn_stream_t *cat_stream; apr_file_t *cat_input; apr_file_t *cat_output; apr_size_t read_size; gchar *line; svn_error_t *error; apr_status_t apr_error; self = SVN_CAT_COMMAND (command); svn_command = SVN_COMMAND (command); apr_file_pipe_create (&cat_output, &cat_input, svn_command_get_pool (svn_command)); apr_file_pipe_timeout_set (cat_output, 0); apr_file_pipe_timeout_set (cat_input, 0); cat_stream = svn_stream_from_aprfile2 (cat_input, FALSE, svn_command_get_pool (svn_command)); revision.kind = svn_opt_revision_number; revision.value.number = self->priv->revision; peg_revision.kind = svn_opt_revision_unspecified; error = svn_client_cat2 (cat_stream, self->priv->path, &peg_revision, &revision, svn_command_get_client_context (svn_command), svn_command_get_pool (svn_command)); if (error) { svn_command_set_error (svn_command, error); return 1; } while (apr_file_eof (cat_output) != APR_EOF) { read_size = 80; line = g_new0 (gchar, (read_size + 1)); apr_error = apr_file_read (cat_output, line, &read_size); if (apr_error) break; if (strlen (line)) { anjuta_async_command_lock (ANJUTA_ASYNC_COMMAND (command)); g_queue_push_tail (self->priv->output, g_strdup (line)); anjuta_async_command_unlock (ANJUTA_ASYNC_COMMAND (command)); g_free (line); anjuta_command_notify_data_arrived (command); } } return 0; }
//----------------------------------------------------------------------------- // loadMotions() //----------------------------------------------------------------------------- BOOL LLKeyframeMotionParam::loadMotions() { //------------------------------------------------------------------------- // Load named file by concatenating the character prefix with the motion name. // Load data into a buffer to be parsed. //------------------------------------------------------------------------- std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix()) + "_" + getName() + ".llp"; //------------------------------------------------------------------------- // open the file //------------------------------------------------------------------------- S32 fileSize = 0; LLAPRFile infile ; infile.open(path, LL_APR_R, NULL, &fileSize); apr_file_t* fp = infile.getFileHandle() ; if (!fp || fileSize == 0) { llinfos << "ERROR: can't open: " << path << llendl; return FALSE; } // allocate a text buffer char *text = new char[ fileSize+1 ]; if ( !text ) { llinfos << "ERROR: can't allocated keyframe text buffer." << llendl; return FALSE; } //------------------------------------------------------------------------- // load data from file into buffer //------------------------------------------------------------------------- bool error = false; char *p = text; while ( 1 ) { if (apr_file_eof(fp) == APR_EOF) { break; } if (apr_file_gets(p, 1024, fp) != APR_SUCCESS) { error = true; break; } while ( *(++p) ) ; } //------------------------------------------------------------------------- // close the file //------------------------------------------------------------------------- infile.close(); //------------------------------------------------------------------------- // check for error //------------------------------------------------------------------------- llassert( p <= (text+fileSize) ); if ( error ) { llinfos << "ERROR: error while reading from " << path << llendl; delete [] text; return FALSE; } llinfos << "Loading parametric keyframe data for: " << getName() << llendl; //------------------------------------------------------------------------- // parse the text and build keyframe data structures //------------------------------------------------------------------------- p = text; S32 num; char strA[80]; /* Flawfinder: ignore */ char strB[80]; /* Flawfinder: ignore */ F32 floatA = 0.0f; //------------------------------------------------------------------------- // get priority //------------------------------------------------------------------------- BOOL isFirstMotion = TRUE; num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */ while(1) { if (num == 0 || num == EOF) break; if ((num != 3)) { llinfos << "WARNING: can't read parametric motion" << llendl; delete [] text; return FALSE; } addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA); if (isFirstMotion) { isFirstMotion = FALSE; setDefaultKeyframeMotion(strA); } p = strstr(p, "\n"); if (!p) { break; } p++; num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */ } delete [] text; return TRUE; }
//----------------------------------------------------------------------------- // loadMotions() //----------------------------------------------------------------------------- BOOL LLKeyframeMotionParam::loadMotions() { //------------------------------------------------------------------------- // Load named file by concatenating the character prefix with the motion name. // Load data into a buffer to be parsed. //------------------------------------------------------------------------- //std::string path = gDirUtilp->getExpandedFilename(LL_PATH_MOTIONS,mCharacter->getAnimationPrefix()) // + "_" + getName() + ".llp"; //RN: deprecated unused reference to "motion" directory std::string path; //------------------------------------------------------------------------- // open the file //------------------------------------------------------------------------- S32 fileSize = 0; LLAPRFile infile ; infile.open(path, LL_APR_R, NULL, &fileSize); // <FS:ND> Remove LLVolatileAPRPool/apr_file_t and use FILE* instead // apr_file_t* fp = infile.getFileHandle() ; LLAPRFile::tFiletype* fp = infile.getFileHandle() ; // </FS:ND> if (!fp || fileSize == 0) { LL_INFOS() << "ERROR: can't open: " << path << LL_ENDL; return FALSE; } // allocate a text buffer std::vector<char> text(fileSize+1); //------------------------------------------------------------------------- // load data from file into buffer //------------------------------------------------------------------------- bool error = false; char *p = &text[0]; while ( 1 ) { if (apr_file_eof(fp) == APR_EOF) { break; } if (apr_file_gets(p, 1024, fp) != APR_SUCCESS) { error = true; break; } while ( *(++p) ) ; } //------------------------------------------------------------------------- // close the file //------------------------------------------------------------------------- infile.close(); //------------------------------------------------------------------------- // check for error //------------------------------------------------------------------------- llassert( p <= (&text[0] + fileSize) ); if ( error ) { LL_INFOS() << "ERROR: error while reading from " << path << LL_ENDL; return FALSE; } LL_INFOS() << "Loading parametric keyframe data for: " << getName() << LL_ENDL; //------------------------------------------------------------------------- // parse the text and build keyframe data structures //------------------------------------------------------------------------- p = &text[0]; S32 num; char strA[80]; /* Flawfinder: ignore */ char strB[80]; /* Flawfinder: ignore */ F32 floatA = 0.0f; //------------------------------------------------------------------------- // get priority //------------------------------------------------------------------------- BOOL isFirstMotion = TRUE; num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */ while(1) { if (num == 0 || num == EOF) break; if ((num != 3)) { LL_INFOS() << "WARNING: can't read parametric motion" << LL_ENDL; return FALSE; } addKeyframeMotion(strA, gAnimLibrary.stringToAnimState(std::string(strA)), strB, floatA); if (isFirstMotion) { isFirstMotion = FALSE; setDefaultKeyframeMotion(strA); } p = strstr(p, "\n"); if (!p) { break; } p++; num = sscanf(p, "%79s %79s %f", strA, strB, &floatA); /* Flawfinder: ignore */ } return TRUE; }
/* Return the next *HUNK from a PATCH in APR_FILE. * If no hunk can be found, set *HUNK to NULL. * Set IS_PROPERTY to TRUE if we have a property hunk. If the returned HUNK * is the first belonging to a certain property, then PROP_NAME and * PROP_OPERATION will be set too. If we have a text hunk, PROP_NAME will be * NULL. If IGNORE_WHITESPACE is TRUE, lines without leading spaces will be * treated as context lines. Allocate results in RESULT_POOL. * Use SCRATCH_POOL for all other allocations. */ static svn_error_t * parse_next_hunk(svn_diff_hunk_t **hunk, svn_boolean_t *is_property, const char **prop_name, svn_diff_operation_kind_t *prop_operation, svn_patch_t *patch, apr_file_t *apr_file, svn_boolean_t ignore_whitespace, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { static const char * const minus = "--- "; static const char * const text_atat = "@@"; static const char * const prop_atat = "##"; svn_stringbuf_t *line; svn_boolean_t eof, in_hunk, hunk_seen; apr_off_t pos, last_line; apr_off_t start, end; apr_off_t original_end; apr_off_t modified_end; svn_linenum_t original_lines; svn_linenum_t modified_lines; svn_linenum_t leading_context; svn_linenum_t trailing_context; svn_boolean_t changed_line_seen; enum { noise_line, original_line, modified_line, context_line } last_line_type; apr_pool_t *iterpool; *prop_operation = svn_diff_op_unchanged; /* We only set this if we have a property hunk header. */ *prop_name = NULL; *is_property = FALSE; if (apr_file_eof(apr_file) == APR_EOF) { /* No more hunks here. */ *hunk = NULL; return SVN_NO_ERROR; } in_hunk = FALSE; hunk_seen = FALSE; leading_context = 0; trailing_context = 0; changed_line_seen = FALSE; original_end = 0; modified_end = 0; *hunk = apr_pcalloc(result_pool, sizeof(**hunk)); /* Get current seek position -- APR has no ftell() :( */ pos = 0; SVN_ERR(svn_io_file_seek(apr_file, APR_CUR, &pos, scratch_pool)); /* Start out assuming noise. */ last_line_type = noise_line; iterpool = svn_pool_create(scratch_pool); do { svn_pool_clear(iterpool); /* Remember the current line's offset, and read the line. */ last_line = pos; SVN_ERR(readline(apr_file, &line, NULL, &eof, APR_SIZE_MAX, iterpool, iterpool)); /* Update line offset for next iteration. */ pos = 0; SVN_ERR(svn_io_file_seek(apr_file, APR_CUR, &pos, iterpool)); /* Lines starting with a backslash are comments, such as * "\ No newline at end of file". */ if (line->data[0] == '\\') { if (in_hunk && ((!*is_property && strcmp(line->data, "\\ No newline at end of file") == 0) || (*is_property && strcmp(line->data, "\\ No newline at end of property") == 0))) { char eolbuf[2]; apr_size_t len; apr_off_t off; apr_off_t hunk_text_end; /* Comment terminates the hunk text and says the hunk text * has no trailing EOL. Snip off trailing EOL which is part * of the patch file but not part of the hunk text. */ off = last_line - 2; SVN_ERR(svn_io_file_seek(apr_file, APR_SET, &off, iterpool)); len = sizeof(eolbuf); SVN_ERR(svn_io_file_read_full2(apr_file, eolbuf, len, &len, &eof, iterpool)); if (eolbuf[0] == '\r' && eolbuf[1] == '\n') hunk_text_end = last_line - 2; else if (eolbuf[1] == '\n' || eolbuf[1] == '\r') hunk_text_end = last_line - 1; else hunk_text_end = last_line; if (last_line_type == original_line && original_end == 0) original_end = hunk_text_end; else if (last_line_type == modified_line && modified_end == 0) modified_end = hunk_text_end; else if (last_line_type == context_line) { if (original_end == 0) original_end = hunk_text_end; if (modified_end == 0) modified_end = hunk_text_end; break; } SVN_ERR(svn_io_file_seek(apr_file, APR_SET, &pos, iterpool)); } continue; } if (in_hunk) { char c; static const char add = '+'; static const char del = '-'; if (! hunk_seen) { /* We're reading the first line of the hunk, so the start * of the line just read is the hunk text's byte offset. */ start = last_line; } c = line->data[0]; if (original_lines > 0 && modified_lines > 0 && ((c == ' ') /* Tolerate chopped leading spaces on empty lines. */ || (! eof && line->len == 0) /* Maybe tolerate chopped leading spaces on non-empty lines. */ || (ignore_whitespace && c != del && c != add))) { /* It's a "context" line in the hunk. */ hunk_seen = TRUE; original_lines--; modified_lines--; if (changed_line_seen) trailing_context++; else leading_context++; last_line_type = context_line; } else if (original_lines > 0 && c == del) { /* It's a "deleted" line in the hunk. */ hunk_seen = TRUE; changed_line_seen = TRUE; /* A hunk may have context in the middle. We only want trailing lines of context. */ if (trailing_context > 0) trailing_context = 0; original_lines--; last_line_type = original_line; } else if (modified_lines > 0 && c == add) { /* It's an "added" line in the hunk. */ hunk_seen = TRUE; changed_line_seen = TRUE; /* A hunk may have context in the middle. We only want trailing lines of context. */ if (trailing_context > 0) trailing_context = 0; modified_lines--; last_line_type = modified_line; } else { if (eof) { /* The hunk ends at EOF. */ end = pos; } else { /* The start of the current line marks the first byte * after the hunk text. */ end = last_line; } if (original_end == 0) original_end = end; if (modified_end == 0) modified_end = end; break; /* Hunk was empty or has been read. */ } } else { if (starts_with(line->data, text_atat)) { /* Looks like we have a hunk header, try to rip it apart. */ in_hunk = parse_hunk_header(line->data, *hunk, text_atat, iterpool); if (in_hunk) { original_lines = (*hunk)->original_length; modified_lines = (*hunk)->modified_length; *is_property = FALSE; } } else if (starts_with(line->data, prop_atat)) { /* Looks like we have a property hunk header, try to rip it * apart. */ in_hunk = parse_hunk_header(line->data, *hunk, prop_atat, iterpool); if (in_hunk) { original_lines = (*hunk)->original_length; modified_lines = (*hunk)->modified_length; *is_property = TRUE; } } else if (starts_with(line->data, "Added: ")) { SVN_ERR(parse_prop_name(prop_name, line->data, "Added: ", result_pool)); if (*prop_name) *prop_operation = svn_diff_op_added; } else if (starts_with(line->data, "Deleted: ")) { SVN_ERR(parse_prop_name(prop_name, line->data, "Deleted: ", result_pool)); if (*prop_name) *prop_operation = svn_diff_op_deleted; } else if (starts_with(line->data, "Modified: ")) { SVN_ERR(parse_prop_name(prop_name, line->data, "Modified: ", result_pool)); if (*prop_name) *prop_operation = svn_diff_op_modified; } else if (starts_with(line->data, minus) || starts_with(line->data, "diff --git ")) /* This could be a header of another patch. Bail out. */ break; } } /* Check for the line length since a file may not have a newline at the * end and we depend upon the last line to be an empty one. */ while (! eof || line->len > 0); svn_pool_destroy(iterpool); if (! eof) /* Rewind to the start of the line just read, so subsequent calls * to this function or svn_diff_parse_next_patch() don't end * up skipping the line -- it may contain a patch or hunk header. */ SVN_ERR(svn_io_file_seek(apr_file, APR_SET, &last_line, scratch_pool)); if (hunk_seen && start < end) { (*hunk)->patch = patch; (*hunk)->apr_file = apr_file; (*hunk)->leading_context = leading_context; (*hunk)->trailing_context = trailing_context; (*hunk)->diff_text_range.start = start; (*hunk)->diff_text_range.current = start; (*hunk)->diff_text_range.end = end; (*hunk)->original_text_range.start = start; (*hunk)->original_text_range.current = start; (*hunk)->original_text_range.end = original_end; (*hunk)->modified_text_range.start = start; (*hunk)->modified_text_range.current = start; (*hunk)->modified_text_range.end = modified_end; } else /* Something went wrong, just discard the result. */ *hunk = NULL; return SVN_NO_ERROR; }
svn_error_t * svn_diff_parse_next_patch(svn_patch_t **patch, svn_patch_file_t *patch_file, svn_boolean_t reverse, svn_boolean_t ignore_whitespace, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { apr_off_t pos, last_line; svn_boolean_t eof; svn_boolean_t line_after_tree_header_read = FALSE; apr_pool_t *iterpool; enum parse_state state = state_start; if (apr_file_eof(patch_file->apr_file) == APR_EOF) { /* No more patches here. */ *patch = NULL; return SVN_NO_ERROR; } *patch = apr_pcalloc(result_pool, sizeof(**patch)); pos = patch_file->next_patch_offset; SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_SET, &pos, scratch_pool)); iterpool = svn_pool_create(scratch_pool); do { svn_stringbuf_t *line; svn_boolean_t valid_header_line = FALSE; int i; svn_pool_clear(iterpool); /* Remember the current line's offset, and read the line. */ last_line = pos; SVN_ERR(readline(patch_file->apr_file, &line, NULL, &eof, APR_SIZE_MAX, iterpool, iterpool)); if (! eof) { /* Update line offset for next iteration. */ pos = 0; SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_CUR, &pos, iterpool)); } /* Run the state machine. */ for (i = 0; i < (sizeof(transitions) / sizeof(transitions[0])); i++) { if (line->len > strlen(transitions[i].expected_input) && starts_with(line->data, transitions[i].expected_input) && state == transitions[i].required_state) { SVN_ERR(transitions[i].fn(&state, line->data, *patch, result_pool, iterpool)); valid_header_line = TRUE; break; } } if (state == state_unidiff_found || state == state_git_header_found) { /* We have a valid diff header, yay! */ break; } else if (state == state_git_tree_seen && line_after_tree_header_read) { /* We have a valid diff header for a patch with only tree changes. * Rewind to the start of the line just read, so subsequent calls * to this function don't end up skipping the line -- it may * contain a patch. */ SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_SET, &last_line, scratch_pool)); break; } else if (state == state_git_tree_seen) { line_after_tree_header_read = TRUE; } else if (! valid_header_line && state != state_start) { /* We've encountered an invalid diff header. * * Rewind to the start of the line just read - it may be a new * header that begins there. */ SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_SET, &last_line, scratch_pool)); state = state_start; } } while (! eof); (*patch)->reverse = reverse; if (reverse) { const char *temp; temp = (*patch)->old_filename; (*patch)->old_filename = (*patch)->new_filename; (*patch)->new_filename = temp; } if ((*patch)->old_filename == NULL || (*patch)->new_filename == NULL) { /* Something went wrong, just discard the result. */ *patch = NULL; } else SVN_ERR(parse_hunks(*patch, patch_file->apr_file, ignore_whitespace, result_pool, iterpool)); svn_pool_destroy(iterpool); patch_file->next_patch_offset = 0; SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_CUR, &patch_file->next_patch_offset, scratch_pool)); if (*patch) { /* Usually, hunks appear in the patch sorted by their original line * offset. But just in case they weren't parsed in this order for * some reason, we sort them so that our caller can assume that hunks * are sorted as if parsed from a usual patch. */ qsort((*patch)->hunks->elts, (*patch)->hunks->nelts, (*patch)->hunks->elt_size, compare_hunks); } return SVN_NO_ERROR; }