[v3] git: use ^=1 to toggle between 0 and 1

Commit Message

Seija Kijin Dec. 18, 2024, 12:42 a.m. UTC

From: Seija Kijin <[e-mail]>

If it is known that an int is either 1 or 0,
doing an exclusive or to switch instead of a
modulus makes more sense and is more efficient.

Signed-off-by: Seija <[e-mail]>
---
    git: use ^=1 to toggle between 0 and 1
    
    If it is known that an int is either 1 or 0, doing an exclusive or to
    switch instead of a modulus makes more sense and is more efficient.
    
    Signed-off-by: Seija Kijin [e-mail]

Published-As: https://github.com/gitgitgadget/git/releases/tag/pr-git-1620%2FAreaZR%2Fbuffer-v3
Fetch-It-Via: git fetch https://github.com/gitgitgadget/git pr-git-1620/AreaZR/buffer-v3
Pull-Request: https://github.com/git/git/pull/1620

Range-diff vs v2:

 1:  5819a51526b ! 1:  f6e75d8eff0 Use ^=1 to toggle between 0 and 1
     @@ Metadata
      Author: Seija Kijin <[e-mail]>
      
       ## Commit message ##
     -    Use ^=1 to toggle between 0 and 1
     +    git: use ^=1 to toggle between 0 and 1
      
          If it is known that an int is either 1 or 0,
          doing an exclusive or to switch instead of a


 diff.c                     | 2 +-
 t/helper/test-path-utils.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)


base-commit: 063bcebf0c917140ca0e705cbe0fdea127e90086

Comments

Junio C Hamano Dec. 18, 2024, 3:46 p.m. UTC | #1

"AreaZR via GitGitGadget" <[e-mail]> writes:

> From: Seija Kijin <[e-mail]>
>
> If it is known that an int is either 1 or 0,
> doing an exclusive or to switch instead of a
> modulus makes more sense and is more efficient.

FWIW, it is much more idiomatic in this codebase to say

	foo = !foo;

to flip the polarity of foo when foo is used as a Boolean.  It is
both more readable than toggling only the bottom bit, and it is much
more robust.  Here 'used as a Boolean' means 'is it zero, or is it
non-zero?', the norm used in the C language.

If the reference to "foo", other than the place where the value of
foo is consulted for the sole purpose of fliping between true-false,
were to check if it is true or not, i.e.

	if (foo)
		do something;
	else
		do something else;

then at this "real" use site, only the zero-ness of the value
matters.  foo==0 does something different from foo==1, but the code
behaves the same way as the case where foo==1, if foo==2 or foo==3.

But the code that flips by

	foo = 1 - foo;
	foo ^= 1;

makes an assumption different from and stricter than the real use
site.  It only allows foo==0 and foo==1 without a good reason.

But

	foo = !foo;

keeps the same assumption as the real use site, which is why we
prefer that form.

And like it or not, it is natural to assume that 0 is false and
everything else is true when writing in C, and especially in the
codebase of this project.  So let's not flip

	foo = !foo;

into

	foo ^= 1;

just to make it look different.  Going the other way, or rewriting
rewriting modulo 2 arithmetic into !foo form, would be more
preferrable.

The "flipped_block" is used like so:

	if (flipped_block && o->color_moved != COLOR_MOVED_BLOCKS)
		set MOVED_LINE_ALT bit in flags word;

so it is very much Boolean whose zero-ness matters.

Patch

diff --git a/diff.c b/diff.c
index 266ddf18e73..5c2ac8d6fd1 100644
--- a/diff.c
+++ b/diff.c
@@ -1231,7 +1231,7 @@  static void mark_color_as_moved(struct diff_options *o,
 							    &pmb_nr);
 
 			if (contiguous && pmb_nr && moved_symbol == l->s)
-				flipped_block = (flipped_block + 1) % 2;
+				flipped_block ^= 1;
 			else
 				flipped_block = 0;
 
diff --git a/t/helper/test-path-utils.c b/t/helper/test-path-utils.c
index 3129aa28fd2..0810647c722 100644
--- a/t/helper/test-path-utils.c
+++ b/t/helper/test-path-utils.c
@@ -188,7 +188,7 @@  static int check_dotfile(const char *x, const char **argv,
 	int res = 0, expect = 1;
 	for (; *argv; argv++) {
 		if (!strcmp("--not", *argv))
-			expect = !expect;
+			expect ^= 1;
 		else if (expect != (is_hfs(*argv) || is_ntfs(*argv)))
 			res = error("'%s' is %s.git%s", *argv,
 				    expect ? "not " : "", x);