Re: [commit] Fix fnchange.lst

Joel Brobecker
2009-09-20T16:11:40Z

[-- Attachment #1: Type: text/plain, Size: 1398 bytes --]

> But I do think we should re-check this before a tarball is released.

Doing so a couple of days before a schedule release is indeed
reasonable; it avoids last second surprises. We have the ARI results
published daily for the branch at:

http://www.sourceware.org/gdb/ari/

I see there are 10 warnings remaining. Are these actually fixable?
I don't quite understand what the warnings say, because I can't find
files such as decimal1.h, for instance.

> > If someone extracts out the script that does "dos checking" in
> > the ARI script, and returns a textual list of files that cause
> > problem, I don't mind adding it to the release procedure.
>
> If Pierre can do that, fine. If not, if someone can tell me where do
> I download the ARI script, I will give it a try.

There is an "ss" repository that's owned by gdbadmin on sourceware:

% cvs -d sourceware.org:/cvs/gdbadmin co ss

The only file that I found that made references to fnchange.lst is
update-web-ari. There is a section of the script that uses that file
and emits the appropriate warnings for the ARI.

I don't think you'll have write priviledges. If you want, I can add
your key to the authorized_keys, or I can commit the changes for you.
Although, my advice would be to make the new script a part of the GDB
tarball. That way, anyone can run the script, instead of just those
who log on sourceware.org.

--
Joel

[-- Attachment #2: update-web-ari --]
[-- Type: text/plain, Size: 23182 bytes --]

#!/bin/sh -x

# TODO: setjmp.h, setjmp and longjmp.

PATH=/bin:/usr/bin:/usr/local/bin:$HOME/bin
export PATH

# Direct stderr into stdout but still hang onto stderr (/dev/fd/3)
exec 3>&2 2>&1
ECHO ()
{
# echo "$@" | tee /dev/fd/3 1>&2
echo "$@" 1>&2
echo "$@" 1>&3
}

# Really mindless usage
if test $# -ne 4
then
echo "Usage: $0 <snapshot> <tmpdir> <destdir> <project>" 1>&2
exit 1
fi
snapshot=$1 ; shift
tmpdir=$1 ; shift
wwwdir=$1 ; shift
project=$1 ; shift

if [ ! -w ${wwwdir} -o ! -d ${wwwdir} ]
then
echo ERROR: Can not write to directory ${wwwdir} >&2
exit 2
fi

if [ ! -r ${snapshot} ]
then
echo ERROR: Can not read snapshot file 1>&2
exit 1
fi

# FILE formats
# ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
# ari.*.idx: <BUG>:<FILE>:<CATEGORY>
# ari.*.doc: <BUG>:<COUNT>:<CATEGORY>:<DOC>
# Where ``*'' is {source,warning,indent,doschk}

unpack_source_p=true
delete_source_p=true

check_warning_p=false # broken
check_indent_p=false # too slow, too many fail
check_source_p=true
check_doschk_p=true
check_werror_p=true

update_doc_p=true
update_web_p=true

if awk --version 2>&1 </dev/null | grep -i gnu > /dev/null
then
AWK=awk
else
AWK=gawk
fi

# Set up a few cleanups
if ${delete_source_p}
then
trap "cd /tmp; rm -rf ${tmpdir}; exit" 0 1 2 15
fi

# unpack the tar-ball
if ${unpack_source_p}
then
# Was it previously unpacked?
if ${delete_source_p} || test ! -d ${tmpdir}/${module}*
then
/bin/rm -rf "${tmpdir}"
/bin/mkdir ${tmpdir}
if [ ! -d ${tmpdir} ]
then
echo "Problem creating work directory"
exit 1
fi
cd ${tmpdir} || exit 1
echo `date`: Unpacking tar-ball ...
case ${snapshot} in
*.tar.bz2 ) bzcat ${snapshot} ;;
*.tar ) cat ${snapshot} ;;
* ) ECHO Bad file ${snapshot} ; exit 1 ;;
esac | tar xf -
fi
fi
module=`basename ${snapshot}`
module=`basename ${module} .bz2`
module=`basename ${module} .tar`
srcdir=`echo ${tmpdir}/${module}*`
version_in=${srcdir}/gdb/version.in
if [ ! -r ${version_in} ]
then
echo ERROR: missing version file 1>&2
exit 1
fi
version=`cat ${version_in}`

# THIS HAS SUFFERED BIT ROT
if ${check_warning_p} && test -d "${srcdir}"
then
echo `date`: Parsing compiler warnings 1>&2
cat ${root}/ari.compile | $AWK '
BEGIN {
FS=":";
}
/^[^:]*:[0-9]*: warning:/ {
file = $1;
#sub (/^.*\//, "", file);
warning[file] += 1;
}
/^[^:]*:[0-9]*: error:/ {
file = $1;
#sub (/^.*\//, "", file);
error[file] += 1;
}
END {
for (file in warning) {
print file ":warning:" level[file]
}
for (file in error) {
print file ":error:" level[file]
}
}
' > ${root}/ari.warning.bug
fi

# THIS HAS SUFFERED BIT ROT
if ${check_indent_p} && test -d "${srcdir}"
then
printf "Analizing file indentation:" 1>&2
( cd "${srcdir}" && /bin/sh $HOME/ss/gdb_find.sh ${project} | while read f
do
if /bin/sh $HOME/ss/gdb_indent.sh < ${f} 2>/dev/null | cmp -s - ${f}
then
:
else
# ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
echo "${f}:0: info: indent: Indentation does not match GNU indent output"
fi
done ) > ${wwwdir}/ari.indent.bug
echo ""
fi

if ${check_source_p} && test -d "${srcdir}"
then
bugf=${wwwdir}/ari.source.bug
oldf=${wwwdir}/ari.source.old
srcf=${wwwdir}/ari.source.lines
oldsrcf=${wwwdir}/ari.source.lines-old

diff=${wwwdir}/ari.source.diff
diffin=${diff}-in
newf1=${bugf}1
oldf1=${oldf}1
oldpruned=${oldf1}-pruned
newpruned=${newf1}-pruned

cp -f ${bugf} ${oldf}
cp -f ${srcf} ${oldsrcf}
rm -f ${srcf}
echo "`date`: Using source lines ${srcf}" 1>&2
echo "`date`: Checking source code" 1>&2
( cd "${srcdir}" && /bin/sh $HOME/ss/gdb_find.sh "${project}" | \
xargs /bin/sh $HOME/ss/gdb_ari.sh -Werror -Wall --print-idx --src=${srcf}
) > ${bugf}
# Remove things we are not interested in to signal by email
# gdbarch changes are not important here
sed -e "/.*: gdbarch:.*/d" ${oldf} > ${oldf1}
sed -e "/.*: gdbarch:.*/d" ${bugf} > ${newf1}
# Remove line number info so that code inclusion/deletion
# has no impact on the result
sed -e "s/\([^:]*\):\([^:]*\):\(.*\)/\1:0:\3/" ${oldf1} > ${oldpruned}
sed -e "s/\([^:]*\):\([^:]*\):\(.*\)/\1:0:\3/" ${newf1} > ${newpruned}
# Use diff without option to get normal diff output that
# is reparsed after
diff ${oldpruned} ${newpruned} > ${diffin}
# Only keep new warnings
sed -n -e "/^>.*/p" ${diffin} > ${diff}
sedscript=${wwwdir}/sedscript
script=${wwwdir}/script
sed -n -e "s|\(^[0-9,]*\)a\(.*\)|echo \1a\2 \n \
sed -n \'\2s:\\\\(.*\\\\):> \\\\1:p\' ${newf1}|p" \
-e "s|\(^[0-9,]*\)d\(.*\)|echo \1d\2\n \
sed -n \'\1s:\\\\(.*\\\\):< \\\\1:p\' ${oldf1}|p" \
-e "s|\(^[0-9,]*\)c\(.*\)|echo \1c\2\n \
sed -n \'\1s:\\\\(.*\\\\):< \\\\1:p\' ${oldf1} \n \
sed -n \"\2s:\\\\(.*\\\\):> \\\\1:p\" ${newf1}|p" \
${diffin} > ${sedscript}
${SHELL} ${sedscript} > ${wwwdir}/message
sed -n \
-e "s;\(.*\);echo \\\"\1\\\";p" \
-e "s;.*< \([^:]*\):\([0-9]*\):.*;grep \"^\1:\2:\" ${oldsrcf};p" \
-e "s;.*> \([^:]*\):\([0-9]*\):.*;grep \"^\1:\2:\" ${srcf};p" \
${wwwdir}/message > ${script}
${SHELL} ${script} > ${wwwdir}/mail-message
# Check if ${diff} is not empty
if [ -s ${diff} ]; then
# Send an email to muller@sourceware.org
mutt -s "New ARI warning `date`" -i ${wwwdir}/mail-message \
muller@sourceware.org
else
if [ -s ${mail-message} ]; then
# Send an email to muller@sourceware.org
mutt -s "ARI warning list change `date`" -i ${wwwdir}/mail-message \
muller@sourceware.org
fi
fi
fi

if ${check_doschk_p} && test -d "${srcdir}"
then
echo "`date`: Checking for doschk" 1>&2
rm -f "${wwwdir}"/ari.doschk.*
fnchange_lst="${srcdir}"/gdb/config/djgpp/fnchange.lst
fnchange_awk="${wwwdir}"/ari.doschk.awk
doschk_in="${wwwdir}"/ari.doschk.in
doschk_out="${wwwdir}"/ari.doschk.out
doschk_bug="${wwwdir}"/ari.doschk.bug
doschk_char="${wwwdir}"/ari.doschk.char

# Transform fnchange.lst into fnchange.awk. The program DJTAR
# does a textual substitution of each file name using the list.
# Generate an awk script that does the equivalent - matches an
# exact line and then outputs the replacement.

sed -e 's;@[^@]*@[/]*\([^ ]*\) @[^@]*@[/]*\([^ ]*\);\$0 == "\1" { print "\2"\; next\; };' \
< "${fnchange_lst}" > "${fnchange_awk}"
echo '{ print }' >> "${fnchange_awk}"

# Do the raw analysis - transform the list of files into the DJGPP
# equivalents putting it in the .in file
( cd "${srcdir}" && find * \
-name '*.info-[0-9]*' -prune \
-o -name tcl -prune \
-o -name itcl -prune \
-o -name tk -prune \
-o -name libgui -prune \
-o -name tix -prune \
-o -name dejagnu -prune \
-o -name expect -prune \
-o -type f -print ) \
| $AWK -f ${fnchange_awk} > ${doschk_in}

# Start with a clean slate
rm -f ${doschk_bug}

# Check for any invalid characters.
grep '[\+\,\;\=\[\]\|\<\>\\\"\:\?\*]' < ${doschk_in} > ${doschk_char}
# ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
sed < ${doschk_char} >> ${doschk_bug} \
-e s'/$/:0: dos: DOSCHK: Invalid DOS character/'

# Magic to map ari.doschk.out to ari.doschk.bug goes here
doschk < ${doschk_in} > ${doschk_out}
cat ${doschk_out} | $AWK >> ${doschk_bug} '
BEGIN {
state = 1;
invalid_dos = state++; bug[invalid_dos] = "invalid DOS file name"; category[invalid_dos] = "dos";
same_dos = state++; bug[same_dos] = "DOS 8.3"; category[same_dos] = "dos";
same_sysv = state++; bug[same_sysv] = "SysV";
long_sysv = state++; bug[long_sysv] = "long SysV";
internal = state++; bug[internal] = "internal doschk"; category[internal] = "internal";
state = 0;
}
/^$/ { state = 0; next; }
/^The .* not valid DOS/ { state = invalid_dos; next; }
/^The .* same DOS/ { state = same_dos; next; }
/^The .* same SysV/ { state = same_sysv; next; }
/^The .* too long for SysV/ { state = long_sysv; next; }
/^The .* / { state = internal; next; }

NF == 0 { next }

NF == 3 { name = $1 ; file = $3 }
NF == 1 { file = $1 }
NF > 3 && $2 == "-" { file = $1 ; name = gensub(/^.* - /, "", 1) }

state == same_dos {
# ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
print file ":0: " category[state] ": " \
name " " bug[state] " " " dup: " \
" DOSCHK - the names " name " and " file " resolve to the same" \
" file on a " bug[state] \
" system. For DOS, this can be fixed by modifying the file" \
" fnchange.lst."
next
}
state == invalid_dos {
# ari.*.bug: <FILE>:<LINE>: <SEVERITY>: <CATEGORY>: <DOC>
print file ":0: " category[state] ": " name ": DOSCHK - " name
next
}
state == internal {
# ari.*.bug: <FILE>:<LINE>: <SEVERITY>: <CATEGORY>: <DOC>
print file ":0: " category[state] ": " bug[state] ": DOSCHK - a " \
bug[state] " problem"
}
'
fi

if ${check_werror_p} && test -d "${srcdir}"
then
echo "`date`: Checking Makefile.in for non- -Werror rules"
rm -f ${wwwdir}/ari.werror.*
cat "${srcdir}/${project}/Makefile.in" | $AWK > ${wwwdir}/ari.werror.bug '
BEGIN {
count = 0
cont_p = 0
full_line = ""
}
/^[-_[:alnum:]]+\.o:/ {
file = gensub(/.o:.*/, "", 1) ".c"
}

/[^\\]\\$/ { gsub (/\\$/, ""); full_line = full_line $0; cont_p = 1; next; }
cont_p { $0 = full_line $0; cont_p = 0; full_line = ""; }

/\$\(COMPILE\.pre\)/ {
print file " has line " $0
if (($0 !~ /\$\(.*ERROR_CFLAGS\)/) && ($0 !~ /\$\(INTERNAL_CFLAGS\)/)) {
# ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
print "'"${project}"'/" file ":0: info: Werror: The file is not being compiled with -Werror"
}
}
'
fi

# From the warnings, generate the doc and indexed bug files
if ${update_doc_p}
then
cd ${wwwdir}
rm -f ari.doc ari.idx ari.doc.bug
# Generate an extra file containing all the bugs that the ARI can detect.
/bin/sh $HOME/ss/gdb_ari.sh -Werror -Wall --print-idx --print-doc >> ari.doc.bug
cat ari.*.bug | $AWK > ari.idx '
BEGIN {
FS=": *"
}
{
# ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
file = $1
line = $2
category = $3
bug = $4
if (! (bug in cat)) {
cat[bug] = category
# strip any trailing .... (supplement)
doc[bug] = gensub(/ \([^\)]*\)$/, "", 1, $5)
count[bug] = 0
}
if (file != "") {
count[bug] += 1
# ari.*.idx: <BUG>:<FILE>:<CATEGORY>
print bug ":" file ":" category
}
# Also accumulate some categories as obsolete
if (category == "deprecated") {
# ari.*.idx: <BUG>:<FILE>:<CATEGORY>
if (file != "") {
print category ":" file ":" "obsolete"
}
#count[category]++
#doc[category] = "Contains " category " code"
}
}
END {
i = 0;
for (bug in count) {
# ari.*.doc: <BUG>:<COUNT>:<CATEGORY>:<DOC>
print bug ":" count[bug] ":" cat[bug] ":" doc[bug] >> "ari.doc"
}
}
'
fi

# print_toc BIAS MIN_COUNT CATEGORIES TITLE

# Print a table of contents containing the bugs CATEGORIES. If the
# BUG count >= MIN_COUNT print it in the table-of-contents. If
# MIN_COUNT is non -ve, also include a link to the table.Adjust the
# printed BUG count by BIAS.

all=

print_toc ()
{
bias="$1" ; shift
min_count="$1" ; shift

all=" $all $1 "
categories=""
for c in $1; do
categories="${categories} categories[\"${c}\"] = 1 ;"
done
shift

title="$@" ; shift

echo " " >> ${newari}
echo "" | tr '[A-Z]' '[a-z]' >> ${newari}
echo " ${title} " >> ${newari}
cat >> ${newari} # description

cat >> ${newari} <<EOF


BUG Total Description
EOF
# ari.*.doc: <BUG>:<COUNT>:<CATEGORY>:<DOC>
cat ${wwwdir}/ari.doc \
| sort -t: +1rn -2 +0d \
| $AWK >> ${newari} '
BEGIN {
FS=":"
'"$categories"'
MIN_COUNT = '${min_count}'
BIAS = '${bias}'
total = 0
nr = 0
}
{
# ari.*.doc: <BUG>:<COUNT>:<CATEGORY>:<DOC>
bug = $1
count = $2
category = $3
doc = $4
if (count < MIN_COUNT) next
if (!(category in categories)) next
nr += 1
total += count
printf " "
printf " ", bug
printf "%s", gensub(/_/, " ", "g", bug)
printf " "
printf " "
if (count > 0 && MIN_COUNT >= 0) {
printf "%d ", bug, count + BIAS
} else {
printf "%d", count + BIAS
}
printf " "
printf " %s ", doc
printf " "
print ""
}
END {
print " " nr " " total " "
}
'
cat >> ${newari} <<EOF


EOF
}

print_table ()
{
categories=""
for c in $1; do
categories="${categories} categories[\"${c}\"] = 1 ;"
done
# Remember to prune the dir prefix from projects files
# ari.*.idx: <BUG>:<FILE>:<CATEGORY>
cat ${wwwdir}/ari.idx | $AWK >> ${newari} '
function qsort (table,
middle, tmp, left, nr_left, right, nr_right, result) {
middle = ""
for (middle in table) { break; }
nr_left = 0;
nr_right = 0;
for (tmp in table) {
if (tolower(tmp) < tolower(middle)) {
nr_left++
left[tmp] = tmp
} else if (tolower(tmp) > tolower(middle)) {
nr_right++
right[tmp] = tmp
}
}
#print "qsort " nr_left " " middle " " nr_right > "/dev/stderr"
result = ""
if (nr_left > 0) {
result = qsort(left) SUBSEP
}
result = result middle
if (nr_right > 0) {
result = result SUBSEP qsort(right)
}
return result
}
function print_heading (where, bug_i) {
print ""
print " "
print " File "
print " Total "
print " "
for (bug_i = 1; bug_i <= nr_bug; bug_i++) {
bug = i2bug[bug_i];
printf " "
# The title names are offset by one. Otherwize, when the browser
# jumps to the name it leaves out half the relevant column.
#printf " ", bug
printf " ", i2bug[bug_i-1]
printf "", bug
printf "%s", gensub(/_/, " ", "g", bug)
printf "\n"
printf " \n"
}
#print " "
printf " \n", i2bug[bug_i-1]
print " Total "
print " File "
print " "
}
function print_totals (where, bug_i) {
print " Totals "
printf " "
printf "%s", total
printf "&gt;"
printf " \n"
print " ";
for (bug_i = 1; bug_i <= nr_bug; bug_i++) {
bug = i2bug[bug_i];
printf " "
printf ""
printf "%d", bug, bug_total[bug]
printf "";
printf "^", prev_file[bug, where], bug
printf "v", next_file[bug, where], bug
printf " ", where, bug
printf " ";
print ""
}
print " "
printf " "
printf "%s", total
printf "&lt;"
printf " \n"
print " Totals "
print " "
}
BEGIN {
FS = ":"
'"${categories}"'
nr_file = 0;
nr_bug = 0;
}
{
# ari.*.idx: <BUG>:<FILE>:<CATEGORY>
bug = $1
file = $2
category = $3
# Interested in this
if (!(category in categories)) next
# Totals
db[bug, file] += 1
bug_total[bug] += 1
file_total[file] += 1
total += 1
}
END {

# Sort the files and bugs creating indexed lists.
nr_bug = split(qsort(bug_total), i2bug, SUBSEP);
nr_file = split(qsort(file_total), i2file, SUBSEP);

# Dummy entries for first/last
i2file[0] = 0
i2file[-1] = -1
i2bug[0] = 0
i2bug[-1] = -1

# Construct a cycle of next/prev links. The file/bug "0" and "-1"
# are used to identify the start/end of the cycle. Consequently,
# prev(0) = -1 (prev of start is the end) and next(-1) = 0 (next
# of end is the start).

# For all the bugs, create a cycle that goes to the prev / next file.
for (bug_i = 1; bug_i <= nr_bug; bug_i++) {
bug = i2bug[bug_i]
prev = 0
prev_file[bug, 0] = -1
next_file[bug, -1] = 0
for (file_i = 1; file_i <= nr_file; file_i++) {
file = i2file[file_i]
if ((bug, file) in db) {
prev_file[bug, file] = prev
next_file[bug, prev] = file
prev = file
}
}
prev_file[bug, -1] = prev
next_file[bug, prev] = -1
}

# For all the files, create a cycle that goes to the prev / next bug.
for (file_i = 1; file_i <= nr_file; file_i++) {
file = i2file[file_i]
prev = 0
prev_bug[file, 0] = -1
next_bug[file, -1] = 0
for (bug_i = 1; bug_i <= nr_bug; bug_i++) {
bug = i2bug[bug_i]
if ((bug, file) in db) {
prev_bug[file, bug] = prev
next_bug[file, prev] = bug
prev = bug
}
}
prev_bug[file, -1] = prev
next_bug[file, prev] = -1
}

print " "
print " "
print_heading(0);
print " "
print_totals(0);
print " "

for (file_i = 1; file_i <= nr_file; file_i++) {
file = i2file[file_i];
pfile = gensub(/^'${project}'\//, "", 1, file)
print ""
print " "
print " " pfile " "
printf " "
printf "%s", file_total[file]
printf ">", file, next_bug[file, 0]
printf " \n"
print " "
for (bug_i = 1; bug_i <= nr_bug; bug_i++) {
bug = i2bug[bug_i];
if ((bug, file) in db) {
printf " "
printf "%d", bug, db[bug, file]
printf "^", prev_file[bug, file], bug
printf "v", next_file[bug, file], bug
printf " ", file, bug
printf " "
print ""
} else {
print " "
#print " "
}
}
print " "
printf " "
printf "%s", file_total[file]
printf "<", file, prev_bug[file, -1]
printf " \n"
print " " pfile " "
print " "
}

print " "
print_totals(-1)
print " "
print_heading(-1);
print " "
print ""
print " "
print ""
}
'
}

# Make the scripts available
cp $HOME/ss/gdb_*.sh ${wwwdir}

# Compute the ARI index - ratio of zero vs non-zero problems.
indexes=`awk '
BEGIN {
FS=":"
}
{
# ari.*.doc: <BUG>:<COUNT>:<CATEGORY>:<DOC>
bug = $1; count = $2; category = $3; doc = $4

if (bug ~ /^legacy_/) legacy++
if (bug ~ /^deprecated_/) deprecated++

if (category !~ /^gdbarch$/) {
bugs += count
}
if (count == 0) {
oks++
}
}
END {
#print "tests/ok:", nr / ok
#print "bugs/tests:", bugs / nr
#print "bugs/ok:", bugs / ok
print bugs / ( oks + legacy + deprecated )
}
' ${wwwdir}/ari.doc`

# Merge, generating the ARI tables.
if ${update_web_p}
then
echo "Create the ARI table" 1>&2
oldari=${wwwdir}/old.html
ari=${wwwdir}/index.html
newari=${wwwdir}/new.html
rm -f ${newari} ${newari}.gz
cat <<EOF >> ${newari}


A.R. Index for GDB version ${version}



A.R. Index for GDB version ${version}



<!-- Navigation. This page contains the following anchors.
"BUG": The definition of the bug.
"FILE,BUG": The row/column containing FILEs BUG count
"0,BUG", "-1,BUG": The top/bottom total for BUGs column.
"FILE,O", "FILE,-1": The left/right total for FILEs row.
",BUG": The top title for BUGs column.
"FILE,": The left title for FILEs row.
-->

${indexes}
You can not take this seriously!


Also available:
most recent branch
|
current
|
last release



Last updated: `date -u`

EOF

print_toc 0 1 "internal regression" Critical <<EOF
Things previously eliminated but returned. This should always be empty.
EOF

print_table "regression code comment obsolete"

print_toc 0 0 code Code <<EOF
Coding standard problems, portability problems, readability problems.
EOF

print_toc 0 0 comment Comments <<EOF
Problems concerning comments in source files.
EOF

print_toc 0 -1 dos DOS 8.3 File Names <<EOF
File names with problems on 8.3 file systems.
EOF

print_toc -2 -1 deprecated Deprecated <<EOF
Mechanisms that have been replaced with something better, simpler,
cleaner; or are no longer required by core-GDB. New code should not
use deprecated mechanisms. Existing code, when touched, should be
updated to use non-deprecated mechanisms. See obsolete and deprecate.
(The declaration and definition are hopefully excluded from count so
zero should indicate no remaining uses).
EOF

print_toc 0 0 obsolete Obsolete <<EOF
Mechanisms that have been replaced, but have not yet been marked as
such (using the deprecated_ prefix). See deprecate and deprecated.
EOF

print_toc 0 -1 deprecate Deprecate <<EOF
Mechanisms that are a candidate for being made obsolete. Once core
GDB no longer depends on these mechanisms and/or there is a
replacement available, these mechanims can be deprecated (adding the
deprecated prefix) obsoleted (put into category obsolete) or deleted.
See obsolete and deprecated.
EOF

print_toc -2 -1 legacy Legacy <<EOF
Methods used to prop up targets using targets that still depend on
deprecated mechanisms. (The method's declaration and definition are
hopefully excluded from count).
EOF

print_toc -2 -1 gdbarch Gdbarch <<EOF
Count of calls to the gdbarch set methods. (Declaration and
definition hopefully excluded from count).
EOF

print_toc 0 -1 macro Macro <<EOF
Breakdown of macro definitions (and #undef) in configuration files.
EOF

print_toc 0 0 regression Fixed <<EOF
Problems that have been expunged from the source code.
EOF

# Check for invalid categories
for a in $all; do
alls="$alls all[$a] = 1 ;"
done
cat ari.*.doc | $AWK >> ${newari} '
BEGIN {
FS = ":"
'"$alls"'
}
{
# ari.*.doc: <BUG>:<COUNT>:<CATEGORY>:<DOC>
bug = $1
count = $2
category = $3
doc = $4
if (!(category in all)) {
print "" category ": no documentation "
}
}
'

cat >> ${newari} <<EOF

Input files:
`( cd ${wwwdir} && ls ari.*.bug ari.idx ari.doc ) | while read f
do
echo "${f}"
done`



Scripts:
`( cd ${wwwdir} && ls *.sh ) | while read f
do
echo "${f}"
done`





EOF

for i in . .. ../..; do
x=${wwwdir}/${i}/index.sh
if test -x $x; then
$x ${newari}
break
fi
done

gzip -c -v -9 ${newari} > ${newari}.gz

cp ${ari} ${oldari}
cp ${ari}.gz ${oldari}.gz
cp ${newari} ${ari}
cp ${newari}.gz ${ari}.gz

fi # update_web_p

# ls -l ${wwwdir}

exit 0