Revision: 76569
http://sourceforge.net/p/brlcad/code/76569
Author: starseeker
Date: 2020-07-29 14:16:57 +0000 (Wed, 29 Jul 2020)
Log Message:
-----------
Merge changes from trunk through r76568
Modified Paths:
--------------
brlcad/branches/bioh/misc/CMakeLists.txt
brlcad/branches/bioh/misc/repoconv/CONVERT.sh
brlcad/branches/bioh/misc/repoconv/NOTES
brlcad/branches/bioh/misc/repoconv/verify/verify.cpp
brlcad/branches/bioh/misc/repowork/README
brlcad/branches/bioh/misc/repowork/commit.cpp
brlcad/branches/bioh/misc/repowork/repowork.cpp
brlcad/branches/bioh/misc/repowork/repowork.h
brlcad/branches/bioh/src/conv/vdeck/vdeck.c
brlcad/branches/bioh/src/libbg/polygon.c
brlcad/branches/bioh/src/libbg/polygon_triangulate.cpp
brlcad/branches/bioh/src/libbg/tests/chull.c
brlcad/branches/bioh/src/libbg/tests/obr.c
brlcad/branches/bioh/src/libbg/trimesh_isect.cpp
brlcad/branches/bioh/src/libbn/tabdata.c
brlcad/branches/bioh/src/libdm/plot/dm-plot.c
brlcad/branches/bioh/src/libgcv/plugins/obj/obj_read.c
brlcad/branches/bioh/src/libgcv/plugins/obj/wfobj/obj_parser.cpp
brlcad/branches/bioh/src/libged/3ptarb/3ptarb.c
brlcad/branches/bioh/src/libged/attr/attr.cpp
brlcad/branches/bioh/src/libged/bb/bb.c
brlcad/branches/bioh/src/libged/bigE/bigE.c
brlcad/branches/bioh/src/libged/bo/bo.c
brlcad/branches/bioh/src/libged/bot/bot_dump.c
brlcad/branches/bioh/src/libged/bot/bot_face_sort.c
brlcad/branches/bioh/src/libged/bot/bot_fuse.c
brlcad/branches/bioh/src/libged/brep/plot.cpp
brlcad/branches/bioh/src/libged/check/check.c
brlcad/branches/bioh/src/libged/check/check_adj_air.c
brlcad/branches/bioh/src/libged/check/check_exp_air.c
brlcad/branches/bioh/src/libged/check/check_gap.c
brlcad/branches/bioh/src/libged/check/check_overlaps.c
brlcad/branches/bioh/src/libged/check/check_unconf_air.c
brlcad/branches/bioh/src/libged/check/check_volume.c
brlcad/branches/bioh/src/libged/clone/clone.c
brlcad/branches/bioh/src/libged/color/color.c
brlcad/branches/bioh/src/libged/comb/comb.c
brlcad/branches/bioh/src/libged/constraint/constraint.c
brlcad/branches/bioh/src/libged/copyeval/copyeval.c
brlcad/branches/bioh/src/libged/decompose/decompose.c
brlcad/branches/bioh/src/libged/display_list.c
brlcad/branches/bioh/src/libged/draw/draw.c
brlcad/branches/bioh/src/libged/draw/loadview.c
brlcad/branches/bioh/src/libged/draw/preview.c
brlcad/branches/bioh/src/libged/dump/dump.c
brlcad/branches/bioh/src/libged/edcodes/edcodes.c
brlcad/branches/bioh/src/libged/erase/erase.c
brlcad/branches/bioh/src/libged/facetize/facetize.cpp
brlcad/branches/bioh/src/libged/fb2pix/fb2pix.c
brlcad/branches/bioh/src/libged/fracture/fracture.c
brlcad/branches/bioh/src/libged/ged_init.cpp
brlcad/branches/bioh/src/libged/ged_util.c
brlcad/branches/bioh/src/libged/get_comb/get_comb.c
brlcad/branches/bioh/src/libged/get_obj_bounds.c
brlcad/branches/bioh/src/libged/glob/glob.c
brlcad/branches/bioh/src/libged/gqa/gqa.c
brlcad/branches/bioh/src/libged/heal/heal.c
brlcad/branches/bioh/src/libged/how/how.c
brlcad/branches/bioh/src/libged/human/human.c
brlcad/branches/bioh/src/libged/joint/joint.c
brlcad/branches/bioh/src/libged/keep/keep.c
brlcad/branches/bioh/src/libged/lc/lc.c
brlcad/branches/bioh/src/libged/lint/lint.cpp
brlcad/branches/bioh/src/libged/mater/mater.cpp
brlcad/branches/bioh/src/libged/metaball/metaball.c
brlcad/branches/bioh/src/libged/move_all/move_all.c
brlcad/branches/bioh/src/libged/nmg/nmg.c
brlcad/branches/bioh/src/libged/nmg/nmg_cmface.c
brlcad/branches/bioh/src/libged/nmg/nmg_collapse.c
brlcad/branches/bioh/src/libged/nmg/nmg_kill_f.c
brlcad/branches/bioh/src/libged/nmg/nmg_kill_v.c
brlcad/branches/bioh/src/libged/nmg/nmg_make_v.c
brlcad/branches/bioh/src/libged/nmg/nmg_mm.c
brlcad/branches/bioh/src/libged/nmg/nmg_move_v.c
brlcad/branches/bioh/src/libged/overlay/overlay.c
brlcad/branches/bioh/src/libged/pix2fb/pix2fb.c
brlcad/branches/bioh/src/libged/plot/plot.c
brlcad/branches/bioh/src/libged/png/png.c
brlcad/branches/bioh/src/libged/png2fb/png2fb.c
brlcad/branches/bioh/src/libged/pnts/pnts.cpp
brlcad/branches/bioh/src/libged/ps/ps.c
brlcad/branches/bioh/src/libged/rcodes/rcodes.c
brlcad/branches/bioh/src/libged/red/red.c
brlcad/branches/bioh/src/libged/rmater/rmater.c
brlcad/branches/bioh/src/libged/rot/rot.c
brlcad/branches/bioh/src/libged/rt/rt.c
brlcad/branches/bioh/src/libged/savekey/savekey.c
brlcad/branches/bioh/src/libged/saveview/saveview.c
brlcad/branches/bioh/src/libged/screengrab/screengrab.c
brlcad/branches/bioh/src/libged/set_transparency/set_transparency.c
brlcad/branches/bioh/src/libged/shells/shells.c
brlcad/branches/bioh/src/libged/tables/tables.c
brlcad/branches/bioh/src/libged/tests/test_list.c
brlcad/branches/bioh/src/libged/tol/tol.c
brlcad/branches/bioh/src/libged/tops/tops.c
brlcad/branches/bioh/src/libged/trace.c
brlcad/branches/bioh/src/libged/typein/typein.c
brlcad/branches/bioh/src/libged/view/data_lines.c
brlcad/branches/bioh/src/libged/view/snap.c
brlcad/branches/bioh/src/libged/wcodes/wcodes.c
brlcad/branches/bioh/src/libged/whatid/whatid.c
brlcad/branches/bioh/src/libged/wmater/wmater.c
brlcad/branches/bioh/src/sig/dmod.c
brlcad/branches/bioh/src/sig/imod.c
brlcad/branches/bioh/src/util/asc-plot3.c
brlcad/branches/bioh/src/util/bwshrink.c
brlcad/branches/bioh/src/util/double-asc.c
brlcad/branches/bioh/src/util/dpix-pix.c
brlcad/branches/bioh/src/util/halftone.c
brlcad/branches/bioh/src/util/lowp.c
brlcad/branches/bioh/src/util/pixshrink.c
brlcad/branches/bioh/src/util/pixtile.c
Added Paths:
-----------
brlcad/branches/bioh/misc/repoconv/cvs_info.sh
brlcad/branches/bioh/misc/repoconv/domap.sh
brlcad/branches/bioh/misc/repoconv/verify/cvs.sh
brlcad/branches/bioh/misc/repoconv/verify/cvs_repaired/
brlcad/branches/bioh/misc/repoconv/verify/md5.hpp
brlcad/branches/bioh/misc/repoconv/verify/sha1.hpp
brlcad/branches/bioh/misc/repoconv/verify/svn.sh
brlcad/branches/bioh/misc/repoconv/verify/svn_de-rcs.cxx
brlcad/branches/bioh/misc/repoconv/verify/verify.sh
Property Changed:
----------------
brlcad/branches/bioh/
Index: brlcad/branches/bioh
===================================================================
--- brlcad/branches/bioh 2020-07-29 14:07:05 UTC (rev 76568)
+++ brlcad/branches/bioh 2020-07-29 14:16:57 UTC (rev 76569)
Property changes on: brlcad/branches/bioh
___________________________________________________________________
Modified: svn:mergeinfo
## -9,4 +9,4 ##
/brlcad/branches/osg:62110-62113
/brlcad/branches/prep-cache:68236-68933
/brlcad/branches/tcltk86:68300-75257
-/brlcad/trunk:75720-76157,76160-76365,76386-76505
\ No newline at end of property
+/brlcad/trunk:75720-76157,76160-76365,76386-76568
\ No newline at end of property
Modified: brlcad/branches/bioh/misc/CMakeLists.txt
===================================================================
--- brlcad/branches/bioh/misc/CMakeLists.txt 2020-07-29 14:07:05 UTC (rev
76568)
+++ brlcad/branches/bioh/misc/CMakeLists.txt 2020-07-29 14:16:57 UTC (rev
76569)
@@ -210,6 +210,8 @@
repoconv/account-map_svnfexport.txt
repoconv/cvs_authormap
repoconv/cvs_authormap_svnfexport.txt
+ repoconv/cvs_info.sh
+ repoconv/domap.sh
repoconv/email_fixups.txt
repoconv/cvs_repaired/sphflake.pix,v
repoconv/gitattributes
@@ -255,8 +257,15 @@
repoconv/sync_commit_trunk.sh
repoconv/tagmap.sh
repoconv/terra.dsp
+ repoconv/verify/cvs.sh
+ repoconv/verify/cvs_repaired/sphflake.pix,v
repoconv/verify/cxxopts.hpp
+ repoconv/verify/md5.hpp
+ repoconv/verify/sha1.hpp
+ repoconv/verify/svn.sh
+ repoconv/verify/svn_de-rcs.cxx
repoconv/verify/verify.cpp
+ repoconv/verify/verify.sh
repowork/COPYING
repowork/README
repowork/blob.cpp
Modified: brlcad/branches/bioh/misc/repoconv/CONVERT.sh
===================================================================
--- brlcad/branches/bioh/misc/repoconv/CONVERT.sh 2020-07-29 14:07:05 UTC
(rev 76568)
+++ brlcad/branches/bioh/misc/repoconv/CONVERT.sh 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -98,7 +98,7 @@
diff -qrw -I '\$Id' -I '\$Revision' -I'\$Header' -I'$Source' -I'$Date'
-I'$Log' -I'$Locker' --exclude "terra.dsp" brlcad_cvs-r29886 brlcad_svn-r29886
# cleanup
-rm -rf brlcad_cvs
+#rm -rf brlcad_cvs
rm -rf brlcad_cvs-r29886
rm -rf brlcad_svn-r29886
rm brlcad_cvs-r29886.tar.gz
@@ -149,12 +149,66 @@
# Create an svn revision to author map
svn log file://$REPODIR | grep "|" | grep "^r[0-9][0-9 ]" | grep -v \(no\
author\) | awk -F "|" '{print $1 $2}' | sed -e 's/r//' | sed -e 's/ $//' | sed
-e 's/ / /' > rev_map
+# MANUAL: Generate mapping files with the cvs_info.sh script. Need
+# two maps - one from the archival repo's msg+time key to the data
+# we need, and the other a map from that same key to the SHA1 commits
+# of the new repository. The "key" is a SHA1 hash of just the commit
+# message, with the Unix time appended to the string produced. It is
+# not guaranteed to be universally unique as a key, but it should be
+# for anything we care about (unless we've got two commits with the
+# same message and same timestamp in the history, and even then that
+# would be a practical problem only if those commits had different
+# CVS branches or authors.)
+rm -rf cvs_info && mkdir cvs_info && cp cvs_info.sh cvs_info/ && cd cvs_info
+./cvs_info.sh
+mv key_authormap .. && mv key_branchmap ..
+cd ..
+
+# With the basic maps generated from a basic (no authormap) cvs-fast-export
+# conversion of the CVS repository, generate the map for our target repo
+# (the output of the svnfexport process. This will produce the
msgtime_sha1_map
+# file used later in the process
+cd cvs_git && ../domap.sh && cd ..
+
+# MANUAL: Run verify on the CVS conversion and stage any differences found for
+# incorporation - not sure if we're going to do this yet... Here's how to kick
+# off the process with just a CVS check.
+#mkdir verify && cd verify
+#g++ -O3 -o verify ../verify.cpp
+#cp -r ../brlcad_cvs .
+#cp -r ../cvs_git .
+#./verify --keymap ../msgtime_sha1_map --branchmap ../key_branchmap --cvs-repo
/home/user/verify/brlcad_cvs cvs_git
+# mkdir ../trees && cp *.fi ../trees/
+#cd ..
+# If we need to do this, will also need the children map from git:
+# cd cvs_git && git rev-list --children --all > ../children && cd ..
+
# Create a fast export file of the conversion. IMPORTANT - need
# original ids if we're going to process the git notes down into
# the commit messages.
-cd cvs_git && git fast-export --show-original-ids --all > ../brlcad_raw.fi &&
cd ..
-repowork -t -w -e email_fixups.txt -n -r cvs_git -s rev_map ~/brlcad_raw.fi
brlcad_final.fi
+cd cvs_git && git checkout master && git fast-export --show-original-ids --all
> ../brlcad_raw.fi && cd ..
+# Build the repowork processing tool
+cd ../repowork && mkdir build && cd build && cmake .. && make -j5 && cd
../../repoconv
+
+# With the preliminaries complete, we use the repowork tool to finalize the
conversion:
+
+../repowork/build/repowork -t \
+ -e email_fixups.txt \
+ -n -r cvs_git \
+ -s rev_map \
+ --keymap msgtime_sha1_map --cvs-auth-map key_authormap
--cvs-branch-map key_branchmap \
+ ~/brlcad_raw.fi brlcad_final.fi
+
+# If we do rebuild CVS commits, the command becomes:
+#../repowork/build/repowork -t \
+# -e email_fixups.txt \
+# -n -r cvs_git \
+# -s rev_map \
+# --cvs-rebuild-ids cvs_problem_sha1.txt --children children \
+# --keymap msgtime_sha1_map --cvs-auth-map key_authormap
--cvs-branch-map key_branchmap \
+# ~/brlcad_raw.fi brlcad_final.fi
+
mkdir brlcad_final.git && cd brlcad_final.git && git init
cat ../brlcad_final.fi | git fast-import
Modified: brlcad/branches/bioh/misc/repoconv/NOTES
===================================================================
--- brlcad/branches/bioh/misc/repoconv/NOTES 2020-07-29 14:07:05 UTC (rev
76568)
+++ brlcad/branches/bioh/misc/repoconv/NOTES 2020-07-29 14:16:57 UTC (rev
76569)
@@ -303,3 +303,13 @@
This may be enough information pre-notes-merge in repowork to allow us to
assign one additional property - the cvs/svn commit author name.
+
+#############################################################################
+A note when running git fast-export - you want to make sure and checkout master
+before doing the export - I accidentally did so while in a detached HEAD
+state, and ended up with a HEAD branch in the conversion (which completely
+messed up gitk).
+
+cd brlcad && git checkout master
+git fast-export --all --show-original-ids > ../brlcad.fi
+
Copied: brlcad/branches/bioh/misc/repoconv/cvs_info.sh (from rev 76568,
brlcad/trunk/misc/repoconv/cvs_info.sh)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/cvs_info.sh
(rev 0)
+++ brlcad/branches/bioh/misc/repoconv/cvs_info.sh 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -0,0 +1,172 @@
+#!/bin/bash
+if [ ! -e "cvs-fast-export" ]; then
+ curl -o cvs-fast-export.tar.gz
https://gitlab.com/esr/cvs-fast-export/-/archive/1.48/cvs-fast-export-1.48.tar.gz
+ tar -xvf cvs-fast-export.tar.gz
+ mv cvs-fast-export-1.48 cvs-fast-export
+fi
+cd cvs-fast-export && make cvs-fast-export && cd ..
+
+# To run the conversion (need to use cvs-fast-export rather than cvsconvert
+# for the actual conversion to support the authors file):
+if [ ! -e "brlcad_cvs.tar.gz" ]; then
+ curl -o brlcad_cvs.tar.gz https://brlcad.org/brlcad_cvs.tar.gz
+fi
+
+
+if [ ! -e "brlcad_cvs" ];
+then
+ rm -rf brlcad_cvs
+ tar -xf brlcad_cvs.tar.gz
+ cd brlcad_cvs/brlcad
+ # Create Git repository without author map (to preserve original CVS
names)
+ echo "Running cvs-fast-export $PWD"
+ find . | ../../cvs-fast-export/cvs-fast-export > ../../brlcad_cvs_git.fi
+ cd ../..
+ rm -rf brlcad_cvs_git
+ mkdir brlcad_cvs_git
+ cd brlcad_cvs_git
+ git init
+ cat ../brlcad_cvs_git.fi | git fast-import
+ git checkout master
+ # Find branches
+ git branch|sed -e 's/*//'|sed -e 's/ *//' > ../branches.txt
+ cd ..
+fi
+
+# Find commits on branches
+rm -rf branches
+mkdir branches
+cd brlcad_cvs_git
+
+while IFS="" read -r p || [ -n "$p" ]
+do
+ printf '%s\n' "$p"
+ OFILE=$p
+ git rev-list --first-parent $p > ../branches/$OFILE
+done < ../branches.txt
+
+mv ../branches/master ..
+cd ..
+
+# Find commits unique to branches (i.e. not on master)
+rm -rf branches_uniq
+mkdir branches_uniq
+cd branches
+for f in *;
+do
+ echo "Uniq: $f"
+ grep -Fvx -f ../master $f > uniq.txt
+ mv uniq.txt ../branches_uniq/$f
+done
+cd ..
+
+# For each branch, walk the non-master commits looking for the
+# newest commit timestamp on the branch. Store that date
+cd brlcad_cvs_git
+
+declare -A datemap
+
+for f in ../branches_uniq/*;
+do
+ branch="$(basename $f)"
+ skip="master"
+ if [ $branch != $skip ];
+ then
+ echo "Date check: $branch"
+ newcommit=0
+ while IFS="" read -r p || [ -n "$p" ]
+ do
+ CDATE=$(git log -n1 --pretty=format:"%ct" $p)
+ if [ "$CDATE" -gt "$newcommit" ];
+ then
+ newcommit=$CDATE;
+ fi;
+ done < $f
+ echo "$branch $newcommit"
+ datemap[$branch]=$newcommit
+ fi;
+done
+
+cd ..
+
+# For all branches, if a branch has a newest commit date older
+# than the current branch, remove that branches commits from the
+# current branch
+cd branches_uniq
+for f in *;
+do
+ FDATE=${datemap[$f]}
+ for g in *;
+ do
+ if [ $g != $f ];
+ then
+ GDATE=${datemap[$g]}
+ if [ "$GDATE" -lt "$FDATE" ];
+ then
+ echo "Scrub $FDATE:$GDATE : $f/$g"
+ grep -Fvx -f $g $f > uniq.txt
+ mv uniq.txt $f
+ fi;
+ fi;
+ done
+done
+
+# Couple special cases I can't seem to detect otherwise:
+grep -Fvx -f bobWinPort bobWinPort-20051223-freeze > uniq.txt
+mv uniq.txt bobWinPort-20051223-freeze
+grep -Fvx -f brlcad_5_1_alpha_patch rel-5-1 > uniq.txt
+mv uniq.txt rel-5-1
+
+cd ../brlcad_cvs_git
+for f in ../branches_uniq/*;
+do
+ branch="$(basename $f)"
+ echo "Date check: $branch"
+ oldcommit=9223372036854775807
+ newcommit=0
+ while IFS="" read -r p || [ -n "$p" ]
+ do
+ CDATE=$(git log -n1 --pretty=format:"%ct" $p)
+ if [ "$CDATE" -lt "$oldcommit" ];
+ then
+ oldcommit=$CDATE;
+ fi;
+ if [ "$CDATE" -gt "$newcommit" ];
+ then
+ newcommit=$CDATE;
+ fi;
+ done < $f
+ echo "$branch $newcommit:$oldcommit"
+done
+
+cd ..
+
+
+# Write out information to map files, using as a key msg sha1 + date in seconds
+
+# mv master branches_uniq/ - Note: shouldn't need master explicitly, it's
assumed
+
+rm -f key_branchmap sha1_branchmap key_authormap sha1_authormap
+cd brlcad_cvs_git
+for f in ../branches_uniq/*;
+do
+ branch="$(basename $f)"
+ echo "Map write: $branch"
+ while IFS="" read -r p || [ -n "$p" ]
+ do
+ MSGSHA1=$(git log -n1 --pretty=format:"%B" $p | sha1sum | head
-c 40)
+ CDATE=$(git log -n1 --pretty=format:"%ct" $p)
+ AUTHORNAME=$(git log -n1 --pretty=format:"%an" $p)
+ echo $p:$branch >> ../sha1_branchmap
+ echo $p:$AUTHORNAME >> ../sha1_authormap
+ echo $MSGSHA1$CDATE:$branch >> ../key_branchmap
+ echo $MSGSHA1$CDATE:$AUTHORNAME>> ../key_authormap
+ done < $f
+done
+
+cd ..
+
+
+# NOTE: to generate a map between the above keys and sha1 values, run the
+# domap.sh script from within the repository you wish to map to.
+
Copied: brlcad/branches/bioh/misc/repoconv/domap.sh (from rev 76568,
brlcad/trunk/misc/repoconv/domap.sh)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/domap.sh (rev 0)
+++ brlcad/branches/bioh/misc/repoconv/domap.sh 2020-07-29 14:16:57 UTC (rev
76569)
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# To generate a map between the msg/time keys and sha1 values, run the
+# following script from within the repository you wish to map to (i.e.
+# the target repository to which the information in the original map
+# is to be applied:
+
+git log --all --pretty=format:"%H" > sha1s.txt
+
+while IFS="" read -r p || [ -n "$p" ]
+do
+ MSGSHA1=$(git log -n1 --pretty=format:"%B" $p | sha1sum | head -c 40)
+ CDATE=$(git log -n1 --pretty=format:"%ct" $p)
+ echo $MSGSHA1$CDATE:$p >> ../msgtime_sha1_map
+done < sha1s.txt
+
+rm sha1s.txt
Copied: brlcad/branches/bioh/misc/repoconv/verify/cvs.sh (from rev 76568,
brlcad/trunk/misc/repoconv/verify/cvs.sh)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/verify/cvs.sh
(rev 0)
+++ brlcad/branches/bioh/misc/repoconv/verify/cvs.sh 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -0,0 +1,29 @@
+#!/bin/bash
+if [ ! -e "brlcad_cvs.tar.gz" ]; then
+ curl -o brlcad_cvs.tar.gz https://brlcad.org/brlcad_cvs.tar.gz
+fi
+rm -rf brlcad_cvs
+tar -xf brlcad_cvs.tar.gz
+cd brlcad_cvs/brlcad
+rm src/librt/Attic/parse.c,v
+rm pix/sphflake.pix,v
+cp ../../cvs_repaired/sphflake.pix,v pix/
+# RCS headers introduce unnecessary file differences, which are poison pills
+# for git log --follow
+echo "Scrubbing expanded RCS headers"
+echo "Date"
+find . -type f -exec sed -i 's/$Date:[^$;"]*/$Date/' {} \;
+echo "Header"
+find . -type f -exec sed -i 's/$Header:[^$;"]*/$Header/' {} \;
+echo "Id"
+find . -type f -exec sed -i 's/$Id:[^$;"]*/$Id/' {} \;
+echo "Log"
+find . -type f -exec sed -i 's/$Log:[^$;"]*/$Log/' {} \;
+echo "Revision"
+find . -type f -exec sed -i 's/$Revision:[^$;"]*/$Revision/' {} \;
+echo "Source"
+find . -type f -exec sed -i 's/$Source:[^$;"]*/$Source/' {} \;
+sed -i 's/$Author:[^$;"]*/$Author/' misc/Attic/cvs2cl.pl,v
+sed -i 's/$Author:[^$;"]*/$Author/' sh/Attic/cvs2cl.pl,v
+sed -i 's/$Locker:[^$;"]*/$Locker/' src/other/URToolkit/tools/mallocNd.c,v
+
Copied: brlcad/branches/bioh/misc/repoconv/verify/md5.hpp (from rev 76568,
brlcad/trunk/misc/repoconv/verify/md5.hpp)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/verify/md5.hpp
(rev 0)
+++ brlcad/branches/bioh/misc/repoconv/verify/md5.hpp 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -0,0 +1,437 @@
+/* This utility includes a de-namespaced version of
+ *
https://github.com/Microsoft/cpprestsdk/blob/master/Release/libs/websocketpp/websocketpp/common/md5.hpp
+ * to be self contained: */
+
+/*
+ md5.hpp is a reformulation of the md5.h and md5.c code from
+ http://www.opensource.apple.com/source/cups/cups-59/cups/md5.c to allow it
to
+ function as a component of a header only library. This conversion was done
by
+ Peter Thorson ([email protected]) in 2012 for the WebSocket++ project.
The
+ changes are released under the same license as the original (listed below)
+ */
+/*
+ Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+ L. Peter Deutsch
+ [email protected]
+ */
+/*
+ Independent implementation of MD5 (RFC 1321).
+ This code implements the MD5 Algorithm defined in RFC 1321, whose
+ text is available at
+ http://www.ietf.org/rfc/rfc1321.txt
+ The code is derived from the text of the RFC, including the test suite
+ (section A.5) but excluding the rest of Appendix A. It does not include
+ any code or documentation that is identified in the RFC as being
+ copyrighted.
+ The original and principal author of md5.h is L. Peter Deutsch
+ <[email protected]>. Other authors are noted in the change history
+ that follows (in reverse chronological order):
+ 2002-04-13 lpd Removed support for non-ANSI compilers; removed
+ references to Ghostscript; clarified derivation from RFC 1321;
+ now handles byte order either statically or dynamically.
+ 1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+ 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+ added conditionalization for C++ compilation from Martin
+ Purschke <[email protected]>.
+ 1999-05-03 lpd Original version.
+ */
+
+#ifndef MD5_HPP
+#define MD5_HPP
+
+/*
+ * This package supports both compile-time and run-time determination of CPU
+ * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
+ * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
+ * defined as non-zero, the code will be compiled to run only on big-endian
+ * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
+ * run on either big- or little-endian CPUs, but will run slightly less
+ * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
+ */
+
+#include <stddef.h>
+#include <string>
+#include <cstring>
+
+typedef unsigned char md5_byte_t; /* 8-bit byte */
+typedef unsigned int md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+ md5_word_t count[2]; /* message length in bits, lsw first */
+ md5_word_t abcd[4]; /* digest buffer */
+ md5_byte_t buf[64]; /* accumulate block */
+} md5_state_t;
+
+/* Initialize the algorithm. */
+inline void md5_init(md5_state_t *pms);
+
+/* Append a string to the message. */
+inline void md5_append(md5_state_t *pms, md5_byte_t const * data, size_t
nbytes);
+
+/* Finish the message and return the digest. */
+inline void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+
+#undef ZSW_MD5_BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown
*/
+#ifdef ARCH_IS_BIG_ENDIAN
+# define ZSW_MD5_BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#else
+# define ZSW_MD5_BYTE_ORDER 0
+#endif
+
+#define ZSW_MD5_T_MASK ((md5_word_t)~0)
+#define ZSW_MD5_T1 /* 0xd76aa478 */ (ZSW_MD5_T_MASK ^ 0x28955b87)
+#define ZSW_MD5_T2 /* 0xe8c7b756 */ (ZSW_MD5_T_MASK ^ 0x173848a9)
+#define ZSW_MD5_T3 0x242070db
+#define ZSW_MD5_T4 /* 0xc1bdceee */ (ZSW_MD5_T_MASK ^ 0x3e423111)
+#define ZSW_MD5_T5 /* 0xf57c0faf */ (ZSW_MD5_T_MASK ^ 0x0a83f050)
+#define ZSW_MD5_T6 0x4787c62a
+#define ZSW_MD5_T7 /* 0xa8304613 */ (ZSW_MD5_T_MASK ^ 0x57cfb9ec)
+#define ZSW_MD5_T8 /* 0xfd469501 */ (ZSW_MD5_T_MASK ^ 0x02b96afe)
+#define ZSW_MD5_T9 0x698098d8
+#define ZSW_MD5_T10 /* 0x8b44f7af */ (ZSW_MD5_T_MASK ^ 0x74bb0850)
+#define ZSW_MD5_T11 /* 0xffff5bb1 */ (ZSW_MD5_T_MASK ^ 0x0000a44e)
+#define ZSW_MD5_T12 /* 0x895cd7be */ (ZSW_MD5_T_MASK ^ 0x76a32841)
+#define ZSW_MD5_T13 0x6b901122
+#define ZSW_MD5_T14 /* 0xfd987193 */ (ZSW_MD5_T_MASK ^ 0x02678e6c)
+#define ZSW_MD5_T15 /* 0xa679438e */ (ZSW_MD5_T_MASK ^ 0x5986bc71)
+#define ZSW_MD5_T16 0x49b40821
+#define ZSW_MD5_T17 /* 0xf61e2562 */ (ZSW_MD5_T_MASK ^ 0x09e1da9d)
+#define ZSW_MD5_T18 /* 0xc040b340 */ (ZSW_MD5_T_MASK ^ 0x3fbf4cbf)
+#define ZSW_MD5_T19 0x265e5a51
+#define ZSW_MD5_T20 /* 0xe9b6c7aa */ (ZSW_MD5_T_MASK ^ 0x16493855)
+#define ZSW_MD5_T21 /* 0xd62f105d */ (ZSW_MD5_T_MASK ^ 0x29d0efa2)
+#define ZSW_MD5_T22 0x02441453
+#define ZSW_MD5_T23 /* 0xd8a1e681 */ (ZSW_MD5_T_MASK ^ 0x275e197e)
+#define ZSW_MD5_T24 /* 0xe7d3fbc8 */ (ZSW_MD5_T_MASK ^ 0x182c0437)
+#define ZSW_MD5_T25 0x21e1cde6
+#define ZSW_MD5_T26 /* 0xc33707d6 */ (ZSW_MD5_T_MASK ^ 0x3cc8f829)
+#define ZSW_MD5_T27 /* 0xf4d50d87 */ (ZSW_MD5_T_MASK ^ 0x0b2af278)
+#define ZSW_MD5_T28 0x455a14ed
+#define ZSW_MD5_T29 /* 0xa9e3e905 */ (ZSW_MD5_T_MASK ^ 0x561c16fa)
+#define ZSW_MD5_T30 /* 0xfcefa3f8 */ (ZSW_MD5_T_MASK ^ 0x03105c07)
+#define ZSW_MD5_T31 0x676f02d9
+#define ZSW_MD5_T32 /* 0x8d2a4c8a */ (ZSW_MD5_T_MASK ^ 0x72d5b375)
+#define ZSW_MD5_T33 /* 0xfffa3942 */ (ZSW_MD5_T_MASK ^ 0x0005c6bd)
+#define ZSW_MD5_T34 /* 0x8771f681 */ (ZSW_MD5_T_MASK ^ 0x788e097e)
+#define ZSW_MD5_T35 0x6d9d6122
+#define ZSW_MD5_T36 /* 0xfde5380c */ (ZSW_MD5_T_MASK ^ 0x021ac7f3)
+#define ZSW_MD5_T37 /* 0xa4beea44 */ (ZSW_MD5_T_MASK ^ 0x5b4115bb)
+#define ZSW_MD5_T38 0x4bdecfa9
+#define ZSW_MD5_T39 /* 0xf6bb4b60 */ (ZSW_MD5_T_MASK ^ 0x0944b49f)
+#define ZSW_MD5_T40 /* 0xbebfbc70 */ (ZSW_MD5_T_MASK ^ 0x4140438f)
+#define ZSW_MD5_T41 0x289b7ec6
+#define ZSW_MD5_T42 /* 0xeaa127fa */ (ZSW_MD5_T_MASK ^ 0x155ed805)
+#define ZSW_MD5_T43 /* 0xd4ef3085 */ (ZSW_MD5_T_MASK ^ 0x2b10cf7a)
+#define ZSW_MD5_T44 0x04881d05
+#define ZSW_MD5_T45 /* 0xd9d4d039 */ (ZSW_MD5_T_MASK ^ 0x262b2fc6)
+#define ZSW_MD5_T46 /* 0xe6db99e5 */ (ZSW_MD5_T_MASK ^ 0x1924661a)
+#define ZSW_MD5_T47 0x1fa27cf8
+#define ZSW_MD5_T48 /* 0xc4ac5665 */ (ZSW_MD5_T_MASK ^ 0x3b53a99a)
+#define ZSW_MD5_T49 /* 0xf4292244 */ (ZSW_MD5_T_MASK ^ 0x0bd6ddbb)
+#define ZSW_MD5_T50 0x432aff97
+#define ZSW_MD5_T51 /* 0xab9423a7 */ (ZSW_MD5_T_MASK ^ 0x546bdc58)
+#define ZSW_MD5_T52 /* 0xfc93a039 */ (ZSW_MD5_T_MASK ^ 0x036c5fc6)
+#define ZSW_MD5_T53 0x655b59c3
+#define ZSW_MD5_T54 /* 0x8f0ccc92 */ (ZSW_MD5_T_MASK ^ 0x70f3336d)
+#define ZSW_MD5_T55 /* 0xffeff47d */ (ZSW_MD5_T_MASK ^ 0x00100b82)
+#define ZSW_MD5_T56 /* 0x85845dd1 */ (ZSW_MD5_T_MASK ^ 0x7a7ba22e)
+#define ZSW_MD5_T57 0x6fa87e4f
+#define ZSW_MD5_T58 /* 0xfe2ce6e0 */ (ZSW_MD5_T_MASK ^ 0x01d3191f)
+#define ZSW_MD5_T59 /* 0xa3014314 */ (ZSW_MD5_T_MASK ^ 0x5cfebceb)
+#define ZSW_MD5_T60 0x4e0811a1
+#define ZSW_MD5_T61 /* 0xf7537e82 */ (ZSW_MD5_T_MASK ^ 0x08ac817d)
+#define ZSW_MD5_T62 /* 0xbd3af235 */ (ZSW_MD5_T_MASK ^ 0x42c50dca)
+#define ZSW_MD5_T63 0x2ad7d2bb
+#define ZSW_MD5_T64 /* 0xeb86d391 */ (ZSW_MD5_T_MASK ^ 0x14792c6e)
+
+static void md5_process(md5_state_t *pms, md5_byte_t const * data /*[64]*/) {
+ md5_word_t
+ a = pms->abcd[0], b = pms->abcd[1],
+ c = pms->abcd[2], d = pms->abcd[3];
+ md5_word_t t;
+#if ZSW_MD5_BYTE_ORDER > 0
+ /* Define storage only for big-endian CPUs. */
+ md5_word_t X[16];
+#else
+ /* Define storage for little-endian or both types of CPUs. */
+ md5_word_t xbuf[16];
+ md5_word_t const * X;
+#endif
+
+ {
+#if ZSW_MD5_BYTE_ORDER == 0
+ /*
+ * Determine dynamically whether this is a big-endian or
+ * little-endian machine, since we can use a more efficient
+ * algorithm on the latter.
+ */
+ static int const w = 1;
+
+ if (*((md5_byte_t const *)&w)) /* dynamic little-endian */
+#endif
+#if ZSW_MD5_BYTE_ORDER <= 0 /* little-endian */
+ {
+ /*
+ * On little-endian machines, we can process properly aligned
+ * data without copying it.
+ */
+ if (!((data - (md5_byte_t const *)0) & 3)) {
+ /* data are properly aligned */
+ X = (md5_word_t const *)data;
+ } else {
+ /* not aligned */
+ std::memcpy(xbuf, data, 64);
+ X = xbuf;
+ }
+ }
+#endif
+#if ZSW_MD5_BYTE_ORDER == 0
+ else /* dynamic big-endian */
+#endif
+#if ZSW_MD5_BYTE_ORDER >= 0 /* big-endian */
+ {
+ /*
+ * On big-endian machines, we must arrange the bytes in the
+ * right order.
+ */
+ const md5_byte_t *xp = data;
+ int i;
+
+# if ZSW_MD5_BYTE_ORDER == 0
+ X = xbuf; /* (dynamic only) */
+# else
+# define xbuf X /* (static only) */
+# endif
+ for (i = 0; i < 16; ++i, xp += 4)
+ xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+ }
+#endif
+ }
+
+#define ZSW_MD5_ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+ /* Round 1. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_F(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 7, ZSW_MD5_T1);
+ SET(d, a, b, c, 1, 12, ZSW_MD5_T2);
+ SET(c, d, a, b, 2, 17, ZSW_MD5_T3);
+ SET(b, c, d, a, 3, 22, ZSW_MD5_T4);
+ SET(a, b, c, d, 4, 7, ZSW_MD5_T5);
+ SET(d, a, b, c, 5, 12, ZSW_MD5_T6);
+ SET(c, d, a, b, 6, 17, ZSW_MD5_T7);
+ SET(b, c, d, a, 7, 22, ZSW_MD5_T8);
+ SET(a, b, c, d, 8, 7, ZSW_MD5_T9);
+ SET(d, a, b, c, 9, 12, ZSW_MD5_T10);
+ SET(c, d, a, b, 10, 17, ZSW_MD5_T11);
+ SET(b, c, d, a, 11, 22, ZSW_MD5_T12);
+ SET(a, b, c, d, 12, 7, ZSW_MD5_T13);
+ SET(d, a, b, c, 13, 12, ZSW_MD5_T14);
+ SET(c, d, a, b, 14, 17, ZSW_MD5_T15);
+ SET(b, c, d, a, 15, 22, ZSW_MD5_T16);
+#undef SET
+
+ /* Round 2. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_G(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 1, 5, ZSW_MD5_T17);
+ SET(d, a, b, c, 6, 9, ZSW_MD5_T18);
+ SET(c, d, a, b, 11, 14, ZSW_MD5_T19);
+ SET(b, c, d, a, 0, 20, ZSW_MD5_T20);
+ SET(a, b, c, d, 5, 5, ZSW_MD5_T21);
+ SET(d, a, b, c, 10, 9, ZSW_MD5_T22);
+ SET(c, d, a, b, 15, 14, ZSW_MD5_T23);
+ SET(b, c, d, a, 4, 20, ZSW_MD5_T24);
+ SET(a, b, c, d, 9, 5, ZSW_MD5_T25);
+ SET(d, a, b, c, 14, 9, ZSW_MD5_T26);
+ SET(c, d, a, b, 3, 14, ZSW_MD5_T27);
+ SET(b, c, d, a, 8, 20, ZSW_MD5_T28);
+ SET(a, b, c, d, 13, 5, ZSW_MD5_T29);
+ SET(d, a, b, c, 2, 9, ZSW_MD5_T30);
+ SET(c, d, a, b, 7, 14, ZSW_MD5_T31);
+ SET(b, c, d, a, 12, 20, ZSW_MD5_T32);
+#undef SET
+
+ /* Round 3. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_H(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 5, 4, ZSW_MD5_T33);
+ SET(d, a, b, c, 8, 11, ZSW_MD5_T34);
+ SET(c, d, a, b, 11, 16, ZSW_MD5_T35);
+ SET(b, c, d, a, 14, 23, ZSW_MD5_T36);
+ SET(a, b, c, d, 1, 4, ZSW_MD5_T37);
+ SET(d, a, b, c, 4, 11, ZSW_MD5_T38);
+ SET(c, d, a, b, 7, 16, ZSW_MD5_T39);
+ SET(b, c, d, a, 10, 23, ZSW_MD5_T40);
+ SET(a, b, c, d, 13, 4, ZSW_MD5_T41);
+ SET(d, a, b, c, 0, 11, ZSW_MD5_T42);
+ SET(c, d, a, b, 3, 16, ZSW_MD5_T43);
+ SET(b, c, d, a, 6, 23, ZSW_MD5_T44);
+ SET(a, b, c, d, 9, 4, ZSW_MD5_T45);
+ SET(d, a, b, c, 12, 11, ZSW_MD5_T46);
+ SET(c, d, a, b, 15, 16, ZSW_MD5_T47);
+ SET(b, c, d, a, 2, 23, ZSW_MD5_T48);
+#undef SET
+
+ /* Round 4. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define ZSW_MD5_I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + ZSW_MD5_I(b,c,d) + X[k] + Ti;\
+ a = ZSW_MD5_ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 6, ZSW_MD5_T49);
+ SET(d, a, b, c, 7, 10, ZSW_MD5_T50);
+ SET(c, d, a, b, 14, 15, ZSW_MD5_T51);
+ SET(b, c, d, a, 5, 21, ZSW_MD5_T52);
+ SET(a, b, c, d, 12, 6, ZSW_MD5_T53);
+ SET(d, a, b, c, 3, 10, ZSW_MD5_T54);
+ SET(c, d, a, b, 10, 15, ZSW_MD5_T55);
+ SET(b, c, d, a, 1, 21, ZSW_MD5_T56);
+ SET(a, b, c, d, 8, 6, ZSW_MD5_T57);
+ SET(d, a, b, c, 15, 10, ZSW_MD5_T58);
+ SET(c, d, a, b, 6, 15, ZSW_MD5_T59);
+ SET(b, c, d, a, 13, 21, ZSW_MD5_T60);
+ SET(a, b, c, d, 4, 6, ZSW_MD5_T61);
+ SET(d, a, b, c, 11, 10, ZSW_MD5_T62);
+ SET(c, d, a, b, 2, 15, ZSW_MD5_T63);
+ SET(b, c, d, a, 9, 21, ZSW_MD5_T64);
+#undef SET
+
+ /* Then perform the following additions. (That is increment each
+ of the four registers by the value it had before this block
+ was started.) */
+ pms->abcd[0] += a;
+ pms->abcd[1] += b;
+ pms->abcd[2] += c;
+ pms->abcd[3] += d;
+}
+
+void md5_init(md5_state_t *pms) {
+ pms->count[0] = pms->count[1] = 0;
+ pms->abcd[0] = 0x67452301;
+ pms->abcd[1] = /*0xefcdab89*/ ZSW_MD5_T_MASK ^ 0x10325476;
+ pms->abcd[2] = /*0x98badcfe*/ ZSW_MD5_T_MASK ^ 0x67452301;
+ pms->abcd[3] = 0x10325476;
+}
+
+void md5_append(md5_state_t *pms, md5_byte_t const * data, size_t nbytes) {
+ md5_byte_t const * p = data;
+ size_t left = nbytes;
+ int offset = (pms->count[0] >> 3) & 63;
+ md5_word_t nbits = (md5_word_t)(nbytes << 3);
+
+ if (nbytes <= 0)
+ return;
+
+ /* Update the message length. */
+ pms->count[1] += nbytes >> 29;
+ pms->count[0] += nbits;
+ if (pms->count[0] < nbits)
+ pms->count[1]++;
+
+ /* Process an initial partial block. */
+ if (offset) {
+ int copy = (offset + nbytes > 64 ? 64 - offset :
static_cast<int>(nbytes));
+
+ std::memcpy(pms->buf + offset, p, copy);
+ if (offset + copy < 64)
+ return;
+ p += copy;
+ left -= copy;
+ md5_process(pms, pms->buf);
+ }
+
+ /* Process full blocks. */
+ for (; left >= 64; p += 64, left -= 64)
+ md5_process(pms, p);
+
+ /* Process a final partial block. */
+ if (left)
+ std::memcpy(pms->buf, p, left);
+}
+
+void md5_finish(md5_state_t *pms, md5_byte_t digest[16]) {
+ static md5_byte_t const pad[64] = {
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ };
+ md5_byte_t data[8];
+ int i;
+
+ /* Save the length before padding. */
+ for (i = 0; i < 8; ++i)
+ data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+ /* Pad to 56 bytes mod 64. */
+ md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+ /* Append the length. */
+ md5_append(pms, data, 8);
+ for (i = 0; i < 16; ++i)
+ digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}
+
+// some convenience c++ functions
+inline std::string md5_hash_string(const char *input, size_t len) {
+ char digest[16];
+
+ md5_state_t state;
+
+ md5_init(&state);
+ md5_append(&state, (md5_byte_t const *)input, len);
+ md5_finish(&state, (md5_byte_t *)digest);
+
+ std::string ret;
+ ret.resize(16);
+ std::copy(digest,digest+16,ret.begin());
+
+ return ret;
+}
+
+const char hexval[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'};
+
+inline std::string md5_hash_hex(const char *input, size_t len) {
+ std::string hash = md5_hash_string(input, len);
+ std::string hex;
+
+ for (size_t i = 0; i < hash.size(); i++) {
+ hex.push_back(hexval[((hash[i] >> 4) & 0xF)]);
+ hex.push_back(hexval[(hash[i]) & 0x0F]);
+ }
+
+ return hex;
+}
+
+#endif // MD5_HPP
+
Copied: brlcad/branches/bioh/misc/repoconv/verify/sha1.hpp (from rev 76568,
brlcad/trunk/misc/repoconv/verify/sha1.hpp)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/verify/sha1.hpp
(rev 0)
+++ brlcad/branches/bioh/misc/repoconv/verify/sha1.hpp 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -0,0 +1,337 @@
+/*
+SHA-1 in C
+By Steve Reid <[email protected]>
+100% Public Domain
+
+from https://github.com/clibs/sha1
+
+Test Vectors (from FIPS PUB 180-1)
+"abc"
+ A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+ 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+A million repetitions of "a"
+ 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */
+/* #define SHA1HANDSOFF * Copies data before messing with it. */
+
+#define SHA1HANDSOFF
+
+#include <stdio.h>
+#include <string.h>
+
+/* for uint32_t */
+#include <stdint.h>
+
+typedef struct
+{
+ uint32_t state[5];
+ uint32_t count[2];
+ unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Transform(
+ uint32_t state[5],
+ const unsigned char buffer[64]
+ );
+
+void SHA1Init(
+ SHA1_CTX * context
+ );
+
+void SHA1Update(
+ SHA1_CTX * context,
+ const unsigned char *data,
+ uint32_t len
+ );
+
+void SHA1Final(
+ unsigned char digest[20],
+ SHA1_CTX * context
+ );
+
+void SHA1(
+ char *hash_out,
+ const char *str,
+ int len);
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+ |(rol(block->l[i],8)&0x00FF00FF))
+#elif BYTE_ORDER == BIG_ENDIAN
+#define blk0(i) block->l[i]
+#else
+#error "Endianness not defined!"
+#endif
+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
+ ^block->l[(i+2)&15]^block->l[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i)
z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i)
z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i)
z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void SHA1Transform(
+ uint32_t state[5],
+ const unsigned char buffer[64]
+)
+{
+ uint32_t a, b, c, d, e;
+
+ typedef union
+ {
+ unsigned char c[64];
+ uint32_t l[16];
+ } CHAR64LONG16;
+
+#ifdef SHA1HANDSOFF
+ CHAR64LONG16 block[1]; /* use array to appear as a pointer */
+
+ memcpy(block, buffer, 64);
+#else
+ /* The following had better never be used because it causes the
+ * pointer-to-const buffer to be cast into a pointer to non-const.
+ * And the result is written through. I threw a "const" in, hoping
+ * this will cause a diagnostic.
+ */
+ CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer;
+#endif
+ /* Copy context->state[] to working vars */
+ a = state[0];
+ b = state[1];
+ c = state[2];
+ d = state[3];
+ e = state[4];
+ /* 4 rounds of 20 operations each. Loop unrolled. */
+ R0(a, b, c, d, e, 0);
+ R0(e, a, b, c, d, 1);
+ R0(d, e, a, b, c, 2);
+ R0(c, d, e, a, b, 3);
+ R0(b, c, d, e, a, 4);
+ R0(a, b, c, d, e, 5);
+ R0(e, a, b, c, d, 6);
+ R0(d, e, a, b, c, 7);
+ R0(c, d, e, a, b, 8);
+ R0(b, c, d, e, a, 9);
+ R0(a, b, c, d, e, 10);
+ R0(e, a, b, c, d, 11);
+ R0(d, e, a, b, c, 12);
+ R0(c, d, e, a, b, 13);
+ R0(b, c, d, e, a, 14);
+ R0(a, b, c, d, e, 15);
+ R1(e, a, b, c, d, 16);
+ R1(d, e, a, b, c, 17);
+ R1(c, d, e, a, b, 18);
+ R1(b, c, d, e, a, 19);
+ R2(a, b, c, d, e, 20);
+ R2(e, a, b, c, d, 21);
+ R2(d, e, a, b, c, 22);
+ R2(c, d, e, a, b, 23);
+ R2(b, c, d, e, a, 24);
+ R2(a, b, c, d, e, 25);
+ R2(e, a, b, c, d, 26);
+ R2(d, e, a, b, c, 27);
+ R2(c, d, e, a, b, 28);
+ R2(b, c, d, e, a, 29);
+ R2(a, b, c, d, e, 30);
+ R2(e, a, b, c, d, 31);
+ R2(d, e, a, b, c, 32);
+ R2(c, d, e, a, b, 33);
+ R2(b, c, d, e, a, 34);
+ R2(a, b, c, d, e, 35);
+ R2(e, a, b, c, d, 36);
+ R2(d, e, a, b, c, 37);
+ R2(c, d, e, a, b, 38);
+ R2(b, c, d, e, a, 39);
+ R3(a, b, c, d, e, 40);
+ R3(e, a, b, c, d, 41);
+ R3(d, e, a, b, c, 42);
+ R3(c, d, e, a, b, 43);
+ R3(b, c, d, e, a, 44);
+ R3(a, b, c, d, e, 45);
+ R3(e, a, b, c, d, 46);
+ R3(d, e, a, b, c, 47);
+ R3(c, d, e, a, b, 48);
+ R3(b, c, d, e, a, 49);
+ R3(a, b, c, d, e, 50);
+ R3(e, a, b, c, d, 51);
+ R3(d, e, a, b, c, 52);
+ R3(c, d, e, a, b, 53);
+ R3(b, c, d, e, a, 54);
+ R3(a, b, c, d, e, 55);
+ R3(e, a, b, c, d, 56);
+ R3(d, e, a, b, c, 57);
+ R3(c, d, e, a, b, 58);
+ R3(b, c, d, e, a, 59);
+ R4(a, b, c, d, e, 60);
+ R4(e, a, b, c, d, 61);
+ R4(d, e, a, b, c, 62);
+ R4(c, d, e, a, b, 63);
+ R4(b, c, d, e, a, 64);
+ R4(a, b, c, d, e, 65);
+ R4(e, a, b, c, d, 66);
+ R4(d, e, a, b, c, 67);
+ R4(c, d, e, a, b, 68);
+ R4(b, c, d, e, a, 69);
+ R4(a, b, c, d, e, 70);
+ R4(e, a, b, c, d, 71);
+ R4(d, e, a, b, c, 72);
+ R4(c, d, e, a, b, 73);
+ R4(b, c, d, e, a, 74);
+ R4(a, b, c, d, e, 75);
+ R4(e, a, b, c, d, 76);
+ R4(d, e, a, b, c, 77);
+ R4(c, d, e, a, b, 78);
+ R4(b, c, d, e, a, 79);
+ /* Add the working vars back into context.state[] */
+ state[0] += a;
+ state[1] += b;
+ state[2] += c;
+ state[3] += d;
+ state[4] += e;
+ /* Wipe variables */
+ a = b = c = d = e = 0;
+#ifdef SHA1HANDSOFF
+ memset(block, '\0', sizeof(block));
+#endif
+}
+
+
+/* SHA1Init - Initialize new context */
+
+void SHA1Init(
+ SHA1_CTX * context
+)
+{
+ /* SHA1 initialization constants */
+ context->state[0] = 0x67452301;
+ context->state[1] = 0xEFCDAB89;
+ context->state[2] = 0x98BADCFE;
+ context->state[3] = 0x10325476;
+ context->state[4] = 0xC3D2E1F0;
+ context->count[0] = context->count[1] = 0;
+}
+
+
+/* Run your data through this. */
+
+void SHA1Update(
+ SHA1_CTX * context,
+ const unsigned char *data,
+ uint32_t len
+)
+{
+ uint32_t i;
+
+ uint32_t j;
+
+ j = context->count[0];
+ if ((context->count[0] += len << 3) < j)
+ context->count[1]++;
+ context->count[1] += (len >> 29);
+ j = (j >> 3) & 63;
+ if ((j + len) > 63)
+ {
+ memcpy(&context->buffer[j], data, (i = 64 - j));
+ SHA1Transform(context->state, context->buffer);
+ for (; i + 63 < len; i += 64)
+ {
+ SHA1Transform(context->state, &data[i]);
+ }
+ j = 0;
+ }
+ else
+ i = 0;
+ memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+
+/* Add padding and return the message digest. */
+
+void SHA1Final(
+ unsigned char digest[20],
+ SHA1_CTX * context
+)
+{
+ unsigned i;
+
+ unsigned char finalcount[8];
+
+ unsigned char c;
+
+#if 0 /* untested "improvement" by DHR */
+ /* Convert context->count to a sequence of bytes
+ * in finalcount. Second element first, but
+ * big-endian order within element.
+ * But we do it all backwards.
+ */
+ unsigned char *fcp = &finalcount[8];
+
+ for (i = 0; i < 2; i++)
+ {
+ uint32_t t = context->count[i];
+
+ int j;
+
+ for (j = 0; j < 4; t >>= 8, j++)
+ *--fcp = (unsigned char) t}
+#else
+ for (i = 0; i < 8; i++)
+ {
+ finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >>
((3 - (i & 3)) * 8)) & 255); /* Endian independent */
+ }
+#endif
+ c = 0200;
+ SHA1Update(context, &c, 1);
+ while ((context->count[0] & 504) != 448)
+ {
+ c = 0000;
+ SHA1Update(context, &c, 1);
+ }
+ SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
+ for (i = 0; i < 20; i++)
+ {
+ digest[i] = (unsigned char)
+ ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
+ }
+ /* Wipe variables */
+ memset(context, '\0', sizeof(*context));
+ memset(&finalcount, '\0', sizeof(finalcount));
+}
+
+void SHA1(
+ char *hash_out,
+ const char *str,
+ int len)
+{
+ SHA1_CTX ctx;
+ unsigned int ii;
+
+ SHA1Init(&ctx);
+ for (ii=0; ii<len; ii+=1)
+ SHA1Update(&ctx, (const unsigned char*)str + ii, 1);
+ SHA1Final((unsigned char *)hash_out, &ctx);
+ hash_out[20] = '\0';
+}
+
+std::string sha1_hash_hex(const char *buffer, int len)
+{
+ char sha1_result[21];
+ char sha1_hex[41];
+ SHA1(sha1_result, buffer, len);
+ for (size_t offset = 0; offset < 20; offset++) {
+ sprintf( ( sha1_hex + (2*offset)), "%02x", sha1_result[offset]&0xff);
+ }
+ return std::string(sha1_hex);
+}
Copied: brlcad/branches/bioh/misc/repoconv/verify/svn.sh (from rev 76568,
brlcad/trunk/misc/repoconv/verify/svn.sh)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/verify/svn.sh
(rev 0)
+++ brlcad/branches/bioh/misc/repoconv/verify/svn.sh 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+REPODIR="$PWD/brlcad_repo"
+
+echo "Rsyncing BRL-CAD SVN repository"
+mv $REPODIR code
+rsync -av svn.code.sf.net::p/brlcad/code .
+mv code $REPODIR
+
+# Make a dump file
+svnadmin dump $REPODIR > brlcad_full.dump
+
+# Strip the populated RCS tags from as much of the SVN repo
+# as we can, then use the new dump file to populate a
+# repo to make sure the dump file wasn't damaged
+g++ -O3 -o dercs svn_de-rcs.cxx
+rm -f brlcad_full_dercs.dump
+./dercs brlcad_full.dump brlcad_full_dercs.dump
+rm -rf repo_dercs
+svnadmin create repo_dercs
+svnadmin load repo_dercs < brlcad_full_dercs.dump
+
Copied: brlcad/branches/bioh/misc/repoconv/verify/svn_de-rcs.cxx (from rev
76568, brlcad/trunk/misc/repoconv/verify/svn_de-rcs.cxx)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/verify/svn_de-rcs.cxx
(rev 0)
+++ brlcad/branches/bioh/misc/repoconv/verify/svn_de-rcs.cxx 2020-07-29
14:16:57 UTC (rev 76569)
@@ -0,0 +1,574 @@
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <regex>
+#include "md5.hpp"
+#include "sha1.hpp"
+
+#define sfcmp(_s1, _s2) _s1.compare(0, _s2.size(), _s2) && _s1.size() >=
_s2.size()
+#define svn_str(_s1, _s2) (!sfcmp(_s1, _s2)) ? _s1.substr(_s2.size(),
_s1.size()-_s2.size()) : std::string()
+
+std::map<std::string, std::string> md5_map;
+std::map<std::string, std::string> sha1_map;
+
+bool is_binary(const char *cstr, int len, std::string &npath)
+{
+ // https://stackoverflow.com/a/567918/2037687
+ for (int i = 0; i < len; i++) {
+ if (cstr[i] == '\0') {
+ return true;
+ }
+ }
+
+ // We may be processing the file contents as C++ with regex - make
+ // sure we can represent the contents successfully.
+ std::string sbuff;
+ sbuff.assign(cstr, len);
+ if (sbuff.length() != len) {
+ std::cout << "C++ string representation failed (size delta " <<
abs(sbuff.length() - len) << "): " << npath << "\n";
+ return true;
+ }
+
+ return false;
+}
+
+bool skip_dercs(std::string &npath) {
+ if (npath.find("/re2c/") != std::string::npos) return false;
+ if (npath.find("/misc/Cakefile.defs") != std::string::npos) return false;
+ if (npath.find("/misc/win32-msvc8") != std::string::npos) return false;
+ if (npath.find("/misc/rcs2log") != std::string::npos) return false;
+ if (npath.find("/misc/win32-msvc") != std::string::npos) return false;
+ if (npath.find("/misc/archlinux/brlcad.install") != std::string::npos)
return false;
+ if (npath.find("/misc/brlcad.spec.in") != std::string::npos) return false;
+ if (npath.find("/misc/") != std::string::npos) return true;
+ if (npath.find("/src/other/step") != std::string::npos) return true;
+ if (npath.find("/src/conv/step") != std::string::npos) return true;
+ if (npath.find("/ap242.exp") != std::string::npos) return true;
+ return false;
+}
+
+std::string de_rcs(const char *cstr, int len)
+{
+ std::regex rcs_date("\\$Date:[^\\$;\"\n\r]*");
+ std::regex rcs_header("\\$Header:[^\\$;\"\n\r]*");
+ std::regex rcs_id("\\$Id:[^\\$;\"\n\r]*");
+ std::regex rcs_log("\\$Log:[^\\$;\"\n\r]*");
+ std::regex rcs_revision("\\$Revision:[^\\$;\"\n\r]*");
+ std::regex rcs_source("\\$Source:[^\\$;\"\n\r]*");
+ std::regex rcs_author("\\$Author:[^\\$;\"\n\r]*");
+ std::regex rcs_locker("\\$Locker:[^\\$;\"\n\r]*");
+
+ std::string buff01;
+ buff01.assign(cstr, len);
+ std::string buff02 = std::regex_replace(buff01, rcs_date, "$Date");
+ std::string buff03 = std::regex_replace(buff02, rcs_header, "$Header");
+ std::string buff04 = std::regex_replace(buff03, rcs_id, "$Id");
+ std::string buff05 = std::regex_replace(buff04, rcs_log, "$Log");
+ std::string buff06 = std::regex_replace(buff05, rcs_revision, "$Revision");
+ std::string buff07 = std::regex_replace(buff06, rcs_source, "$Source");
+ std::string buff08 = std::regex_replace(buff07, rcs_author, "$Author");
+ std::string buff09 = std::regex_replace(buff08, rcs_locker, "$Locker");
+
+#if 0
+ if (buff01 != buff09) {
+ std::ofstream ofile("orig.f", std::ios::out | std::ios::binary);
+ ofile.write(cstr, len);
+ ofile.close();
+ std::ofstream nfile("new.f", std::ios::out | std::ios::binary);
+ nfile << buff09;
+ nfile.close();
+
+ std::cout << "RCS stripping complete.\n";
+ }
+#endif
+ return buff09;
+}
+
+long int svn_lint(std::string s1, std::string s2)
+{
+ if (!s1.length() || !s2.length()) return -1;
+ return std::stol(svn_str(s1, s2));
+}
+
+/* Newer subversion doesn't like non-LF line endings in properties,
+ * so strip them out */
+void
+skip_rev_props(std::ifstream &infile, std::ofstream &outfile)
+{
+ std::string kkey("K ");
+ std::string pend("PROPS-END");
+ std::string line;
+
+ // Go until we hit PROPS-END
+ while (std::getline(infile, line) && line.compare(pend)) {
+ // K <N> line is the trigger
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ outfile << line << "\n";
+ std::string key = svn_str(line, kkey);
+ if (!key.length()) continue;
+
+ // Key associated with K line and value
+ std::getline(infile, key);
+ std::replace(key.begin(), key.end(), '\r', '\n');
+ outfile << key << "\n";
+ std::getline(infile, line);
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ outfile << line << "\n";
+ }
+ outfile << "PROPS-END\n";
+}
+
+
+/* Newer subversion doesn't like non-LF line endings in properties,
+ * so strip them out */
+void
+skip_node_props(std::ifstream &infile, std::vector<std::string> &node_lines)
+{
+ std::string kkey("K ");
+ std::string pend("PROPS-END");
+ std::string line;
+
+ // Go until we hit PROPS-END
+ while (std::getline(infile, line)) {
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ node_lines.push_back(line);
+
+ // If we get PROPS-END, we're done
+ if (!line.compare(pend)) {
+ return;
+ }
+
+ // K <N> line is the trigger
+ std::string key = svn_str(line, kkey);
+ if (!key.length()) continue;
+
+ // Key and value line associated with K line
+ std::getline(infile, key);
+ std::replace(key.begin(), key.end(), '\r', '\n');
+ node_lines.push_back(key);
+ std::getline(infile, line);
+ std::replace(line.begin(), line.end(), '\r', '\n');
+ node_lines.push_back(line);
+ }
+}
+
+int curr_md5_line(std::string line, std::string key, std::ofstream &outfile)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_md5 = svn_str(line, key);
+ m_it = md5_map.find(old_md5);
+ if (m_it != md5_map.end()) {
+ outfile << key << m_it->second << "\n";
+ } else {
+ outfile << line << "\n";
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+int curr_sha1_line(std::string line, std::string key, std::ofstream &outfile)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_sha1 = svn_str(line, key);
+ m_it = sha1_map.find(old_sha1);
+ if (m_it != sha1_map.end()) {
+ outfile << key << m_it->second << "\n";
+ } else {
+ outfile << line << "\n";
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+
+int curr_md5_line2(std::string line, std::string key, std::string &oval,
std::vector<std::string> &node_lines)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_md5 = svn_str(line, key);
+ if (old_md5.length()) {
+ m_it = md5_map.find(old_md5);
+ if (m_it != md5_map.end()) {
+ std::string nline = key + m_it->second;
+ node_lines.push_back(nline);
+ oval = m_it->second;
+ } else {
+ oval = old_md5;
+ node_lines.push_back(line);
+ }
+ } else {
+ oval = old_md5;
+ node_lines.push_back(line);
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+int curr_sha1_line2(std::string line, std::string key, std::string &oval,
std::vector<std::string> &node_lines)
+{
+ if (!sfcmp(line, key)) {
+ std::map<std::string, std::string>::iterator m_it;
+ std::string old_sha1 = svn_str(line, key);
+ m_it = sha1_map.find(old_sha1);
+ if (old_sha1.length()) {
+ if (m_it != sha1_map.end()) {
+ std::string nline = key + m_it->second;
+ node_lines.push_back(nline);
+ oval = m_it->second;
+ } else {
+ oval = old_sha1;
+ node_lines.push_back(line);
+ }
+ } else {
+ oval = old_sha1;
+ node_lines.push_back(line);
+ }
+ return 1;
+ }
+ return 0;
+}
+
+
+
+
+/* Return 1 if we successfully processed a node, else 0 */
+int
+process_node(std::ifstream &infile, std::ofstream &outfile)
+{
+ std::string text_copy_source_md5;
+ std::string text_copy_source_sha1;
+ std::string text_content_md5;
+ std::string text_content_sha1;
+ long int text_content_length = 0;
+ long int prop_content_length = 0;
+ long int content_length = 0;
+ std::string npath("");
+ std::string rkey("Revision-number: ");
+ std::string npkey("Node-path: ");
+ std::string pclkey("Prop-content-length: ");
+ std::string tcsmkey("Text-copy-source-md5: ");
+ std::string tcsskey("Text-copy-source-sha1: ");
+ std::string tcmkey("Text-content-md5: ");
+ std::string tcskey("Text-content-sha1: ");
+ std::string tclkey("Text-content-length: ");
+ std::string clkey("Content-length: ");
+ std::string line;
+ std::vector<std::string> node_lines;
+ std::vector<std::string>::iterator nl_it;
+
+ // Find node path, or bail if we hit a new revision first
+ size_t line_start = infile.tellg();
+ while (!npath.length() && std::getline(infile, line)) {
+ if (!sfcmp(line, rkey)) {
+ infile.seekg(line_start);
+ return -1; // Done with revision
+ }
+ node_lines.push_back(line);
+ npath = svn_str(line, npkey);
+ }
+
+ // If no node path, no node and presumably the end of the revision
+ if (!npath.length()) return -1;
+
+
+ // Have a path, so we're in a node. Find node contents, or bail if we hit a
+ // new revision/path
+ while (std::getline(infile, line)) {
+
+ // If we hit an empty line, we're done with the node itself
+ // and its down to properties and content, if any.
+ if (!line.length()) break;
+
+ if (!sfcmp(line, rkey)) {
+ return -1; // Done with revision
+ }
+ if (!sfcmp(line, npkey)) {
+ return 1; // Done with node
+ }
+
+ // Have path, get guts.
+ if (curr_md5_line2(line, tcsmkey, text_copy_source_md5, node_lines)) {
+ continue;
+ }
+ if (curr_sha1_line2(line, tcsskey, text_copy_source_sha1, node_lines)) {
+ continue;
+ }
+ if (!sfcmp(line, tcmkey)) {
+ text_content_md5 = svn_str(line, tcmkey);
+ node_lines.push_back(line);
+ continue;
+ }
+ if (!sfcmp(line, tcskey)) {
+ text_content_sha1 = svn_str(line, tcskey);
+ node_lines.push_back(line);
+ continue;
+ }
+ if (!sfcmp(line, tclkey)) {
+ text_content_length = svn_lint(line, tclkey);
+ node_lines.push_back(line);
+ continue;
+ }
+ if (!sfcmp(line, clkey)) {
+ content_length = svn_lint(line, clkey);
+ node_lines.push_back(line);
+ node_lines.push_back(std::string(""));
+ continue;
+ }
+ if (!sfcmp(line, pclkey)) {
+ prop_content_length = svn_lint(line, pclkey);
+ node_lines.push_back(line);
+ continue;
+ }
+
+ node_lines.push_back(line);
+ }
+
+ // If we have properties, skip beyond them
+ if (prop_content_length > 0) {
+ skip_node_props(infile, node_lines);
+ }
+
+ // If we have neither properties nor content, we're done
+ if (!prop_content_length && !text_content_length) {
+ for (nl_it = node_lines.begin(); nl_it != node_lines.end(); nl_it++) {
+ outfile << *nl_it << "\n";
+ }
+ outfile << "\n";
+ return 1;
+ }
+
+ // If we have content, store the file offset, process the content
+ // for possible RCS edits, set up the new values for md5 and sha1,
+ // and jump the seek beyond the old content.
+ char *buffer = NULL;
+ std::string new_content("");
+ size_t oldpos;
+ size_t after_content;
+ if (text_content_length > 0) {
+ oldpos = infile.tellg();
+ after_content = oldpos + text_content_length + 1;
+ buffer = new char [text_content_length];
+ infile.read(buffer, text_content_length);
+ infile.seekg(after_content);
+ }
+
+ if (buffer && !skip_dercs(npath)) {
+ if (!is_binary(buffer, text_content_length, npath)) {
+ std::string calc_md5 = md5_hash_hex(buffer, text_content_length);
+ std::string calc_sha1 = sha1_hash_hex(buffer, text_content_length);
+ if (text_content_md5 != calc_md5 || text_content_sha1 != calc_sha1)
{
+ std::cout << "Stored vs. calculated mismatch: " << npath <<
"\n";
+ std::cout << "Read md5 : " << text_content_md5 << "\n";
+ std::cout << "Calculated md5 : " << calc_md5 << "\n";
+ std::cout << "Read sha1 : " << text_content_sha1 << "\n";
+ std::cout << "Calculated sha1: " << calc_sha1 << "\n";
+ /*
+ if (npath == std::string("brlcad/trunk/misc/vfont/fix.6r")) {
+ std::ofstream cfile("fix-extracted.6r", std::ios::out |
std::ios::binary);
+ cfile.write(buffer, text_content_length);
+ cfile.close();
+ }
+ */
+ }
+ new_content = de_rcs(buffer, text_content_length);
+ std::string new_md5 = md5_hash_hex(new_content.c_str(),
new_content.length());
+ std::string new_sha1 = sha1_hash_hex(new_content.c_str(),
new_content.length());
+ if (text_content_md5 != new_md5 || text_content_sha1 != new_sha1) {
+ std::cout << "Altered: " << npath << "\n";
+ std::cout << "Original md5 : " << text_content_md5 << "\n";
+ std::cout << "Calculated md5 : " << new_md5 << "\n";
+ std::cout << "Original sha1 : " << text_content_sha1 << "\n";
+ std::cout << "Calculated sha1: " << new_sha1 << "\n";
+
md5_map.insert(std::pair<std::string,std::string>(text_content_md5, new_md5));
+
sha1_map.insert(std::pair<std::string,std::string>(text_content_sha1,
new_sha1));
+ }
+ }
+ }
+
+#if 0
+ std::regex cvsignore(".*cvsignore$");
+
+ if (!std::regex_match(npath, cvsignore)) {
+#endif
+ // Write out the node lines and content.
+ std::map<std::string, std::string>::iterator m_it;
+ for (nl_it = node_lines.begin(); nl_it != node_lines.end(); nl_it++) {
+ if (skip_dercs(npath)) {
+ outfile << *nl_it << "\n";
+ continue;
+ }
+ line = *nl_it;
+ // Text-copy-source-md5
+ if (curr_md5_line(line, tcsmkey, outfile)) {
+ continue;
+ }
+ // Text-copy-source-sha1
+ if (curr_sha1_line(line, tcsskey, outfile)) {
+ continue;
+ }
+
+ // Text-content-md5
+ if (curr_md5_line(line, tcmkey, outfile)) {
+ continue;
+ }
+
+ // Text-content-sha1
+ if (curr_sha1_line(line, tcskey, outfile)) {
+ continue;
+ }
+
+ // Text-content-length
+ if (!sfcmp(line, tclkey)) {
+ if (new_content.length()) {
+ outfile << "Text-content-length: " << new_content.length()
<< "\n";
+ } else {
+ outfile << *nl_it << "\n";
+ }
+ continue;
+ }
+
+ // Content-length
+ if (!sfcmp(line, clkey)) {
+ if (new_content.length()) {
+ outfile << "Content-length: " << new_content.length() +
prop_content_length << "\n";
+ } else {
+ outfile << *nl_it << "\n";
+ }
+ continue;
+ }
+
+ outfile << *nl_it << "\n";
+ }
+ if (buffer) {
+ if (new_content.length()) {
+ outfile << new_content;
+ } else {
+ outfile.write(buffer, text_content_length);
+ }
+ outfile << "\n";
+ }
+#if 0
+ } else {
+ std::cout << "Skipping " << npath << "\n";
+ }
+#endif
+
+ if (buffer) {
+ delete buffer;
+ }
+
+ return 1;
+}
+
+/* Return 1 if we successfully processed a revision, else 0 */
+int
+process_revision(std::ifstream &infile, std::ofstream &outfile)
+{
+ std::string rkey("Revision-number: ");
+ std::string ckey("Content-length: ");
+ int node_ret = 0;
+ int success = 0;
+ std::string line;
+ long int revision_number = -1;
+
+ while (revision_number < 0) {
+ if (!std::getline(infile, line)) return success; // No rkey and no
input, no revision
+ outfile << line << "\n";
+ outfile.flush();
+ if (!sfcmp(line, rkey)) revision_number = svn_lint(line, rkey);
+ }
+ success = 1; // For the moment, finding the revision is enough to qualify
as success...
+
+ // "Usually" a revision will have properties, but they are apparently not
+ // technically required. For revision properties Content-length and
+ // Prop-content-length will always match if non-zero, and Content-length
+ // appears to be requried by the dump file spec, so just find and use
+ // Content-length
+ long int rev_prop_length = -1;
+ while (rev_prop_length < 0) {
+ if (!std::getline(infile, line)) return success; // Rev num but no
contents, no revision
+ outfile << line << "\n";
+ outfile.flush();
+ if (!sfcmp(line, ckey)) rev_prop_length = svn_lint(line, ckey);
+ }
+ if (rev_prop_length) skip_rev_props(infile, outfile);
+
+ //std::cerr << "Revision-number: " << revision_number << ", prop length "
<< rev_prop_length << std::endl;
+
+ /* Have revision number - grab nodes until we spot another one */
+ while (node_ret != -1 && infile.peek() != EOF) {
+ node_ret = process_node(infile, outfile);
+ }
+
+ outfile.flush();
+ std::cout << "Processed r" << revision_number << "\n";
+
+ return success;
+}
+
+int
+main(int argc, const char **argv)
+{
+ std::string uuid;
+ long int dump_format_version = -1;
+ std::ifstream infile(argv[1]);
+ std::ofstream outfile(argv[2], std::ios::out | std::ios::binary);
+ if (!infile.good()) return -1;
+ if (!outfile.good()) return -1;
+ std::string line;
+ std::string fmtkey("SVN-fs-dump-format-version: ");
+ // The first non-empty line has to be the format version, or we're done.
+ while (std::getline(infile, line) && !line.length()) {
+ outfile << line;
+ };
+ if (line.compare(0, fmtkey.length(), fmtkey)) {
+ return -1;
+ }
+ outfile << line << "\n";
+
+ // Grab the format number
+ dump_format_version = svn_lint(line, fmtkey);
+
+ while (!uuid.length() && std::getline(infile, line)) {
+ outfile << line << "\n";
+ uuid = svn_str(line, std::string("UUID: "));
+ }
+
+ outfile.flush();
+
+ /* As long as we're not done, read revisions */
+ while (infile.peek() != EOF) {
+ process_revision(infile, outfile);
+ }
+
+ outfile << "\n";
+ outfile << "\n";
+
+ infile.close();
+ outfile.close();
+
+ return 0;
+}
+
+
+
+// Local Variables:
+// tab-width: 8
+// mode: C++
+// c-basic-offset: 4
+// indent-tabs-mode: t
+// c-file-style: "stroustrup"
+// End:
+// ex: shiftwidth=4 tabstop=8
Modified: brlcad/branches/bioh/misc/repoconv/verify/verify.cpp
===================================================================
--- brlcad/branches/bioh/misc/repoconv/verify/verify.cpp 2020-07-29
14:07:05 UTC (rev 76568)
+++ brlcad/branches/bioh/misc/repoconv/verify/verify.cpp 2020-07-29
14:16:57 UTC (rev 76569)
@@ -16,25 +16,276 @@
#include <iostream>
#include <map>
#include <regex>
+#include <set>
#include <sstream>
#include <string>
#include "cxxopts.hpp"
+#include "./sha1.hpp"
class cmp_info {
public:
+ std::string sha1;
+ std::string msg;
+ std::string timestamp_str;
+ long timestamp = 0;
std::string rev;
- std::string branch_svn;
- std::string sha1;
+ long svn_rev = 0;
+
+ std::string branch_svn = "trunk";
+ std::set<std::string> branches;
std::string cvs_date;
+ bool branch_delete = false;
+
std::string cvs_check_cmds;
std::string git_check_cmds;
std::string svn_check_cmds;
};
-int verify_repos_cvs(cmp_info &info, std::string git_repo, std::string
cvs_repo) {
+void
+read_key_sha1_map(std::map<std::string, std::string> &key2sha1, std::string
&keysha1file)
+{
+ std::ifstream infile(keysha1file, std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: " << keysha1file << "\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ size_t cpos = line.find_first_of(":");
+ std::string key = line.substr(0, cpos);
+ std::string sha1 = line.substr(cpos+1, std::string::npos);
+ if (key2sha1.find(key) != key2sha1.end()) {
+ //std::cout << "non-unique key: " << line << "\n";
+ } else {
+ key2sha1[key] = sha1;
+ }
+ }
+ infile.close();
+}
+
+void
+read_branch_sha1_map(
+ std::map<std::string, std::string> &sha12branch,
+ std::map<std::string, std::string> &key2sha1,
+ std::string &branchfile)
+{
+ std::map<std::string, std::string> key2branch;
+ std::ifstream infile(branchfile, std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: " << branchfile << "\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ size_t cpos = line.find_first_of(":");
+ std::string key = line.substr(0, cpos);
+ std::string branch = line.substr(cpos+1, std::string::npos);
+ if (key2branch.find(key) != key2branch.end()) {
+ std::string oldbranch = key2branch[key];
+ if (oldbranch != branch) {
+ std::cout << "WARNING: non-unique key maps to both " <<
oldbranch << " and " << branch << "\n";
+ }
+ } else {
+ key2branch[key] = branch;
+ }
+ }
+ infile.close();
+
+ std::map<std::string, std::string>::iterator k2s_it;
+ for (k2s_it = key2sha1.begin(); k2s_it != key2sha1.end(); k2s_it++) {
+ std::string key = k2s_it->first;
+ std::string sha1 = k2s_it->second;
+ if (key2branch.find(key) == key2branch.end()) {
+ continue;
+ }
+ sha12branch[sha1] = key2branch[key];
+ std::cout << sha1 << " -> " << key2branch[key] << "\n";
+ }
+}
+
+/* Assuming a tree checked out, build a tree based on the contents */
+
+class filemodify {
+ public:
+ std::string mode;
+ std::string hash;
+ std::string path;
+};
+
+void run_cmd(std::string &cmd)
+{
+ if (std::system(cmd.c_str())) {
+ std::cerr << "cmd \"" << cmd << "\" failed!\n";
+ exit(1);
+ }
+}
+
+void
+get_done_sha1s(std::set<std::string> &done, std::string &done_file)
+{
+ std::ifstream infile(done_file, std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: " << done_file << "\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ done.insert(line);
+ }
+ infile.close();
+}
+
+
+void
+get_exec_paths(std::vector<filemodify> &m)
+{
+ std::string exec_cmd = std::string("cd brlcad && find . -type f ! -name
.cvsignore ! -path \\*/CVS/\\* -executable | sed -e 's/.\\///' > ../exec.txt &&
cd ..");
+ run_cmd(exec_cmd);
+ std::ifstream infile("exec.txt", std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: exec.txt\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ filemodify nm;
+ nm.mode = std::string("100755");
+ nm.path = line;
+ m.push_back(nm);
+ }
+ infile.close();
+}
+
+void
+get_noexec_paths(std::vector<filemodify> &m)
+{
+ std::string noexec_cmd = std::string("cd brlcad && find . -type f ! -name
.cvsignore ! -path \\*/CVS/\\* ! -executable | sed -e 's/.\\///' >
../noexec.txt && cd ..");
+ run_cmd(noexec_cmd);
+ std::ifstream infile("noexec.txt", std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: noexec.txt\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ filemodify nm;
+ nm.mode = std::string("100644");
+ nm.path = line;
+ m.push_back(nm);
+ }
+ infile.close();
+}
+
+std::string
+git_sha1(const char *b, size_t size)
+{
+ std::string go_buff;
+ go_buff.append("blob ");
+ go_buff.append(std::to_string(size));
+ go_buff.append(1, '\0');
+ go_buff.append(b, size);
+ std::string git_sha1 = sha1_hash_hex(go_buff.c_str(), go_buff.length());
+ return git_sha1;
+}
+
+/* Even if writing out the blobs is disabled, we still need to calculate the
+ * sha1 hashes for the tree output. */
+void
+process_blobs(std::vector<filemodify> &mods, std::string &sha1)
+{
+ // The -blob.fi file is prepared in case the tree incorporates a blob that
+ // was never preserved in the original conversion. blob.fi files take a
+ // significant amount of space and slow subsequent fast-imports, so they
+ // should be enabled only if that situation is discovered.
+//#define WRITE_BLOBS
+#ifdef WRITE_BLOBS
+ std::string sha1file = sha1 + std::string("-blob.fi");
+ std::ofstream outfile(sha1file.c_str(), std::ifstream::binary);
+ if (!outfile.good()) {
+ std::cerr << "Could not open file: " << sha1file << "\n";
+ exit(-1);
+ }
+#endif
+
+ for (size_t i = 0; i < mods.size(); i++) {
+ std::string path = std::string("brlcad/") + mods[i].path;
+ std::ifstream file(path, std::ios::binary | std::ios::ate);
+ if (!file.good()) {
+ std::cerr << "Could not open file: " << path << "\n";
+ exit(-1);
+ }
+ std::streamsize size = file.tellg();
+ file.seekg(0, std::ios::beg);
+ std::vector<char> buffer(size);
+ if (file.read(buffer.data(), size))
+ {
+
+ const char *b = reinterpret_cast<char*>(buffer.data());
+ mods[i].hash = git_sha1(b, size);
+
+#ifdef WRITE_BLOBS
+ outfile << "blob\n";
+ outfile << "data " << size << "\n";
+ outfile.write(reinterpret_cast<char*>(buffer.data()), size);
+#endif
+ }
+ file.close();
+ }
+
+#ifdef WRITE_BLOBS
+ outfile.close();
+#endif
+}
+
+int
+build_cvs_tree(std::string sha1)
+{
+ std::vector<filemodify> mods;
+ get_exec_paths(mods);
+ get_noexec_paths(mods);
+ process_blobs(mods, sha1);
+
+ if (!mods.size()) {
+ return -1;
+ }
+
+ std::string sha1file = sha1 + std::string("-tree.fi");
+ std::ofstream outfile(sha1file.c_str(), std::ifstream::binary);
+ if (!outfile.good()) {
+ std::cerr << "Could not open file: " << sha1file << "\n";
+ exit(-1);
+ }
+
+ for (size_t i = 0; i < mods.size(); i++) {
+ outfile << "M " << mods[i].mode << " " << mods[i].hash << " \"" <<
mods[i].path << "\"\n";
+ }
+
+ std::string cleanup("rm exec.txt noexec.txt");
+ run_cmd(cleanup);
+ return 0;
+}
+
+int verify_repos_cvs(std::ofstream &cvs_problem_sha1s, cmp_info &info,
std::string git_repo, std::string cvs_repo) {
std::string cvs_cmd;
- if (info.branch_svn == std::string("trunk")) {
+
+ std::regex tag_invalid(".*[$,.:;@].*");
+ if (std::regex_match(info.branch_svn, tag_invalid)) {
+ std::cout << "Branch name contains invalid char, cannot be checked out
by CVS, skipping\n";
+ return 0;
+ }
+ std::regex muregex(".*master-UNNAMED-BRANCH.*");
+ if (std::regex_match(info.branch_svn, muregex)) {
+ std::cout << "Branch is master-UNNAMED-BRANCH, cannot be checked out by
CVS, skipping\n";
+ return 0;
+ }
+
+ if (info.branch_svn == std::string("trunk") || info.branch_svn ==
std::string("master")) {
cvs_cmd = std::string("cvs -d ") + cvs_repo + std::string(" -Q co -ko
-D \"") + info.cvs_date + std::string("\" -P brlcad");
} else {
cvs_cmd = std::string("cvs -d ") + cvs_repo + std::string(" -Q co -ko
-D \"") + info.cvs_date + std::string("\" -r ") + info.branch_svn +
std::string(" -P brlcad");
@@ -49,11 +300,12 @@
exit(1);
}
if (std::system(cvs_cmd.c_str())) {
- std::cerr << "cvs checkout failed!\n";
+ std::cerr << "cvs checkout failed: " << cvs_cmd << "\n";
+ std::cerr << "skipping " << info.sha1 << "\n";
if (std::system(cleanup_cmd.c_str())) {
std::cerr << "verify cleanup failed!\n";
}
- exit(1);
+ return 0;
}
// Have both, do diff
@@ -65,8 +317,15 @@
int diff_ret = std::system(repo_diff.c_str());
if (diff_ret) {
- std::cerr << "CVS vs Git: diff test failed, r" << info.rev << ",
branch " << info.branch_svn << "\n";
- return 1;
+ std::cerr << "CVS vs Git: diff test failed, SHA1" << info.sha1 << ",
branch " << info.branch_svn << "\n";
+ if (build_cvs_tree(info.sha1)) {
+ std::cerr << "CVS tree empty - probably not what is intended,
skipping\n";
+ return 0;
+
+ }
+ cvs_problem_sha1s << info.sha1 << "\n";
+ cvs_problem_sha1s.flush();
+ return 1;
}
return 0;
@@ -135,19 +394,110 @@
return 0;
}
+void
+parse_git_info(std::vector<cmp_info> &commits, const char *fname)
+{
+ // Build up a map of SVN revs to SHA1 ids. We'll work in SVN order for a
more intuitive result
+ std::ifstream infile("commits.txt", std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open info file: commits.txt\n";
+ exit(-1);
+ }
+
+ std::string bstr("GITCOMMIT");
+ std::string estr("GITCOMMITEND");
+ std::regex revnum_regex(".*svn:revision:([0-9]+).*");
+ std::regex branch_regex(".*svn:branch:([a-zA-Z0-9_-]+).*");
+ std::regex bdelete_regex(".*svn branch delete.*");
+ std::regex note_regex(".*Note SVN revision and branch*");
+ std::regex note_regex2(".*Note SVN revision [0-9]+.*");
+
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ if (line == bstr) {
+ cmp_info ncommit;
+ std::getline(infile, ncommit.sha1);
+ std::getline(infile, ncommit.timestamp_str);
+ ncommit.timestamp = std::stol(ncommit.timestamp_str);
+ std::getline(infile, ncommit.cvs_date);
+ bool note_commit = false;
+
+ while (line != estr) {
+ std::getline(infile, line);
+ if (line == estr) {
+ break;
+ }
+ ncommit.msg.append(line);
+ std::smatch rmatch;
+ if (std::regex_search(line, rmatch, revnum_regex)) {
+ ncommit.rev = std::string(rmatch[1]);
+ ncommit.svn_rev = std::stol(ncommit.rev);
+ }
+ std::smatch bmatch;
+ if (std::regex_search(line, bmatch, branch_regex)) {
+ ncommit.branch_svn = std::string(bmatch[1]);
+ }
+ std::smatch bd_match;
+ if (std::regex_search(line, bd_match, bdelete_regex)) {
+ ncommit.branch_delete = true;
+ }
+ std::smatch note_match;
+ if (std::regex_search(line, note_match, note_regex)) {
+ note_commit = true;
+ }
+ std::smatch note_match2;
+ if (std::regex_search(line, note_match2, note_regex2)) {
+ note_commit = true;
+ }
+ }
+
+ if (note_commit) {
+ continue;
+ }
+
+ commits.push_back(ncommit);
+ }
+ }
+ infile.close();
+}
+
+// trim whitespace - https://stackoverflow.com/a/49253841
+static inline void wtrim(std::string &s) {
+ if (s.empty()) return;
+ while (s.find(" ") == 0) {s.erase(0, 1);}
+ size_t len = s.size();
+ while (s.rfind(" ") == --len) { s.erase(len, len + 1); }
+}
+
int main(int argc, char *argv[])
{
int ret;
- int start_rev = INT_MAX;
+ std::string keymap = std::string();
+ std::string branchmap = std::string();
std::string cvs_repo = std::string();
+ std::string svn_repo = std::string();
+ std::string done_list = std::string();
+ long cvs_maxtime = 1199132714;
+ long min_timestamp = 0;
+ long max_timestamp = LONG_MAX;
+ long max_rev = LONG_MAX;
+ long min_rev = 0;
+ std::ofstream cvs_problem_sha1s("cvs_problem_sha1.txt",
std::ifstream::binary);
+
try
{
cxxopts::Options options(argv[0], " - verify svn->git conversion");
options.add_options()
- ("cvs-repo", "Use the specified CVS repository for checks",
cxxopts::value<std::vector<std::string>>(), "path to repo")
- ("s,start-rev", "Skip any revision higher than this number",
cxxopts::value<int>(), "#")
+ ("cvs-repo", "Use the specified CVS repository for checks",
cxxopts::value<std::vector<std::string>>(), "repo")
+ ("keymap", "msgtim key to SHA1 lookup map",
cxxopts::value<std::vector<std::string>>(), "file")
+ ("branchmap", "msgtim key to CVS branch lookup map",
cxxopts::value<std::vector<std::string>>(), "file")
+ ("svn-repo", "Use the specified SVN repository for checks",
cxxopts::value<std::vector<std::string>>(), "repo")
+ ("max-rev", "Skip any revision higher than this number",
cxxopts::value<int>(), "#")
+ ("min-rev", "Skip any revision lower than this number",
cxxopts::value<int>(), "#")
+ ("done", "File with SHA1 identifiers (1/line) which have already
been checked", cxxopts::value<std::vector<std::string>>(), "repo")
("h,help", "Print help")
;
@@ -165,11 +515,40 @@
cvs_repo = ff[0];
}
- if (result.count("s"))
+ if (result.count("keymap"))
{
- start_rev = result["s"].as<int>();
+ auto& ff = result["keymap"].as<std::vector<std::string>>();
+ keymap = ff[0];
}
+ if (result.count("branchmap"))
+ {
+ auto& ff = result["branchmap"].as<std::vector<std::string>>();
+ branchmap = ff[0];
+ }
+
+ if (result.count("svn-repo"))
+ {
+ auto& ff = result["svn-repo"].as<std::vector<std::string>>();
+ svn_repo = ff[0];
+ }
+
+ if (result.count("done"))
+ {
+ auto& ff = result["done"].as<std::vector<std::string>>();
+ done_list = ff[0];
+ }
+
+ if (result.count("max-rev"))
+ {
+ max_rev = result["max-rev"].as<int>();
+ }
+
+ if (result.count("min-rev"))
+ {
+ min_rev = result["min-rev"].as<int>();
+ }
+
}
catch (const cxxopts::OptionException& e)
{
@@ -178,129 +557,138 @@
}
- if (argc != 3) {
- std::cerr << "Usage: verify [options] <git_repo_full_path>
<svn_repo_full_path>\n";
+ if (argc != 2) {
+ std::cerr << "Usage: verify [options] <git_repo_full_path>\n";
return -1;
}
- std::string svn_repo(argv[2]);
- std::string git_repo(argv[1]);
- std::string list_sha1 = std::string("cd ") + git_repo + std::string(" &&
git log --all --pretty=format:\"%H\" > ../commits.txt && cd ..");
- ret = std::system(list_sha1.c_str());
- if (ret) {
- std::cerr << "sha1 listing failed!\n";
- return -1;
+
+ std::set<std::string> done_sha1;
+ if (done_list.length()) {
+ get_done_sha1s(done_sha1, done_list);
}
+ std::map<std::string, std::string> sha12branch;
+ if (keymap.length()) {
+ std::map<std::string, std::string> key2sha1;
+ read_key_sha1_map(key2sha1, keymap);
+ if (branchmap.length()) {
+ read_branch_sha1_map(sha12branch, key2sha1, branchmap);
+ }
+ }
+
+
// Set up working git repo
+ std::string git_repo(argv[1]);
std::string git_working("git_working");
std::string git_init = std::string("git clone ") + git_repo +
std::string(" ") + git_working;
- // Build up a map of SVN revs to SHA1 ids. We'll work in SVN order for a
more intuitive result
- std::ifstream infile("commits.txt", std::ifstream::binary);
- if (!infile.good()) {
- std::cerr << "Could not open sha1 file: commits.txt\n";
- exit(-1);
+
+ // Get the necessary information
+ std::string get_git_info = std::string("cd ") + git_repo + std::string("
&& git log --all
--pretty=format:\"GITCOMMIT%n%H%n%ct%n%ci%n%B%n%N%nGITCOMMITEND%n\" >
../commits.txt && cd ..");
+ ret = std::system(get_git_info.c_str());
+ if (ret) {
+ std::cerr << "git commit listing failed!\n";
+ return -1;
}
+ std::vector<cmp_info> commits;
+ parse_git_info(commits, "commits.txt");
- std::map<int, cmp_info> rev_to_cmp;
+ // If we're doing a CVS only check, there's no point in working
+ // with newer commits
+ if (!svn_repo.length() && cvs_repo.length()) {
+ max_timestamp = cvs_maxtime;
+ }
- std::string sha1;
- std::cout << "Building test pairing information...\n";
- while (std::getline(infile, sha1)) {
- // Skip empty lines
- if (!sha1.length()) {
- continue;
- }
-
- // Get commit msg
- std::string get_msg = std::string("cd ") + git_repo + std::string(" &&
git log -1 " + sha1 + " --pretty=format:\"%B\" > ../msg.txt && cd ..");
- ret = std::system(get_msg.c_str());
- if (ret) {
- std::cerr << "getting git commit message failed!\n";
- return -1;
+ // Figure out min/max timestamps from the min/max revs, if we have them
+ std::map<long, long> rev_to_timestamp;
+ for (size_t i = 0; i < commits.size(); i++) {
+ if (commits[i].svn_rev) {
+ rev_to_timestamp[commits[i].svn_rev] = commits[i].timestamp;
}
-
- std::ifstream msg_infile("msg.txt");
- if (!msg_infile.good()) {
- std::cerr << "Could not open msg.txt file\n";
- exit(-1);
+ }
+ if (max_rev < LONG_MAX) {
+ bool have_timestamp = false;
+ int mrev = max_rev;
+ while (!have_timestamp && mrev < commits.size()) {
+ if (rev_to_timestamp.find(mrev) != rev_to_timestamp.end()) {
+ have_timestamp = true;
+ max_timestamp = rev_to_timestamp[mrev];
+ }
+ mrev++;
}
+ }
+ if (min_rev) {
+ bool have_timestamp = false;
+ int mrev = min_rev;
+ while (!have_timestamp && mrev > 0) {
+ if (rev_to_timestamp.find(mrev) != rev_to_timestamp.end()) {
+ have_timestamp = true;
+ min_timestamp = rev_to_timestamp[mrev];
+ }
+ mrev--;
+ }
+ }
- std::string msg((std::istreambuf_iterator<char>(msg_infile)),
std::istreambuf_iterator<char>());
- msg_infile.close();
+ std::set<std::pair<long, size_t>> timestamp_to_cmp;
+ for (size_t i = 0; i < commits.size(); i++) {
-
- std::regex revnum_regex(".*svn:revision:([0-9]+).*");
- std::smatch rmatch;
- if (!std::regex_search(msg, rmatch, revnum_regex)) {
- std::cerr << "No svn id found for " << sha1 << ", skipping
verification\n";
+ // Skip any commits we've already checked
+ if (done_sha1.find(commits[i].sha1) != done_sha1.end()) {
continue;
}
- std::string rev = std::string(rmatch[1]);
- if (std::stol(rev) > start_rev) {
+ // Skip any commits that don't meet the criteria
+ if (min_timestamp && commits[i].timestamp < min_timestamp) {
continue;
}
-
- // svn branch deletes can't be verified by checkout, skip those
- std::regex bdelete_regex(".*svn branch delete.*");
- std::smatch bd_match;
- if (std::regex_search(msg, bd_match, bdelete_regex)) {
- std::cerr << rev << " is a branch delete commit, skipping
verification\n";
+ if (max_timestamp != LONG_MAX && commits[i].timestamp > max_timestamp) {
continue;
}
- std::string branch("trunk");
- std::regex branch_regex(".*svn:branch:([a-zA-Z0-9_-]+).*");
- std::smatch bmatch;
- if (std::regex_search(msg, bmatch, branch_regex)) {
- branch = std::string(bmatch[1]);
- }
- cmp_info info;
- info.rev = rev;
- info.branch_svn = branch;
- info.sha1 = sha1;
-
- // If old enough and we have a CVS repo to check against, get CVS
compatible date
- if (std::stol(rev) < 29866 && cvs_repo.length()) {
- std::string get_date = std::string("cd ") + git_repo +
std::string(" && git log -1 " + sha1 + " --pretty=format:\"%ci\" > ../date.txt
&& cd ..");
- ret = std::system(get_date.c_str());
- if (ret) {
- std::cerr << "getting git commit date failed!\n";
- return -1;
- }
-
- std::ifstream date_infile("date.txt");
- if (!date_infile.good()) {
- std::cerr << "Could not open date.txt file\n";
- exit(-1);
- }
-
- std::string date((std::istreambuf_iterator<char>(date_infile)),
std::istreambuf_iterator<char>());
- date_infile.close();
-
- info.cvs_date = date;
- //std::cout << "Date(" << rev << "): " << info.cvs_date << "\n";
+ timestamp_to_cmp.insert(std::make_pair(commits[i].timestamp, i));
+ if (commits[i].svn_rev) {
+ std::cout << "Queueing revision " << commits[i].rev << "\n";
} else {
- info.cvs_date = std::string();
+ std::cout << "Queueing " << commits[i].sha1 << ", timestamp " <<
commits[i].timestamp << "\n";
}
-
- rev_to_cmp[std::stol(rev)] = info;
}
std::cerr << "Starting verifications...\n";
- std::map<int, cmp_info>::reverse_iterator r_it;
- for(r_it = rev_to_cmp.rbegin(); r_it != rev_to_cmp.rend(); r_it++) {
+ std::string dfout;
+ if (done_list.length()) {
+ dfout = done_list;
+ } else {
+ dfout = std::string("done_sha1.txt");
+ }
+ std::ofstream ofile(dfout, std::ios_base::app);
+ if (!ofile.good()) {
+ std::cerr << "Couldn't open " << dfout << " for writing.\n";
+ exit(1);
+ }
+
+ std::set<std::pair<long, size_t>>::reverse_iterator r_it;
+ for(r_it = timestamp_to_cmp.rbegin(); r_it != timestamp_to_cmp.rend();
r_it++) {
int cvs_err = 0;
- int svn_err = 1;
- cmp_info &info = r_it->second;
+ int svn_err = 0;
+ cmp_info &info = commits[r_it->second];
- std::cout << "Check SVN revision " << info.rev << "\n";
+ if (info.rev.length()) {
+ std::cout << "Checking SVN revision " << info.rev << "\n";
+ } else {
+ std::cout << "Checking non-SVN commit, timestamp " << r_it->first
<< "\n";
+ }
+ if (info.timestamp < cvs_maxtime) {
+ info.branch_svn = sha12branch[info.sha1];
+ if (!info.branch_svn.length()) {
+ info.branch_svn = std::string("master");
+ }
+ }
+
// Git checkout
std::string git_checkout = std::string("cd ") + git_repo +
std::string(" && git checkout --quiet ") + info.sha1 + std::string(" && cd ..");
info.git_check_cmds.append(git_checkout);
@@ -311,21 +699,23 @@
}
// If we're old enough and have the cvs repository, check it
- if (info.cvs_date.length() && std::stol(info.rev) < 29866) {
- cvs_err = verify_repos_cvs(info, git_repo, cvs_repo);
+ if (cvs_repo.length() && info.timestamp < cvs_maxtime) {
+ cvs_err = verify_repos_cvs(cvs_problem_sha1s, info, git_repo,
cvs_repo);
}
- // Always check the SVN repository
- svn_err = verify_repos_svn(info, git_repo, svn_repo);
+ // If we have the SVN repo and a revision, check SVN
+ if (svn_repo.length() && info.rev.length()) {
+ svn_err = verify_repos_svn(info, git_repo, svn_repo);
+ }
// If we saw any errors, report the commands that prompted them:
if (cvs_err || svn_err) {
- std::cerr << "Differences found:\n";
+ std::cerr << "Differences found (" << info.sha1 << "):\n";
std::cerr << "Git checkout command:\n\t" << info.git_check_cmds <<
"\n";
if (cvs_err) {
std::cerr << "CVS check cmds:\n\t" << info.cvs_check_cmds <<
"\n";
} else {
- if (info.cvs_date.length() && std::stol(info.rev) < 29866) {
+ if (cvs_repo.length() && info.timestamp < cvs_maxtime) {
std::cerr << "CVS check: OK\n";
}
}
@@ -332,11 +722,19 @@
if (svn_err) {
std::cerr << "SVN check cmds:\n\t" << info.svn_check_cmds <<
"\n";
} else {
- std::cerr << "SVN check: OK\n";
+ if (svn_repo.length() && info.rev.length()) {
+ std::cerr << "SVN check: OK\n";
+ }
}
}
+ ofile << info.sha1 << "\n";
+ ofile.flush();
+
}
+ ofile.close();
+
+ cvs_problem_sha1s.close();
}
// Local Variables:
Copied: brlcad/branches/bioh/misc/repoconv/verify/verify.sh (from rev 76568,
brlcad/trunk/misc/repoconv/verify/verify.sh)
===================================================================
--- brlcad/branches/bioh/misc/repoconv/verify/verify.sh
(rev 0)
+++ brlcad/branches/bioh/misc/repoconv/verify/verify.sh 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Do initial setup for appropriate comparison repositories
+./cvs.sh
+./svn.sh
+
+CVSDIR="$PWD/brlcad_cvs"
+SVNDIR="$PWD/repo_dercs"
+
+./verify --cvs-repo $CVSDIR --svn-repo $SVNDIR $1
Modified: brlcad/branches/bioh/misc/repowork/README
===================================================================
--- brlcad/branches/bioh/misc/repowork/README 2020-07-29 14:07:05 UTC (rev
76568)
+++ brlcad/branches/bioh/misc/repowork/README 2020-07-29 14:16:57 UTC (rev
76569)
@@ -25,3 +25,22 @@
addresses for proper integration with the hosting platform - that was one issue
encountered with the migration to github.com)
+Examples:
+
+
+* Rebuild CVS only conversion with verify generated .fi files:
+
+cd brlcad_cvs_git && git rev-list --children --all > children.txt && cd ..
+./repowork -r brlcad_cvs_git --children children_cvs --cvs-ids
cvs_problem_sha1.txt ~/brlcad_cvs.fi test_cvs.fi
+
+
+
+* Enabling all features:
+
+./repowork -t -w -n -r brlcad.git -e brlcad_map -s rev_map --cvs-ids
cvs_problem_sha1.txt --children children.txt ~/brlcad.fi final.fi
+
+* Adding CVS info:
+
+./repowork -t -n -r brlcad.git --keymap msgtime_sha1_map --cvs-auth-map
key_authormap --cvs-branch-map key_branchmap brlcad_input.
+fi test.fi
+
Modified: brlcad/branches/bioh/misc/repowork/commit.cpp
===================================================================
--- brlcad/branches/bioh/misc/repowork/commit.cpp 2020-07-29 14:07:05 UTC
(rev 76568)
+++ brlcad/branches/bioh/misc/repowork/commit.cpp 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -169,6 +169,9 @@
line.erase(0, 13); // Remove "original-oid " prefix
cd->id.sha1 = line;
cd->s->have_sha1s = true;
+ if (cd->s->sha12key.find(cd->id.sha1) != cd->s->sha12key.end()) {
+ std::cout << "Have CVS info for commit " << cd->id.sha1 << "\n";
+ }
return 0;
}
@@ -487,6 +490,46 @@
}
}
+ // Check for CVS information to add
+ if (c->s->sha12key.find(c->id.sha1) != c->s->sha12key.end()) {
+ std::string cvsmsg = nmsg;
+ std::string key = c->s->sha12key[c->id.sha1];
+ int have_ret = (c->svn_id.length()) ? 1 : 0;
+ if (c->s->key2cvsbranch.find(key) != c->s->key2cvsbranch.end()) {
+ //std::cout << "Found branch: " << c->s->key2cvsbranch[key] << "\n";
+ if (!have_ret) {
+ cvsmsg.append("\n");
+ have_ret = 1;
+ }
+ std::string cb = c->s->key2cvsbranch[key];
+ cvsmsg.append("cvs:branch:");
+ if (cb == std::string("master")) {
+ cvsmsg.append("trunk");
+ } else {
+ cvsmsg.append(cb);
+ }
+ cvsmsg.append("\n");
+ }
+ if (c->s->key2cvsauthor.find(key) != c->s->key2cvsauthor.end()) {
+ //std::cout << "Found author: " << c->s->key2cvsauthor[key] << "\n";
+ if (!have_ret) {
+ cvsmsg.append("\n");
+ have_ret = 1;
+ }
+ std::string svnname = std::string("svn:account:") +
c->s->key2cvsauthor[key];
+ std::string cvsaccount = std::string("cvs:account:") +
c->s->key2cvsauthor[key];
+ size_t index = cvsmsg.find(svnname);
+ if (index != std::string::npos) {
+ std::cout << "Replacing svn:account\n";
+ cvsmsg.replace(index, cvsaccount.length(), cvsaccount);
+ } else {
+ cvsmsg.append(cvsaccount);
+ cvsmsg.append("\n");
+ }
+ }
+ nmsg = cvsmsg;
+ }
+
return nmsg;
}
@@ -507,6 +550,27 @@
return 0;
}
+#if 0
+ // If this is a rebuild, write the blobs first
+ if (c->id.sha1.length()) {
+ if (c->s->rebuild_commits.find(c->id.sha1) !=
c->s->rebuild_commits.end()) {
+ std::cout << "rebuild commit!\n";
+ std::string sha1blobs = c->id.sha1 + std::string("-blob.fi");
+ std::ifstream s1b(sha1blobs, std::ifstream::binary | std::ios::ate);
+ std::streamsize size = s1b.tellg();
+ s1b.seekg(0, std::ios::beg);
+ std::vector<char> buffer(size);
+ if (s1b.read(buffer.data(), size)) {
+ outfile.write(reinterpret_cast<char*>(buffer.data()), size);
+ } else {
+ std::cerr << "Failed to open rebuild file " << sha1blobs <<
"\n";
+ exit(1);
+ }
+ s1b.close();
+ }
+ }
+#endif
+
// Header
if (c->notes_commit) {
// Don't output notes commits - we're handling things differently.
@@ -537,9 +601,31 @@
for (size_t i = 0; i < c->merges.size(); i++) {
outfile << "merge :" << c->merges[i].mark << "\n";
}
- for (size_t i = 0; i < c->fileops.size(); i++) {
- write_op(outfile, &c->fileops[i]);
+
+ bool write_ops = true;
+ if (c->id.sha1.length()) {
+ if ((c->s->rebuild_commits.find(c->id.sha1) !=
c->s->rebuild_commits.end()) ||
+ (c->s->reset_commits.find(c->id.sha1) !=
c->s->reset_commits.end())) {
+ write_ops = false;
+ std::string sha1tree = std::string("trees/") + c->id.sha1 +
std::string("-tree.fi");
+ std::ifstream s1t(sha1tree, std::ifstream::binary | std::ios::ate);
+ std::streamsize size = s1t.tellg();
+ s1t.seekg(0, std::ios::beg);
+ std::vector<char> buffer(size);
+ if (s1t.read(buffer.data(), size)) {
+ outfile.write(reinterpret_cast<char*>(buffer.data()), size);
+ } else {
+ std::cerr << "Failed to open rebuild file " << sha1tree << "\n";
+ exit(1);
+ }
+ s1t.close();
+ }
}
+ if (write_ops) {
+ for (size_t i = 0; i < c->fileops.size(); i++) {
+ write_op(outfile, &c->fileops[i]);
+ }
+ }
outfile << "\n";
return 0;
}
Modified: brlcad/branches/bioh/misc/repowork/repowork.cpp
===================================================================
--- brlcad/branches/bioh/misc/repowork/repowork.cpp 2020-07-29 14:07:05 UTC
(rev 76568)
+++ brlcad/branches/bioh/misc/repowork/repowork.cpp 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -100,6 +100,11 @@
s->commits[i].svn_id = std::string(svnidvar[1]);
std::cout << "Identified revision " << s->commits[i].svn_id << "\n";
+ // Store the id->sha1 relationship for potential later use
+ if (s->commits[i].id.sha1.length()) {
+ s->rev_to_sha1[s->commits[i].svn_id] = s->commits[i].id.sha1;
+ }
+
// We wrote the wrong SVN branch name for older dmtogl branches -
// names were deliberately collapsed in git conversion, but we
// should reflect the original SVN history in the metadata. Undo
@@ -221,9 +226,225 @@
return 0;
}
+void
+read_key_sha1_map(git_fi_data *s, std::string &keysha1file)
+{
+ std::ifstream infile(keysha1file, std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: " << keysha1file << "\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ size_t cpos = line.find_first_of(":");
+ std::string key = line.substr(0, cpos);
+ std::string sha1 = line.substr(cpos+1, std::string::npos);
+ s->sha12key[sha1] = key;
+ s->key2sha1[key] = sha1;
+ }
+ infile.close();
+}
+void
+read_key_cvsbranch_map(
+ git_fi_data *s,
+ std::string &branchfile)
+{
+ std::map<std::string, std::string> key2branch;
+ std::ifstream infile(branchfile, std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: " << branchfile << "\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ size_t cpos = line.find_first_of(":");
+ std::string key = line.substr(0, cpos);
+ std::string branch = line.substr(cpos+1, std::string::npos);
+ if (key2branch.find(key) != key2branch.end()) {
+ std::string oldbranch = key2branch[key];
+ if (oldbranch != branch) {
+ std::cout << "WARNING: non-unique key maps to both branch " <<
oldbranch << " and branch " << branch << ", overriding\n";
+ }
+ }
+ if (s->key2sha1.find(key) != s->key2sha1.end()) {
+ s->key2cvsbranch[key] = branch;
+ }
+ }
+ infile.close();
+}
+void
+read_key_cvsauthor_map( git_fi_data *s, std::string &authorfile)
+{
+ std::map<std::string, std::string> key2author;
+ std::ifstream infile(authorfile, std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open file: " << authorfile << "\n";
+ exit(-1);
+ }
+ std::string line;
+ while (std::getline(infile, line)) {
+ if (!line.length()) continue;
+ size_t cpos = line.find_first_of(":");
+ std::string key = line.substr(0, cpos);
+ std::string author = line.substr(cpos+1, std::string::npos);
+ if (key2author.find(key) != key2author.end()) {
+ std::string oldauthor = key2author[key];
+ if (oldauthor != author) {
+ std::cout << "WARNING: non-unique key maps to both author " <<
oldauthor << " and author " << author << ", overriding\n";
+ }
+ }
+ if (s->key2sha1.find(key) != s->key2sha1.end()) {
+ s->key2cvsauthor[key] = author;
+ }
+ }
+ infile.close();
+}
+void
+process_ls_tree(std::string &sha1)
+{
+ // read children
+ std::ifstream tfile("tree.txt", std::ifstream::binary);
+ if (!tfile.good()) {
+ std::cerr << "Could not open tree file tree.txt\n";
+ exit(-1);
+ }
+ std::string sha1tree = std::string("trees/") + sha1 +
std::string("-tree.fi");
+ std::ofstream ofile(sha1tree, std::ios::out | std::ios::binary);
+ ofile << "deleteall\n";
+
+ std::string tline;
+ while (std::getline(tfile, tline)) {
+ std::string ltree = tline;
+ std::regex bregex(" blob ");
+ std::string ltree2 = std::regex_replace(ltree, bregex, " ");
+ std::regex sregex("^");
+ ltree = std::regex_replace(ltree2, sregex , "M ");
+ std::regex tregex("\t");
+ ltree2 = std::regex_replace(ltree, tregex , " \"");
+ ofile << ltree2 << "\"\n";
+ }
+
+ ofile.close();
+
+ std::remove("tree.txt");
+}
+
+int
+git_id_rebuild_commits(git_fi_data *s, std::string &id_file, std::string
&repo_path, std::string &child_commits_file)
+{
+ {
+ // read children
+ std::ifstream cfile(child_commits_file, std::ifstream::binary);
+ if (!cfile.good()) {
+ std::cerr << "Could not open child_commits_file file: " <<
child_commits_file << "\n";
+ exit(-1);
+ }
+
+ std::string rline;
+ while (std::getline(cfile, rline)) {
+ // Skip empty lines
+ if (!rline.length()) {
+ continue;
+ }
+
+ // First 40 characters are the key
+ std::string key = rline.substr(0, 40);
+ rline.erase(0,41); // Remove key and space
+ std::set<std::string> vals;
+ while (rline.length() >= 40) {
+ std::string val = rline.substr(0, 40);
+ vals.insert(val);
+ rline.erase(0,41);
+ }
+ if (vals.size()) {
+ s->children[key] = vals;
+ }
+ }
+ }
+
+ {
+ // read ids
+ std::ifstream infile(id_file, std::ifstream::binary);
+ if (!infile.good()) {
+ std::cerr << "Could not open id_file file: " << id_file << "\n";
+ exit(-1);
+ }
+
+ std::string line;
+ while (std::getline(infile, line)) {
+ // Skip empty lines
+ if (!line.length()) {
+ continue;
+ }
+
+ std::string sha1;
+ if (line.length() < 40) {
+ // Given an svn revision - translate it to a sha1
+ if (s->rev_to_sha1.find(line) == s->rev_to_sha1.end()) {
+ std::cerr << "SVN revision " << line << " could not be
mapped to SHA1. May need to re-export fast import file with
--show-original-ids.\n";
+ exit(1);
+ }
+ sha1 = s->rev_to_sha1[line];
+ } else {
+ sha1 = line;
+ }
+
+ s->rebuild_commits.insert(sha1);
+ std::cout << "rebuild commit: " << line << " -> " << sha1 << "\n";
+ }
+ }
+
+ // Children of the rebuilt commits will need to fully define their
+ // contents, unless they are also being rebuilt (in which case their
+ // children will need to reset themselves.)
+ std::set<std::string> rbc = s->rebuild_commits;
+ while (rbc.size()) {
+ std::string rb = *rbc.begin();
+ rbc.erase(rb);
+ std::cout << "Finding reset commit(s) for: " << rb << "\n";
+ if (s->children.find(rb) == s->children.end()) {
+ // No child commits - no further work needed.
+ std::cout << "Leaf commit: " << rb << "\n";
+ continue;
+ }
+ std::set<std::string>::iterator c_it;
+ std::set<std::string> rc = s->children[rb];
+ while (rc.size()) {
+ std::string rcs = *rc.begin();
+ rc.erase(rcs);
+ if (s->rebuild_commits.find(rcs) == s->rebuild_commits.end()) {
+ std::cout << "found reset commit: " << rcs << "\n";
+ s->reset_commits.insert(rcs);
+ } else {
+ if (s->children.find(rcs) != s->children.end()) {
+ rc.insert(s->children[rcs].begin(), s->children[rcs].end());
+ }
+ }
+ }
+ }
+
+ // Now that we know what the reset commits are, generate the trees that
will
+ // achieve this.
+ std::set<std::string>::iterator s_it;
+ for (s_it = s->reset_commits.begin(); s_it != s->reset_commits.end();
s_it++) {
+ std::string sha1 = *s_it;
+ std::string git_ls_tree_cmd = std::string("cd ") + repo_path +
std::string(" && git ls-tree --full-tree -r ") + sha1 + std::string(" >
../tree.txt && cd ..");
+ if (std::system(git_ls_tree_cmd.c_str())) {
+ std::cout << "git_ls_tree_cmd \"" << git_ls_tree_cmd << "\"
failed\n";
+ exit(-1);
+ }
+ process_ls_tree(sha1);
+ }
+
+ return 0;
+}
+
+
typedef int (*gitcmd_t)(git_fi_data *, std::ifstream &);
gitcmd_t
@@ -298,6 +519,11 @@
std::string repo_path;
std::string email_map;
std::string svn_map;
+ std::string cvs_auth_map;
+ std::string cvs_branch_map;
+ std::string keymap;
+ std::string children_file;
+ std::string id_file;
int cwidth = 72;
// TODO - might be good do have a "validate" option that does the fast
import and then
@@ -308,12 +534,22 @@
options.add_options()
("e,email-map", "Specify replacement username+email mappings (one
map per line, format is commit-id-1;commit-id-2)",
cxxopts::value<std::vector<std::string>>(), "map file")
- ("n,collapse-notes", "Take any git-notes contents and append them
to regular commit messages.", cxxopts::value<bool>(collapse_notes))
- ("r,repo", "Original git repository path (must support running git
log)", cxxopts::value<std::vector<std::string>>(), "path to repo")
("s,svn-map", "Specify svn rev -> committer map (one mapping per
line, format is commit-rev name)", cxxopts::value<std::vector<std::string>>(),
"map file")
+
+ ("cvs-auth-map", "msg&time -> cvs author map (needs sha1->key
map)", cxxopts::value<std::vector<std::string>>(), "file")
+ ("cvs-branch-map", "msg&time -> cvs branch map (needs sha1->key
map)", cxxopts::value<std::vector<std::string>>(), "file")
+ ("keymap", "sha1 -> msg&time map (needs original-oid tags)",
cxxopts::value<std::vector<std::string>>(), "file")
+
("t,trim-whitespace", "Trim extra spaces and end-of-line characters
from the end of commit messages", cxxopts::value<bool>(trim_whitespace))
("w,wrap-commit-lines", "Wrap long commit lines to 72 cols (won't
wrap messages already having multiple non-empty lines)",
cxxopts::value<bool>(wrap_commit_lines))
("width", "Column wrapping width (if enabled)",
cxxopts::value<int>(), "N")
+
+ ("r,repo", "Original git repository path (must support running git
log)", cxxopts::value<std::vector<std::string>>(), "path")
+ ("n,collapse-notes", "Take any git-notes contents and append them
to regular commit messages.", cxxopts::value<bool>(collapse_notes))
+
+ ("rebuild-ids", "Specify commits (revision number or SHA1) to
rebuild. Requires git-repo be set as well. Needs --show-original-ids
information in fast import file", cxxopts::value<std::vector<std::string>>(),
"file")
+ ("rebuild-ids-children", "File with output of \"git rev-list
--children --all\" - needed for processing rebuild-ids",
cxxopts::value<std::vector<std::string>>(), "file")
+
("h,help", "Print help")
;
@@ -343,6 +579,36 @@
svn_map = ff[0];
}
+ if (result.count("rebuild-ids"))
+ {
+ auto& ff = result["rebuild-ids"].as<std::vector<std::string>>();
+ id_file = ff[0];
+ }
+
+ if (result.count("rebuild-ids-children"))
+ {
+ auto& ff =
result["rebuild-ids-children"].as<std::vector<std::string>>();
+ children_file = ff[0];
+ }
+
+ if (result.count("cvs-auth-map"))
+ {
+ auto& ff = result["cvs-auth-map"].as<std::vector<std::string>>();
+ cvs_auth_map = ff[0];
+ }
+
+ if (result.count("cvs-branch-map"))
+ {
+ auto& ff = result["cvs-branch-map"].as<std::vector<std::string>>();
+ cvs_branch_map = ff[0];
+ }
+
+ if (result.count("keymap"))
+ {
+ auto& ff = result["keymap"].as<std::vector<std::string>>();
+ keymap = ff[0];
+ }
+
if (result.count("width"))
{
cwidth = result["width"].as<int>();
@@ -360,6 +626,11 @@
return -1;
}
+ if (id_file.length() && !repo_path.length()) {
+ std::cerr << "Need Git repository path for CVS id list processing!\n";
+ return -1;
+ }
+
if (argc != 3) {
std::cout << "repowork [opts] <input_file> <output_file>\n";
return -1;
@@ -384,6 +655,26 @@
git_unpack_notes(&fi_data, infile, repo_path);
}
+ if (keymap.length()) {
+ read_key_sha1_map(&fi_data, keymap);
+ }
+
+ if (cvs_auth_map.length()) {
+ if (!keymap.length()) {
+ std::cerr << "CVS author map specified without key map\n";
+ return -1;
+ }
+ read_key_cvsauthor_map(&fi_data, cvs_auth_map);
+ }
+
+ if (cvs_branch_map.length()) {
+ if (!keymap.length()) {
+ std::cerr << "CVS branch map specified without key map\n";
+ return -1;
+ }
+ read_key_cvsbranch_map(&fi_data, cvs_branch_map);
+ }
+
if (email_map.length()) {
// Reset the input stream
infile.clear();
@@ -398,6 +689,11 @@
git_map_svn_committers(&fi_data, svn_map);
}
+ if (id_file.length()) {
+ // Handle rebuild info
+ git_id_rebuild_commits(&fi_data, id_file, repo_path, children_file);
+ }
+
fi_data.wrap_width = cwidth;
fi_data.wrap_commit_lines = wrap_commit_lines;
fi_data.trim_whitespace = trim_whitespace;
Modified: brlcad/branches/bioh/misc/repowork/repowork.h
===================================================================
--- brlcad/branches/bioh/misc/repowork/repowork.h 2020-07-29 14:07:05 UTC
(rev 76568)
+++ brlcad/branches/bioh/misc/repowork/repowork.h 2020-07-29 14:16:57 UTC
(rev 76569)
@@ -99,6 +99,9 @@
// to the existing notes-based info to id SVN usernames
std::string svn_id;
std::string svn_committer;
+
+ std::string cvs_id;
+ std::string cvs_branch;
};
class git_tag_data {
@@ -162,6 +165,31 @@
return mark;
};
+ // For CVS rebuild, we need to store a) which commits must be rebuilt
+ // from the CVS checkout and b) which commits that are "good" in git
+ // immediately follow the rebuilt commits in their respective branches.
+ // The former need new trees and blobs based on the CVS checkout, and
+ // the latter need a full tree deleteall + rebuild commit based on the
+ // git contents (a diff tree in the commit may no longer make the
+ // necessary changes given the previous commit will have changed.)
+ //
+ // If a commit that would otherwise have been a reset commit is a
+ // rebuild commit, it is promoted to rebuild and the next commit
+ // becomes the reset commit.
+ std::set<std::string> rebuild_commits;
+ std::set<std::string> reset_commits;
+ std::map<std::string, std::set<std::string>> children;
+
+ // We also need to be able to translate SVN revs into sha1s
+ std::map<std::string, std::string> rev_to_sha1;
+
+
+ // Containers holding information specific to CVS
+ std::map<std::string, std::string> sha12key;
+ std::map<std::string, std::string> key2sha1;
+ std::map<std::string, std::string> key2cvsauthor;
+ std::map<std::string, std::string> key2cvsbranch;
+
private:
long mark = -1;
};
Modified: brlcad/branches/bioh/src/conv/vdeck/vdeck.c
===================================================================
--- brlcad/branches/bioh/src/conv/vdeck/vdeck.c 2020-07-29 14:07:05 UTC (rev
76568)
+++ brlcad/branches/bioh/src/conv/vdeck/vdeck.c 2020-07-29 14:16:57 UTC (rev
76569)
@@ -1676,6 +1676,7 @@
for (i = 0; i < maxchars; ++i) {
c = getchar();
switch (c) {
+ case '\r':
case '\n':
case EOF:
/* end of input */
@@ Diff output truncated at 100000 characters. @@
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
_______________________________________________
BRL-CAD Source Commits mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/brlcad-commits
