8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / tools / scripts / jstyle.pl

#!/usr/bin/perl -w
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#

#
# Copyright 2015 Toomas Soome <tsoome@me.com>
# Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# jstyle - check for some common stylistic errors.
#

require 5.006;
use Getopt::Std;
use strict;

my $usage =
"usage: jstyle [-c] [-h] [-p] [-t] [-v] [-C] file ...
        -c      check continuation line indenting
        -h      perform heuristic checks that are sometimes wrong
        -p      perform some of the more picky checks
        -t      insist on indenting by tabs
        -v      verbose
        -C      don't check anything in header block comments
";

my %opts;

# Keep -s, as it's been around for a while.  It just doesn't do anything
# anymore.
if (!getopts("chpstvC", \%opts)) {
        print $usage;
        exit 2;
}

my $check_continuation = $opts{'c'};
my $heuristic = $opts{'h'};
my $picky = $opts{'p'};
my $tabs = $opts{'t'};
my $verbose = $opts{'v'};
my $ignore_hdr_comment = $opts{'C'};

my ($filename, $line, $prev);
my $err_stat = 0;               # Exit status

my $fmt;

if ($verbose) {
        $fmt = "%s: %d: %s\n%s\n";
} else {
        $fmt = "%s: %d: %s\n";
}

# Note, following must be in single quotes so that \s and \w work right.
my $typename = '(int|char|boolean|byte|short|long|float|double)';
my $keywords = '(for|if|while|switch|return|catch|synchronized|throw|assert)';
# See perlre(1) for the meaning of (??{ ... })
my $annotations = ""; $annotations = qr/@\w+\((?:(?>[^()]+)|(??{ $annotations }))*\)/;
my $generics = ""; $generics = qr/<(([\s\w,.?[\]]| & )+|(??{ $generics }))*>/;
my $relationalops = qr/>=|<=|<|>|!=|==/;
my $shiftops = qr/<<<|>>>|<<|>>/;
my $shiftassignmentops = qr/[<>]{2,3}=/;
my $assignmentops = qr/[-+\/*|&^%]?=/;
# These need to be in decreasing order of length
my $allops = qr/$shiftassignmentops|$shiftops|$relationalops|$assignmentops/;

if ($#ARGV >= 0) {
        foreach my $arg (@ARGV) {
                if (!open(STDIN, $arg)) {
                        printf "%s: can not open\n", $arg;
                } else {
                        &jstyle($arg);
                        close STDIN;
                }
        }
} else {
        &jstyle("<stdin>");
}
exit $err_stat;

sub err($) {
        if ($verbose) {
                printf $fmt, $filename, $., $_[0], $line;
        } else {
                printf $fmt, $filename, $., $_[0];
        }
        $err_stat = 1;
}

sub jstyle($) {

my $in_comment = 0;
my $in_header_comment = 0;
my $in_continuation = 0;
my $in_class = 0;
my $in_declaration = 0;
my $nextok = 0;
my $nocheck = 0;
my $expect_continuation = 0;
my $continuation_indent;
my $okmsg;
my $comment_prefix;
my $comment_done;
my $cpp_comment;

$filename = $_[0];

line: while (<STDIN>) {
        s/\r?\n$//;     # strip return and newline

        # save the original line, then remove all text from within
        # double or single quotes, we do not want to check such text.

        $line = $_;
        s/"[^"]*"/\"\"/g;
        s/'.'/''/g;

        # an /* END JSTYLED */ comment ends a no-check block.
        if ($nocheck) {
                if (/\/\* *END *JSTYLED *\*\//) {
                        $nocheck = 0;
                } else {
                        next line;
                }
        }

        # a /*JSTYLED*/ comment indicates that the next line is ok.
        if ($nextok) {
                if ($okmsg) {
                        err($okmsg);
                }
                $nextok = 0;
                $okmsg = 0;
                if (/\/\* *JSTYLED.*\*\//) {
                        /^.*\/\* *JSTYLED *(.*) *\*\/.*$/;
                        $okmsg = $1;
                        $nextok = 1;
                }
                $prev = $line;
                next line;
        }

        # remember whether we expect to be inside a continuation line.
        $in_continuation = $expect_continuation;

        # check for proper continuation line.  blank lines
        # in the middle of the
        # continuation do not count.
        # XXX - only check within functions.
        if ($check_continuation && $expect_continuation && $in_class &&
            !/^\s*$/) {
                # continuation line must start with whitespace of
                # previous line, plus either 4 spaces or a tab, but
                # do not check lines that start with a string constant
                # since they are often shifted to the left to make them
                # fit on the line.
                if (!/^$continuation_indent    \S/ &&
                    !/^$continuation_indent\t\S/ && !/^\s*"/) {
                        err("continuation line improperly indented");
                }
                $expect_continuation = 0;
        }

        # a /* BEGIN JSTYLED */ comment starts a no-check block.
        if (/\/\* *BEGIN *JSTYLED *\*\//) {
                $nocheck = 1;
        }

        # a /*JSTYLED*/ comment indicates that the next line is ok.
        if (/\/\* *JSTYLED.*\*\//) {
                /^.*\/\* *JSTYLED *(.*) *\*\/.*$/;
                $okmsg = $1;
                $nextok = 1;
        }
        if (/\/\/ *JSTYLED/) {
                /^.*\/\/ *JSTYLED *(.*)$/;
                $okmsg = $1;
                $nextok = 1;
        }

        # is this the beginning or ending of a class?
        if (/^(public\s+)*\w(class|interface)\s/) {
                $in_class = 1;
                $in_declaration = 1;
                $prev = $line;
                next line;
        }
        if (/^}\s*(\/\*.*\*\/\s*)*$/) {
                $in_class = 0;
                $prev = $line;
                next line;
        }

        if ($comment_done) {
                $in_comment = 0;
                $in_header_comment = 0;
                $comment_done = 0;
        }
        # does this looks like the start of a block comment?
        if (/^\s*\/\*/ && !/^\s*\/\*.*\*\//) {
                if (/^\s*\/\*./ && !/^\s*\/\*\*$/) {
                        err("improper first line of block comment");
                }
                if (!/^(\t|    )*\/\*/) {
                        err("block comment not indented properly");
                }
                $in_comment = 1;
                /^(\s*)\//;
                $comment_prefix = $1;
                if ($comment_prefix eq "") {
                        $in_header_comment = 1;
                }
                $prev = $line;
                next line;
        }
        # are we still in the block comment?
        if ($in_comment) {
                if (/^$comment_prefix \*\/$/) {
                        $comment_done = 1;
                } elsif (/\*\//) {
                        $comment_done = 1;
                        err("improper block comment close")
                            unless ($ignore_hdr_comment && $in_header_comment);
                } elsif (!/^$comment_prefix \*[ \t]/ &&
                    !/^$comment_prefix \*$/) {
                        err("improper block comment")
                            unless ($ignore_hdr_comment && $in_header_comment);
                }
        }

        if ($in_header_comment && $ignore_hdr_comment) {
                $prev = $line;
                next line;
        }

        # check for errors that might occur in comments and in code.

        # check length of line.
        # first, a quick check to see if there is any chance of being too long.
        if ($line =~ tr/\t/\t/ * 7 + length($line) > 80) {
                # yes, there is a chance.
                # replace tabs with spaces and check again.
                my $eline = $line;
                1 while $eline =~
                    s/\t+/' ' x (length($&) * 8 - length($`) % 8)/e;
                if (length($eline) > 80) {
                        err("line > 80 characters");
                }
        }

        # Allow spaces to be used to draw pictures in header comments, but
        # disallow blocks of spaces almost everywhere else.  In particular,
        # five spaces are also allowed at the end of a line's indentation
        # if the rest of the line belongs to a block comment.
        if (!$in_header_comment &&
            /[^ ]     / &&
            !(/^\t*     \*/ && !/^\t*     \*.*     /)) {
                err("spaces instead of tabs");
        }
        if ($tabs && /^ / && !/^ \*[ \t\/]/ && !/^ \*$/ &&
            (!/^    \w/ || $in_class != 0)) {
                err("indent by spaces instead of tabs");
        }
        if (!$in_comment && (/^(\t    )* {1,3}\S/ || /^(\t    )* {5,7}\S/) &&
            !(/^\s*[-+|&\/?:=]/ || ($prev =~ /,\s*$/))) {
                err("indent not a multiple of 4");
        }
        if (/\s$/) {
                err("space or tab at end of line");
        }
if (0) {
        if (/^[\t]+ [^ \t\*]/ || /^[\t]+  \S/ || /^[\t]+   \S/) {
                err("continuation line not indented by 4 spaces");
        }
}
        if (/\/\//) {
                $cpp_comment = 1;
        }
        if (!$cpp_comment && /[^ \t(\/]\/\*/ && !/\w\(\/\*.*\*\/\);/) {
                err("comment preceded by non-blank");
        }
        if (/\t +\t/) {
                err("spaces between tabs");
        }
        if (/ \t+ /) {
                err("tabs between spaces");
        }

        if ($in_comment) {      # still in comment
                $prev = $line;
                next line;
        }

        if (!$cpp_comment && ((/\/\*\S/ && !/\/\*\*/) || /\/\*\*\S/)) {
                err("missing blank after open comment");
        }
        if (!$cpp_comment && /\S\*\//) {
                err("missing blank before close comment");
        }
        # check for unterminated single line comments.
        if (/\S.*\/\*/ && !/\S.*\/\*.*\*\//) {
                err("unterminated single line comment");
        }

        # delete any comments and check everything else.  Be sure to leave
        # //-style comments intact, and if there are multiple comments on a
        # line, preserve whatever's in between.
        s/(?<!\/)\/\*.*?\*\//\x01/g;
        # Check for //-style comments only outside of block comments
        if (m{(//(?!$))} && substr($_, $+[0], 1) !~ /[ \t]/) {
                err("missing blank after start comment");
        }
        s/\/\/.*$/\x01/;           # C++ comments
        $cpp_comment = 0;

        # delete any trailing whitespace; we have already checked for that.
        s/\s*$//;

        # We don't style (yet) what's inside annotations, so just delete them.
        s/$annotations//;

        # following checks do not apply to text in comments.

        # if it looks like an operator at the end of the line, and it is
        # not really the end of a comment (...*/), and it is not really
        # a label (done:), and it is not a case label (case FOO:),
        # or we are not in a function definition (ANSI C style) and the
        # operator is a "," (to avoid hitting "int\nfoo(\n\tint i,\n\tint j)"),
        # or we are in a function and the operator is a
        # "*" (to avoid hitting on "char*\nfunc()").
        if ((/[-+|&\/?:=]$/ && !/\*\/$/ && !/^\s*\w*:$/ &&
            !/^\s\s*case\s\s*\w*:$/) ||
            /,$/ ||
            ($in_class && /\*$/)) {
                $expect_continuation = 1;
                if (!$in_continuation) {
                        /^(\s*)\S/;
                        $continuation_indent = $1;
                }
        }
        while (/($allops)/g) {
                my $z = substr($_, $-[1] - 1);
                if ($z !~ /\s\Q$1\E(?:\s|$)/) {
                        my $m = $1;
                        my $shift;
                        # @+ is available only in the currently active
                        # dynamic scope.  Assign it to a new variable
                        # to pass it into the if block.
                        if ($z =~ /($generics)/ &&
                            ($shift = $+[1])) {
                                pos $_ += $shift;
                                next;
                        }

                        # These need to be in decreasing order of length
                        # (violable as long as there's no ambiguity)
                        my $nospace = "missing space around";
                        if ($m =~ $shiftassignmentops) {
                                err("$nospace assignment operator");
                        } elsif ($m =~ $shiftops) {
                                err("$nospace shift operator");
                        } elsif ($m =~ $relationalops) {
                                err("$nospace relational operator");
                        } elsif ($m =~ $assignmentops) {
                                err("$nospace assignment operator");
                        }
                }
        }
        if (/[,;]\S/ && !/\bfor \(;;\)/) {
                err("comma or semicolon followed by non-blank");
        }
        # allow "for" statements to have empty "while" clauses
        if (/\s[,;]/ && !/^[\t]+;$/ && !/^\s*for \([^;]*; ;[^;]*\)/) {
                err("comma or semicolon preceded by blank");
        }
if (0) {
        if (/^\s*(&&|\|\|)/) {
                err("improper boolean continuation");
        }
}
        if ($picky && /\S   *(&&|\|\|)/ || /(&&|\|\|)   *\S/) {
                err("more than one space around boolean operator");
        }
        if (/\b$keywords\(/) {
                err("missing space between keyword and paren");
        }
        if (/(\b$keywords\b.*){2,}/ && !/\bcase\b.*/) { # "case" excepted
                err("more than one keyword on line");
        }
        if (/\b$keywords\s\s+\(/ &&
            !/^#if\s+\(/) {
                err("extra space between keyword and paren");
        }
        # try to detect "func (x)" but not "if (x)" or
        # "int (*func)();"
        if (/\w\s\(/) {
                my $save = $_;
                # strip off all keywords on the line
                s/\b$keywords\s\(/XXX(/g;
                #s/\b($typename|void)\s+\(+/XXX(/og;
                if (/\w\s\(/) {
                        err("extra space between function name and left paren");
                }
                $_ = $save;
        }
        if (/\(\s/) {
                err("whitespace after left paren");
        }
        # allow "for" statements to have empty "continue" clauses
        if (/\s\)/ && !/^\s*for \([^;]*;[^;]*; \)/) {
                err("whitespace before right paren");
        }
        if (/^\s*\(void\)[^ ]/) {
                err("missing space after (void) cast");
        }
        if (/\S\{/ && !/\{\{/) {
                err("missing space before left brace");
        }
        if ($in_class && /^\s+{/ && ($prev =~ /\)\s*$/)) {
                err("left brace starting a line");
        }
        if (/}(else|while)/) {
                err("missing space after right brace");
        }
        if (/}\s\s+(else|while)/) {
                err("extra space after right brace");
        }
        if (/\b$typename\*/o) {
                err("missing space between type name and *");
        }
        if ($heuristic) {
                # cannot check this everywhere due to "struct {\n...\n} foo;"
                if ($in_class && !$in_declaration &&
                    /}./ && !/}\s+=/ && !/{.*}[;,]$/ && !/}(\s|\x01)*$/ &&
                    !/} (else|while)/ && !/}}/) {
                        err("possible bad text following right brace");
                }
                # cannot check this because sub-blocks in
                # the middle of code are ok
                if ($in_class && /^\s+{/) {
                        err("possible left brace starting a line");
                }
        }
        if (/^\s*else\W/) {
                if ($prev =~ /^\s*}$/) {
                        my $str = "else and right brace should be on same line";
                        printf $fmt, $filename, $., $str, $prev;
                        if ($verbose) {
                                printf "%s\n", $line;
                        }
                }
        }
        $prev = $line;
}

if ($picky && $prev eq "") {
        err("last line in file is blank");
}

}