├── .gitignore
├── README.md
└── jsstyle


/.gitignore:
--------------------------------------------------------------------------------
1 | /tmp
2 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # jsstyle
  2 | 
  3 | ## Overview
  4 | 
  5 | `jsstyle` is a style checker for JavaScript coding style.  This tool is derived
  6 | from the cstyle tool used to check for the style used in the Solaris kernel,
  7 | sometimes known as "Bill Joy Normal Form".  This tool is a *little bit*
  8 | configurable. However it strives to enforces a single coding style based on
  9 | that cstyle. See "Configuration Options" below.
 10 | 
 11 | The original cstyle tool can be found here:
 12 | <https://github.com/illumos/illumos-gate/blob/master/usr/src/tools/scripts/cstyle.pl>
 13 | 
 14 | The document describing C Style is available here:
 15 | <http://www.cis.upenn.edu/~lee/06cse480/data/cstyle.ms.pdf>
 16 | 
 17 | Examples of conditions checked by this tool include:
 18 | 
 19 | * Strings must be quoted with single quotes.
 20 | * Blocks must be indented with tabs, not spaces.
 21 | * Continuation lines must be indented with 4 spaces.
 22 | * Keywords (for, if, function, etc.) must be followed with a space.
 23 | * One line cannot contain multiple keywords.
 24 | * Relational operators must be surrounded with spaces.
 25 | * There must be no spaces between tabs, nor tabs between spaces.
 26 | * Lines must not end with whitespace.
 27 | * Multi-line block comments must start and end with a blank line.
 28 | * Return expressions must be parenthesized.
 29 | 
 30 | 
 31 | ## Status
 32 | 
 33 | No new features planned.  The biggest known issue is that jsstyle doesn't grok
 34 | regexes, so you usually need to wrap these in JSSTYLED comments (see below).
 35 | 
 36 | 
 37 | ## Usage
 38 | 
 39 |     jsstyle [OPTIONS] file1.js [file2.js ...]
 40 | 
 41 | 
 42 | ## Configuration Options
 43 | 
 44 | Configuration options may be specified in a file (one option per line)
 45 | with the "-f PATH" switch, or on the command line with the "-o
 46 | OPTION1,OPTION2" switch.
 47 | 
 48 | As stated about, `jsstyle` is opinionated and intends to stay that way.
 49 | That said, this author was arm twisted under duress to allow the following
 50 | configurability.
 51 | 
 52 |     doxygen                 Allow doxygen-style block comments `/** /*!`.
 53 |     splint                  Allow splint-style lint comments `/*@ ... @*/`.
 54 |                             This is legacy. Does anyone use this?
 55 |     indent=<NUM|tab>        An integer number of spaces for indentation, or
 56 |                             'tab' for tab indentation (the default).
 57 |     strict-indent           Boolean option, set to 1 to force indents of spaces
 58 |                             to be a multiple of indent parameter.
 59 |     line-length             An integer number to specify the maximum length
 60 |                             of a line (default: 80)
 61 |     literal-string-quote    'single' (the default) or 'double'. Specifies
 62 |                             the preferred quote character for literal strings.
 63 |     unparenthesized-return  Boolean option, set to 0 to disable the
 64 |                             "unparenthesized return expression" check.
 65 |     blank-after-start-comment
 66 |                             Boolean option, set to 0 to disable the
 67 |                             "missing blank after start comment" check. `// `
 68 |     blank-after-open-comment
 69 |                             Boolean option, set to 0 to disable the
 70 |                             "missing blank after open comment" check. `/* */`
 71 |     no-blank-for-anon-function
 72 |                             Boolean option, set to 1 to allow anonymous
 73 |                             functions without blank before paren. `function() { ... }`
 74 |     continuation-at-front   Boolean option, set to 1 to force continations
 75 |                             to be at the beginning rather than end of line.
 76 |     leading-right-paren-ok  Boolean option, set to 1 to allow ) to start a
 77 |                             line.
 78 | 
 79 |     whitespace-after-left-paren-ok
 80 |                             Boolean option, allow whitespace after a (
 81 |                             character.
 82 | 
 83 |     leading-comma-ok        Boolean option to allow lines to begin with commas
 84 |                             (preceded by whitespace).
 85 | 
 86 |     uncuddled-else-ok       Boolean option to allow for an else block to begin
 87 |                             on a new line.
 88 | 
 89 | ## "JSSTYLED"-comments
 90 | 
 91 | When you want `jsstyle` to ignore a line, you can use this:
 92 | 
 93 |     /* JSSTYLED */
 94 |     ignore = this + line;
 95 | 
 96 | Or for a block:
 97 | 
 98 |     /* BEGIN JSSTYLED */
 99 |     var here
100 |       , be
101 |       , some = funky
102 |       , style
103 |     /* END JSSTYLED */
104 | 
105 | 
106 | ## License
107 | 
108 | CDDL
109 | 


--------------------------------------------------------------------------------
/jsstyle:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env perl
  2 | #
  3 | # CDDL HEADER START
  4 | #
  5 | # The contents of this file are subject to the terms of the
  6 | # Common Development and Distribution License (the "License").
  7 | # You may not use this file except in compliance with the License.
  8 | #
  9 | # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 10 | # or http://www.opensolaris.org/os/licensing.
 11 | # See the License for the specific language governing permissions
 12 | # and limitations under the License.
 13 | #
 14 | # When distributing Covered Code, include this CDDL HEADER in each
 15 | # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 16 | # If applicable, add the following below this CDDL HEADER, with the
 17 | # fields enclosed by brackets "[]" replaced with your own identifying
 18 | # information: Portions Copyright [yyyy] [name of copyright owner]
 19 | #
 20 | # CDDL HEADER END
 21 | #
 22 | #
 23 | # Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 24 | # Use is subject to license terms.
 25 | #
 26 | # Copyright 2017 Joyent, Inc. All rights reserved.
 27 | #
 28 | # jsstyle - check for some common stylistic errors.
 29 | #
 30 | #	jsstyle is a sort of "lint" for Javascript coding style.  This tool is
 31 | #	derived from the cstyle tool, used to check for the style used in the
 32 | #	Solaris kernel, sometimes known as "Bill Joy Normal Form".
 33 | #
 34 | #	There's a lot this can't check for, like proper indentation of code
 35 | #	blocks.  There's also a lot more this could check for.
 36 | #
 37 | #	A note to the non perl literate:
 38 | #
 39 | #		perl regular expressions are pretty much like egrep
 40 | #		regular expressions, with the following special symbols
 41 | #
 42 | #		\s	any space character
 43 | #		\S	any non-space character
 44 | #		\w	any "word" character [a-zA-Z0-9_]
 45 | #		\W	any non-word character
 46 | #		\d	a digit [0-9]
 47 | #		\D	a non-digit
 48 | #		\b	word boundary (between \w and \W)
 49 | #		\B	non-word boundary
 50 | #
 51 | 
 52 | require 5.0;
 53 | use IO::File;
 54 | use Getopt::Std;
 55 | use strict;
 56 | 
 57 | my $usage =
 58 | "Usage: jsstyle [-h?vcC] [-t <num>] [-f <path>] [-o <config>] file ...
 59 | 
 60 | Check your JavaScript file for style.
 61 | See <https://github.com/joyent/jsstyle> for details on config options.
 62 | Report bugs to <https://github.com/joyent/jsstyle/issues>.
 63 | 
 64 | Options:
 65 | 	-h 	print this help and exit
 66 | 	-v	verbose
 67 | 
 68 | 	-c	check continuation indentation inside functions
 69 | 	-t	specify tab width for line length calculation
 70 | 	-C	don't check anything in header block comments
 71 | 
 72 | 	-f PATH
 73 | 		path to a jsstyle config file
 74 | 	-o OPTION1,OPTION2
 75 | 		set config options, e.g. '-o doxygen,indent=2'
 76 | 
 77 | ";
 78 | 
 79 | my %opts;
 80 | 
 81 | if (!getopts("ch?o:t:f:vC", \%opts)) {
 82 | 	print $usage;
 83 | 	exit 2;
 84 | }
 85 | 
 86 | if (defined($opts{'h'}) || defined($opts{'?'})) {
 87 | 	print $usage;
 88 | 	exit;
 89 | }
 90 | 
 91 | my $check_continuation = $opts{'c'};
 92 | my $verbose = $opts{'v'};
 93 | my $ignore_hdr_comment = $opts{'C'};
 94 | my $tab_width = $opts{'t'};
 95 | 
 96 | # By default, tabs are 8 characters wide
 97 | if (! defined($opts{'t'})) {
 98 | 	$tab_width = 8;
 99 | }
100 | 
101 | 
102 | # Load config
103 | my %config = (
104 | 	indent => "tab",
105 | 	"line-length" => 80,
106 | 	doxygen => 0,  	# doxygen comments: /** ... */
107 | 	splint => 0,    # splint comments. Needed?
108 | 	"unparenthesized-return" => 1,
109 | 	"literal-string-quote" => "single",  # 'single' or 'double'
110 | 	"blank-after-start-comment" => 1,
111 | 	"blank-after-open-comment" => 1,
112 | 	"no-blank-for-anon-function" => 0,
113 | 	"continuation-at-front" => 0,
114 | 	"leading-right-paren-ok" => 0,
115 | 	"strict-indent" => 0
116 | );
117 | sub add_config_var ($$) {
118 | 	my ($scope, $str) = @_;
119 | 
120 | 	if ($str !~ /^([\w-]+)(?:\s*=\s*(.*?))?$/) {
121 | 		die "$scope: invalid option: '$str'";
122 | 	}
123 | 	my $name = $1;
124 | 	my $value = ($2 eq '' ? 1 : $2);
125 | 	#print "scope: '$scope', str: '$str', name: '$name', value: '$value'\n";
126 | 
127 | 	# Validate config var.
128 | 	if ($name eq "indent") {
129 | 		# A number of spaces or "tab".
130 | 		if ($value !~ /^\d+$/ && $value ne "tab") {
131 | 			die "$scope: invalid '$name': must be a number (of ".
132 | 				"spaces) or 'tab'";
133 | 		}
134 | 	} elsif ($name eq "line-length") { # numeric vars
135 | 		if ($value !~ /^\d+$/) {
136 | 			die "$scope: invalid '$name': must be a number";
137 | 		}
138 | 	} elsif ($name eq "doxygen" ||   # boolean vars
139 | 		 $name eq "splint" ||
140 | 		 $name eq "unparenthesized-return" ||
141 | 		 $name eq "continuation-at-front" ||
142 | 		 $name eq "leading-right-paren-ok" ||
143 | 		 $name eq "leading-comma-ok" ||
144 | 		 $name eq "uncuddled-else-ok" ||
145 | 		 $name eq "whitespace-after-left-paren-ok" ||
146 | 		 $name eq "strict-indent" ||
147 | 		 $name eq "blank-after-open-comment" ||
148 | 		 $name eq "blank-after-start-comment" ||
149 | 		 $name eq "no-blank-for-anon-function") {
150 | 
151 | 		if ($value != 1 && $value != 0) {
152 | 			die "$scope: invalid '$name': don't give a value";
153 | 		}
154 | 	} elsif ($name eq "literal-string-quote") {
155 | 		if ($value !~ /single|double/) {
156 | 			die "$scope: invalid '$name': must be 'single' ".
157 | 				"or 'double'";
158 | 		}
159 | 	} else {
160 | 		die "$scope: unknown config var: $name";
161 | 	}
162 | 	$config{$name} = $value;
163 | }
164 | 
165 | if (defined($opts{'f'})) {
166 | 	my $path = $opts{'f'};
167 | 	my $fh = new IO::File $path, "r";
168 | 	if (!defined($fh)) {
169 | 		die "cannot open config path '$path'";
170 | 	}
171 | 	my $line = 0;
172 | 	while (<$fh>) {
173 | 		$line++;
174 | 		s/^\s*//;  # drop leading space
175 | 		s/\s*$//;  # drop trailing space
176 | 		next if ! $_;  # skip empty line
177 | 		next if /^#/;  # skip comments
178 | 		add_config_var "$path:$line", $_;
179 | 	}
180 | }
181 | 
182 | if (defined($opts{'o'})) {
183 | 	for my $x (split /,/, $opts{'o'}) {
184 | 		add_config_var "'-o' option", $x;
185 | 	}
186 | }
187 | 
188 | 
189 | my ($filename, $line, $prev);		# shared globals
190 | 
191 | my $fmt;
192 | my $hdr_comment_start;
193 | 
194 | if ($verbose) {
195 | 	$fmt = "%s: %d: %s\n%s\n";
196 | } else {
197 | 	$fmt = "%s: %d: %s\n";
198 | }
199 | 
200 | if ($config{"doxygen"}) {
201 | 	# doxygen comments look like "/*!" or "/**"; allow them.
202 | 	$hdr_comment_start = qr/^\s*\/\*[\!\*]?$/;
203 | } else {
204 | 	$hdr_comment_start = qr/^\s*\/\*$/;
205 | }
206 | 
207 | # Note, following must be in single quotes so that \s and \w work right.
208 | my $lint_re = qr/\/\*(?:
209 | 	jsl:\w+?|ARGSUSED[0-9]*|NOTREACHED|LINTLIBRARY|VARARGS[0-9]*|
210 | 	CONSTCOND|CONSTANTCOND|CONSTANTCONDITION|EMPTY|
211 | 	FALLTHRU|FALLTHROUGH|LINTED.*?|PRINTFLIKE[0-9]*|
212 | 	PROTOLIB[0-9]*|SCANFLIKE[0-9]*|JSSTYLED.*?
213 |     )\*\//x;
214 | 
215 | my $splint_re = qr/\/\*@.*?@\*\//x;
216 | 
217 | my $err_stat = 0;		# exit status
218 | 
219 | if ($#ARGV >= 0) {
220 | 	foreach my $arg (@ARGV) {
221 | 		open(my $fh, "<:encoding(UTF-8)", $arg);
222 | 		if (!defined($fh)) {
223 | 			printf "%s: cannot open\n", $arg;
224 | 		} else {
225 | 			&jsstyle($arg, $fh);
226 | 			close $fh;
227 | 		}
228 | 	}
229 | } else {
230 | 	&jsstyle("<stdin>", *STDIN);
231 | }
232 | exit $err_stat;
233 | 
234 | my $no_errs = 0;		# set for JSSTYLED-protected lines
235 | 
236 | sub err($) {
237 | 	my ($error) = @_;
238 | 	unless ($no_errs) {
239 | 		printf $fmt, $filename, $., $error, $line;
240 | 		$err_stat = 1;
241 | 	}
242 | }
243 | 
244 | sub err_prefix($$) {
245 | 	my ($prevline, $error) = @_;
246 | 	my $out = $prevline."\n".$line;
247 | 	unless ($no_errs) {
248 | 		printf $fmt, $filename, $., $error, $out;
249 | 		$err_stat = 1;
250 | 	}
251 | }
252 | 
253 | sub err_prev($) {
254 | 	my ($error) = @_;
255 | 	unless ($no_errs) {
256 | 		printf $fmt, $filename, $. - 1, $error, $prev;
257 | 		$err_stat = 1;
258 | 	}
259 | }
260 | 
261 | sub jsstyle($$) {
262 | 
263 | my ($fn, $filehandle) = @_;
264 | $filename = $fn;			# share it globally
265 | 
266 | my $in_cpp = 0;
267 | my $next_in_cpp = 0;
268 | 
269 | my $in_comment = 0;
270 | my $in_header_comment = 0;
271 | my $comment_done = 0;
272 | my $in_function = 0;
273 | my $in_function_header = 0;
274 | my $in_declaration = 0;
275 | my $note_level = 0;
276 | my $nextok = 0;
277 | my $nocheck = 0;
278 | 
279 | my $in_string = 0;
280 | 
281 | my ($okmsg, $comment_prefix);
282 | 
283 | $line = '';
284 | $prev = '';
285 | reset_indent();
286 | 
287 | line: while (<$filehandle>) {
288 | 	s/\r?\n$//;	# strip return and newline
289 | 
290 | 	# save the original line, then remove all text from within
291 | 	# double or single quotes, we do not want to check such text.
292 | 
293 | 	$line = $_;
294 | 
295 | 	#
296 | 	# C allows strings to be continued with a backslash at the end of
297 | 	# the line.  We translate that into a quoted string on the previous
298 | 	# line followed by an initial quote on the next line.
299 | 	#
300 | 	# (we assume that no-one will use backslash-continuation with character
301 | 	# constants)
302 | 	#
303 | 	$_ = '"' . $_		if ($in_string && !$nocheck && !$in_comment);
304 | 
305 | 	#
306 | 	# normal strings and characters
307 | 	#
308 | 	s/'([^\\']|\\.)*'/\'\'/g;
309 | 	s/"([^\\"]|\\.)*"/\"\"/g;
310 | 
311 | 	#
312 | 	# Strip out contents of easily identifiable regular expressions so that
313 | 	# they don't trip us up. We only modify those that start with '^' or end
314 | 	# with '$' since these are unlikely to be confused with other legitimate
315 | 	# uses of '/' (such as division or comments).
316 | 	#
317 | 	s!/\^([^\\/]|\\.)*/!/ /!g;
318 | 	s!/([^\\/]|\\.)*\$/!/ /!g;
319 | 
320 | 	#
321 | 	# detect string continuation
322 | 	#
323 | 	if ($nocheck || $in_comment) {
324 | 		$in_string = 0;
325 | 	} else {
326 | 		#
327 | 		# Now that all full strings are replaced with "", we check
328 | 		# for unfinished strings continuing onto the next line.
329 | 		#
330 | 		$in_string =
331 | 		    (s/([^"](?:"")*)"([^\\"]|\\.)*\\$/$1""/ ||
332 | 		    s/^("")*"([^\\"]|\\.)*\\$/""/);
333 | 	}
334 | 
335 | 	#
336 | 	# figure out if we are in a cpp directive
337 | 	#
338 | 	$in_cpp = $next_in_cpp || /^\s*#/;	# continued or started
339 | 	$next_in_cpp = $in_cpp && /\\$/;	# only if continued
340 | 
341 | 	# strip off trailing backslashes, which appear in long macros
342 | 	s/\s*\\$//;
343 | 
344 | 	# an /* END JSSTYLED */ comment ends a no-check block.
345 | 	if ($nocheck) {
346 | 		if (/\/\* *END *JSSTYLED *\*\//) {
347 | 			$nocheck = 0;
348 | 		} else {
349 | 			reset_indent();
350 | 			next line;
351 | 		}
352 | 	}
353 | 
354 | 	# a /*JSSTYLED*/ comment indicates that the next line is ok.
355 | 	if ($nextok) {
356 | 		if ($okmsg) {
357 | 			err($okmsg);
358 | 		}
359 | 		$nextok = 0;
360 | 		$okmsg = 0;
361 | 		if (/\/\* *JSSTYLED.*\*\//) {
362 | 			/^.*\/\* *JSSTYLED *(.*) *\*\/.*$/;
363 | 			$okmsg = $1;
364 | 			$nextok = 1;
365 | 		}
366 | 		$no_errs = 1;
367 | 	} elsif ($no_errs) {
368 | 		$no_errs = 0;
369 | 	}
370 | 
371 | 	# check length of line.
372 | 	# first, a quick check to see if there is any chance of being too long.
373 | 	if ((($line =~ tr/\t/\t/) * ($tab_width - 1)) + length($line) > $config{"line-length"}) {
374 | 		# yes, there is a chance.
375 | 		# replace tabs with spaces and check again.
376 | 		my $eline = $line;
377 | 		1 while $eline =~
378 | 		    s/\t+/' ' x
379 | 			(length($&) * $tab_width - length($`) % $tab_width)/e;
380 | 		if (length($eline) > $config{"line-length"}) {
381 | 			err("line > " . $config{"line-length"} . " characters");
382 | 		}
383 | 	}
384 | 
385 | 	# ignore NOTE(...) annotations (assumes NOTE is on lines by itself).
386 | 	if ($note_level || /\b_?NOTE\s*\(/) { # if in NOTE or this is NOTE
387 | 		s/[^()]//g;			  # eliminate all non-parens
388 | 		$note_level += s/\(//g - length;  # update paren nest level
389 | 		next;
390 | 	}
391 | 
392 | 	# a /* BEGIN JSSTYLED */ comment starts a no-check block.
393 | 	if (/\/\* *BEGIN *JSSTYLED *\*\//) {
394 | 		$nocheck = 1;
395 | 	}
396 | 
397 | 	# a /*JSSTYLED*/ comment indicates that the next line is ok.
398 | 	if (/\/\* *JSSTYLED.*\*\//) {
399 | 		/^.*\/\* *JSSTYLED *(.*) *\*\/.*$/;
400 | 		$okmsg = $1;
401 | 		$nextok = 1;
402 | 	}
403 | 	if (/\/\/ *JSSTYLED/) {
404 | 		/^.*\/\/ *JSSTYLED *(.*)$/;
405 | 		$okmsg = $1;
406 | 		$nextok = 1;
407 | 	}
408 | 
409 | 	# universal checks; apply to everything
410 | 	if (/\t +\t/) {
411 | 		err("spaces between tabs");
412 | 	}
413 | 	if (/ \t+ /) {
414 | 		err("tabs between spaces");
415 | 	}
416 | 	if (/\s$/) {
417 | 		err("space or tab at end of line");
418 | 	}
419 | 	if (/[^ \t(]\/\*/ && !/\w\(\/\*.*\*\/\);/) {
420 | 		err("comment preceded by non-blank");
421 | 	}
422 | 
423 | 	# is this the beginning or ending of a function?
424 | 	# (not if "struct foo\n{\n")
425 | 	if (/^{$/ && $prev =~ /\)\s*(const\s*)?(\/\*.*\*\/\s*)?\\?$/) {
426 | 		$in_function = 1;
427 | 		$in_declaration = 1;
428 | 		$in_function_header = 0;
429 | 		$prev = $line;
430 | 		next line;
431 | 	}
432 | 	if (/^}\s*(\/\*.*\*\/\s*)*$/) {
433 | 		if ($prev =~ /^\s*return\s*;/) {
434 | 			err_prev("unneeded return at end of function");
435 | 		}
436 | 		$in_function = 0;
437 | 		reset_indent();		# we don't check between functions
438 | 		$prev = $line;
439 | 		next line;
440 | 	}
441 | 	if (/^\w*\($/) {
442 | 		$in_function_header = 1;
443 | 	}
444 | 
445 | 	# a blank line terminates the declarations within a function.
446 | 	# XXX - but still a problem in sub-blocks.
447 | 	if ($in_declaration && /^$/) {
448 | 		$in_declaration = 0;
449 | 	}
450 | 
451 | 	if ($comment_done) {
452 | 		$in_comment = 0;
453 | 		$in_header_comment = 0;
454 | 		$comment_done = 0;
455 | 	}
456 | 	# does this looks like the start of a block comment?
457 | 	if (/$hdr_comment_start/) {
458 | 		if ($config{"indent"} eq "tab") {
459 | 			if (!/^\t*\/\*/) {
460 | 				err("block comment not indented by tabs");
461 | 			}
462 | 		} elsif (!/^ *\/\*/) {
463 | 			err("block comment not indented by spaces");
464 | 		}
465 | 		$in_comment = 1;
466 | 		/^(\s*)\//;
467 | 		$comment_prefix = $1;
468 | 		if ($comment_prefix eq "") {
469 | 			$in_header_comment = 1;
470 | 		}
471 | 		$prev = $line;
472 | 		next line;
473 | 	}
474 | 	# are we still in the block comment?
475 | 	if ($in_comment) {
476 | 		if (/^$comment_prefix \*\/$/) {
477 | 			$comment_done = 1;
478 | 		} elsif (/\*\//) {
479 | 			$comment_done = 1;
480 | 			err("improper block comment close")
481 | 			    unless ($ignore_hdr_comment && $in_header_comment);
482 | 		} elsif (!/^$comment_prefix \*[ \t]/ &&
483 | 		    !/^$comment_prefix \*$/) {
484 | 			err("improper block comment")
485 | 			    unless ($ignore_hdr_comment && $in_header_comment);
486 | 		}
487 | 	}
488 | 
489 | 	if ($in_header_comment && $ignore_hdr_comment) {
490 | 		$prev = $line;
491 | 		next line;
492 | 	}
493 | 
494 | 	# check for errors that might occur in comments and in code.
495 | 
496 | 	# allow spaces to be used to draw pictures in header comments.
497 | 	#if (/[^ ]     / && !/".*     .*"/ && !$in_header_comment) {
498 | 	#	err("spaces instead of tabs");
499 | 	#}
500 | 	#if (/^ / && !/^ \*[ \t\/]/ && !/^ \*$/ &&
501 | 	#    (!/^    \w/ || $in_function != 0)) {
502 | 	#	err("indent by spaces instead of tabs");
503 | 	#}
504 | 	if ($config{"indent"} eq "tab") {
505 | 		if (/^ {2,}/ && !/^    [^ ]/) {
506 | 			err("indent by spaces instead of tabs");
507 | 		}
508 | 	} elsif (/^\t/) {
509 | 		err("indent by tabs instead of spaces")
510 | 	} elsif (/^( +)/ && !$in_comment) {
511 | 		my $indent = $1;
512 | 		if (length($indent) < $config{"indent"}) {
513 | 			err("indent of " . length($indent) .
514 | 				" space(s) instead of " . $config{"indent"});
515 | 		} elsif ($config{"strict-indent"} &&
516 | 			length($indent) % $config{"indent"} != 0) {
517 | 			err("indent is " . length($indent) .
518 | 				" not a multiple of " . $config{'indent'} . " spaces");
519 | 		}
520 | 	}
521 | 	if (/^\t+ [^ \t\*]/ || /^\t+  \S/ || /^\t+   \S/) {
522 | 		err("continuation line not indented by 4 spaces");
523 | 	}
524 | 
525 | 	# A multi-line block comment must not have content on the first line.
526 | 	if (/^\s*\/\*./ && !/^\s*\/\*.*\*\// && !/$hdr_comment_start/) {
527 | 		err("improper first line of block comment");
528 | 	}
529 | 
530 | 	if ($in_comment) {	# still in comment, don't do further checks
531 | 		$prev = $line;
532 | 		next line;
533 | 	}
534 | 
535 | 	if ($config{"blank-after-open-comment"} && (/[^(]\/\*\S/ || /^\/\*\S/) &&
536 | 	    !(/$lint_re/ || ($config{"splint"} && /$splint_re/))) {
537 | 		err("missing blank after open comment");
538 | 	}
539 | 	if (/\S\*\/[^)]|\S\*\/$/ &&
540 | 	    !(/$lint_re/ || ($config{"splint"} && /$splint_re/))) {
541 | 		err("missing blank before close comment");
542 | 	}
543 | 	if ($config{"blank-after-start-comment"} && /(?<!\w:)\/\/\S/) {	# C++ comments
544 | 		err("missing blank after start comment");
545 | 	}
546 | 	# check for unterminated single line comments, but allow them when
547 | 	# they are used to comment out the argument list of a function
548 | 	# declaration.
549 | 	if (/\S.*\/\*/ && !/\S.*\/\*.*\*\// && !/\(\/\*/) {
550 | 		err("unterminated single line comment");
551 | 	}
552 | 
553 | 	if (/^(#else|#endif|#include)(.*)$/) {
554 | 		$prev = $line;
555 | 		next line;
556 | 	}
557 | 
558 | 	#
559 | 	# delete any comments and check everything else.  Note that
560 | 	# ".*?" is a non-greedy match, so that we don't get confused by
561 | 	# multiple comments on the same line.
562 | 	#
563 | 	s/\/\*.*?\*\//
/g;
564 | 	s/\/\/.*$/
/;		# C++ comments
565 | 
566 | 	# delete any trailing whitespace; we have already checked for that.
567 | 	s/\s*$//;
568 | 
569 | 	# following checks do not apply to text in comments.
570 | 	my $quote = $config{"literal-string-quote"};
571 | 	if ($quote eq "single") {
572 | 		if (/"/) {
573 | 			err("literal string using double-quote instead of single");
574 | 		}
575 | 	} elsif ($quote eq "double") {
576 | 		if (/'/) {
577 | 			err("literal string using single-quote instead of double");
578 | 		}
579 | 	}
580 | 
581 | 	if (/[^=!<>\s][!<>=]=/ || /[^<>!=][!<>=]==?[^\s,=]/ ||
582 | 	    (/[^->]>[^,=>\s]/ && !/[^->]>$/) ||
583 | 	    (/[^<]<[^,=<\s]/ && !/[^<]<$/) ||
584 | 	    /[^<\s]<[^<]/ || /[^->\s]>[^>]/) {
585 | 		err("missing space around relational operator");
586 | 	}
587 | 	if (/\S>>=/ || /\S<<=/ || />>=\S/ || /<<=\S/ || /\S[-+*\/&|^%]=/ ||
588 | 	    (/[^-+*\/&|^%!<>=\s]=[^=]/ && !/[^-+*\/&|^%!<>=\s]=$/) ||
589 | 	    (/[^!<>=]=[^=\s]/ && !/[^!<>=]=$/)) {
590 | 		# XXX - should only check this for C++ code
591 | 		# XXX - there are probably other forms that should be allowed
592 | 		if (!/\soperator=/) {
593 | 			err("missing space around assignment operator");
594 | 		}
595 | 	}
596 | 	if (/[,;]\S/ && !/\bfor \(;;\)/ &&
597 | 	    # Allow a comma in a regex quantifier.
598 | 	    !/\/.*?\{\d+,?\d*\}.*?\//) {
599 | 		err("comma or semicolon followed by non-blank");
600 | 	}
601 | 	# check for commas preceded by blanks
602 | 	if ((!$config{"leading-comma-ok"} && /^\s*,/) || (!/^\s*,/ && /\s,/)) {
603 | 		err("comma preceded by blank");
604 | 	}
605 | 	# check for semicolons preceded by blanks
606 | 	# allow "for" statements to have empty "while" clauses
607 | 	if (/\s;/ && !/^[\t]+;$/ && !/^\s*for \([^;]*; ;[^;]*\)/) {
608 | 		err("semicolon preceded by blank");
609 | 	}
610 | 	if (!$config{"continuation-at-front"} && /^\s*(&&|\|\|)/) {
611 | 		err("improper boolean continuation");
612 | 	} elsif ($config{"continuation-at-front"} && /(&&|\|\||[^+]\+)$/) {
613 | 		err("improper continuation");
614 | 	}
615 | 	if (/\S   *(&&|\|\|)/ || /(&&|\|\|)   *\S/) {
616 | 		err("more than one space around boolean operator");
617 | 	}
618 | 	# We allow methods which look like obj.delete() but not keywords without
619 | 	# spaces ala: delete(obj)
620 | 	if (!$config{"no-blank-for-anon-function"} && /(?<!\.)\bfunction\(/) {
621 | 		err("missing space between 'function' and paren");
622 | 	} elsif ($config{"no-blank-for-anon-function"} && /(?<!\.)\bfunction\s+\(/) {
623 | 		err("space between 'function' and paren");
624 | 	}
625 | 	if (/(?<!\.)\b(delete|typeof|instanceof|throw|with|catch|new|in|for|if|while|switch|return|case)\(/) {
626 | 		err("missing space between keyword and paren");
627 | 	}
628 | 	if (/(\b(catch|for|if|with|while|switch|return)\b.*){2,}/) {
629 | 		# multiple "case" and "sizeof" allowed
630 | 		err("more than one keyword on line");
631 | 	}
632 | 	if (/\b(delete|typeof|instanceOf|with|throw|catch|new|function|in|for|if|while|switch|return|case)\s\s+\(/ &&
633 | 	    !/^#if\s+\(/) {
634 | 		err("extra space between keyword and paren");
635 | 	}
636 | 	# try to detect "func (x)" but not "if (x)" or
637 | 	# "#define foo (x)" or "int (*func)();"
638 | 	if (/\w\s\(/) {
639 | 		my $s = $_;
640 | 		# strip off all keywords on the line
641 | 		s/\b(delete|typeof|instanceOf|throw|with|catch|new|function|in|for|if|while|switch|return|case)\s\(/XXX(/g;
642 | 		s/#elif\s\(/XXX(/g;
643 | 		s/^#define\s+\w+\s+\(/XXX(/;
644 | 		# do not match things like "void (*f)();"
645 | 		# or "typedef void (func_t)();"
646 | 		s/\w\s\(+\*/XXX(*/g;
647 | 		s/\b(void)\s+\(+/XXX(/og;
648 | 		if (/\w\s\(/) {
649 | 			err("extra space between function name and left paren");
650 | 		}
651 | 		$_ = $s;
652 | 	}
653 | 
654 | 	if ($config{"unparenthesized-return"} &&
655 | 	    /^\s*return\W[^;]*;/ && !/^\s*return\s*\(.*\);/) {
656 | 		err("unparenthesized return expression");
657 | 	}
658 | 	if (/\btypeof\b/ && !/\btypeof\s*\(.*\)/) {
659 | 		err("unparenthesized typeof expression");
660 | 	}
661 | 	if (!$config{"whitespace-after-left-paren-ok"} && /\(\s/) {
662 | 		err("whitespace after left paren");
663 | 	}
664 | 	# allow "for" statements to have empty "continue" clauses
665 | 	if (/\s\)/ && !/^\s*for \([^;]*;[^;]*; \)/) {
666 | 		if ($config{"leading-right-paren-ok"} && /^\s+\)/) {
667 | 			# this is allowed
668 | 		} else {
669 | 			err("whitespace before right paren");
670 | 		}
671 | 	}
672 | 	if (/^\s*\(void\)[^ ]/) {
673 | 		err("missing space after (void) cast");
674 | 	}
675 | 	if (/\S\{/ && !/(\{|\()\{/ &&
676 | 	    # Allow a brace in a regex quantifier.
677 | 	    !/\/.*?\{\d+,?\d*\}.*?\//) {
678 | 		err("missing space before left brace");
679 | 	}
680 | 	if ($in_function && /^\s+\{/ &&
681 | 	    ($prev =~ /\)\s*$/ || $prev =~ /\bstruct\s+\w+$/)) {
682 | 		err("left brace starting a line");
683 | 	}
684 | 	if (/}(else|while)/) {
685 | 		err("missing space after right brace");
686 | 	}
687 | 	if (/}\s\s+(else|while)/) {
688 | 		err("extra space after right brace");
689 | 	}
690 | 	if (/^\s+#/) {
691 | 		err("preprocessor statement not in column 1");
692 | 	}
693 | 	if (/^#\s/) {
694 | 		err("blank after preprocessor #");
695 | 	}
696 | 
697 | 	#
698 | 	# We completely ignore, for purposes of indentation:
699 | 	#  * lines outside of functions
700 | 	#  * preprocessor lines
701 | 	#
702 | 	if ($check_continuation && $in_function && !$in_cpp) {
703 | 		process_indent($_);
704 | 	}
705 | 
706 | 	if (/^\s*else\W/) {
707 | 		if (!$config{"uncuddled-else-ok"} && $prev =~ /^\s*}$/) {
708 | 			err_prefix($prev,
709 | 			    "else and right brace should be on same line");
710 | 		}
711 | 	}
712 | 	$prev = $line;
713 | }
714 | 
715 | if ($prev eq "") {
716 | 	err("last line in file is blank");
717 | }
718 | 
719 | }
720 | 
721 | #
722 | # Continuation-line checking
723 | #
724 | # The rest of this file contains the code for the continuation checking
725 | # engine.  It's a pretty simple state machine which tracks the expression
726 | # depth (unmatched '('s and '['s).
727 | #
728 | # Keep in mind that the argument to process_indent() has already been heavily
729 | # processed; all comments have been replaced by control-A, and the contents of
730 | # strings and character constants have been elided.
731 | #
732 | 
733 | my $cont_in;		# currently inside of a continuation
734 | my $cont_off;		# skipping an initializer or definition
735 | my $cont_noerr;		# suppress cascading errors
736 | my $cont_start;		# the line being continued
737 | my $cont_base;		# the base indentation
738 | my $cont_first;		# this is the first line of a statement
739 | my $cont_multiseg;	# this continuation has multiple segments
740 | 
741 | my $cont_special;	# this is a C statement (if, for, etc.)
742 | my $cont_macro;		# this is a macro
743 | my $cont_case;		# this is a multi-line case
744 | 
745 | my @cont_paren;		# the stack of unmatched ( and [s we've seen
746 | 
747 | sub
748 | reset_indent()
749 | {
750 | 	$cont_in = 0;
751 | 	$cont_off = 0;
752 | }
753 | 
754 | sub
755 | delabel($)
756 | {
757 | 	#
758 | 	# replace labels with tabs.  Note that there may be multiple
759 | 	# labels on a line.
760 | 	#
761 | 	local $_ = $_[0];
762 | 
763 | 	while (/^(\t*)( *(?:(?:\w+\s*)|(?:case\b[^:]*)): *)(.*)$/) {
764 | 		my ($pre_tabs, $label, $rest) = ($1, $2, $3);
765 | 		$_ = $pre_tabs;
766 | 		while ($label =~ s/^([^\t]*)(\t+)//) {
767 | 			$_ .= "\t" x (length($2) + length($1) / 8);
768 | 		}
769 | 		$_ .= ("\t" x (length($label) / 8)).$rest;
770 | 	}
771 | 
772 | 	return ($_);
773 | }
774 | 
775 | sub
776 | process_indent($)
777 | {
778 | 	require strict;
779 | 	local $_ = $_[0];			# preserve the global $_
780 | 
781 | 	s/
//g;	# No comments
782 | 	s/\s+$//;	# Strip trailing whitespace
783 | 
784 | 	return			if (/^$/);	# skip empty lines
785 | 
786 | 	# regexps used below; keywords taking (), macros, and continued cases
787 | 	my $special = '(?:(?:\}\s*)?else\s+)?(?:if|for|while|switch)\b';
788 | 	my $macro = '[A-Z_][A-Z_0-9]*\(';
789 | 	my $case = 'case\b[^:]*$';
790 | 
791 | 	# skip over enumerations, array definitions, initializers, etc.
792 | 	if ($cont_off <= 0 && !/^\s*$special/ &&
793 | 	    (/(?:(?:\b(?:enum|struct|union)\s*[^\{]*)|(?:\s+=\s*))\{/ ||
794 | 	    (/^\s*\{/ && $prev =~ /=\s*(?:\/\*.*\*\/\s*)*$/))) {
795 | 		$cont_in = 0;
796 | 		$cont_off = tr/{/{/ - tr/}/}/;
797 | 		return;
798 | 	}
799 | 	if ($cont_off) {
800 | 		$cont_off += tr/{/{/ - tr/}/}/;
801 | 		return;
802 | 	}
803 | 
804 | 	if (!$cont_in) {
805 | 		$cont_start = $line;
806 | 
807 | 		if (/^\t* /) {
808 | 			err("non-continuation indented 4 spaces");
809 | 			$cont_noerr = 1;		# stop reporting
810 | 		}
811 | 		$_ = delabel($_);	# replace labels with tabs
812 | 
813 | 		# check if the statement is complete
814 | 		return		if (/^\s*\}?$/);
815 | 		return		if (/^\s*\}?\s*else\s*\{?$/);
816 | 		return		if (/^\s*do\s*\{?$/);
817 | 		return		if (/\{$/);
818 | 		return		if (/}[,;]?$/);
819 | 
820 | 		# Allow macros on their own lines
821 | 		return		if (/^\s*[A-Z_][A-Z_0-9]*$/);
822 | 
823 | 		# cases we don't deal with, generally non-kosher
824 | 		if (/\{/) {
825 | 			err("stuff after {");
826 | 			return;
827 | 		}
828 | 
829 | 		# Get the base line, and set up the state machine
830 | 		/^(\t*)/;
831 | 		$cont_base = $1;
832 | 		$cont_in = 1;
833 | 		@cont_paren = ();
834 | 		$cont_first = 1;
835 | 		$cont_multiseg = 0;
836 | 
837 | 		# certain things need special processing
838 | 		$cont_special = /^\s*$special/? 1 : 0;
839 | 		$cont_macro = /^\s*$macro/? 1 : 0;
840 | 		$cont_case = /^\s*$case/? 1 : 0;
841 | 	} else {
842 | 		$cont_first = 0;
843 | 
844 | 		# Strings may be pulled back to an earlier (half-)tabstop
845 | 		unless ($cont_noerr || /^$cont_base    / ||
846 | 		    (/^\t*(?:    )?(?:gettext\()?\"/ && !/^$cont_base\t/)) {
847 | 			err_prefix($cont_start,
848 | 			    "continuation should be indented 4 spaces");
849 | 		}
850 | 	}
851 | 
852 | 	my $rest = $_;			# keeps the remainder of the line
853 | 
854 | 	#
855 | 	# The split matches 0 characters, so that each 'special' character
856 | 	# is processed separately.  Parens and brackets are pushed and
857 | 	# popped off the @cont_paren stack.  For normal processing, we wait
858 | 	# until a ; or { terminates the statement.  "special" processing
859 | 	# (if/for/while/switch) is allowed to stop when the stack empties,
860 | 	# as is macro processing.  Case statements are terminated with a :
861 | 	# and an empty paren stack.
862 | 	#
863 | 	foreach $_ (split /[^\(\)\[\]\{\}\;\:]*/) {
864 | 		next		if (length($_) == 0);
865 | 
866 | 		# rest contains the remainder of the line
867 | 		my $rxp = "[^\Q$_\E]*\Q$_\E";
868 | 		$rest =~ s/^$rxp//;
869 | 
870 | 		if (/\(/ || /\[/) {
871 | 			push @cont_paren, $_;
872 | 		} elsif (/\)/ || /\]/) {
873 | 			my $cur = $_;
874 | 			tr/\)\]/\(\[/;
875 | 
876 | 			my $old = (pop @cont_paren);
877 | 			if (!defined($old)) {
878 | 				err("unexpected '$cur'");
879 | 				$cont_in = 0;
880 | 				last;
881 | 			} elsif ($old ne $_) {
882 | 				err("'$cur' mismatched with '$old'");
883 | 				$cont_in = 0;
884 | 				last;
885 | 			}
886 | 
887 | 			#
888 | 			# If the stack is now empty, do special processing
889 | 			# for if/for/while/switch and macro statements.
890 | 			#
891 | 			next		if (@cont_paren != 0);
892 | 			if ($cont_special) {
893 | 				if ($rest =~ /^\s*{?$/) {
894 | 					$cont_in = 0;
895 | 					last;
896 | 				}
897 | 				if ($rest =~ /^\s*;$/) {
898 | 					err("empty if/for/while body ".
899 | 					    "not on its own line");
900 | 					$cont_in = 0;
901 | 					last;
902 | 				}
903 | 				if (!$cont_first && $cont_multiseg == 1) {
904 | 					err_prefix($cont_start,
905 | 					    "multiple statements continued ".
906 | 					    "over multiple lines");
907 | 					$cont_multiseg = 2;
908 | 				} elsif ($cont_multiseg == 0) {
909 | 					$cont_multiseg = 1;
910 | 				}
911 | 				# We've finished this section, start
912 | 				# processing the next.
913 | 				goto section_ended;
914 | 			}
915 | 			if ($cont_macro) {
916 | 				if ($rest =~ /^$/) {
917 | 					$cont_in = 0;
918 | 					last;
919 | 				}
920 | 			}
921 | 		} elsif (/\;/) {
922 | 			if ($cont_case) {
923 | 				err("unexpected ;");
924 | 			} elsif (!$cont_special) {
925 | 				err("unexpected ;")	if (@cont_paren != 0);
926 | 				if (!$cont_first && $cont_multiseg == 1) {
927 | 					err_prefix($cont_start,
928 | 					    "multiple statements continued ".
929 | 					    "over multiple lines");
930 | 					$cont_multiseg = 2;
931 | 				} elsif ($cont_multiseg == 0) {
932 | 					$cont_multiseg = 1;
933 | 				}
934 | 				if ($rest =~ /^$/) {
935 | 					$cont_in = 0;
936 | 					last;
937 | 				}
938 | 				if ($rest =~ /^\s*$special/) {
939 | 					err("if/for/while/switch not started ".
940 | 					    "on its own line");
941 | 				}
942 | 				goto section_ended;
943 | 			}
944 | 		} elsif (/\{/) {
945 | 			err("{ while in parens/brackets") if (@cont_paren != 0);
946 | 			err("stuff after {")		if ($rest =~ /[^\s}]/);
947 | 			$cont_in = 0;
948 | 			last;
949 | 		} elsif (/\}/) {
950 | 			err("} while in parens/brackets") if (@cont_paren != 0);
951 | 			if (!$cont_special && $rest !~ /^\s*(while|else)\b/) {
952 | 				if ($rest =~ /^$/) {
953 | 					err("unexpected }");
954 | 				} else {
955 | 					err("stuff after }");
956 | 				}
957 | 				$cont_in = 0;
958 | 				last;
959 | 			}
960 | 		} elsif (/\:/ && $cont_case && @cont_paren == 0) {
961 | 			err("stuff after multi-line case") if ($rest !~ /$^/);
962 | 			$cont_in = 0;
963 | 			last;
964 | 		}
965 | 		next;
966 | section_ended:
967 | 		# End of a statement or if/while/for loop.  Reset
968 | 		# cont_special and cont_macro based on the rest of the
969 | 		# line.
970 | 		$cont_special = ($rest =~ /^\s*$special/)? 1 : 0;
971 | 		$cont_macro = ($rest =~ /^\s*$macro/)? 1 : 0;
972 | 		$cont_case = 0;
973 | 		next;
974 | 	}
975 | 	$cont_noerr = 0			if (!$cont_in);
976 | }
977 | 


--------------------------------------------------------------------------------