FilesExpand file tree

 master

/

replace.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

159 lines (133 loc) · 3.94 KB

 master

/

replace.c

Copy path

Top

File metadata and controls

• Code
• Blame

159 lines (133 loc) · 3.94 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

/*

* Builtin "git replace"

*

* Copyright (c) 2008 Christian Couder <chriscool@tuxfamily.org>

*

* Based on builtin-tag.c by Kristian Høgsberg <krh@redhat.com>

* and Carlos Rica <jasampler@gmail.com> that was itself based on

* git-tag.sh and mktag.c by Linus Torvalds.

*/

#include "cache.h"

#include "builtin.h"

#include "refs.h"

#include "parse-options.h"

static const char * const git_replace_usage[] = {

"git replace [-f] <object> <replacement>",

"git replace -d <object>...",

"git replace -l [<pattern>]",

NULL

};

static int show_reference(const char *refname, const unsigned char *sha1,

int flag, void *cb_data)

{

const char *pattern = cb_data;

if (!fnmatch(pattern, refname, 0))

printf("%s\n", refname);

return 0;

}

static int list_replace_refs(const char *pattern)

{

if (pattern == NULL)

pattern = "*";

for_each_replace_ref(show_reference, (void *) pattern);

return 0;

}

typedef int (*each_replace_name_fn)(const char *name, const char *ref,

const unsigned char *sha1);

static int for_each_replace_name(const char **argv, each_replace_name_fn fn)

{

const char **p;

char ref[PATH_MAX];

int had_error = 0;

unsigned char sha1[20];

for (p = argv; *p; p++) {

if (snprintf(ref, sizeof(ref), "refs/replace/%s", *p)

>= sizeof(ref)) {

error("replace ref name too long: %.*s...", 50, *p);

had_error = 1;

continue;

}

if (!resolve_ref(ref, sha1, 1, NULL)) {

error("replace ref '%s' not found.", *p);

had_error = 1;

continue;

}

if (fn(*p, ref, sha1))

had_error = 1;

}

return had_error;

}

static int delete_replace_ref(const char *name, const char *ref,

const unsigned char *sha1)

{

if (delete_ref(ref, sha1, 0))

return 1;

printf("Deleted replace ref '%s'\n", name);

return 0;

}

static int replace_object(const char *object_ref, const char *replace_ref,

int force)

{

unsigned char object[20], prev[20], repl[20];

char ref[PATH_MAX];

struct ref_lock *lock;

if (get_sha1(object_ref, object))

die("Failed to resolve '%s' as a valid ref.", object_ref);

if (get_sha1(replace_ref, repl))

die("Failed to resolve '%s' as a valid ref.", replace_ref);

if (snprintf(ref, sizeof(ref),

"refs/replace/%s",

sha1_to_hex(object)) > sizeof(ref) - 1)

die("replace ref name too long: %.*s...", 50, ref);

if (check_ref_format(ref))

die("'%s' is not a valid ref name.", ref);

if (!resolve_ref(ref, prev, 1, NULL))

hashclr(prev);

else if (!force)

die("replace ref '%s' already exists", ref);

lock = lock_any_ref_for_update(ref, prev, 0);

if (!lock)

die("%s: cannot lock the ref", ref);

if (write_ref_sha1(lock, repl, NULL) < 0)

die("%s: cannot update the ref", ref);

return 0;

}

int cmd_replace(int argc, const char **argv, const char *prefix)

{

int list = 0, delete = 0, force = 0;

struct option options[] = {

OPT_BOOLEAN('l', NULL, &list, "list replace refs"),

OPT_BOOLEAN('d', NULL, &delete, "delete replace refs"),

OPT_BOOLEAN('f', NULL, &force, "replace the ref if it exists"),

OPT_END()

};

argc = parse_options(argc, argv, prefix, options, git_replace_usage, 0);

if (list && delete)

usage_msg_opt("-l and -d cannot be used together",

git_replace_usage, options);

if (force && (list || delete))

usage_msg_opt("-f cannot be used with -d or -l",

git_replace_usage, options);

/* Delete refs */

if (delete) {

if (argc < 1)

usage_msg_opt("-d needs at least one argument",

git_replace_usage, options);

return for_each_replace_name(argv, delete_replace_ref);

}

/* Replace object */

if (!list && argc) {

if (argc != 2)

usage_msg_opt("bad number of arguments",

git_replace_usage, options);

return replace_object(argv[0], argv[1], force);

}

/* List refs, even if "list" is not set */

if (argc > 1)

usage_msg_opt("only one pattern can be given with -l",

git_replace_usage, options);

if (force)

usage_msg_opt("-f needs some arguments",

git_replace_usage, options);

return list_replace_refs(argv[0]);

}