Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
# include "cache.h"
# include "builtin.h"
# include "parse-options.h"
# include "refs.h"
# include "commit.h"
# include "tree.h"
# include "tree-walk.h"
2009-04-20 12:58:18 +02:00
# include "cache-tree.h"
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
# include "unpack-trees.h"
# include "dir.h"
# include "run-command.h"
# include "merge-recursive.h"
# include "branch.h"
# include "diff.h"
# include "revision.h"
2008-02-17 02:17:09 +01:00
# include "remote.h"
2008-08-30 16:52:24 +02:00
# include "blob.h"
# include "xdiff-interface.h"
# include "ll-merge.h"
2009-12-25 09:30:51 +01:00
# include "resolve-undo.h"
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
static const char * const checkout_usage [ ] = {
" git checkout [options] <branch> " ,
" git checkout [options] [<branch>] -- <file>... " ,
NULL ,
} ;
2008-08-30 16:46:55 +02:00
struct checkout_opts {
int quiet ;
int merge ;
int force ;
2008-08-30 16:48:18 +02:00
int writeout_stage ;
2008-08-30 16:46:55 +02:00
int writeout_error ;
const char * new_branch ;
int new_branch_log ;
enum branch_track track ;
} ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
static int post_checkout_hook ( struct commit * old , struct commit * new ,
int changed )
{
2009-01-16 20:09:59 +01:00
return run_hook ( NULL , " post-checkout " ,
sha1_to_hex ( old ? old - > object . sha1 : null_sha1 ) ,
sha1_to_hex ( new ? new - > object . sha1 : null_sha1 ) ,
changed ? " 1 " : " 0 " , NULL ) ;
2009-01-16 20:09:58 +01:00
/* "new" can be NULL when checking out from the index before
a commit exists . */
2009-01-16 20:09:59 +01:00
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
static int update_some ( const unsigned char * sha1 , const char * base , int baselen ,
2008-07-14 21:22:12 +02:00
const char * pathname , unsigned mode , int stage , void * context )
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
{
int len ;
struct cache_entry * ce ;
if ( S_ISDIR ( mode ) )
return READ_TREE_RECURSIVE ;
len = baselen + strlen ( pathname ) ;
ce = xcalloc ( 1 , cache_entry_size ( len ) ) ;
hashcpy ( ce - > sha1 , sha1 ) ;
memcpy ( ce - > name , base , baselen ) ;
memcpy ( ce - > name + baselen , pathname , len - baselen ) ;
ce - > ce_flags = create_ce_flags ( len , 0 ) ;
ce - > ce_mode = create_ce_mode ( mode ) ;
add_cache_entry ( ce , ADD_CACHE_OK_TO_ADD | ADD_CACHE_OK_TO_REPLACE ) ;
return 0 ;
}
static int read_tree_some ( struct tree * tree , const char * * pathspec )
{
2008-07-14 21:22:12 +02:00
read_tree_recursive ( tree , " " , 0 , 0 , pathspec , update_some , NULL ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
/* update the index with the given tree's info
* for all args , expanding wildcards , and exit
* with any non - zero return code .
*/
return 0 ;
}
2008-08-29 22:40:36 +02:00
static int skip_same_name ( struct cache_entry * ce , int pos )
{
while ( + + pos < active_nr & &
! strcmp ( active_cache [ pos ] - > name , ce - > name ) )
; /* skip */
return pos ;
}
2008-08-30 16:48:18 +02:00
static int check_stage ( int stage , struct cache_entry * ce , int pos )
{
while ( pos < active_nr & &
! strcmp ( active_cache [ pos ] - > name , ce - > name ) ) {
if ( ce_stage ( active_cache [ pos ] ) = = stage )
return 0 ;
pos + + ;
}
return error ( " path '%s' does not have %s version " ,
ce - > name ,
( stage = = 2 ) ? " our " : " their " ) ;
}
2008-08-30 16:52:24 +02:00
static int check_all_stages ( struct cache_entry * ce , int pos )
{
if ( ce_stage ( ce ) ! = 1 | |
active_nr < = pos + 2 | |
strcmp ( active_cache [ pos + 1 ] - > name , ce - > name ) | |
ce_stage ( active_cache [ pos + 1 ] ) ! = 2 | |
strcmp ( active_cache [ pos + 2 ] - > name , ce - > name ) | |
ce_stage ( active_cache [ pos + 2 ] ) ! = 3 )
return error ( " path '%s' does not have all three versions " ,
ce - > name ) ;
return 0 ;
}
2008-08-30 16:48:18 +02:00
static int checkout_stage ( int stage , struct cache_entry * ce , int pos ,
struct checkout * state )
{
while ( pos < active_nr & &
! strcmp ( active_cache [ pos ] - > name , ce - > name ) ) {
if ( ce_stage ( active_cache [ pos ] ) = = stage )
return checkout_entry ( active_cache [ pos ] , state , NULL ) ;
pos + + ;
}
return error ( " path '%s' does not have %s version " ,
ce - > name ,
( stage = = 2 ) ? " our " : " their " ) ;
}
2008-08-29 22:40:36 +02:00
2008-08-30 16:52:24 +02:00
/* NEEDSWORK: share with merge-recursive */
static void fill_mm ( const unsigned char * sha1 , mmfile_t * mm )
{
unsigned long size ;
enum object_type type ;
if ( ! hashcmp ( sha1 , null_sha1 ) ) {
mm - > ptr = xstrdup ( " " ) ;
mm - > size = 0 ;
return ;
}
mm - > ptr = read_sha1_file ( sha1 , & type , & size ) ;
if ( ! mm - > ptr | | type ! = OBJ_BLOB )
die ( " unable to read blob object %s " , sha1_to_hex ( sha1 ) ) ;
mm - > size = size ;
}
static int checkout_merged ( int pos , struct checkout * state )
{
struct cache_entry * ce = active_cache [ pos ] ;
const char * path = ce - > name ;
mmfile_t ancestor , ours , theirs ;
int status ;
unsigned char sha1 [ 20 ] ;
mmbuffer_t result_buf ;
if ( ce_stage ( ce ) ! = 1 | |
active_nr < = pos + 2 | |
strcmp ( active_cache [ pos + 1 ] - > name , path ) | |
ce_stage ( active_cache [ pos + 1 ] ) ! = 2 | |
strcmp ( active_cache [ pos + 2 ] - > name , path ) | |
ce_stage ( active_cache [ pos + 2 ] ) ! = 3 )
return error ( " path '%s' does not have all 3 versions " , path ) ;
fill_mm ( active_cache [ pos ] - > sha1 , & ancestor ) ;
fill_mm ( active_cache [ pos + 1 ] - > sha1 , & ours ) ;
fill_mm ( active_cache [ pos + 2 ] - > sha1 , & theirs ) ;
status = ll_merge ( & result_buf , path , & ancestor ,
& ours , " ours " , & theirs , " theirs " , 1 ) ;
free ( ancestor . ptr ) ;
free ( ours . ptr ) ;
free ( theirs . ptr ) ;
if ( status < 0 | | ! result_buf . ptr ) {
free ( result_buf . ptr ) ;
return error ( " path '%s': cannot merge " , path ) ;
}
/*
* NEEDSWORK :
* There is absolutely no reason to write this as a blob object
2009-04-17 20:13:30 +02:00
* and create a phony cache entry just to leak . This hack is
2008-08-30 16:52:24 +02:00
* primarily to get to the write_entry ( ) machinery that massages
* the contents to work - tree format and writes out which only
* allows it for a cache entry . The code in write_entry ( ) needs
* to be refactored to allow us to feed a < buffer , size , mode >
* instead of a cache entry . Such a refactoring would help
* merge_recursive as well ( it also writes the merge result to the
* object database even when it may contain conflicts ) .
*/
if ( write_sha1_file ( result_buf . ptr , result_buf . size ,
blob_type , sha1 ) )
die ( " Unable to add merge result for '%s' " , path ) ;
ce = make_cache_entry ( create_ce_mode ( active_cache [ pos + 1 ] - > ce_mode ) ,
sha1 ,
path , 2 , 0 ) ;
2008-10-05 04:14:40 +02:00
if ( ! ce )
die ( " make_cache_entry failed for path '%s' " , path ) ;
2008-08-30 16:52:24 +02:00
status = checkout_entry ( ce , state , NULL ) ;
return status ;
}
2008-08-29 22:40:36 +02:00
2008-08-30 16:46:55 +02:00
static int checkout_paths ( struct tree * source_tree , const char * * pathspec ,
struct checkout_opts * opts )
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
{
int pos ;
struct checkout state ;
static char * ps_matched ;
unsigned char rev [ 20 ] ;
int flag ;
struct commit * head ;
2008-05-28 23:48:57 +02:00
int errs = 0 ;
2008-08-30 16:48:18 +02:00
int stage = opts - > writeout_stage ;
2008-08-30 16:52:24 +02:00
int merge = opts - > merge ;
2008-02-28 22:52:44 +01:00
int newfd ;
struct lock_file * lock_file = xcalloc ( 1 , sizeof ( struct lock_file ) ) ;
newfd = hold_locked_index ( lock_file , 1 ) ;
2009-05-10 00:11:17 +02:00
if ( read_cache_preload ( pathspec ) < 0 )
2008-12-06 02:54:10 +01:00
return error ( " corrupt index file " ) ;
2008-02-28 22:52:44 +01:00
if ( source_tree )
read_tree_some ( source_tree , pathspec ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
for ( pos = 0 ; pathspec [ pos ] ; pos + + )
;
ps_matched = xcalloc ( 1 , pos ) ;
for ( pos = 0 ; pos < active_nr ; pos + + ) {
struct cache_entry * ce = active_cache [ pos ] ;
2009-01-14 15:54:35 +01:00
match_pathspec ( pathspec , ce - > name , ce_namelen ( ce ) , 0 , ps_matched ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
if ( report_path_error ( ps_matched , pathspec , 0 ) )
return 1 ;
2008-08-29 22:40:36 +02:00
/* Any unmerged paths? */
for ( pos = 0 ; pos < active_nr ; pos + + ) {
struct cache_entry * ce = active_cache [ pos ] ;
2009-01-14 15:54:35 +01:00
if ( match_pathspec ( pathspec , ce - > name , ce_namelen ( ce ) , 0 , NULL ) ) {
2008-08-29 22:40:36 +02:00
if ( ! ce_stage ( ce ) )
continue ;
2008-08-30 16:46:55 +02:00
if ( opts - > force ) {
warning ( " path '%s' is unmerged " , ce - > name ) ;
2008-08-30 16:48:18 +02:00
} else if ( stage ) {
errs | = check_stage ( stage , ce , pos ) ;
2008-08-30 16:52:24 +02:00
} else if ( opts - > merge ) {
errs | = check_all_stages ( ce , pos ) ;
2008-08-30 16:46:55 +02:00
} else {
errs = 1 ;
error ( " path '%s' is unmerged " , ce - > name ) ;
}
2008-08-29 22:40:36 +02:00
pos = skip_same_name ( ce , pos ) - 1 ;
}
}
if ( errs )
return 1 ;
2008-05-28 23:48:57 +02:00
/* Now we are committed to check them out */
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
memset ( & state , 0 , sizeof ( state ) ) ;
state . force = 1 ;
state . refresh_cache = 1 ;
for ( pos = 0 ; pos < active_nr ; pos + + ) {
struct cache_entry * ce = active_cache [ pos ] ;
2009-01-14 15:54:35 +01:00
if ( match_pathspec ( pathspec , ce - > name , ce_namelen ( ce ) , 0 , NULL ) ) {
2008-08-29 22:40:36 +02:00
if ( ! ce_stage ( ce ) ) {
errs | = checkout_entry ( ce , & state , NULL ) ;
continue ;
}
2008-08-30 16:48:18 +02:00
if ( stage )
errs | = checkout_stage ( stage , ce , pos , & state ) ;
2008-08-30 16:52:24 +02:00
else if ( merge )
errs | = checkout_merged ( pos , & state ) ;
2008-08-29 22:40:36 +02:00
pos = skip_same_name ( ce , pos ) - 1 ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
}
2008-02-28 22:52:44 +01:00
if ( write_cache ( newfd , active_cache , active_nr ) | |
commit_locked_index ( lock_file ) )
die ( " unable to write new index file " ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
resolve_ref ( " HEAD " , rev , 0 , & flag ) ;
head = lookup_commit_reference_gently ( rev , 1 ) ;
2008-05-28 23:48:57 +02:00
errs | = post_checkout_hook ( head , head , 0 ) ;
return errs ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
static void show_local_changes ( struct object * head )
{
struct rev_info rev ;
/* I think we want full paths, even if we're in a subdirectory. */
init_revisions ( & rev , NULL ) ;
rev . abbrev = 0 ;
rev . diffopt . output_format | = DIFF_FORMAT_NAME_STATUS ;
2009-02-17 03:59:00 +01:00
if ( diff_setup_done ( & rev . diffopt ) < 0 )
die ( " diff_setup_done failed " ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
add_pending_object ( & rev , head , NULL ) ;
run_diff_index ( & rev , 0 ) ;
}
static void describe_detached_head ( char * msg , struct commit * commit )
{
2008-10-09 21:12:12 +02:00
struct strbuf sb = STRBUF_INIT ;
2009-10-19 17:48:08 +02:00
struct pretty_print_context ctx = { 0 } ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
parse_commit ( commit ) ;
2009-10-19 17:48:08 +02:00
pretty_print_commit ( CMIT_FMT_ONELINE , commit , & sb , & ctx ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
fprintf ( stderr , " %s %s... %s \n " , msg ,
find_unique_abbrev ( commit - > object . sha1 , DEFAULT_ABBREV ) , sb . buf ) ;
strbuf_release ( & sb ) ;
}
2008-05-28 23:59:40 +02:00
static int reset_tree ( struct tree * tree , struct checkout_opts * o , int worktree )
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
{
struct unpack_trees_options opts ;
struct tree_desc tree_desc ;
2008-03-06 21:26:14 +01:00
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
memset ( & opts , 0 , sizeof ( opts ) ) ;
opts . head_idx = - 1 ;
2008-05-28 23:59:40 +02:00
opts . update = worktree ;
opts . skip_unmerged = ! worktree ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
opts . reset = 1 ;
opts . merge = 1 ;
opts . fn = oneway_merge ;
2008-05-28 23:59:40 +02:00
opts . verbose_update = ! o - > quiet ;
2008-03-07 03:12:28 +01:00
opts . src_index = & the_index ;
opts . dst_index = & the_index ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
parse_tree ( tree ) ;
init_tree_desc ( & tree_desc , tree - > buffer , tree - > size ) ;
2008-05-29 00:26:59 +02:00
switch ( unpack_trees ( 1 , & tree_desc , & opts ) ) {
case - 2 :
o - > writeout_error = 1 ;
/*
* We return 0 nevertheless , as the index is all right
* and more importantly we have made best efforts to
* update paths in the work tree , and we cannot revert
* them .
*/
case 0 :
return 0 ;
default :
2008-05-28 23:54:02 +02:00
return 128 ;
2008-05-29 00:26:59 +02:00
}
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
struct branch_info {
const char * name ; /* The short name used */
const char * path ; /* The full name of a real branch */
struct commit * commit ; /* The named commit */
} ;
static void setup_branch_path ( struct branch_info * branch )
{
2008-10-09 21:12:12 +02:00
struct strbuf buf = STRBUF_INIT ;
2009-01-17 17:09:53 +01:00
2009-03-21 21:17:30 +01:00
strbuf_branchname ( & buf , branch - > name ) ;
if ( strcmp ( buf . buf , branch - > name ) )
2009-01-17 17:09:53 +01:00
branch - > name = xstrdup ( buf . buf ) ;
2009-03-21 21:17:30 +01:00
strbuf_splice ( & buf , 0 , 0 , " refs/heads/ " , 11 ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
branch - > path = strbuf_detach ( & buf , NULL ) ;
}
static int merge_working_tree ( struct checkout_opts * opts ,
2008-02-21 16:50:42 +01:00
struct branch_info * old , struct branch_info * new )
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
{
int ret ;
struct lock_file * lock_file = xcalloc ( 1 , sizeof ( struct lock_file ) ) ;
int newfd = hold_locked_index ( lock_file , 1 ) ;
2008-12-06 02:54:10 +01:00
2009-05-10 00:11:17 +02:00
if ( read_cache_preload ( NULL ) < 0 )
2008-12-06 02:54:10 +01:00
return error ( " corrupt index file " ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
2009-12-25 09:30:51 +01:00
resolve_undo_clear ( ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( opts - > force ) {
2008-05-28 23:59:40 +02:00
ret = reset_tree ( new - > commit - > tree , opts , 1 ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( ret )
return ret ;
} else {
struct tree_desc trees [ 2 ] ;
struct tree * tree ;
struct unpack_trees_options topts ;
2008-03-06 21:26:14 +01:00
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
memset ( & topts , 0 , sizeof ( topts ) ) ;
topts . head_idx = - 1 ;
2008-03-07 03:12:28 +01:00
topts . src_index = & the_index ;
topts . dst_index = & the_index ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
2008-05-17 21:03:49 +02:00
topts . msgs . not_uptodate_file = " You have local changes to '%s'; cannot switch branches. " ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
refresh_cache ( REFRESH_QUIET ) ;
if ( unmerged_cache ( ) ) {
2008-02-24 00:45:19 +01:00
error ( " you need to resolve your current index first " ) ;
return 1 ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
2008-02-24 00:45:19 +01:00
/* 2-way merge to the new branch */
checkout: Fix "initial checkout" detection
Earlier commit 5521883 (checkout: do not lose staged removal, 2008-09-07)
tightened the rule to prevent switching branches from losing local
changes, so that staged removal of paths can be protected, while
attempting to keep a loophole to still allow a special case of switching
out of an un-checked-out state.
However, the loophole was made a bit too tight, and did not allow
switching from one branch (in an un-checked-out state) to check out
another branch.
The change to builtin-checkout.c in this commit loosens it to allow this,
by not insisting the original commit and the new commit to be the same.
It also introduces a new function, is_index_unborn (and an associated
macro, is_cache_unborn), to check if the repository is truly in an
un-checked-out state more reliably, by making sure that $GIT_INDEX_FILE
did not exist when populating the in-core index structure. A few places
the earlier commit 5521883 added the check for the initial checkout
condition are updated to use this function.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-11-12 20:52:35 +01:00
topts . initial_checkout = is_cache_unborn ( ) ;
2008-02-24 00:45:19 +01:00
topts . update = 1 ;
topts . merge = 1 ;
topts . gently = opts - > merge ;
topts . verbose_update = ! opts - > quiet ;
topts . fn = twoway_merge ;
topts . dir = xcalloc ( 1 , sizeof ( * topts . dir ) ) ;
2009-02-16 13:20:25 +01:00
topts . dir - > flags | = DIR_SHOW_IGNORED ;
2008-02-24 00:45:19 +01:00
topts . dir - > exclude_per_dir = " .gitignore " ;
checkout: do not imply "-f" on unborn branches
When checkout sees that HEAD points to a non-existent ref,
it currently acts as if "-f" was given; this behavior dates
back to 5a03e7f, which enabled checkout from unborn branches
in the shell version of "git-checkout". The reasoning given
is to avoid the code path which tries to merge the tree
contents. When checkout was converted to C, this code
remained intact.
The unfortunate side effect of this strategy is that the
"force" code path will overwrite working tree and index
state that may be precious to the user. Instead of enabling
"force", this patch uses the normal "merge" codepath for an
unborn branch, but substitutes the empty tree for the "old"
commit.
This means that in the absence of an index, any files in the
working tree will be treated as untracked files, and a
checkout which would overwrite them is aborted. Similarly,
any paths in the index will be merged with an empty entry
as the base, meaning that unless the new branch's content is
identical to what's in the index, there will be a conflict
and the checkout will be aborted.
The user is then free to correct the situation or proceed
with "-f" as appropriate.
This patch also removes the "warning: you are on a branch
yet to be born" message. Its function was to warn the user
that we were enabling the "-f" option. Since we are no
longer doing that, there is no reason for the user to care
whether we are switching away from an unborn branch.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-08-25 05:03:16 +02:00
tree = parse_tree_indirect ( old - > commit ?
old - > commit - > object . sha1 :
( unsigned char * ) EMPTY_TREE_SHA1_BIN ) ;
2008-02-24 00:45:19 +01:00
init_tree_desc ( & trees [ 0 ] , tree - > buffer , tree - > size ) ;
tree = parse_tree_indirect ( new - > commit - > object . sha1 ) ;
init_tree_desc ( & trees [ 1 ] , tree - > buffer , tree - > size ) ;
2008-05-29 00:26:59 +02:00
ret = unpack_trees ( 2 , trees , & topts ) ;
2009-05-12 18:41:28 +02:00
if ( ret = = - 1 ) {
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
/*
* Unpack couldn ' t do a trivial merge ; either
* give up or do a real merge , depending on
* whether the merge flag was used .
*/
struct tree * result ;
struct tree * work ;
2008-08-25 16:25:57 +02:00
struct merge_options o ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( ! opts - > merge )
return 1 ;
parse_commit ( old - > commit ) ;
/* Do more real merge */
/*
* We update the index fully , then write the
* tree from the index , then merge the new
* branch with the current tree , with the old
* branch as the base . Then we reset the index
* ( but not the working tree ) to the new
* branch , leaving the working tree as the
* merged version , but skipping unmerged
* entries in the index .
*/
2008-05-12 19:58:10 +02:00
add_files_to_cache ( NULL , NULL , 0 ) ;
2008-08-25 16:25:57 +02:00
init_merge_options ( & o ) ;
o . verbosity = 0 ;
work = write_tree_from_memory ( & o ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
2008-05-28 23:59:40 +02:00
ret = reset_tree ( new - > commit - > tree , opts , 1 ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( ret )
return ret ;
2008-08-25 16:25:57 +02:00
o . branch1 = new - > name ;
o . branch2 = " local " ;
merge_trees ( & o , new - > commit - > tree , work ,
old - > commit - > tree , & result ) ;
2008-05-28 23:59:40 +02:00
ret = reset_tree ( new - > commit - > tree , opts , 0 ) ;
2008-05-28 23:54:02 +02:00
if ( ret )
return ret ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
}
if ( write_cache ( newfd , active_cache , active_nr ) | |
commit_locked_index ( lock_file ) )
die ( " unable to write new index file " ) ;
2008-09-25 10:35:38 +02:00
if ( ! opts - > force & & ! opts - > quiet )
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
show_local_changes ( & new - > commit - > object ) ;
return 0 ;
}
2008-07-02 09:51:18 +02:00
static void report_tracking ( struct branch_info * new )
2008-02-17 02:17:09 +01:00
{
2008-07-02 09:51:18 +02:00
struct strbuf sb = STRBUF_INIT ;
2008-02-21 04:42:53 +01:00
struct branch * branch = branch_get ( new - > name ) ;
2008-02-17 02:17:09 +01:00
2008-07-02 09:51:18 +02:00
if ( ! format_tracking_info ( branch , & sb ) )
2008-02-17 02:17:09 +01:00
return ;
2008-07-02 09:51:18 +02:00
fputs ( sb . buf , stdout ) ;
strbuf_release ( & sb ) ;
2008-02-21 00:05:23 +01:00
}
2008-02-17 02:17:09 +01:00
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
static void update_refs_for_switch ( struct checkout_opts * opts ,
struct branch_info * old ,
struct branch_info * new )
{
2008-10-09 21:12:12 +02:00
struct strbuf msg = STRBUF_INIT ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
const char * old_desc ;
if ( opts - > new_branch ) {
create_branch ( old - > name , opts - > new_branch , new - > name , 0 ,
opts - > new_branch_log , opts - > track ) ;
new - > name = opts - > new_branch ;
setup_branch_path ( new ) ;
}
old_desc = old - > name ;
2008-11-08 13:03:59 +01:00
if ( ! old_desc & & old - > commit )
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
old_desc = sha1_to_hex ( old - > commit - > object . sha1 ) ;
strbuf_addf ( & msg , " checkout: moving from %s to %s " ,
2008-11-08 13:03:59 +01:00
old_desc ? old_desc : " (invalid) " , new - > name ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( new - > path ) {
create_symref ( " HEAD " , new - > path , msg . buf ) ;
if ( ! opts - > quiet ) {
if ( old - > path & & ! strcmp ( new - > path , old - > path ) )
2009-03-21 10:00:54 +01:00
fprintf ( stderr , " Already on '%s' \n " ,
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
new - > name ) ;
else
2009-03-21 10:00:54 +01:00
fprintf ( stderr , " Switched to%s branch '%s' \n " ,
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
opts - > new_branch ? " a new " : " " ,
new - > name ) ;
}
} else if ( strcmp ( new - > name , " HEAD " ) ) {
update_ref ( msg . buf , " HEAD " , new - > commit - > object . sha1 , NULL ,
REF_NODEREF , DIE_ON_ERR ) ;
if ( ! opts - > quiet ) {
if ( old - > path )
2009-03-21 10:00:54 +01:00
fprintf ( stderr , " Note: moving to '%s' which isn't a local branch \n If you want to create a new branch from this checkout, you may do so \n (now or later) by using -b with the checkout command again. Example: \n git checkout -b <new_branch_name> \n " , new - > name ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
describe_detached_head ( " HEAD is now at " , new - > commit ) ;
}
}
remove_branch_state ( ) ;
strbuf_release ( & msg ) ;
2008-02-21 00:05:23 +01:00
if ( ! opts - > quiet & & ( new - > path | | ! strcmp ( new - > name , " HEAD " ) ) )
2008-07-02 09:51:18 +02:00
report_tracking ( new ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
2008-02-21 16:50:42 +01:00
static int switch_branches ( struct checkout_opts * opts , struct branch_info * new )
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
{
int ret = 0 ;
struct branch_info old ;
unsigned char rev [ 20 ] ;
int flag ;
memset ( & old , 0 , sizeof ( old ) ) ;
old . path = resolve_ref ( " HEAD " , rev , 0 , & flag ) ;
old . commit = lookup_commit_reference_gently ( rev , 1 ) ;
if ( ! ( flag & REF_ISSYMREF ) )
old . path = NULL ;
if ( old . path & & ! prefixcmp ( old . path , " refs/heads/ " ) )
old . name = old . path + strlen ( " refs/heads/ " ) ;
if ( ! new - > name ) {
new - > name = " HEAD " ;
new - > commit = old . commit ;
if ( ! new - > commit )
die ( " You are on a branch yet to be born " ) ;
parse_commit ( new - > commit ) ;
}
2008-02-21 16:50:42 +01:00
ret = merge_working_tree ( opts , & old , new ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( ret )
return ret ;
2009-05-16 19:54:45 +02:00
/*
* If we were on a detached HEAD , but have now moved to
* a new commit , we want to mention the old commit once more
* to remind the user that it might be lost .
*/
if ( ! opts - > quiet & & ! old . path & & old . commit & & new - > commit ! = old . commit )
describe_detached_head ( " Previous HEAD position was " , old . commit ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
update_refs_for_switch ( opts , & old , new ) ;
2008-05-29 00:26:59 +02:00
ret = post_checkout_hook ( old . commit , new - > commit , 1 ) ;
return ret | | opts - > writeout_error ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
2008-08-30 16:52:24 +02:00
static int git_checkout_config ( const char * var , const char * value , void * cb )
{
return git_xmerge_config ( var , value , cb ) ;
}
2009-08-15 13:48:30 +02:00
static int interactive_checkout ( const char * revision , const char * * pathspec ,
struct checkout_opts * opts )
{
return run_add_interactive ( revision , " --patch=checkout " , pathspec ) ;
}
2009-10-18 09:13:47 +02:00
struct tracking_name_data {
const char * name ;
char * remote ;
int unique ;
} ;
static int check_tracking_name ( const char * refname , const unsigned char * sha1 ,
int flags , void * cb_data )
{
struct tracking_name_data * cb = cb_data ;
const char * slash ;
if ( prefixcmp ( refname , " refs/remotes/ " ) )
return 0 ;
slash = strchr ( refname + 13 , ' / ' ) ;
if ( ! slash | | strcmp ( slash + 1 , cb - > name ) )
return 0 ;
if ( cb - > remote ) {
cb - > unique = 0 ;
return 0 ;
}
cb - > remote = xstrdup ( refname ) ;
return 0 ;
}
static const char * unique_tracking_name ( const char * name )
{
struct tracking_name_data cb_data = { name , NULL , 1 } ;
for_each_ref ( check_tracking_name , & cb_data ) ;
if ( cb_data . unique )
return cb_data . remote ;
free ( cb_data . remote ) ;
return NULL ;
}
2009-08-15 13:48:30 +02:00
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
int cmd_checkout ( int argc , const char * * argv , const char * prefix )
{
struct checkout_opts opts ;
unsigned char rev [ 20 ] ;
const char * arg ;
struct branch_info new ;
struct tree * source_tree = NULL ;
2008-09-01 04:32:40 +02:00
char * conflict_style = NULL ;
2009-08-15 13:48:30 +02:00
int patch_mode = 0 ;
2009-10-18 09:49:23 +02:00
int dwim_new_local_branch = 1 ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
struct option options [ ] = {
OPT__QUIET ( & opts . quiet ) ,
OPT_STRING ( ' b ' , NULL , & opts . new_branch , " new branch " , " branch " ) ,
OPT_BOOLEAN ( ' l ' , NULL , & opts . new_branch_log , " log for new branch " ) ,
2008-04-24 01:04:48 +02:00
OPT_SET_INT ( ' t ' , " track " , & opts . track , " track " ,
2008-02-19 17:24:37 +01:00
BRANCH_TRACK_EXPLICIT ) ,
2008-08-30 16:48:18 +02:00
OPT_SET_INT ( ' 2 ' , " ours " , & opts . writeout_stage , " stage " ,
2 ) ,
OPT_SET_INT ( ' 3 ' , " theirs " , & opts . writeout_stage , " stage " ,
3 ) ,
2009-08-29 11:05:00 +02:00
OPT_BOOLEAN ( ' f ' , " force " , & opts . force , " force " ) ,
2008-09-01 04:32:40 +02:00
OPT_BOOLEAN ( ' m ' , " merge " , & opts . merge , " merge " ) ,
OPT_STRING ( 0 , " conflict " , & conflict_style , " style " ,
" conflict style (merge or diff3) " ) ,
2009-08-15 13:48:30 +02:00
OPT_BOOLEAN ( ' p ' , " patch " , & patch_mode , " select hunks interactively " ) ,
2009-10-18 09:49:23 +02:00
{ OPTION_BOOLEAN , 0 , " guess " , & dwim_new_local_branch , NULL ,
" second guess 'git checkout no-such-branch' " ,
PARSE_OPT_NOARG | PARSE_OPT_HIDDEN } ,
2008-02-18 11:20:20 +01:00
OPT_END ( ) ,
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
} ;
2008-07-23 12:15:33 +02:00
int has_dash_dash ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
memset ( & opts , 0 , sizeof ( opts ) ) ;
memset ( & new , 0 , sizeof ( new ) ) ;
2008-08-30 16:52:24 +02:00
git_config ( git_checkout_config , NULL ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
2008-08-21 19:23:20 +02:00
opts . track = BRANCH_TRACK_UNSPECIFIED ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
2009-05-23 20:53:12 +02:00
argc = parse_options ( argc , argv , prefix , options , checkout_usage ,
2008-07-23 12:15:32 +02:00
PARSE_OPT_KEEP_DASHDASH ) ;
2008-07-23 12:15:33 +02:00
2009-08-15 13:48:30 +02:00
if ( patch_mode & & ( opts . track > 0 | | opts . new_branch
| | opts . new_branch_log | | opts . merge | | opts . force ) )
die ( " --patch is incompatible with all other options " ) ;
2008-08-09 16:00:12 +02:00
/* --track without -b should DWIM */
2008-08-21 19:23:20 +02:00
if ( 0 < opts . track & & ! opts . new_branch ) {
const char * argv0 = argv [ 0 ] ;
if ( ! argc | | ! strcmp ( argv0 , " -- " ) )
2008-08-09 16:00:12 +02:00
die ( " --track needs a branch name " ) ;
2008-08-21 19:23:20 +02:00
if ( ! prefixcmp ( argv0 , " refs/ " ) )
argv0 + = 5 ;
if ( ! prefixcmp ( argv0 , " remotes/ " ) )
argv0 + = 8 ;
argv0 = strchr ( argv0 , ' / ' ) ;
if ( ! argv0 | | ! argv0 [ 1 ] )
2008-08-09 16:00:12 +02:00
die ( " Missing branch name; try -b " ) ;
2008-08-21 19:23:20 +02:00
opts . new_branch = argv0 + 1 ;
2008-08-09 16:00:12 +02:00
}
2008-09-01 04:32:40 +02:00
if ( conflict_style ) {
opts . merge = 1 ; /* implied */
git_xmerge_config ( " merge.conflictstyle " , conflict_style , NULL ) ;
}
2008-07-23 12:15:33 +02:00
if ( opts . force & & opts . merge )
die ( " git checkout: -f and -m are incompatible " ) ;
/*
* case 1 : git checkout < ref > - - [ < paths > ]
*
* < ref > must be a valid tree , everything after the ' - - ' must be
* a path .
*
* case 2 : git checkout - - [ < paths > ]
*
* everything after the ' - - ' must be paths .
*
* case 3 : git checkout < something > [ < paths > ]
*
* With no paths , if < something > is a commit , that is to
* switch to the branch or detach HEAD at it .
*
2009-10-18 09:13:47 +02:00
* With no paths , if < something > is _not_ a commit , no - t nor - b
* was given , and there is a tracking branch whose name is
* < something > in one and only one remote , then this is a short - hand
* to fork local < something > from that remote tracking branch .
*
2008-07-23 12:15:33 +02:00
* Otherwise < something > shall not be ambiguous .
* - If it ' s * only * a reference , treat it like case ( 1 ) .
* - If it ' s only a path , treat it like case ( 2 ) .
* - else : fail .
*
*/
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( argc ) {
2008-07-23 12:15:33 +02:00
if ( ! strcmp ( argv [ 0 ] , " -- " ) ) { /* case (2) */
argv + + ;
argc - - ;
goto no_reference ;
}
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
arg = argv [ 0 ] ;
2008-07-23 12:15:33 +02:00
has_dash_dash = ( argc > 1 ) & & ! strcmp ( argv [ 1 ] , " -- " ) ;
2009-01-17 17:09:56 +01:00
if ( ! strcmp ( arg , " - " ) )
arg = " @{-1} " ;
2008-07-23 12:15:33 +02:00
if ( get_sha1 ( arg , rev ) ) {
if ( has_dash_dash ) /* case (1) */
die ( " invalid reference: %s " , arg ) ;
2009-10-18 09:13:47 +02:00
if ( ! patch_mode & &
2009-10-18 09:49:23 +02:00
dwim_new_local_branch & &
2009-10-18 09:13:47 +02:00
opts . track = = BRANCH_TRACK_UNSPECIFIED & &
! opts . new_branch & &
! check_filename ( NULL , arg ) & &
argc = = 1 ) {
const char * remote = unique_tracking_name ( arg ) ;
if ( ! remote | | get_sha1 ( remote , rev ) )
goto no_reference ;
opts . new_branch = arg ;
arg = remote ;
/* DWIMmed to create local branch */
}
else
goto no_reference ;
2008-07-23 12:15:33 +02:00
}
/* we can't end up being in (2) anymore, eat the argument */
argv + + ;
argc - - ;
2009-01-03 13:07:32 +01:00
new . name = arg ;
2008-07-23 12:15:33 +02:00
if ( ( new . commit = lookup_commit_reference_gently ( rev , 1 ) ) ) {
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
setup_branch_path ( & new ) ;
if ( resolve_ref ( new . path , rev , 1 , NULL ) )
new . commit = lookup_commit_reference ( rev ) ;
else
new . path = NULL ;
parse_commit ( new . commit ) ;
source_tree = new . commit - > tree ;
2008-07-23 12:15:33 +02:00
} else
source_tree = parse_tree_indirect ( rev ) ;
if ( ! source_tree ) /* case (1): want a tree */
die ( " reference is not a tree: %s " , arg ) ;
if ( ! has_dash_dash ) { /* case (3 -> 1) */
/*
* Do not complain the most common case
* git checkout branch
* even if there happen to be a file called ' branch ' ;
* it would be extremely annoying .
*/
if ( argc )
verify_non_filename ( NULL , arg ) ;
}
else {
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
argv + + ;
argc - - ;
}
}
2008-07-23 12:15:33 +02:00
no_reference :
2009-10-18 09:13:47 +02:00
if ( opts . track = = BRANCH_TRACK_UNSPECIFIED )
opts . track = git_branch_track ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( argc ) {
const char * * pathspec = get_pathspec ( prefix , argv ) ;
2008-02-28 17:30:47 +01:00
if ( ! pathspec )
die ( " invalid path specification " ) ;
2009-08-15 13:48:30 +02:00
if ( patch_mode )
return interactive_checkout ( new . name , pathspec , & opts ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
/* Checkout paths */
2008-08-30 16:52:24 +02:00
if ( opts . new_branch ) {
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( argc = = 1 ) {
2008-08-30 16:46:55 +02:00
die ( " git checkout: updating paths is incompatible with switching branches. \n Did you intend to checkout '%s' which can not be resolved as commit? " , argv [ 0 ] ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
} else {
2008-08-30 16:46:55 +02:00
die ( " git checkout: updating paths is incompatible with switching branches. " ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
}
2008-08-30 16:52:24 +02:00
if ( 1 < ! ! opts . writeout_stage + ! ! opts . force + ! ! opts . merge )
die ( " git checkout: --ours/--theirs, --force and --merge are incompatible when \n checking out of the index. " ) ;
2008-08-30 16:46:55 +02:00
return checkout_paths ( source_tree , pathspec , & opts ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}
2009-08-15 13:48:30 +02:00
if ( patch_mode )
return interactive_checkout ( new . name , NULL , & opts ) ;
2008-09-21 20:36:06 +02:00
if ( opts . new_branch ) {
2008-10-09 21:12:12 +02:00
struct strbuf buf = STRBUF_INIT ;
2009-03-21 22:35:51 +01:00
if ( strbuf_check_branch_ref ( & buf , opts . new_branch ) )
die ( " git checkout: we do not like '%s' as a branch name. " ,
opts . new_branch ) ;
2008-09-21 20:36:06 +02:00
if ( ! get_sha1 ( buf . buf , rev ) )
die ( " git checkout: branch %s already exists " , opts . new_branch ) ;
strbuf_release ( & buf ) ;
}
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
if ( new . name & & ! new . commit ) {
die ( " Cannot switch branch to a non-commit. " ) ;
}
2008-08-30 16:48:18 +02:00
if ( opts . writeout_stage )
die ( " --ours/--theirs is incompatible with switching branches. " ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
2008-02-21 16:50:42 +01:00
return switch_branches ( & opts , & new ) ;
Build in checkout
The only differences in behavior should be:
- git checkout -m with non-trivial merging won't print out
merge-recursive messages (see the change in t7201-co.sh)
- git checkout -- paths... will give a sensible error message if
HEAD is invalid as a commit.
- some intermediate states which were written to disk in the shell
version (in particular, index states) are only kept in memory in
this version, and therefore these can no longer be revealed by
later write operations becoming impossible.
- when we change branches, we discard MERGE_MSG, SQUASH_MSG, and
rr-cache/MERGE_RR, like reset always has.
I'm not 100% sure I got the merge recursive setup exactly right; the
base for a non-trivial merge in the shell code doesn't seem
theoretically justified to me, but I tried to match it anyway, and the
tests all pass this way.
Other than these items, the results should be identical to the shell
version, so far as I can tell.
[jc: squashed lock-file fix from Dscho in]
Signed-off-by: Daniel Barkalow <barkalow@iabervon.org>
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-02-07 17:40:23 +01:00
}