#!/bin/bash

#

# Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

#

# This code is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License version 2 only, as

# published by the Free Software Foundation.

#

# This code is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

# version 2 for more details (a copy is included in the LICENSE file that

# accompanied this code).

#

# You should have received a copy of the GNU General Public License version

# 2 along with this work; if not, write to the Free Software Foundation,

# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

#

# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

# or visit www.oracle.com if you need additional information or have any

# questions.

#

# This script is processed by configure before it's usable. It is run from 

# the root of the build directory.

##########################################################################################

# Check that we are run via the wrapper generated by configure

if [ -z "$SRC_ROOT" ]; then

    echo "Error: You must run this script using build/[conf]/compare.sh"

    exit 1

fi

if [ "$OPENJDK_TARGET_OS" = "macosx" ]; then

    FULLDUMP_CMD="$OTOOL -v -V -h -X -t -d"

    LDD_CMD="$OTOOL -L"

    DIS_CMD="$OTOOL -v -t"

    STAT_PRINT_SIZE="-f %z"

elif [ "$OPENJDK_TARGET_OS" = "windows" ]; then

    FULLDUMP_CMD="$DUMPBIN -all"

    LDD_CMD="$DUMPBIN -dependants | $GREP .dll"

    DIS_CMD="$DUMPBIN -disasm:nobytes"

    STAT_PRINT_SIZE="-c %s"

else

    FULLDUMP_CMD="$READELF -a"

    LDD_CMD="$LDD"

    DIS_CMD="$OBJDUMP -d"

    STAT_PRINT_SIZE="-c %s"

fi

UNARCHIVE="$UNZIP -q"

COMPARE_EXCEPTIONS_INCLUDE="$SRC_ROOT/common/bin/compare_exceptions.sh.incl"

if [ ! -e "$COMPARE_EXCEPTIONS_INCLUDE" ]; then

    echo "Error: Cannot locate the exceptions file, it should have been here: $COMPARE_EXCEPTIONS_INCLUDE"

    exit 1

fi

# Include exception definitions

. "$COMPARE_EXCEPTIONS_INCLUDE"

##########################################################################################

# Compare text files and ignore specific differences:

#

#  * Timestamps in Java sources generated by idl2java

#  * Sorting order and cleanup style in .properties files

diff_text() {

    OTHER_FILE=$1

    THIS_FILE=$2

    SUFFIX="${THIS_FILE##*.}"

    TMP=1

    if [[ "$THIS_FILE" = *"META-INF/MANIFEST.MF" ]]; then

        TMP=$(LANG=C $DIFF $OTHER_FILE $THIS_FILE | \

            $GREP '^[<>]' | \

            $SED -e '/[<>] Ant-Version: Apache Ant .*/d' \

	         -e '/[<>] Created-By: .* (Oracle Corporation).*/d')

    fi

    if test "x$SUFFIX" = "xjava"; then

        TMP=$(LANG=C $DIFF $OTHER_FILE $THIS_FILE | \

            $GREP '^[<>]' | \

            $SED -e '/[<>] \* from.*\.idl/d' \

                 -e '/[<>] \*.*[0-9]\{4\}_[0-9]\{2\}_[0-9]\{2\}_[0-9]\{2\}_[0-9]\{2\}-b[0-9]\{2\}.*/d' \

                 -e '/[<>] \*.*[0-9]\{4\} [0-9][0-9]*:[0-9]\{2\}:[0-9]\{2\}.*/d' \

                 -e '/\/\/ Generated from input file.*/d' \

                 -e '/\/\/ This file was generated AUTOMATICALLY from a template file.*/d' \

                 -e '/\/\/ java GenerateCharacter.*/d')

    fi

    # Ignore date strings in class files.

    # On Macosx the system sources for generated java classes produce different output on 

    # consequtive invokations seemingly randomly.

    # For example a method parameter randomly named "thePoint" or "aPoint". Ignore this.

    if test "x$SUFFIX" = "xclass"; then

        # To improve performance when large diffs are found, do a rough filtering of classes

        # elibeble for these exceptions

        if $GREP -R -e '[0-9]\{4\}_[0-9]\{2\}_[0-9]\{2\}_[0-9]\{2\}_[0-9]\{2\}-b[0-9]\{2\}' -e thePoint -e aPoint -e setItemsPtr ${THIS_FILE} > /dev/null; then

            $JAVAP -c -constants -l -p ${OTHER_FILE} >  ${OTHER_FILE}.javap

            $JAVAP -c -constants -l -p ${THIS_FILE} > ${THIS_FILE}.javap

            TMP=$($DIFF ${OTHER_FILE}.javap ${THIS_FILE}.javap | \

                $GREP '^[<>]' | \

                $SED -e '/[<>].*[0-9]\{4\}_[0-9]\{2\}_[0-9]\{2\}_[0-9]\{2\}_[0-9]\{2\}-b[0-9]\{2\}.*/d' \

 	             -e '/[<>].*Point   Lcom\/apple\/jobjc\/foundation\/NSPoint;/d' \

	             -e '/[<>].*public com\.apple\.jobjc\.Pointer<com\.apple\.jobjc\..*itemsPtr();/d' \

	             -e '/[<>].*public void setItemsPtr(com\.apple\.jobjc\.Pointer<com\.apple\.jobjc\..*);/d')

        fi

    fi

    if test "x$SUFFIX" = "xproperties"; then

        $CAT $OTHER_FILE | $SED -e 's/\([^\\]\):/\1\\:/g' -e  's/\([^\\]\)=/\1\\=/g' -e 's/#.*/#/g' \

            | $SED -f "$SRC_ROOT/common/makefiles/support/unicode2x.sed" \

  	    | $SED -e '/^#/d' -e '/^$/d' \

            -e :a -e '/\\$/N; s/\\\n//; ta' \

  	    -e 's/^[ \t]*//;s/[ \t]*$//' \

	    -e 's/\\=/=/' | LANG=C $SORT > $OTHER_FILE.cleaned

        TMP=$(LANG=C $DIFF $OTHER_FILE.cleaned $THIS_FILE)

    fi

    if test -n "$TMP"; then

        echo Files $OTHER_FILE and $THIS_FILE differ

        return 1

    fi

    return 0

}

##########################################################################################

# Compare directory structure

compare_dirs() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    mkdir -p $WORK_DIR

    (cd $OTHER_DIR && $FIND . -type d | $SORT > $WORK_DIR/dirs_other)

    (cd $THIS_DIR && $FIND . -type d | $SORT > $WORK_DIR/dirs_this)

    $DIFF $WORK_DIR/dirs_other $WORK_DIR/dirs_other > $WORK_DIR/dirs_diff

    echo -n Directory structure...

    if [ -s $WORK_DIR/dirs_diff ]; then

        echo Differences found.

        REGRESSIONS=true

        # Differences in directories found.

        ONLY_OTHER=$($GREP '<' $WORK_DIR/dirs_diff)

        if [ "$ONLY_OTHER" ]; then

            echo Only in $OTHER

            $GREP '<' $WORK_DIR/dirs_diff | $SED 's|< ./|    |g'

        fi

        ONLY_THIS=$($GREP '>' $WORK_DIR/dirs_diff)

        if [ "$ONLY_THIS" ]; then

            echo Only in $THIS

            $GREP '>' $WORK_DIR/dirs_diff | $SED 's|> ./|    |g'

        fi

    else

        echo Identical!

    fi

}

##########################################################################################

# Compare file structure

compare_files() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    $MKDIR -p $WORK_DIR

    (cd $OTHER_DIR && $FIND . ! -type d | $SORT > $WORK_DIR/files_other)

    (cd $THIS_DIR && $FIND . ! -type d | $SORT > $WORK_DIR/files_this)

    $DIFF $WORK_DIR/files_other $WORK_DIR/files_this > $WORK_DIR/files_diff

    echo -n File names...

    if [ -s $WORK_DIR/files_diff ]; then

        echo Differences found.

        REGRESSIONS=true

        # Differences in files found.

        ONLY_OTHER=$($GREP '<' $WORK_DIR/files_diff)

        if [ "$ONLY_OTHER" ]; then

            echo Only in $OTHER

            $GREP '<' $WORK_DIR/files_diff | $SED 's|< ./|    |g'

        fi

        ONLY_THIS=$($GREP '>' $WORK_DIR/files_diff)

        if [ "$ONLY_THIS" ]; then

            echo Only in $THIS

            $GREP '>' $WORK_DIR/files_diff | $SED 's|> ./|    |g'

        fi

    else

        echo Identical!

    fi

}

##########################################################################################

# Compare permissions

compare_permissions() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    mkdir -p $WORK_DIR

    echo -n Permissions...

    found=""

    for f in `cd $OTHER_DIR && $FIND . -type f`

    do

        if [ ! -f ${OTHER_DIR}/$f ]; then continue; fi

        if [ ! -f ${THIS_DIR}/$f ]; then continue; fi

        OP=`ls -l ${OTHER_DIR}/$f | awk '{printf("%.10s\n", $1);}'`

        TP=`ls -l ${THIS_DIR}/$f | awk '{printf("%.10s\n", $1);}'`

        if [ "$OP" != "$TP" ]

        then

	    if [ -z "$found" ]; then echo ; found="yes"; fi

	    $PRINTF "\told: ${OP} new: ${TP}\t$f\n"

        fi

    done

    if [ -z "$found" ]; then 

        echo "Identical!"

    else

        REGRESSIONS=true

    fi

}

##########################################################################################

# Compare file command output

compare_file_types() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    $MKDIR -p $WORK_DIR

    echo -n File types...

    found=""

    for f in `cd $OTHER_DIR && $FIND . ! -type d`

    do

        if [ ! -f ${OTHER_DIR}/$f ]; then continue; fi

        if [ ! -f ${THIS_DIR}/$f ]; then continue; fi

        OF=`cd ${OTHER_DIR} && $FILE -h $f`

        TF=`cd ${THIS_DIR} && $FILE -h $f`

        if [ "$f" = "./src.zip" ] || [[ "$f" = *"/Home/src.zip" ]] || [[ "$f" = *"/lib/JObjC.jar" ]]

        then

	    if [ "`echo $OF | $GREP -ic zip`" -gt 0 -a "`echo $TF | $GREP -ic zip`" -gt 0 ]

	    then

	        # the way we produces zip-files make it so that directories are stored in old file

	        # but not in new (only files with full-path)

	        # this makes file-5.09 report them as different

	        continue;

	    fi

        fi

        if [ "$OF" != "$TF" ]

        then

	    if [ -z "$found" ]; then echo ; found="yes"; fi

	    $PRINTF "\tother: ${OF}\n\tthis : ${TF}\n"

        fi

    done

    if [ -z "$found" ]; then 

        echo "Identical!"

    else

        REGRESSIONS=true

    fi

}

##########################################################################################

# Compare the rest of the files

compare_general_files() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    GENERAL_FILES=$(cd $THIS_DIR && $FIND . -type f ! -name "*.so" ! -name "*.jar" ! -name "*.zip" \

        ! -name "*.debuginfo" ! -name "*.dylib" ! -name "jexec" \

        ! -name "ct.sym" ! -name "*.diz" ! -name "*.dll" \

        ! -name "*.pdb" ! -name "*.exp" ! -name "*.ilk" \

        ! -name "*.lib" ! -name "*.war" \

        | $GREP -v "./bin/"  | $SORT | $FILTER)

    echo General files...

    for f in $GENERAL_FILES

    do

        if [ -e $OTHER_DIR/$f ]; then

            if [ "$(basename $f)" = "release" ]; then

                # Ignore differences in change numbers in release file.

                OTHER_FILE=$WORK_DIR/$f.other

                THIS_FILE=$WORK_DIR/$f.this

                $MKDIR -p $(dirname $OTHER_FILE)

                $MKDIR -p $(dirname $THIS_FILE)

                $CAT $OTHER_DIR/$f | $SED 's/\:[0-9a-f]\{12,12\}/:CHANGE/g' > $OTHER_FILE

                $CAT $THIS_DIR/$f  | $SED 's/\:[0-9a-f]\{12,12\}/:CHANGE/g' > $THIS_FILE

            else

                OTHER_FILE=$OTHER_DIR/$f

                THIS_FILE=$THIS_DIR/$f

            fi

            DIFF_OUT=$($DIFF $OTHER_FILE $THIS_FILE 2>&1)

            if [ -n "$DIFF_OUT" ]; then

                echo $f

                REGRESSIONS=true

                if [ "$SHOW_DIFFS" = "true" ]; then

                    echo "$DIFF_OUT"

                fi

            fi

        fi

    done

}

##########################################################################################

# Compare zip file

compare_zip_file() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    ZIP_FILE=$4

    THIS_ZIP=$THIS_DIR/$ZIP_FILE

    OTHER_ZIP=$OTHER_DIR/$ZIP_FILE

    THIS_SUFFIX="${THIS_ZIP##*.}"

    OTHER_SUFFIX="${OTHER_ZIP##*.}"

    if [ "$THIS_SUFFIX" != "$OTHER_SUFFIX" ]; then

        echo The files do not have the same suffix type!

        return 2

    fi

    TYPE="$THIS_SUFFIX"

    if $CMP $OTHER_ZIP $THIS_ZIP > /dev/null

    then

        return 0

    fi

    # Not quite identical, the might still contain the same data.

    # Unpack the jar/zip files in temp dirs

    THIS_UNZIPDIR=$WORK_DIR/$ZIP_FILE.this

    OTHER_UNZIPDIR=$WORK_DIR/$ZIP_FILE.other

    $RM -rf $THIS_UNZIPDIR $OTHER_UNZIPDIR

    $MKDIR -p $THIS_UNZIPDIR

    $MKDIR -p $OTHER_UNZIPDIR

    (cd $THIS_UNZIPDIR && $UNARCHIVE $THIS_ZIP)

    (cd $OTHER_UNZIPDIR && $UNARCHIVE $OTHER_ZIP)

    CONTENTS_DIFF_FILE=$WORK_DIR/$ZIP_FILE.diff

    # On solaris, there is no -q option.

    if [ "$OPENJDK_TARGET_OS" = "solaris" ]; then

        LANG=C $DIFF -r $OTHER_UNZIPDIR $THIS_UNZIPDIR \

            | $GREP -v -e "^<" -e "^>" -e "^Common subdirectories:" \

            > $CONTENTS_DIFF_FILE

    else

        LANG=C $DIFF -rq $OTHER_UNZIPDIR $THIS_UNZIPDIR > $CONTENTS_DIFF_FILE

    fi

    ONLY_OTHER=$($GREP "^Only in $OTHER_UNZIPDIR" $CONTENTS_DIFF_FILE)

    ONLY_THIS=$($GREP "^Only in $THIS_UNZIPDIR" $CONTENTS_DIFF_FILE)

    return_value=0

    if [ -n "$ONLY_OTHER" ]; then

        echo "        Only OTHER $ZIP_FILE contains:"

        echo "$ONLY_OTHER" | sed "s|Only in $OTHER_UNZIPDIR|            |"g | sed 's|: |/|g'

        return_value=1

    fi

    if [ -n "$ONLY_THIS" ]; then

        echo "        Only THIS $ZIP_FILE contains:"

        echo "$ONLY_THIS" | sed "s|Only in $THIS_UNZIPDIR|            |"g | sed 's|: |/|g'

        return_value=1

    fi

    if [ "$OPENJDK_TARGET_OS" = "solaris" ]; then

        DIFFING_FILES=$($GREP -e "differ$" -e "^diff " $CONTENTS_DIFF_FILE \

            | $CUT -f 3 -d ' ' | $SED "s|$OTHER_UNZIPDIR/||g")

    else

        DIFFING_FILES=$($GREP -e "differ$" $CONTENTS_DIFF_FILE \

            | $CUT -f 2 -d ' ' | $SED "s|$OTHER_UNZIPDIR/||g")

    fi

    $RM -f $WORK_DIR/$ZIP_FILE.diffs

    for file in $DIFFING_FILES; do

            diff_text $OTHER_UNZIPDIR/$file $THIS_UNZIPDIR/$file >> $WORK_DIR/$ZIP_FILE.diffs

	fi

    done

    if [ -s "$WORK_DIR/$ZIP_FILE.diffs" ]; then

        return_value=1

        echo "        Differing files in $ZIP_FILE"

        $CAT $WORK_DIR/$ZIP_FILE.diffs | $GREP differ | cut -f 2 -d ' ' | \

            $SED "s|$OTHER_UNZIPDIR|            |g" > $WORK_DIR/$ZIP_FILE.difflist

        $CAT $WORK_DIR/$ZIP_FILE.difflist

        if [ -n "$SHOW_DIFFS" ]; then

            for i in $(cat $WORK_DIR/$ZIP_FILE.difflist) ; do

                if [ -f "${OTHER_UNZIPDIR}/$i.javap" ]; then

                    LANG=C $DIFF ${OTHER_UNZIPDIR}/$i.javap ${THIS_UNZIPDIR}/$i.javap

                elif [ -f "${OTHER_UNZIPDIR}/$i.cleaned" ]; then

                    LANG=C $DIFF ${OTHER_UNZIPDIR}/$i.cleaned ${THIS_UNZIPDIR}/$i

                else

                    LANG=C $DIFF ${OTHER_UNZIPDIR}/$i ${THIS_UNZIPDIR}/$i

                fi

            done

        fi

    fi

    return $return_value

}

##########################################################################################

# Compare all zip files

compare_all_zip_files() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    ZIPS=$(cd $THIS_DIR && $FIND . -type f -name "*.zip" | $SORT | $FILTER )

    if [ -n "$ZIPS" ]; then

        echo Zip files...

        return_value=0

        for f in $ZIPS; do

            if [ -f "$OTHER_DIR/$f" ]; then

                compare_zip_file $THIS_DIR $OTHER_DIR $WORK_DIR $f

                if [ "$?" != "0" ]; then

                    return_value=1

                    REGRESSIONS=true

                fi

            fi

        done

    fi

    return $return_value

}

##########################################################################################

# Compare all jar files

compare_all_jar_files() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    # TODO filter?

    ZIPS=$(cd $THIS_DIR && $FIND . -type f -name "*.jar" -o -name "*.war" | $SORT | $FILTER)

    if [ -n "$ZIPS" ]; then

        echo Jar files...

        return_value=0

        for f in $ZIPS; do

            if [ -f "$OTHER_DIR/$f" ]; then

                compare_zip_file $THIS_DIR $OTHER_DIR $WORK_DIR $f

                if [ "$?" != "0" ]; then

                    return_value=1

                    REGRESSIONS=true

                fi

            fi

        done

    fi

    return $return_value

}

##########################################################################################

# Compare binary (executable/library) file

compare_bin_file() {

    THIS_DIR=$1

    OTHER_DIR=$2

    WORK_DIR=$3

    BIN_FILE=$4

    THIS_FILE=$THIS_DIR/$BIN_FILE

    OTHER_FILE=$OTHER_DIR/$BIN_FILE

    NAME=$(basename $BIN_FILE)

    WORK_FILE_BASE=$WORK_DIR/$BIN_FILE

    FILE_WORK_DIR=$(dirname $WORK_FILE_BASE)

    $MKDIR -p $FILE_WORK_DIR

    ORIG_THIS_FILE="$THIS_FILE"

    ORIG_OTHER_FILE="$OTHER_FILE"

    if [[ "$STRIP_BEFORE_COMPARE" = *"$BIN_FILE"* ]]; then

        THIS_STRIPPED_FILE=$FILE_WORK_DIR/this/$NAME

        OTHER_STRIPPED_FILE=$FILE_WORK_DIR/other/$NAME

        $MKDIR -p $FILE_WORK_DIR/this $FILE_WORK_DIR/other

        $CP $THIS_FILE $THIS_STRIPPED_FILE

        $CP $OTHER_FILE $OTHER_STRIPPED_FILE

        $STRIP $THIS_STRIPPED_FILE