$fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;				my $line1 = $1;				my $line2 = $2;				fix_insert_line($fixlinenr, ltrim($line1));				fix_insert_line($fixlinenr, "\+{");				if ($line2 !~ /^\s*$/) {					fix_insert_line($fixlinenr, "\+\t" . trim($line2));				}			}		} # open braces for enum, union and struct go on the same line.		if ($line =~ /^.\s*{/ &&		    $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {			if (ERROR("OPEN_BRACE",				  "open brace '{' following $1 go on the same line\n" . $hereprev) &&			    $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {				fix_delete_line($fixlinenr - 1, $prevrawline);				fix_delete_line($fixlinenr, $rawline);				my $fixedline = rtrim($prevrawline) . " {";				fix_insert_line($fixlinenr, $fixedline);				$fixedline = $rawline;				$fixedline =~ s/^(.\s*)\{\s*/$1\t/;				if ($fixedline !~ /^\+\s*$/) {					fix_insert_line($fixlinenr, $fixedline);				}			}		} # missing space after union, struct or enum definition		if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {			if (WARN("SPACING",				 "missing space after $1 definition\n" . $herecurr) &&			    $fix) {				$fixed[$fixlinenr] =~				    s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;			}		} # Function pointer declarations# check spacing between type, funcptr, and args# canonical declaration is "type (*funcptr)(args...)"		if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {			my $declare = $1;			my $pre_pointer_space = $2;			my $post_pointer_space = $3;			my $funcname = $4;			my $post_funcname_space = $5;			my $pre_args_space = $6; # the $Declare variable will capture all spaces after the type# so check it for a missing trailing missing space but pointer return types# don't need a space so don't warn for those.			my $post_declare_space = "";			if ($declare =~ /(\s+)$/) {				$post_declare_space = $1;				$declare = rtrim($declare);			}			if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {				WARN("SPACING",				     "missing space after return type\n" . $herecurr);				$post_declare_space = " ";			} # unnecessary space "type  (*funcptr)(args...)"# This test is not currently implemented because these declarations are# equivalent to#	int  foo(int bar, ...)# and this is form shouldn't/doesn't generate a checkpatch warning.##			elsif ($declare =~ /\s{2,}$/) {#				WARN("SPACING",#				     "Multiple spaces after return type\n" . $herecurr);#			} # unnecessary space "type ( *funcptr)(args...)"			if (defined $pre_pointer_space &&			    $pre_pointer_space =~ /^\s/) {				WARN("SPACING",				     "Unnecessary space after function pointer open parenthesis\n" . $herecurr);			} # unnecessary space "type (* funcptr)(args...)"			if (defined $post_pointer_space &&			    $post_pointer_space =~ /^\s/) {				WARN("SPACING",				     "Unnecessary space before function pointer name\n" . $herecurr);			} # unnecessary space "type (*funcptr )(args...)"			if (defined $post_funcname_space &&			    $post_funcname_space =~ /^\s/) {				WARN("SPACING",				     "Unnecessary space after function pointer name\n" . $herecurr);			} # unnecessary space "type (*funcptr) (args...)"			if (defined $pre_args_space &&			    $pre_args_space =~ /^\s/) {				WARN("SPACING",				     "Unnecessary space before function pointer arguments\n" . $herecurr);			} 			if (show_type("SPACING") && $fix) {				$fixed[$fixlinenr] =~				    s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;			}		} # check for spacing round square brackets; allowed:#  1. with a type on the left -- int [] a;#  2. at the beginning of a line for slice initialisers -- [0...10] = 5,#  3. inside a curly brace -- = { [0...10] = 5 }		while ($line =~ /(.*?\s)\[/g) {			my ($where, $prefix) = ($-[1], $1);			if ($prefix !~ /$Type\s+$/ &&			    ($where != 0 || $prefix !~ /^.\s+$/) &&			    $prefix !~ /[{,:]\s+$/) {				if (ERROR("BRACKET_SPACE",					  "space prohibited before open square bracket '['\n" . $herecurr) &&				    $fix) {				    $fixed[$fixlinenr] =~					s/^(\+.*?)\s+\[/$1\[/;				}			}		} # check for spaces between functions and their parentheses.		while ($line =~ /($Ident)\s+\(/g) {			my $name = $1;			my $ctx_before = substr($line, 0, $-[1]);			my $ctx = "$ctx_before$name"; 			# Ignore those directives where spaces _are_ permitted.			if ($name =~ /^(?:				if|for|while|switch|return|case|				volatile|__volatile__|				__attribute__|format|__extension__|				asm|__asm__|scoped_guard)$/x)			{			# cpp #define statements have non-optional spaces, ie			# if there is a space between the name and the open			# parenthesis it is simply not a parameter group.			} elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) { 			# cpp #elif statement condition may start with a (			} elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) { 			# If this whole things ends with a type its most			# likely a typedef for a function.			} elsif ($ctx =~ /$Type$/) { 			} else {				if (WARN("SPACING",					 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&					     $fix) {					$fixed[$fixlinenr] =~					    s/\b$name\s+\(/$name\(/;				}			}		} # Check operator spacing.		if (!($line=~/\#\s*include/)) {			my $fixed_line = "";			my $line_fixed = 0; 			my $ops = qr{				<<=|>>=|<=|>=|==|!=|				\+=|-=|\*=|\/=|%=|\^=|\|=|&=|				=>|->|<<|>>|<|>|=|!|~|				&&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|				\?:|\?|:			}x;			my @elements = split(/($ops|;)/, $opline); ##			print("element count: <" . $#elements . ">\n");##			foreach my $el (@elements) {##				print("el: <$el>\n");##			} 			my @fix_elements = ();			my $off = 0; 			foreach my $el (@elements) {				push(@fix_elements, substr($rawline, $off, length($el)));				$off += length($el);			} 			$off = 0; 			my $blank = copy_spacing($opline);			my $last_after = -1; 			for (my $n = 0; $n < $#elements; $n += 2) { 				my $good = $fix_elements[$n] . $fix_elements[$n + 1]; ##				print("n: <$n> good: <$good>\n"); 				$off += length($elements[$n]); 				# Pick up the preceding and succeeding characters.				my $ca = substr($opline, 0, $off);				my $cc = '';				if (length($opline) >= ($off + length($elements[$n + 1]))) {					$cc = substr($opline, $off + length($elements[$n + 1]));				}				my $cb = "$ca$;$cc"; 				my $a = '';				$a = 'V' if ($elements[$n] ne '');				$a = 'W' if ($elements[$n] =~ /\s$/);				$a = 'C' if ($elements[$n] =~ /$;$/);				$a = 'B' if ($elements[$n] =~ /(\[|\()$/);				$a = 'O' if ($elements[$n] eq '');				$a = 'E' if ($ca =~ /^\s*$/); 				my $op = $elements[$n + 1]; 				my $c = '';				if (defined $elements[$n + 2]) {					$c = 'V' if ($elements[$n + 2] ne '');					$c = 'W' if ($elements[$n + 2] =~ /^\s/);					$c = 'C' if ($elements[$n + 2] =~ /^$;/);					$c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);					$c = 'O' if ($elements[$n + 2] eq '');					$c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);				} else {					$c = 'E';				} 				my $ctx = "${a}x${c}"; 				my $at = "(ctx:$ctx)"; 				my $ptr = substr($blank, 0, $off) . "^";				my $hereptr = "$hereline$ptr\n"; 				# Pull out the value of this operator.				my $op_type = substr($curr_values, $off + 1, 1); 				# Get the full operator variant.				my $opv = $op . substr($curr_vars, $off, 1); 				# Ignore operators passed as parameters.				if ($op_type ne 'V' &&				    $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) { #				# Ignore comments#				} elsif ($op =~ /^$;+$/) { 				# ; should have either the end of line or a space or \ after it				} elsif ($op eq ';') {					if ($ctx !~ /.x[WEBC]/ &&					    $cc !~ /^\\/ && $cc !~ /^;/) {						if (ERROR("SPACING",							  "space required after that '$op' $at\n" . $hereptr)) {							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";							$line_fixed = 1;						}					} 				# // is a comment				} elsif ($op eq '//') { 				#   :   when part of a bitfield				} elsif ($opv eq ':B') {					# skip the bitfield test for now 				# No spaces for:				#   ->				} elsif ($op eq '->') {					if ($ctx =~ /Wx.|.xW/) {						if (ERROR("SPACING",							  "spaces prohibited around that '$op' $at\n" . $hereptr)) {							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);							if (defined $fix_elements[$n + 2]) {								$fix_elements[$n + 2] =~ s/^\s+//;							}							$line_fixed = 1;						}					} 				# , must not have a space before and must have a space on the right.				} elsif ($op eq ',') {					my $rtrim_before = 0;					my $space_after = 0;					if ($ctx =~ /Wx./) {						if (ERROR("SPACING",							  "space prohibited before that '$op' $at\n" . $hereptr)) {							$line_fixed = 1;							$rtrim_before = 1;						}					}					if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {						if (ERROR("SPACING",							  "space required after that '$op' $at\n" . $hereptr)) {							$line_fixed = 1;							$last_after = $n;							$space_after = 1;						}					}					if ($rtrim_before || $space_after) {						if ($rtrim_before) {							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);						} else {							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);						}						if ($space_after) {							$good .= " ";						}					} 				# '*' as part of a type definition -- reported already.				} elsif ($opv eq '*_') {					#warn "'*' is part of type\n"; 				# unary operators should have a space before and				# none after.  May be left adjacent to another				# unary operator, or a cast				} elsif ($op eq '!' || $op eq '~' ||					 $opv eq '*U' || $opv eq '-U' ||					 $opv eq '&U' || $opv eq '&&U') {					if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {						if (ERROR("SPACING",							  "space required before that '$op' $at\n" . $hereptr)) {							if ($n != $last_after + 2) {								$good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);								$line_fixed = 1;							}						}					}					if ($op eq '*' && $cc =~/\s*$Modifier\b/) {						# A unary '*' may be const 					} elsif ($ctx =~ /.xW/) {						if (ERROR("SPACING",							  "space prohibited after that '$op' $at\n" . $hereptr)) {							$good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);							if (defined $fix_elements[$n + 2]) {								$fix_elements[$n + 2] =~ s/^\s+//;							}							$line_fixed = 1;						}					} 				# unary ++ and unary -- are allowed no space on one side.				} elsif ($op eq '++' or $op eq '--') {					if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {						if (ERROR("SPACING",							  "space required one side of that '$op' $at\n" . $hereptr)) {							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";							$line_fixed = 1;						}					}					if ($ctx =~ /Wx[BE]/ ||					    ($ctx =~ /Wx./ && $cc =~ /^;/)) {						if (ERROR("SPACING",							  "space prohibited before that '$op' $at\n" . $hereptr)) {							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);							$line_fixed = 1;						}					}					if ($ctx =~ /ExW/) {						if (ERROR("SPACING",							  "space prohibited after that '$op' $at\n" . $hereptr)) {							$good = $fix_elements[$n] . trim($fix_elements[$n + 1]);							if (defined $fix_elements[$n + 2]) {								$fix_elements[$n + 2] =~ s/^\s+//;							}							$line_fixed = 1;						}					} 				# << and >> may either have or not have spaces both sides				} elsif ($op eq '<<' or $op eq '>>' or					 $op eq '&' or $op eq '^' or $op eq '|' or					 $op eq '+' or $op eq '-' or					 $op eq '*' or $op eq '/' or					 $op eq '%')				{					if ($check) {						if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {							if (CHK("SPACING",								"spaces preferred around that '$op' $at\n" . $hereptr)) {								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";								$fix_elements[$n + 2] =~ s/^\s+//;								$line_fixed = 1;							}						} elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {							if (CHK("SPACING",								"space preferred before that '$op' $at\n" . $hereptr)) {								$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);								$line_fixed = 1;							}						}					} elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {						if (ERROR("SPACING",							  "need consistent spacing around '$op' $at\n" . $hereptr)) {							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";							if (defined $fix_elements[$n + 2]) {								$fix_elements[$n + 2] =~ s/^\s+//;							}							$line_fixed = 1;						}					} 				# A colon needs no spaces before when it is				# terminating a case value or a label.				} elsif ($opv eq ':C' || $opv eq ':L') {					if ($ctx =~ /Wx./ and $realfile !~ m@.*\.lds\.h$@) {						if (ERROR("SPACING",							  "space prohibited before that '$op' $at\n" . $hereptr)) {							$good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);							$line_fixed = 1;						}					} 				# All the others need spaces both sides.				} elsif ($ctx !~ /[EWC]x[CWE]/) {					my $ok = 0; 					# Ignore email addresses <foo@bar>					if (($op eq '<' &&					     $cc =~ /^\S+\@\S+>/) ||					    ($op eq '>' &&					     $ca =~ /<\S+\@\S+$/))					{						$ok = 1;					} 					# for asm volatile statements					# ignore a colon with another					# colon immediately before or after					if (($op eq ':') &&					    ($ca =~ /:$/ || $cc =~ /^:/)) {						$ok = 1;					} 					# messages are ERROR, but ?: are CHK					if ($ok == 0) {						my $msg_level = \&ERROR;						$msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/); 						if (&{$msg_level}("SPACING",								  "spaces required around that '$op' $at\n" . $hereptr)) {							$good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";							if (defined $fix_elements[$n + 2]) {								$fix_elements[$n + 2] =~ s/^\s+//;							}							$line_fixed = 1;						}					}				}				$off += length($elements[$n + 1]); ##				print("n: <$n> GOOD: <$good>\n"); 				$fixed_line = $fixed_line . $good;			} 			if (($#elements % 2) == 0) {				$fixed_line = $fixed_line . $fix_elements[$#elements];			} 			if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {				$fixed[$fixlinenr] = $fixed_line;			}  		} # check for whitespace before a non-naked semicolon		if ($line =~ /^\+.*\S\s+;\s*$/) {			if (WARN("SPACING",				 "space prohibited before semicolon\n" . $herecurr) &&			    $fix) {				1 while $fixed[$fixlinenr] =~				    s/^(\+.*\S)\s+;/$1;/;			}		} # check for multiple assignments		if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {			CHK("MULTIPLE_ASSIGNMENTS",			    "multiple assignments should be avoided\n" . $herecurr);		} ## # check for multiple declarations, allowing for a function declaration## # continuation.## 		if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&## 		    $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {#### 			# Remove any bracketed sections to ensure we do not## 			# falsely report the parameters of functions.## 			my $ln = $line;## 			while ($ln =~ s/\([^\(\)]*\)//g) {## 			}## 			if ($ln =~ /,/) {

Lines 5001–5500 of 7976. Previous lines Load more