Elijah Newren | 36bf195 | 2023-02-24 00:09:24 +0000 | [diff] [blame] | 1 | #include "git-compat-util.h" |
Brandon Williams | b2141fc | 2017-06-14 11:07:36 -0700 | [diff] [blame] | 2 | #include "config.h" |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 3 | #include "userdiff.h" |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 4 | #include "attr.h" |
Elijah Newren | 36bf195 | 2023-02-24 00:09:24 +0000 | [diff] [blame] | 5 | #include "strbuf.h" |
Jeff King | affe355 | 2024-02-26 05:27:29 -0500 | [diff] [blame] | 6 | #include "environment.h" |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 7 | |
| 8 | static struct userdiff_driver *drivers; |
| 9 | static int ndrivers; |
| 10 | static int drivers_alloc; |
| 11 | |
Ævar Arnfjörð Bjarmason | 2dd75f1 | 2022-02-24 10:33:03 +0100 | [diff] [blame] | 12 | #define PATTERNS(lang, rx, wrx) { \ |
| 13 | .name = lang, \ |
| 14 | .binary = -1, \ |
| 15 | .funcname = { \ |
| 16 | .pattern = rx, \ |
| 17 | .cflags = REG_EXTENDED, \ |
| 18 | }, \ |
| 19 | .word_regex = wrx "|[^[:space:]]|[\xc0-\xff][\x80-\xbf]+", \ |
René Scharfe | be39144 | 2023-04-06 22:19:11 +0200 | [diff] [blame] | 20 | .word_regex_multi_byte = wrx "|[^[:space:]]", \ |
Ævar Arnfjörð Bjarmason | 2dd75f1 | 2022-02-24 10:33:03 +0100 | [diff] [blame] | 21 | } |
| 22 | #define IPATTERN(lang, rx, wrx) { \ |
| 23 | .name = lang, \ |
| 24 | .binary = -1, \ |
| 25 | .funcname = { \ |
| 26 | .pattern = rx, \ |
| 27 | .cflags = REG_EXTENDED | REG_ICASE, \ |
| 28 | }, \ |
| 29 | .word_regex = wrx "|[^[:space:]]|[\xc0-\xff][\x80-\xbf]+", \ |
René Scharfe | be39144 | 2023-04-06 22:19:11 +0200 | [diff] [blame] | 30 | .word_regex_multi_byte = wrx "|[^[:space:]]", \ |
Ævar Arnfjörð Bjarmason | 2dd75f1 | 2022-02-24 10:33:03 +0100 | [diff] [blame] | 31 | } |
Junio C Hamano | b6029b3 | 2021-08-10 15:12:01 -0700 | [diff] [blame] | 32 | |
| 33 | /* |
| 34 | * Built-in drivers for various languages, sorted by their names |
| 35 | * (except that the "default" is left at the end). |
| 36 | * |
| 37 | * When writing or updating patterns, assume that the contents these |
| 38 | * patterns are applied to are syntactically correct. The patterns |
| 39 | * can be simple without implementing all syntactical corner cases, as |
| 40 | * long as they are sufficiently permissive. |
| 41 | */ |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 42 | static struct userdiff_driver builtin_drivers[] = { |
Adrian Johnson | e90d065 | 2012-09-16 13:24:15 +0930 | [diff] [blame] | 43 | IPATTERN("ada", |
Adrian Johnson | 39a87a2 | 2014-02-03 22:03:16 +1030 | [diff] [blame] | 44 | "!^(.*[ \t])?(is[ \t]+new|renames|is[ \t]+separate)([ \t].*)?$\n" |
Adrian Johnson | e90d065 | 2012-09-16 13:24:15 +0930 | [diff] [blame] | 45 | "!^[ \t]*with[ \t].*$\n" |
| 46 | "^[ \t]*((procedure|function)[ \t]+.*)$\n" |
| 47 | "^[ \t]*((package|protected|task)[ \t]+.*)$", |
| 48 | /* -- */ |
| 49 | "[a-zA-Z][a-zA-Z0-9_]*" |
Adrian Johnson | 39a87a2 | 2014-02-03 22:03:16 +1030 | [diff] [blame] | 50 | "|[-+]?[0-9][0-9#_.aAbBcCdDeEfF]*([eE][+-]?[0-9_]+)?" |
Adrian Johnson | e90d065 | 2012-09-16 13:24:15 +0930 | [diff] [blame] | 51 | "|=>|\\.\\.|\\*\\*|:=|/=|>=|<=|<<|>>|<>"), |
Victor Engmark | 2ff6c34 | 2020-10-22 12:45:08 +1300 | [diff] [blame] | 52 | PATTERNS("bash", |
| 53 | /* Optional leading indentation */ |
| 54 | "^[ \t]*" |
| 55 | /* Start of captured text */ |
| 56 | "(" |
| 57 | "(" |
| 58 | /* POSIX identifier with mandatory parentheses */ |
| 59 | "[a-zA-Z_][a-zA-Z0-9_]*[ \t]*\\([ \t]*\\))" |
| 60 | "|" |
| 61 | /* Bashism identifier with optional parentheses */ |
| 62 | "(function[ \t]+[a-zA-Z_][a-zA-Z0-9_]*(([ \t]*\\([ \t]*\\))|([ \t]+))" |
| 63 | ")" |
| 64 | /* Optional whitespace */ |
| 65 | "[ \t]*" |
| 66 | /* Compound command starting with `{`, `(`, `((` or `[[` */ |
| 67 | "(\\{|\\(\\(?|\\[\\[)" |
| 68 | /* End of captured text */ |
| 69 | ")", |
| 70 | /* -- */ |
| 71 | /* Characters not in the default $IFS value */ |
| 72 | "[^ \t]+"), |
Ævar Arnfjörð Bjarmason | 6d1c9c5 | 2021-04-08 17:04:17 +0200 | [diff] [blame] | 73 | PATTERNS("bibtex", |
| 74 | "(@[a-zA-Z]{1,}[ \t]*\\{{0,1}[ \t]*[^ \t\"@',\\#}{~%]*).*$", |
| 75 | /* -- */ |
Ævar Arnfjörð Bjarmason | ddd164d | 2021-04-08 17:04:16 +0200 | [diff] [blame] | 76 | "[={}\"]|[^={}\" \t]+"), |
| 77 | PATTERNS("cpp", |
| 78 | /* Jump targets or access declarations */ |
| 79 | "!^[ \t]*[A-Za-z_][A-Za-z_0-9]*:[[:space:]]*($|/[/*])\n" |
| 80 | /* functions/methods, variables, and compounds at top level */ |
| 81 | "^((::[[:space:]]*)?[A-Za-z_].*)$", |
| 82 | /* -- */ |
Johannes Sixt | 350b87c | 2021-10-08 19:09:55 +0000 | [diff] [blame] | 83 | /* identifiers and keywords */ |
Ævar Arnfjörð Bjarmason | ddd164d | 2021-04-08 17:04:16 +0200 | [diff] [blame] | 84 | "[a-zA-Z_][a-zA-Z0-9_]*" |
Johannes Sixt | 350b87c | 2021-10-08 19:09:55 +0000 | [diff] [blame] | 85 | /* decimal and octal integers as well as floatingpoint numbers */ |
Johannes Sixt | 386076e | 2021-10-24 11:56:43 +0200 | [diff] [blame] | 86 | "|[0-9][0-9.]*([Ee][-+]?[0-9]+)?[fFlLuU]*" |
Johannes Sixt | 350b87c | 2021-10-08 19:09:55 +0000 | [diff] [blame] | 87 | /* hexadecimal and binary integers */ |
Johannes Sixt | 386076e | 2021-10-24 11:56:43 +0200 | [diff] [blame] | 88 | "|0[xXbB][0-9a-fA-F]+[lLuU]*" |
Johannes Sixt | 350b87c | 2021-10-08 19:09:55 +0000 | [diff] [blame] | 89 | /* floatingpoint numbers that begin with a decimal point */ |
Johannes Sixt | 386076e | 2021-10-24 11:56:43 +0200 | [diff] [blame] | 90 | "|\\.[0-9][0-9]*([Ee][-+]?[0-9]+)?[fFlL]?" |
Johannes Sixt | c4fdba3 | 2021-10-10 17:03:04 +0000 | [diff] [blame] | 91 | "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->\\*?|\\.\\*|<=>"), |
Ævar Arnfjörð Bjarmason | ddd164d | 2021-04-08 17:04:16 +0200 | [diff] [blame] | 92 | PATTERNS("csharp", |
Steven Jeuris | ec0e307 | 2024-04-03 21:42:44 +0000 | [diff] [blame] | 93 | /* |
| 94 | * Jump over reserved keywords which are illegal method names, but which |
| 95 | * can be followed by parentheses without special characters in between, |
| 96 | * making them look like methods. |
| 97 | */ |
| 98 | "!(^|[ \t]+)" /* Start of line or whitespace. */ |
| 99 | "(do|while|for|foreach|if|else|new|default|return|switch|case|throw" |
| 100 | "|catch|using|lock|fixed)" |
| 101 | "([ \t(]+|$)\n" /* Whitespace, "(", or end of line. */ |
| 102 | /* |
| 103 | * Methods/constructors: |
| 104 | * The strategy is to identify a minimum of two groups (any combination |
| 105 | * of keywords/type/name) before the opening parenthesis, and without |
| 106 | * final unexpected characters, normally only used in ordinary statements. |
| 107 | */ |
| 108 | "^[ \t]*" /* Remove leading whitespace. */ |
| 109 | "(" /* Start chunk header capture. */ |
| 110 | "(" /* First group. */ |
| 111 | "[][[:alnum:]@_.]" /* Name. */ |
| 112 | "(<[][[:alnum:]@_, \t<>]+>)?" /* Optional generic parameters. */ |
| 113 | ")+" |
| 114 | "([ \t]+" /* Subsequent groups, prepended with space. */ |
| 115 | "([][[:alnum:]@_.](<[][[:alnum:]@_, \t<>]+>)?)+" |
| 116 | ")+" |
| 117 | "[ \t]*" /* Optional space before parameters start. */ |
| 118 | "\\(" /* Start of method parameters. */ |
| 119 | "[^;]*" /* Allow complex parameters, but exclude statements (;). */ |
| 120 | ")$\n" /* Close chunk header capture. */ |
| 121 | /* |
| 122 | * Properties: |
| 123 | * As with methods, expect a minimum of two groups. But, more trivial than |
| 124 | * methods, the vast majority of properties long enough to be worth |
| 125 | * showing a chunk header for don't include "=:;,()" on the line they are |
| 126 | * defined, since they don't have a parameter list. |
| 127 | */ |
| 128 | "^[ \t]*(" |
| 129 | "([][[:alnum:]@_.](<[][[:alnum:]@_, \t<>]+>)?)+" |
| 130 | "([ \t]+" |
| 131 | "([][[:alnum:]@_.](<[][[:alnum:]@_, \t<>]+>)?)+" |
| 132 | ")+" /* Up to here, same as methods regex. */ |
| 133 | "[^;=:,()]*" /* Compared to methods, no parameter list allowed. */ |
| 134 | ")$\n" |
Ævar Arnfjörð Bjarmason | ddd164d | 2021-04-08 17:04:16 +0200 | [diff] [blame] | 135 | /* Type definitions */ |
Julian Verdurmen | c4e3178 | 2021-03-02 00:58:09 +0000 | [diff] [blame] | 136 | "^[ \t]*(((static|public|internal|private|protected|new|unsafe|sealed|abstract|partial)[ \t]+)*(class|enum|interface|struct|record)[ \t]+.*)$\n" |
Ævar Arnfjörð Bjarmason | ddd164d | 2021-04-08 17:04:16 +0200 | [diff] [blame] | 137 | /* Namespace */ |
| 138 | "^[ \t]*(namespace[ \t]+.*)$", |
| 139 | /* -- */ |
| 140 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 141 | "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?" |
| 142 | "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"), |
| 143 | IPATTERN("css", |
| 144 | "![:;][[:space:]]*$\n" |
| 145 | "^[:[@.#]?[_a-z0-9].*$", |
| 146 | /* -- */ |
| 147 | /* |
| 148 | * This regex comes from W3C CSS specs. Should theoretically also |
| 149 | * allow ISO 10646 characters U+00A0 and higher, |
| 150 | * but they are not handled in this regex. |
| 151 | */ |
| 152 | "-?[_a-zA-Z][-_a-zA-Z0-9]*" /* identifiers */ |
| 153 | "|-?[0-9]+|\\#[0-9a-fA-F]+" /* numbers */ |
| 154 | ), |
Stephen Boyd | 3c81760 | 2019-08-19 14:22:43 -0700 | [diff] [blame] | 155 | PATTERNS("dts", |
| 156 | "!;\n" |
Stephen Boyd | 8da56a4 | 2019-10-20 11:52:30 -0700 | [diff] [blame] | 157 | "!=\n" |
Stephen Boyd | 3c81760 | 2019-08-19 14:22:43 -0700 | [diff] [blame] | 158 | /* lines beginning with a word optionally preceded by '&' or the root */ |
Stephen Boyd | 8da56a4 | 2019-10-20 11:52:30 -0700 | [diff] [blame] | 159 | "^[ \t]*((/[ \t]*\\{|&?[a-zA-Z_]).*)", |
Stephen Boyd | 3c81760 | 2019-08-19 14:22:43 -0700 | [diff] [blame] | 160 | /* -- */ |
| 161 | /* Property names and math operators */ |
| 162 | "[a-zA-Z0-9,._+?#-]+" |
| 163 | "|[-+*/%&^|!~]|>>|<<|&&|\\|\\|"), |
Łukasz Niemier | a807200 | 2019-11-08 22:38:24 +0100 | [diff] [blame] | 164 | PATTERNS("elixir", |
| 165 | "^[ \t]*((def(macro|module|impl|protocol|p)?|test)[ \t].*)$", |
Ed Maste | d1b1384 | 2019-12-13 17:55:35 +0000 | [diff] [blame] | 166 | /* -- */ |
Łukasz Niemier | a807200 | 2019-11-08 22:38:24 +0100 | [diff] [blame] | 167 | /* Atoms, names, and module attributes */ |
Ed Maste | d1b1384 | 2019-12-13 17:55:35 +0000 | [diff] [blame] | 168 | "[@:]?[a-zA-Z0-9@_?!]+" |
Łukasz Niemier | a807200 | 2019-11-08 22:38:24 +0100 | [diff] [blame] | 169 | /* Numbers with specific base */ |
| 170 | "|[-+]?0[xob][0-9a-fA-F]+" |
| 171 | /* Numbers */ |
| 172 | "|[-+]?[0-9][0-9_.]*([eE][-+]?[0-9_]+)?" |
| 173 | /* Operators and atoms that represent them */ |
| 174 | "|:?(\\+\\+|--|\\.\\.|~~~|<>|\\^\\^\\^|<?\\|>|<<<?|>?>>|<<?~|~>?>|<~>|<=|>=|===?|!==?|=~|&&&?|\\|\\|\\|?|=>|<-|\\\\\\\\|->)" |
| 175 | /* Not real operators, but should be grouped */ |
| 176 | "|:?%[A-Za-z0-9_.]\\{\\}?"), |
Brandon Casey | 909a549 | 2010-09-10 11:18:14 -0500 | [diff] [blame] | 177 | IPATTERN("fortran", |
Philippe Blain | b79e692 | 2020-08-12 22:30:28 +0000 | [diff] [blame] | 178 | /* Don't match comment lines */ |
Brandon Casey | 909a549 | 2010-09-10 11:18:14 -0500 | [diff] [blame] | 179 | "!^([C*]|[ \t]*!)\n" |
Philippe Blain | b79e692 | 2020-08-12 22:30:28 +0000 | [diff] [blame] | 180 | /* Don't match 'module procedure' lines */ |
Brandon Casey | 909a549 | 2010-09-10 11:18:14 -0500 | [diff] [blame] | 181 | "!^[ \t]*MODULE[ \t]+PROCEDURE[ \t]\n" |
Philippe Blain | b79e692 | 2020-08-12 22:30:28 +0000 | [diff] [blame] | 182 | /* Program, module, block data */ |
Brandon Casey | 909a549 | 2010-09-10 11:18:14 -0500 | [diff] [blame] | 183 | "^[ \t]*((END[ \t]+)?(PROGRAM|MODULE|BLOCK[ \t]+DATA" |
Philippe Blain | b79e692 | 2020-08-12 22:30:28 +0000 | [diff] [blame] | 184 | /* Subroutines and functions */ |
Philippe Blain | 75c3b6b | 2020-08-12 22:30:29 +0000 | [diff] [blame] | 185 | "|([^!'\" \t]+[ \t]+)*(SUBROUTINE|FUNCTION))[ \t]+[A-Z].*)$", |
Brandon Casey | 909a549 | 2010-09-10 11:18:14 -0500 | [diff] [blame] | 186 | /* -- */ |
| 187 | "[a-zA-Z][a-zA-Z0-9_]*" |
| 188 | "|\\.([Ee][Qq]|[Nn][Ee]|[Gg][TtEe]|[Ll][TtEe]|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee]|[Aa][Nn][Dd]|[Oo][Rr]|[Nn]?[Ee][Qq][Vv]|[Nn][Oo][Tt])\\." |
| 189 | /* numbers and format statements like 2E14.4, or ES12.6, 9X. |
| 190 | * Don't worry about format statements without leading digits since |
| 191 | * they would have been matched above as a variable anyway. */ |
| 192 | "|[-+]?[0-9.]+([AaIiDdEeFfLlTtXx][Ss]?[-+]?[0-9.]*)?(_[a-zA-Z0-9][a-zA-Z0-9_]*)?" |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 193 | "|//|\\*\\*|::|[/<>=]="), |
Ævar Arnfjörð Bjarmason | 6d1c9c5 | 2021-04-08 17:04:17 +0200 | [diff] [blame] | 194 | IPATTERN("fountain", |
| 195 | "^((\\.[^.]|(int|ext|est|int\\.?/ext|i/e)[. ]).*)$", |
| 196 | /* -- */ |
Zoë Blade | 69f9c87 | 2015-07-21 14:22:46 +0100 | [diff] [blame] | 197 | "[^ \t-]+"), |
Alban Gruin | 1dbf0c0 | 2018-03-01 12:19:07 +0100 | [diff] [blame] | 198 | PATTERNS("golang", |
| 199 | /* Functions */ |
| 200 | "^[ \t]*(func[ \t]*.*(\\{[ \t]*)?)\n" |
| 201 | /* Structs and interfaces */ |
| 202 | "^[ \t]*(type[ \t].*(struct|interface)[ \t]*(\\{[ \t]*)?)", |
| 203 | /* -- */ |
| 204 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 205 | "|[-+0-9.eE]+i?|0[xX]?[0-9a-fA-F]+i?" |
| 206 | "|[-+*/<>%&^|=!:]=|--|\\+\\+|<<=?|>>=?|&\\^=?|&&|\\|\\||<-|\\.{3}"), |
Ævar Arnfjörð Bjarmason | 6d1c9c5 | 2021-04-08 17:04:17 +0200 | [diff] [blame] | 207 | PATTERNS("html", |
| 208 | "^[ \t]*(<[Hh][1-6]([ \t].*)?>.*)$", |
| 209 | /* -- */ |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 210 | "[^<>= \t]+"), |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 211 | PATTERNS("java", |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 212 | "!^[ \t]*(catch|do|for|if|instanceof|new|return|switch|throw|while)\n" |
Andrei Rybak | 575e6fc | 2023-02-08 00:42:58 +0100 | [diff] [blame] | 213 | /* Class, enum, interface, and record declarations */ |
Andrei Rybak | 93d52ed | 2023-02-08 00:42:59 +0100 | [diff] [blame] | 214 | "^[ \t]*(([a-z-]+[ \t]+)*(class|enum|interface|record)[ \t]+.*)$\n" |
Tassilo Horn | a8cbc89 | 2021-08-11 19:51:04 +0200 | [diff] [blame] | 215 | /* Method definitions; note that constructor signatures are not */ |
| 216 | /* matched because they are indistinguishable from method calls. */ |
| 217 | "^[ \t]*(([A-Za-z_<>&][][?&<>.,A-Za-z_0-9]*[ \t]+)+[A-Za-z_][A-Za-z_0-9]*[ \t]*\\([^;]*)$", |
Paolo Bonzini | 959e2e6 | 2009-06-17 16:26:06 +0200 | [diff] [blame] | 218 | /* -- */ |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 219 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 220 | "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?" |
| 221 | "|[-+*/<>%&^|=!]=" |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 222 | "|--|\\+\\+|<<=?|>>>?=?|&&|\\|\\|"), |
Jaydeep P Das | 09188ed | 2022-03-12 10:18:32 +0530 | [diff] [blame] | 223 | PATTERNS("kotlin", |
| 224 | "^[ \t]*(([a-z]+[ \t]+)*(fun|class|interface)[ \t]+.*)$", |
| 225 | /* -- */ |
| 226 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 227 | /* hexadecimal and binary numbers */ |
| 228 | "|0[xXbB][0-9a-fA-F_]+[lLuU]*" |
| 229 | /* integers and floats */ |
| 230 | "|[0-9][0-9_]*([.][0-9_]*)?([Ee][-+]?[0-9]+)?[fFlLuU]*" |
| 231 | /* floating point numbers beginning with decimal point */ |
| 232 | "|[.][0-9][0-9_]*([Ee][-+]?[0-9]+)?[fFlLuU]?" |
| 233 | /* unary and binary operators */ |
| 234 | "|[-+*/<>%&^|=!]==?|--|\\+\\+|<<=|>>=|&&|\\|\\||->|\\.\\*|!!|[?:.][.:]"), |
Ash Holland | 09dad92 | 2020-05-02 14:15:43 +0100 | [diff] [blame] | 235 | PATTERNS("markdown", |
| 236 | "^ {0,3}#{1,6}[ \t].*", |
Ævar Arnfjörð Bjarmason | 6d1c9c5 | 2021-04-08 17:04:17 +0200 | [diff] [blame] | 237 | /* -- */ |
Ash Holland | 09dad92 | 2020-05-02 14:15:43 +0100 | [diff] [blame] | 238 | "[^<>= \t]+"), |
Gustaf Hendeby | 53b10a1 | 2011-11-15 21:15:03 +0100 | [diff] [blame] | 239 | PATTERNS("matlab", |
Boxuan Li | 2731a78 | 2019-05-30 00:15:39 +0800 | [diff] [blame] | 240 | /* |
| 241 | * Octave pattern is mostly the same as matlab, except that '%%%' and |
Boxuan Li | 91bf382 | 2019-05-18 11:46:23 +0800 | [diff] [blame] | 242 | * '##' can also be used to begin code sections, in addition to '%%' |
Boxuan Li | 2731a78 | 2019-05-30 00:15:39 +0800 | [diff] [blame] | 243 | * that is understood by both. |
| 244 | */ |
Boxuan Li | 91bf382 | 2019-05-18 11:46:23 +0800 | [diff] [blame] | 245 | "^[[:space:]]*((classdef|function)[[:space:]].*)$|^(%%%?|##)[[:space:]].*$", |
Ævar Arnfjörð Bjarmason | 6d1c9c5 | 2021-04-08 17:04:17 +0200 | [diff] [blame] | 246 | /* -- */ |
Gustaf Hendeby | 53b10a1 | 2011-11-15 21:15:03 +0100 | [diff] [blame] | 247 | "[a-zA-Z_][a-zA-Z0-9_]*|[-+0-9.e]+|[=~<>]=|\\.[*/\\^']|\\|\\||&&"), |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 248 | PATTERNS("objc", |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 249 | /* Negate C statements that can look like functions */ |
| 250 | "!^[ \t]*(do|for|if|else|return|switch|while)\n" |
| 251 | /* Objective-C methods */ |
| 252 | "^[ \t]*([-+][ \t]*\\([ \t]*[A-Za-z_][A-Za-z_0-9* \t]*\\)[ \t]*[A-Za-z_].*)$\n" |
| 253 | /* C functions */ |
Paolo Bonzini | 959e2e6 | 2009-06-17 16:26:06 +0200 | [diff] [blame] | 254 | "^[ \t]*(([A-Za-z_][A-Za-z_0-9]*[ \t]+)+[A-Za-z_][A-Za-z_0-9]*[ \t]*\\([^;]*)$\n" |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 255 | /* Objective-C class/protocol definitions */ |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 256 | "^(@(implementation|interface|protocol)[ \t].*)$", |
| 257 | /* -- */ |
| 258 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 259 | "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?" |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 260 | "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"), |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 261 | PATTERNS("pascal", |
Ævar Arnfjörð Bjarmason | 82512e0 | 2021-04-08 17:04:18 +0200 | [diff] [blame] | 262 | "^(((class[ \t]+)?(procedure|function)|constructor|destructor|interface" |
| 263 | "|implementation|initialization|finalization)[ \t]*.*)$\n" |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 264 | "^(.*=[ \t]*(class|record).*)$", |
| 265 | /* -- */ |
| 266 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 267 | "|[-+0-9.e]+|0[xXbB]?[0-9a-fA-F]+" |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 268 | "|<>|<=|>=|:=|\\.\\."), |
Jonathan Nieder | 71a5d4b | 2010-12-26 03:07:31 -0600 | [diff] [blame] | 269 | PATTERNS("perl", |
Jonathan Nieder | ea2ca44 | 2011-05-21 14:38:26 -0500 | [diff] [blame] | 270 | "^package .*\n" |
| 271 | "^sub [[:alnum:]_':]+[ \t]*" |
| 272 | "(\\([^)]*\\)[ \t]*)?" /* prototype */ |
| 273 | /* |
| 274 | * Attributes. A regex can't count nested parentheses, |
| 275 | * so just slurp up whatever we see, taking care not |
| 276 | * to accept lines like "sub foo; # defined elsewhere". |
| 277 | * |
| 278 | * An attribute could contain a semicolon, but at that |
| 279 | * point it seems reasonable enough to give up. |
| 280 | */ |
| 281 | "(:[^;#]*)?" |
| 282 | "(\\{[ \t]*)?" /* brace can come here or on the next line */ |
| 283 | "(#.*)?$\n" /* comment */ |
Jonathan Nieder | f143d9c | 2011-05-22 12:29:32 -0500 | [diff] [blame] | 284 | "^(BEGIN|END|INIT|CHECK|UNITCHECK|AUTOLOAD|DESTROY)[ \t]*" |
Jonathan Nieder | ea2ca44 | 2011-05-21 14:38:26 -0500 | [diff] [blame] | 285 | "(\\{[ \t]*)?" /* brace can come here or on the next line */ |
| 286 | "(#.*)?$\n" |
Jonathan Nieder | 12f0967 | 2011-05-21 14:35:51 -0500 | [diff] [blame] | 287 | "^=head[0-9] .*", /* POD */ |
Jonathan Nieder | 71a5d4b | 2010-12-26 03:07:31 -0600 | [diff] [blame] | 288 | /* -- */ |
| 289 | "[[:alpha:]_'][[:alnum:]_']*" |
| 290 | "|0[xb]?[0-9a-fA-F_]*" |
| 291 | /* taking care not to interpret 3..5 as (3.)(.5) */ |
| 292 | "|[0-9a-fA-F_]+(\\.[0-9a-fA-F_]+)?([eE][-+]?[0-9_]+)?" |
| 293 | "|=>|-[rwxoRWXOezsfdlpSugkbctTBMAC>]|~~|::" |
| 294 | "|&&=|\\|\\|=|//=|\\*\\*=" |
| 295 | "|&&|\\|\\||//|\\+\\+|--|\\*\\*|\\.\\.\\.?" |
| 296 | "|[-+*/%.^&<>=!|]=" |
| 297 | "|=~|!~" |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 298 | "|<<|<>|<=>|>>"), |
Björn Steinbrink | 6d2f208 | 2010-05-23 20:05:40 +0200 | [diff] [blame] | 299 | PATTERNS("php", |
Javier Spagnoletti | aff9282 | 2020-10-07 03:38:18 +0000 | [diff] [blame] | 300 | "^[\t ]*(((public|protected|private|static|abstract|final)[\t ]+)*function.*)$\n" |
USAMI Kenta | 2c7f3aa | 2021-08-31 06:01:25 +0000 | [diff] [blame] | 301 | "^[\t ]*((((final|abstract)[\t ]+)?class|enum|interface|trait).*)$", |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 302 | /* -- */ |
| 303 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 304 | "|[-+0-9.e]+|0[xXbB]?[0-9a-fA-F]+" |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 305 | "|[-+*/<>%&^|=!.]=|--|\\+\\+|<<=?|>>=?|===|&&|\\|\\||::|->"), |
Ævar Arnfjörð Bjarmason | 6d1c9c5 | 2021-04-08 17:04:17 +0200 | [diff] [blame] | 306 | PATTERNS("python", |
| 307 | "^[ \t]*((class|(async[ \t]+)?def)[ \t].*)$", |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 308 | /* -- */ |
| 309 | "[a-zA-Z_][a-zA-Z0-9_]*" |
| 310 | "|[-+0-9.e]+[jJlL]?|0[xX]?[0-9a-fA-F]+[lL]?" |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 311 | "|[-+*/<>%&^|=!]=|//=?|<<=?|>>=?|\\*\\*=?"), |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 312 | /* -- */ |
Ævar Arnfjörð Bjarmason | 6d1c9c5 | 2021-04-08 17:04:17 +0200 | [diff] [blame] | 313 | PATTERNS("ruby", |
| 314 | "^[ \t]*((class|module|def)[ \t].*)$", |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 315 | /* -- */ |
| 316 | "(@|@@|\\$)?[a-zA-Z_][a-zA-Z0-9_]*" |
| 317 | "|[-+0-9.e]+|0[xXbB]?[0-9a-fA-F]+|\\?(\\\\C-)?(\\\\M-)?." |
Jonathan Nieder | 664d44e | 2011-01-11 15:48:50 -0600 | [diff] [blame] | 318 | "|//=?|[-+*/<>%&^|=!]=|<<=?|>>=?|===|\\.{1,3}|::|[!=]~"), |
Marc-André Lureau | d74e786 | 2019-05-17 01:58:15 +0200 | [diff] [blame] | 319 | PATTERNS("rust", |
Konrad Borowski | a04c7e0 | 2020-10-07 13:26:11 +0000 | [diff] [blame] | 320 | "^[\t ]*((pub(\\([^\\)]+\\))?[\t ]+)?((async|const|unsafe|extern([\t ]+\"[^\"]+\"))[\t ]+)?(struct|enum|union|mod|trait|fn|impl|macro_rules!)[< \t]+[^;]*)$", |
Marc-André Lureau | d74e786 | 2019-05-17 01:58:15 +0200 | [diff] [blame] | 321 | /* -- */ |
| 322 | "[a-zA-Z_][a-zA-Z0-9_]*" |
Johannes Sixt | 33be7b3 | 2019-05-30 18:44:35 +0200 | [diff] [blame] | 323 | "|[0-9][0-9_a-fA-Fiosuxz]*(\\.([0-9]*[eE][+-]?)?[0-9_fF]*)?" |
Marc-André Lureau | d74e786 | 2019-05-17 01:58:15 +0200 | [diff] [blame] | 324 | "|[-+*\\/<>%&^|=!:]=|<<=?|>>=?|&&|\\|\\||->|=>|\\.{2}=|\\.{3}|::"), |
Atharva Raykar | a437390 | 2021-04-08 14:44:43 +0530 | [diff] [blame] | 325 | PATTERNS("scheme", |
| 326 | "^[\t ]*(\\(((define|def(struct|syntax|class|method|rules|record|proto|alias)?)[-*/ \t]|(library|module|struct|class)[*+ \t]).*)$", |
| 327 | /* |
| 328 | * R7RS valid identifiers include any sequence enclosed |
| 329 | * within vertical lines having no backslashes |
| 330 | */ |
| 331 | "\\|([^\\\\]*)\\|" |
| 332 | /* All other words should be delimited by spaces or parentheses */ |
| 333 | "|([^][)(}{[ \t])+"), |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 334 | PATTERNS("tex", "^(\\\\((sub)*section|chapter|part)\\*{0,1}\\{.*)$", |
René Scharfe | be39144 | 2023-04-06 22:19:11 +0200 | [diff] [blame] | 335 | "\\\\[a-zA-Z@]+|\\\\.|([a-zA-Z0-9]|[^\x01-\x7f])+"), |
John Cai | a4cf900 | 2023-02-20 21:04:42 +0000 | [diff] [blame] | 336 | { "default", NULL, NULL, -1, { NULL, 0 } }, |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 337 | }; |
Thomas Rast | 80c49c3 | 2009-01-17 17:29:48 +0100 | [diff] [blame] | 338 | #undef PATTERNS |
Brandon Casey | 909a549 | 2010-09-10 11:18:14 -0500 | [diff] [blame] | 339 | #undef IPATTERN |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 340 | |
| 341 | static struct userdiff_driver driver_true = { |
Ævar Arnfjörð Bjarmason | 2dd75f1 | 2022-02-24 10:33:03 +0100 | [diff] [blame] | 342 | .name = "diff=true", |
| 343 | .binary = 0, |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 344 | }; |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 345 | |
| 346 | static struct userdiff_driver driver_false = { |
Ævar Arnfjörð Bjarmason | 2dd75f1 | 2022-02-24 10:33:03 +0100 | [diff] [blame] | 347 | .name = "!diff", |
| 348 | .binary = 1, |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 349 | }; |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 350 | |
Ævar Arnfjörð Bjarmason | f12fa9e | 2021-04-08 17:04:19 +0200 | [diff] [blame] | 351 | struct find_by_namelen_data { |
| 352 | const char *name; |
| 353 | size_t len; |
| 354 | struct userdiff_driver *driver; |
| 355 | }; |
| 356 | |
| 357 | static int userdiff_find_by_namelen_cb(struct userdiff_driver *driver, |
Jeff King | c25d9e5 | 2022-12-13 06:16:57 -0500 | [diff] [blame] | 358 | enum userdiff_driver_type type UNUSED, |
| 359 | void *priv) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 360 | { |
Ævar Arnfjörð Bjarmason | f12fa9e | 2021-04-08 17:04:19 +0200 | [diff] [blame] | 361 | struct find_by_namelen_data *cb_data = priv; |
| 362 | |
René Scharfe | f0e578c | 2024-02-10 08:43:01 +0100 | [diff] [blame] | 363 | if (!xstrncmpz(driver->name, cb_data->name, cb_data->len)) { |
Ævar Arnfjörð Bjarmason | f12fa9e | 2021-04-08 17:04:19 +0200 | [diff] [blame] | 364 | cb_data->driver = driver; |
| 365 | return 1; /* tell the caller to stop iterating */ |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 366 | } |
Ævar Arnfjörð Bjarmason | f12fa9e | 2021-04-08 17:04:19 +0200 | [diff] [blame] | 367 | return 0; |
| 368 | } |
| 369 | |
René Scharfe | be39144 | 2023-04-06 22:19:11 +0200 | [diff] [blame] | 370 | static int regexec_supports_multi_byte_chars(void) |
| 371 | { |
| 372 | static const char not_space[] = "[^[:space:]]"; |
| 373 | static const char utf8_multi_byte_char[] = "\xc2\xa3"; |
| 374 | regex_t re; |
| 375 | regmatch_t match; |
| 376 | static int result = -1; |
| 377 | |
| 378 | if (result != -1) |
| 379 | return result; |
| 380 | if (regcomp(&re, not_space, REG_EXTENDED)) |
| 381 | BUG("invalid regular expression: %s", not_space); |
| 382 | result = !regexec(&re, utf8_multi_byte_char, 1, &match, 0) && |
| 383 | match.rm_so == 0 && |
| 384 | match.rm_eo == strlen(utf8_multi_byte_char); |
| 385 | regfree(&re); |
| 386 | return result; |
| 387 | } |
| 388 | |
Ævar Arnfjörð Bjarmason | f12fa9e | 2021-04-08 17:04:19 +0200 | [diff] [blame] | 389 | static struct userdiff_driver *userdiff_find_by_namelen(const char *name, size_t len) |
| 390 | { |
| 391 | struct find_by_namelen_data udcbdata = { |
| 392 | .name = name, |
| 393 | .len = len, |
| 394 | }; |
| 395 | for_each_userdiff_driver(userdiff_find_by_namelen_cb, &udcbdata); |
| 396 | return udcbdata.driver; |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 397 | } |
| 398 | |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 399 | static int parse_funcname(struct userdiff_funcname *f, const char *k, |
| 400 | const char *v, int cflags) |
| 401 | { |
| 402 | if (git_config_string(&f->pattern, k, v) < 0) |
| 403 | return -1; |
| 404 | f->cflags = cflags; |
Jeff King | 6680a08 | 2012-02-07 13:23:02 -0500 | [diff] [blame] | 405 | return 0; |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 406 | } |
| 407 | |
Jeff King | 122aa6f | 2008-10-05 17:43:36 -0400 | [diff] [blame] | 408 | static int parse_tristate(int *b, const char *k, const char *v) |
| 409 | { |
| 410 | if (v && !strcasecmp(v, "auto")) |
| 411 | *b = -1; |
| 412 | else |
| 413 | *b = git_config_bool(k, v); |
Jeff King | 6680a08 | 2012-02-07 13:23:02 -0500 | [diff] [blame] | 414 | return 0; |
Jeff King | 122aa6f | 2008-10-05 17:43:36 -0400 | [diff] [blame] | 415 | } |
| 416 | |
Jeff King | d9bae1a | 2010-04-01 20:12:15 -0400 | [diff] [blame] | 417 | static int parse_bool(int *b, const char *k, const char *v) |
| 418 | { |
| 419 | *b = git_config_bool(k, v); |
Jeff King | 6680a08 | 2012-02-07 13:23:02 -0500 | [diff] [blame] | 420 | return 0; |
Jeff King | d9bae1a | 2010-04-01 20:12:15 -0400 | [diff] [blame] | 421 | } |
| 422 | |
Jeff King | c7534ef | 2008-10-26 00:45:55 -0400 | [diff] [blame] | 423 | int userdiff_config(const char *k, const char *v) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 424 | { |
| 425 | struct userdiff_driver *drv; |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 426 | const char *name, *type; |
Jeff King | f5914f4 | 2020-04-10 15:44:28 -0400 | [diff] [blame] | 427 | size_t namelen; |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 428 | |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 429 | if (parse_config_key(k, "diff", &name, &namelen, &type) || !name) |
| 430 | return 0; |
| 431 | |
| 432 | drv = userdiff_find_by_namelen(name, namelen); |
| 433 | if (!drv) { |
| 434 | ALLOC_GROW(drivers, ndrivers+1, drivers_alloc); |
| 435 | drv = &drivers[ndrivers++]; |
| 436 | memset(drv, 0, sizeof(*drv)); |
| 437 | drv->name = xmemdupz(name, namelen); |
| 438 | drv->binary = -1; |
| 439 | } |
| 440 | |
| 441 | if (!strcmp(type, "funcname")) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 442 | return parse_funcname(&drv->funcname, k, v, 0); |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 443 | if (!strcmp(type, "xfuncname")) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 444 | return parse_funcname(&drv->funcname, k, v, REG_EXTENDED); |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 445 | if (!strcmp(type, "binary")) |
Jeff King | 122aa6f | 2008-10-05 17:43:36 -0400 | [diff] [blame] | 446 | return parse_tristate(&drv->binary, k, v); |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 447 | if (!strcmp(type, "command")) |
Jeff King | 6680a08 | 2012-02-07 13:23:02 -0500 | [diff] [blame] | 448 | return git_config_string(&drv->external, k, v); |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 449 | if (!strcmp(type, "textconv")) |
Jeff King | 6680a08 | 2012-02-07 13:23:02 -0500 | [diff] [blame] | 450 | return git_config_string(&drv->textconv, k, v); |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 451 | if (!strcmp(type, "cachetextconv")) |
Jeff King | d9bae1a | 2010-04-01 20:12:15 -0400 | [diff] [blame] | 452 | return parse_bool(&drv->textconv_want_cache, k, v); |
Jeff King | 0a5987f | 2013-01-23 01:25:07 -0500 | [diff] [blame] | 453 | if (!strcmp(type, "wordregex")) |
Jeff King | 6680a08 | 2012-02-07 13:23:02 -0500 | [diff] [blame] | 454 | return git_config_string(&drv->word_regex, k, v); |
John Cai | a4cf900 | 2023-02-20 21:04:42 +0000 | [diff] [blame] | 455 | if (!strcmp(type, "algorithm")) |
| 456 | return git_config_string(&drv->algorithm, k, v); |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 457 | |
| 458 | return 0; |
| 459 | } |
| 460 | |
Nguyễn Thái Ngọc Duy | 3b33576 | 2018-12-09 11:25:21 +0100 | [diff] [blame] | 461 | struct userdiff_driver *userdiff_find_by_name(const char *name) |
| 462 | { |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 463 | int len = strlen(name); |
René Scharfe | be39144 | 2023-04-06 22:19:11 +0200 | [diff] [blame] | 464 | struct userdiff_driver *driver = userdiff_find_by_namelen(name, len); |
| 465 | if (driver && driver->word_regex_multi_byte) { |
| 466 | if (regexec_supports_multi_byte_chars()) |
| 467 | driver->word_regex = driver->word_regex_multi_byte; |
| 468 | driver->word_regex_multi_byte = NULL; |
| 469 | } |
| 470 | return driver; |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 471 | } |
| 472 | |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 473 | struct userdiff_driver *userdiff_find_by_path(struct index_state *istate, |
| 474 | const char *path) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 475 | { |
Junio C Hamano | 2aef63d | 2017-01-27 18:01:57 -0800 | [diff] [blame] | 476 | static struct attr_check *check; |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 477 | |
Junio C Hamano | 2aef63d | 2017-01-27 18:01:57 -0800 | [diff] [blame] | 478 | if (!check) |
| 479 | check = attr_check_initl("diff", NULL); |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 480 | if (!path) |
| 481 | return NULL; |
John Cai | 44451a2 | 2023-05-06 04:15:29 +0000 | [diff] [blame] | 482 | git_check_attr(istate, path, check); |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 483 | |
Junio C Hamano | 2aef63d | 2017-01-27 18:01:57 -0800 | [diff] [blame] | 484 | if (ATTR_TRUE(check->items[0].value)) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 485 | return &driver_true; |
Junio C Hamano | 2aef63d | 2017-01-27 18:01:57 -0800 | [diff] [blame] | 486 | if (ATTR_FALSE(check->items[0].value)) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 487 | return &driver_false; |
Junio C Hamano | 2aef63d | 2017-01-27 18:01:57 -0800 | [diff] [blame] | 488 | if (ATTR_UNSET(check->items[0].value)) |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 489 | return NULL; |
Junio C Hamano | 2aef63d | 2017-01-27 18:01:57 -0800 | [diff] [blame] | 490 | return userdiff_find_by_name(check->items[0].value); |
Jeff King | be58e70 | 2008-10-05 17:43:21 -0400 | [diff] [blame] | 491 | } |
Jeff King | 3813e69 | 2011-05-23 16:30:14 -0400 | [diff] [blame] | 492 | |
Nguyễn Thái Ngọc Duy | bd7ad45 | 2018-11-10 06:49:06 +0100 | [diff] [blame] | 493 | struct userdiff_driver *userdiff_get_textconv(struct repository *r, |
| 494 | struct userdiff_driver *driver) |
Jeff King | 3813e69 | 2011-05-23 16:30:14 -0400 | [diff] [blame] | 495 | { |
| 496 | if (!driver->textconv) |
| 497 | return NULL; |
| 498 | |
Jeff King | affe355 | 2024-02-26 05:27:29 -0500 | [diff] [blame] | 499 | if (driver->textconv_want_cache && !driver->textconv_cache && |
| 500 | have_git_dir()) { |
Jeff King | 3813e69 | 2011-05-23 16:30:14 -0400 | [diff] [blame] | 501 | struct notes_cache *c = xmalloc(sizeof(*c)); |
| 502 | struct strbuf name = STRBUF_INIT; |
| 503 | |
| 504 | strbuf_addf(&name, "textconv/%s", driver->name); |
Nguyễn Thái Ngọc Duy | bd7ad45 | 2018-11-10 06:49:06 +0100 | [diff] [blame] | 505 | notes_cache_init(r, c, name.buf, driver->textconv); |
Jeff King | 3813e69 | 2011-05-23 16:30:14 -0400 | [diff] [blame] | 506 | driver->textconv_cache = c; |
Rene Scharfe | 460c7eb | 2017-08-30 20:20:15 +0200 | [diff] [blame] | 507 | strbuf_release(&name); |
Jeff King | 3813e69 | 2011-05-23 16:30:14 -0400 | [diff] [blame] | 508 | } |
| 509 | |
| 510 | return driver; |
| 511 | } |
Ævar Arnfjörð Bjarmason | f12fa9e | 2021-04-08 17:04:19 +0200 | [diff] [blame] | 512 | |
| 513 | static int for_each_userdiff_driver_list(each_userdiff_driver_fn fn, |
| 514 | enum userdiff_driver_type type, void *cb_data, |
| 515 | struct userdiff_driver *drv, |
| 516 | int drv_size) |
| 517 | { |
| 518 | int i; |
| 519 | int ret; |
| 520 | for (i = 0; i < drv_size; i++) { |
| 521 | struct userdiff_driver *item = drv + i; |
| 522 | if ((ret = fn(item, type, cb_data))) |
| 523 | return ret; |
| 524 | } |
| 525 | return 0; |
| 526 | } |
| 527 | |
| 528 | int for_each_userdiff_driver(each_userdiff_driver_fn fn, void *cb_data) |
| 529 | { |
| 530 | int ret; |
| 531 | |
| 532 | ret = for_each_userdiff_driver_list(fn, USERDIFF_DRIVER_TYPE_CUSTOM, |
| 533 | cb_data, drivers, ndrivers); |
| 534 | if (ret) |
| 535 | return ret; |
| 536 | |
| 537 | ret = for_each_userdiff_driver_list(fn, USERDIFF_DRIVER_TYPE_BUILTIN, |
| 538 | cb_data, builtin_drivers, |
| 539 | ARRAY_SIZE(builtin_drivers)); |
| 540 | if (ret) |
| 541 | return ret; |
| 542 | |
| 543 | return 0; |
| 544 | } |