home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March B / SCO_CASTOR4RRT.iso / scohelp / root.1 / usr / man / bin / config_man / config_man~
Text File  |  1998-08-19  |  26KB  |  881 lines
  1. #! /bin/sh -h
  2. #
  3. #       @(#) SCCS ID:    15.5
  4. #
  5. #    TechPubs SCCS ID:
  6. #    @(#) Filetype:   AS 
  7. #    @(#) SCCS ID:    100.30 
  8. #    @(#) File:       config_man 
  9. #    @(#) Last delta: 97/12/01 14:00:39 
  10. #    @(#) Last get:   97/12/01 14:00:41 
  11. #    @(#) SCCS file:  /f/doctools/bin/s.config_man 
  12. #    @(#) Book:       odssi 
  13. #    
  14. #    Copyright (C) 1986-1997 The Santa Cruz Operation, Inc.  
  15. #    All Rights Reserved. 
  16. #    
  17. #    This Module contains Proprietary Information of    
  18. #    The Santa Cruz Operation, Inc. and should be    
  19. #    treated as Confidential.             
  20. #
  21. # config_man - incorporates manpage documentation into the SCO help system
  22. #
  23. # usage: config_man [-L lang] [-d mandir] [-n] [mansection] ...
  24. #
  25. # Examines the documentation distribution files in one or more manpage
  26. # section directories, and constructs the necessary files (indexes, whatis
  27. # database, etc.) that hook the documentation into the rest of the help
  28. # system.  This should be run whenever new documentation packages are
  29. # installed.
  30. #
  31. # A separate tool (config_help) performs a similar function for guide
  32. # documentation.
  33. #
  34. # Copyright (C) 1996-1997 The Santa Cruz Operation, Inc.
  35. #
  36. ##########################################################################
  37. #
  38. ####### CONFIGURATION SECTION
  39. #
  40. # The directory containing the various support files and tools used by
  41. # this script.  These are not guarenteed to be in our PATH, so we have
  42. # to access them all via this path.  The code below constructs the path
  43. # from our pathname and the current directory.
  44. ODSSI_TOOL_PATH=`dirname $0`
  45. if [ `expr "/$ODSSI_TOOL_PATH" : //` -eq 0 ]
  46. then    ODSSI_TOOL_PATH="`pwd`/$ODSSI_TOOL_PATH"
  47. fi
  48. #
  49. # The location of the ODSSI configuration data, which depends upon the
  50. # TOOL_PATH.
  51. ODSSI_CONFIG=$ODSSI_TOOL_PATH/odssi.config
  52. #
  53. # Place any configuration parameters that are particular to this specific
  54. # tool below.  Configuration parameters specific to all ODSSI tools are
  55. # in the ODSSI_CONFIG file, specified above.
  56. #
  57. # location of nroff
  58. PATH=$PATH:/usr/ucb
  59. export PATH
  60. #
  61. # Message catalog set number for this tool
  62. MsgSet=2
  63. #
  64. ####### END OF CONFIGURATION SECTION
  65. #
  66. # Get our name for use in error messages.
  67. ME="`basename $0`"
  68. USAGE="[-L lang] [-n] [-d mandir] [mansection] ..."
  69. #
  70. # Set up temporary files and arrange for them to get deleted.
  71. TMP="/var/tmp/cm$$"
  72. Errs=1
  73. trap "rm -rf ${TMP}*; exit 1" 1 2 3 15
  74. trap "rm -rf ${TMP}*; exit \$Errs" 0
  75. if [ -z "$USER_LANG" ]
  76. then    USER_LANG="$LANG"
  77.     if [ -z "$USER_LANG" ]
  78.     then    USER_LANG="C"
  79.     fi
  80.     export USER_LANG
  81. fi
  82. #
  83. #### FUNCTIONS
  84. #
  85. # This outputs the usage line.
  86. Usage ()
  87. {
  88. echo >&2 "usage: $ME $USAGE"
  89. exit 1
  90. }
  91. #
  92. # This outputs an error message.  It does not exit the script.  The arguments
  93. # are a message catalog number, the text of the message, and any arguments
  94. # referenced from within the message using printf-style formatting constructs.
  95. # It writes the message to the standard error.
  96. Error()
  97. {
  98. # Restore the user's LANG for error messages
  99. DOCLANG=$LANG
  100. LANG=$USER_LANG
  101. # This version uses message catalog defined in odssi.config
  102. MsgNum="$1"
  103. shift
  104. echo >&2 "${ME}: ${DOCLANG}: \c"
  105. dspmsg >&2 "$MSG_CATALOG_NAME" -s $MsgSet $MsgNum "$@" 
  106. echo >&2
  107. LANG=$DOCLANG
  108. }
  109. #
  110. # Function to generate our awk script.  This writes the script that produces
  111. # index and whatis files to its standard output.  There are no arguments, and
  112. # no meaningful return value.
  113. GenerateScript()
  114. {
  115. # Start with the common and node functions.
  116. cat $AWK_COMMON_FUNCS $AWK_NODE_FUNCS
  117. #
  118. # Now add in the code that creates the index and whatis files.
  119. cat <<'__END_OF_SCRIPT__'
  120.  
  121. function WhatisSpace(s,n, l,o)
  122.     {    # Makes a string of whitespace to pad s to n tab stops
  123.     l = length(s);
  124.     if    (l > n * 8)
  125.         return(" ");    # Use a single space when s is longer than n.
  126.     o = "\t";        # We always have at least one tab.
  127.     # Add more tabs as necessary to pad it out.
  128.     for    (l = n - int(l / 8) - 1; l > 0; l--)
  129.         o = o "\t";
  130.     return(o);
  131.     }
  132.  
  133. function GetDescList(l)
  134.     {    # Function to get the list portion of a description line.
  135.     # Return the part of the line before the hyphen separator.
  136.     sub(/ - .*/, "", l);
  137.     # If there happens to be a section name here, remove that too.
  138.     sub(/[[:blank:]]*\([^[:blank:]][^[:blank:]]*\)[:blank:]*$/, "", l);
  139.     return(l);
  140.     }
  141.  
  142. function GetDescText(l)
  143.     {    # Function to get the text portion of a description line.
  144.     # Return the part of the line after the hyphen separator.
  145.     sub(/.* - /, "", l);
  146.     return(l);
  147.     }
  148.  
  149. function IndexFromDescription(d,f,s, a,i,n)
  150.     {    # Output index lines for each name in a description line.
  151.     d = GetDescList(d);
  152.     if    (d == "")
  153.         return;        # No data to output.
  154.     n = split(d, a, /[:,][[:blank:]][[:blank:]]*/);
  155.     for    (i = 1; i <= n; i++)
  156.         {    # Write a line for each name in the list.
  157.         printf("%s %s %s\n", a[i], f, s) | IndexPipe;
  158.         }
  159.     }
  160.  
  161. function WhatisFromDescription(d,s, l)
  162.     {    # Output whatis line given description line and section.
  163.     if    (d == "")
  164.         return;
  165.     l = GetDescList(d) " (" s ")";
  166.     d = GetDescText(d);
  167.     printf("%s%s- %s\n", l, WhatisSpace(l, 3), d) | WhatisPipe;
  168.     }
  169.  
  170. END    {    # Process collected nodes.
  171.     # Construct the commands that append the sorted and uniqued index
  172.     # and whatis data to our temporary files.
  173.     IndexPipe  = "sort -u >> " INDEX
  174.     WhatisPipe = "sort -u >> " WHATIS
  175.  
  176.     # Loop through all the nodes.
  177.     for    (n = 1; n <= NumNodes; n++)
  178.         {    # For each possible node.
  179.         if    (! (n in NodeSet))
  180.             continue;    # This node has been deleted.
  181.  
  182.         # Get the filename, without any directory path.
  183.         FileName = NodeSet[n];    # The filename is the node name.
  184.  
  185.         # Get the title and extract the section name from it.
  186.         Title = Section = GetValue(n, K_TITLE);
  187.         sub(/^.*\(/, "", Section);
  188.         sub(/\).*$/, "", Section);
  189.         sub(/\(.*$/, "", Title);
  190.  
  191.         # If we could not get a section number, use the one
  192.         # from the filename.
  193.         if    (Section == "")
  194.             {    # Extract the section number from the filename.
  195.             Section = FileName;
  196.             sub(/.*\./, "", Section);
  197.             }
  198.  
  199.         # Now strip the section number off the filename.
  200.         sub(/\.[^\.]*$/, "", FileName);
  201.  
  202.         # Create the main index entry from the TITLE line.
  203.         if    (Title != "")
  204.             printf("%s %s %s\n", Title,
  205.                 FileName, Section) | IndexPipe;
  206.  
  207.         # Make index and whatis entries from the Name line.
  208.         Value = GetValue(n, K_NAME);
  209.         IndexFromDescription(Value, FileName, Section);
  210.         WhatisFromDescription(Value, Section);
  211.  
  212.         # Make index and whatis entries from any SubName lines.
  213.         for    (i = GetKeyIndex(n, K_SUBNAME); i > 0; \
  214.              i = GetNextKeyIndex(n, K_SUBNAME, i))
  215.             {    # For each SubName line.
  216.             Value = GetValueAtIndex(n, i);
  217.             IndexFromDescription(Value, FileName, Section);
  218.             WhatisFromDescription(Value, Section);
  219.             }
  220.  
  221.         # Make just index entries from any IndexEntry Lines.
  222.         for    (i = GetKeyIndex(n, K_IENTRY); i > 0; \
  223.              i = GetNextKeyIndex(n, K_IENTRY, i))
  224.             IndexFromDescription(GetValueAtIndex(n, i),
  225.                          FileName, Section);
  226.         }
  227.     }
  228. __END_OF_SCRIPT__
  229. }
  230. #
  231. # Function to generate a list of all the section names that exist within
  232. # the current language.  The current directory is assumed to be that of the
  233. # current language, and all directories within it are manpage data directories
  234. # containing manpages in some source format.  We collect the directory names,
  235. # remove the source format prefixes, sort and unique them.  There are no
  236. # arguments, the list of manpage names is written to the standard output.
  237. GetAllSectionNames()
  238. {
  239. # Construct an awk script that removes the source format prefix from each
  240. # directory name on its standard input, outputting the section names.
  241. cat $AWK_COMMON_FUNCS >$TMP-scr
  242. cat <<'__END_OF_SCRIPT__' >>$TMP-scr
  243.     BEGIN    { n = split(DIRS, a, /[[:blank:]]+/);
  244.           for    (i = 1; i <= n; i++)
  245.             a[i] = Quote(a[i]);
  246.         }
  247.         { for    (i = 1; i <= n; i++)
  248.             {    # For each directory prefix.
  249.             if    (match($0, ("^" a[i])))
  250.                 {
  251.                 print substr($0, RSTART + RLENGTH);
  252.                 break
  253.                 }
  254.             }
  255.         }
  256. __END_OF_SCRIPT__
  257. #
  258. # Now use the above script to get the section names.  We use ls to list the
  259. # names within just the current directory, which ignores any hidden
  260. # directories (such as MAN_DATA_DIR), then pass only those entries that
  261. # are directories to our awk script.
  262. ls -1 | while read n; do if [ -d "$n" ]; then echo "$n"; fi; done | \
  263.     awk -v "DIRS=$MAN_SECT_PREFIXES" -f $TMP-scr | \
  264.     sort -u
  265. rm -f $TMP-scr
  266. }
  267. #
  268. # Function to remove any data in the MAN_DATA_DIR for sections which no
  269. # longer exist.  This prevents this old data from being included in any
  270. # new databases we create.  The arguments are the names of all the manpage
  271. # sections.  There is no output and no return value.
  272. RemoveOldSectionData()
  273. {
  274. # If there is no section data, then there is nothing for us to do.
  275. if [ ! -d "$MAN_DATA_DIR" ]
  276. then    return
  277. fi
  278. #
  279. # Write the command line arguments to a file, then pipe the names of all
  280. # the existing section data files into an awk script.  The awk script first
  281. # reads the file of existing section names, then reads its input.  For each
  282. # input line, it strips the directory path and any suffixes, then sees if
  283. # what remains is one of the existing section names.  If not, it outputs
  284. # the original line.  The output of the awk script goes into xargs and rm
  285. # to remove all the files that awk lists.
  286. #
  287. # Write the command line arguments to a file.
  288. for section
  289. do    echo "$section"
  290. done | sort -u >$TMP-sect
  291. #
  292. # Pipe a list of all existing section data file names into our awk script.
  293. find "$MAN_DATA_DIR" -type f -print | \
  294.     awk -v "SECT=$TMP-sect" -v "RMSECT=$TMP-rmsect" '
  295.         BEGIN    { while    ((getline s < SECT) > 0)
  296.                 Sections[s] = 1;
  297.               close(SECT);
  298.             }
  299.         {    # For each section data file.
  300.         f = $0;
  301.         sub(/^.*\//, "", f);        # Strip directory path.
  302.         sub(/\.[^\.]*$/, "", f);    # Strip any suffix.
  303.         if    (! (f in Sections))
  304.             print;            # File for unknown section.
  305.             print > RMSECT        # Save for vbi removal
  306.         }' | \
  307.     xargs rm -f 2>/dev/null
  308.  
  309. # Now also remove any .vbi leftovers
  310. if [ -s $TMP-rmsect ]
  311. then
  312.     cat $TMP-rmsect |\
  313.     while read sect
  314.     do
  315.         # copy vbi file to the deletion area
  316.         if [ -f "$VerityDir/$INDEXED_DIR/man.${sect}.vbi" ]
  317.         then
  318.             cp $VerityDir/$INDEXED_DIR/man.${sect}.vbi $VerityDir/$DELETE_DIR
  319.         fi
  320.     done 
  321. fi
  322. rm -f $TMP-rmsect
  323. }
  324. #
  325. # Function to generate the index and whatis files from the .titles file
  326. # for a section.  The arguments are the section name and the path of the
  327. # awk script that creates the files.  It writes files named index.$1 and
  328. # whatis.$1 to the current directory
  329. MakeIndexAndWhatis()
  330. {
  331. # Run the script that produces the index and whatis files.
  332. awk -v "SECTION=$1" -v "INDEX=$TMP-i$1" \
  333.     -v "WHATIS=$TMP-w$1" -v "ME=$ME" -f $2 \
  334.     $MAN_DATA_DIR/$MAN_TITLES_DIR/$1
  335. #
  336. # If we generated index or whatis data, replace the files.
  337. Index="$MAN_DATA_DIR/$MAN_INDEX_DIR/$1"
  338. Whatis="$MAN_DATA_DIR/$MAN_WHATIS_DIR/$1"
  339. rm -f $Index $Whatis
  340. #
  341. # Make sure the directories we put the index and whatis data in exist.
  342. if [ ! -d "$MAN_DATA_DIR/$MAN_INDEX_DIR" ]
  343. then    if mkdir -p -m 0755 "$MAN_DATA_DIR/$MAN_INDEX_DIR"
  344.     then    :    # We made it.
  345.     else    Error 1 "Could not create title data directory for section %s" "$1"
  346.         return 1
  347.     fi
  348. fi
  349. if [ ! -d "$MAN_DATA_DIR/$MAN_WHATIS_DIR" ]
  350. then    if mkdir -p -m 0755 "$MAN_DATA_DIR/$MAN_WHATIS_DIR"
  351.     then    :    # We made it.
  352.     else    Error 2 "Could not create whatis data directory for section %s" "$1"
  353.         return 1
  354.     fi
  355. fi
  356. #
  357. # Now put the new data in place.
  358. if [ -f $TMP-i$1 ]
  359. then    sort -u $TMP-i$1 > $Index
  360. fi
  361. if [ -f $TMP-w$1 ]
  362. then    sort -u $TMP-w$1 > $Whatis
  363. fi
  364. rm -f $TMP-i$1 $TMP-w$1
  365. }
  366. #
  367. # Function to convert the whatis database for the current language to
  368. # contain language-fallback data.  Entries that are in the whatis database
  369. # for the FALLBACK_LANG which are not in the whatis database for the current
  370. # language are added to the current language, and this replaces the whatis
  371. # database for the current language.  There are no arguments.  It returns
  372. # zero if successful, non-zero if it fails.
  373. WhatisLanguageFallback()
  374. {
  375. # If this is the fallback language or there is no directory for the
  376. # fallback language, do nothing.
  377. if [ "$LANG" = "$FALLBACK_LANG" -o ! -d "$BASE_PATH/$FALLBACK_LANG" ]
  378. then    return 0
  379. fi
  380. #
  381. # If the fallback language does not have a whatis database, complain.
  382. FALLBACK_WHATIS="$BASE_PATH/$FALLBACK_LANG/$MAN_DIR/whatis"
  383. if [ ! -f "$FALLBACK_WHATIS" ]
  384. then    Error 3 "no whatis database for fallback language: %s" "$FALLBACK_LANG"
  385.     return 1
  386. fi
  387. #
  388. # Get lists of the "name list" part of the whatis file for this language and
  389. # for the fallback language.
  390. sed 's/[[:blank:]]*- .*//' < whatis | sort -u >$TMP-w1
  391. sed 's/[[:blank:]]*- .*//' < $FALLBACK_WHATIS | sort -u >$TMP-w2
  392. #
  393. # Get a list of the names in the fallback language that are not in the
  394. # current language, and use this with the whatis file from the fallback
  395. # language to select the missing records.
  396. comm -13 $TMP-w1 $TMP-w2 | awk -v "WHATIS=$FALLBACK_WHATIS" '
  397.         {    # Record names not in current language.
  398.         Names[$0] = 1;
  399.         }
  400.     END    {    # Read the whatis file.
  401.         # Output those lines whose names are in our array.
  402.         while    ((getline < WHATIS) > 0)
  403.             {    # For each line in the whatis database.
  404.             # Get the name list without the description.
  405.             Name = $0;
  406.             sub(/[[:blank:]]*- .*/, "", Name);
  407.             # If this name is not in the Name[] array, output it.
  408.             if    (! ($0 in Names))
  409.                 print;
  410.             }
  411.             close(WHATIS)
  412.         }
  413.     ' >$TMP-w3
  414. rm -f $TMP-w1 $TMP-w2
  415. #
  416. # If we found some whatis data from the fallback language that was not in
  417. # the current language, combine this with the whatis data from the current
  418. # language and replace the whatis file for the current language.
  419. if [ -s $TMP-w3 ]
  420. then    sort -u whatis $TMP-w3 >$TMP-w4
  421.     if [ -s $TMP-w4 ]
  422.     then    if cp $TMP-w4 whatis
  423.         then    :    # It worked.
  424.         else    Error 4 "Could not combine whatis database with language fallback data"
  425.         fi
  426.     fi
  427. fi
  428. rm -f $TMP-w3 $TMP-w4
  429. }
  430. #
  431. # Function to generate the awk script that creates the Verity Bulk Insert
  432. # file from the .titles database.  It writes the script to the standard
  433. # output.
  434. GenerateVBIScript()
  435. {
  436. # Construct our awk script.  Start with the node functions.
  437. cat $AWK_COMMON_FUNCS $AWK_NODE_FUNCS
  438. #
  439. # Now add in the code to output the data in .vbi format.
  440. # title, and so on.
  441. cat <<'__END_OF_SCRIPT__'
  442. END    {    # Process collected nodes.
  443.     # Write the node data in .vbi format.
  444.     for    (i = 1; i <= NumNodes; i++)
  445.         {    # For each node we found.
  446.         if    (! (i in NodeSet))
  447.             continue;
  448.         n = NodeSet[i];
  449.         f = GetValue(i, K_SPATH);
  450.         if (f == "")
  451.             f = n;
  452.         printf("VDKVGWKEY:    %s/%s/%s\n", DOCROOT, MAN, f)
  453.         t = GetValue(i, K_TITLE);
  454.         v = GetValue(i, K_VERSION);
  455.         p = GetValue(i, K_PRINTSEQ);
  456.         if (t != "")
  457.             print "TITLE:        " t;
  458.         if (v != "")
  459.             print "VERSION:      " v;
  460.         if (p != "")
  461.             print "PRINTSEQ:     " p;
  462.         print "<<EOD>>";
  463.         }
  464.     }
  465. __END_OF_SCRIPT__
  466. }
  467. #
  468. # Function to generate the Verity Bulk Insert file from the .titles database.
  469. # The bulk insert file is used by the Verity search engine to decide what
  470. # to include in its indexing process.  The command line argument is the
  471. # section name.  It writes a file named SECTION to the MAN_VERITY_DIR
  472. # directory under the MAN_DATA_DIR under the current directory, which is
  473. # assumed to be the man directory for the current language.
  474. MakeVerityBulkInsertFile()
  475. {
  476. # Make sure the title database exists.
  477. if [ ! -f "$MAN_DATA_DIR/$MAN_TITLES_DIR/$1" ]
  478. then    Error 5 "No title file for section: %s, cannot make VBI." "$1"
  479.     return 1
  480. fi
  481. #
  482. # Name of man section vbi file
  483. MANVBI=man.$1.vbi
  484. #
  485. # Execute the script on the titles file to build the .vbi file
  486. awk -f $VBIScript -v "DOCROOT=$BASE_PATH/$Lang" -v "SECTION=$1" \
  487.     -v "MAN=$MAN_DIR" $MAN_DATA_DIR/$MAN_TITLES_DIR/$1 > $MANVBI
  488. Ret=$?
  489. #
  490. # Move the vbi files as needed for merging
  491. if [ $Ret = 0 ]
  492. then
  493.     # copy old one to delete area
  494.     if [ -f $VerityDir/$INDEXED_DIR/$MANVBI ]
  495.     then
  496.         cp $VerityDir/$INDEXED_DIR/$MANVBI $VerityDir/$DELETE_DIR
  497.     fi
  498.     # Now put new one in insert area
  499.     mv $MANVBI $VerityDir/$INSERT_DIR
  500. fi
  501. return $Ret
  502. }
  503. #
  504. # Function to run mkvdk on Verity bulk insert and delete
  505. # files.  It operates on whatever it finds in the appropriate
  506. # directories, but only if the -n option was not specified to
  507. # defer Verity indexing.
  508. CombineGlobalIndex()
  509. {
  510. # Do this only if -n option does not defer it
  511. if [ "$Nopt" = 1 ] 
  512. then
  513.     return 1
  514. else
  515.     if [ -n "$Lopt" ] 
  516.     then
  517.         $CONFIG_SEARCH -L "$Lopt"
  518.     else
  519.         $CONFIG_SEARCH
  520.     fi
  521. fi
  522. #
  523. return 0
  524. }
  525. #
  526. # Function to generate the REFhome.view file in the TopicViews directory.
  527. # This locates all the CONTENTS.html files under the current directory,
  528. # which should be the "man" directory for the current LANG, and creates
  529. # a view file referring to each such contents file.  There are no arguments.
  530. # it returns zero if successful, one if not.
  531. # Note that this works from the CONTENTS.html files and not the files in
  532. # the MAN_TOC_DIR in order to pick up any "fixed" TOCs.
  533. MakeRefHome()
  534. {
  535. # Generate the awk script that creates the .view file.
  536. Script=$TMP-scr
  537. cat $AWK_COMMON_FUNCS $AWK_NODE_FUNCS $AWK_GETTAG_FUNCS >$Script
  538. cat <<'__END_OF_SCRIPT__' >>$Script
  539.  
  540. END    {    # Each node is the name of a CONTENTS.html file.
  541.     REFView = "RefHome";
  542.     for    (n = 1; n <= NumNodes; n++)
  543.         {    # For each node we found.
  544.         if    (! (n in NodeSet))
  545.             continue;
  546.         # Get information about this node.
  547.         File = NodeSet[n];
  548.         Title = GetSGMLTag(File, "TITLE");
  549.         Section = File;
  550.         sub(/\/[^\/]*$/, "", Section);
  551.         sub(/.*\./, "", Section);
  552.         if    (Title == "")
  553.             Title = Section;    # Use section as title.
  554.         URL = "/" MAN "/" File;
  555.         if    (match(Section, /^[[:alpha:]][[:digit:]]/) &&
  556.              (length(Section) < 3 ||
  557.               match(Section, /^..[[:alpha:]]/)))
  558.             Class = substr(Section, 1, 2);
  559.         else if (match(Section, /^1M/)) 
  560.             Class = substr(Section, 1, 2);
  561.         else    Class = substr(Section, 1, 1);
  562.         Class = "mansect" Class;
  563.  
  564.         # Is there an html intro for this section?
  565.         Intro = ""
  566.         CMD = sprintf("/bin/ls -1 html.%s/[Ii]ntro*.html 2> /dev/null", Section)
  567.         CMD | getline Intro
  568.         close(CMD);
  569.  
  570.         # Set the fields for this node.
  571.         if ( Intro ) {
  572.             Intro = "/" MAN "/" Intro
  573.             SetKeyValue(n, K_OVERVIEW, Intro);
  574.         }
  575.         SetKeyValue(n, K_TITLE, Title);
  576.         SetKeyValue(n, K_URL, URL);
  577.         SetKeyValue(n, K_PARENT, REFView);
  578.         SetKeyValue(n, K_CLASS, Class);
  579.         }
  580.  
  581.     # Create the node for the REFhome view.
  582.     n = AddNode(REFView);
  583.     SetKeyValue(n, K_TITLE, HOME_TITLE);
  584.     SetKeyValue(n, K_URL, HOME_URL);
  585.     SetKeyValue(n, K_PARENT, HOME_PARENT);
  586.     SetKeyValue(n, K_VERSION, HOME_VERSION);
  587.     SetKeyValue(n, K_CLASS, HOME_CLASS);
  588.     SetKeyValue(n, K_OVERVIEW, HOME_OVERVIEW);
  589.  
  590.     # Finally, dump everything out.
  591.     OutputNodes();
  592.     }
  593.  
  594. __END_OF_SCRIPT__
  595. #
  596. # Make sure the directory we want to write into exists, we can write it,
  597. # and the file we want to write can be overwritten if it exists.
  598. HomeDir=`dirname $MAN_HOME_VIEW`
  599. if [ ! -d "$HomeDir" ]
  600. then    if mkdir -p -m 0755 "$HomeDir"
  601.     then    :    # We made it.
  602.     else    Error 7 "Could not create view directory: %s" "$HomeDir"
  603.         return 1
  604.     fi
  605. fi
  606. if [ ! -w "$HomeDir" -o \( -f "$MAN_HOME_VIEW" -a ! -w "$MAN_HOME_VIEW" \) ]
  607. then    Error 8 "Cannot create file for reference view."
  608.     return 1
  609. fi
  610. #
  611. # Find all the CONTENTS.html files, and pipe their paths into sed to
  612. # remove the ./ find creates, then append a colon so each line looks like
  613. # a view file node entry.  Send this to our awk script.
  614. find . -name CONTENTS.html ! -type d -print | \
  615.     sed 's@^\./@@;s/$/:/' | \
  616.     awk -f $Script -v "MAN=$MAN_DIR" -v "HOME_TITLE=$MAN_HOME_TITLE" \
  617.         -v "HOME_URL=$MAN_HOME_URL" \
  618.         -v "HOME_PARENT=$MAN_HOME_PARENT" \
  619.         -v "HOME_VERSION=$MAN_HOME_VERSION" \
  620.         -v "HOME_OVERVIEW=$MAN_HOME_OVERVIEW" \
  621.         -v "HOME_CLASS=$MAN_HOME_CLASS" > $MAN_HOME_VIEW
  622. }
  623. #
  624. # Function to configure a single manpage section within a language.  The only
  625. # argument is the name of the section to be configured.
  626. Config_Section()
  627. {
  628. # Remove any temporary index or whatis files for this section.
  629. rm -f $TMP-[iw]$1
  630. #
  631. # Make the titles database for this section.
  632. if $MKTITLES -m "$1"
  633. then    # Make the other files based on the titles database.
  634.     $MKCONTENTS -m "$1"
  635.     #
  636.     # Make the index and whatis databases for this section.
  637.     MakeIndexAndWhatis "$1" "$Script"
  638.     #
  639.     # Make the Verity bulk insert file for this section.
  640.     MakeVerityBulkInsertFile "$1"
  641. fi
  642. }
  643. #
  644. # Function to configure manpages for a specific language.  The current
  645. # directory is the language-specific manual directory under the BASE_PATH
  646. # of the language whose documentation is to be configured.  The arguments
  647. # are the set of manpage sections to be configured within the language.
  648. # If there are no arguments, all manpage sections within the language
  649. # are configured.  There is no return value.
  650. Config_Language()
  651. {
  652. # Set the location of the Verity collection files for this language
  653. VerityDir=$BASE_PATH/$Lang/$SEARCH_DIR
  654. if [ ! -d $VerityDir ]
  655. then
  656.     mkdir $VerityDir
  657.     if [ $? != 0 ]
  658.     then
  659.         Error 1 "Cannot create search index directory $VerityDir"
  660.         VerityDir=""
  661.     fi
  662. fi
  663. # Create the bulk insert subdirectories if needed
  664. if [ -d "$VerityDir" ]
  665. then
  666.     for subdir in $INDEXED_DIR $DELETE_DIR $INSERT_DIR
  667.     do
  668.         test -d $VerityDir/$subdir || mkdir $VerityDir/$subdir
  669.     done
  670. fi
  671.  
  672. # If no arguments were specified, get all possible manpage section names.
  673. unset Complain
  674. if [ $# -eq 0 ]
  675. then    # Make a list of all the section names.
  676.     set -- `GetAllSectionNames`
  677.     #
  678.     # Now remove any section data for sections that no longer exist.
  679.     RemoveOldSectionData "$@"
  680. else    # We were given section names, complain if any are bad.
  681.     Complain=1
  682. fi
  683. #
  684. # Make the awk script that creates index and whatis files.
  685. Script=$TMP-genidx
  686. GenerateScript >$Script
  687. #
  688. # Make sure the directory we will put the titles database files into exists.
  689. if [ ! -d "$MAN_DATA_DIR/$MAN_TITLES_DIR" ]
  690. then    if mkdir -p -m 0755 "$MAN_DATA_DIR/$MAN_TITLES_DIR"
  691.     then    :    # We made it.
  692.     else    Error 9 "Could not create title data directory"
  693.         return 1
  694.     fi
  695. fi
  696. #
  697. # Make sure the directory we will put the TOC files into exists.
  698. if [ ! -d "$MAN_DATA_DIR/$MAN_TOC_DIR" ]
  699. then    if mkdir -p -m 0755 "$MAN_DATA_DIR/$MAN_TOC_DIR"
  700.     then    :    # We made it.
  701.     else    Error 10 "Could not create Table Of Contents data directory"
  702.         return 1
  703.     fi
  704. fi
  705. #
  706. # Make sure the directories we put the index and whatis data in exist.
  707. if [ ! -d "$MAN_DATA_DIR/$MAN_INDEX_DIR" ]
  708. then    if mkdir -p -m 0755 "$MAN_DATA_DIR/$MAN_INDEX_DIR"
  709.     then    :    # We made it.
  710.     else    Error 11 "Could not create index data directory"
  711.         return 1
  712.     fi
  713. fi
  714. if [ ! -d "$MAN_DATA_DIR/$MAN_WHATIS_DIR" ]
  715. then    if mkdir -p -m 0755 "$MAN_DATA_DIR/$MAN_WHATIS_DIR"
  716.     then    :    # We made it.
  717.     else    Error 12 "Could not create whatis data directory"
  718.         return 1
  719.     fi
  720. fi
  721. #
  722. # Make sure the directory we will put the VBI file into exists.
  723. if [ ! -d "$MAN_DATA_DIR/$MAN_VERITY_DIR" ]
  724. then    if mkdir -p -m 0755 "$MAN_DATA_DIR/$MAN_VERITY_DIR"
  725.     then    :    # We made it.
  726.     else    Error 13 "Could not create Verity data directory"
  727.         return 1
  728.     fi
  729. fi
  730. #
  731. # Get the path of the directory we start out in, so we can restore it.
  732. StartDir="`pwd`"
  733. #
  734. # Loop over each manpage section name.
  735. ProcList=""
  736. NumProcs=0
  737. for Section
  738. do    # Process each section.
  739.     #
  740.     # Check if we need to wait for processes to finish.
  741.     if [ $NumProcs -ge $MAX_PARALLEL_SECTIONS ]
  742.     then    # Too many background processes active.
  743.         wait $ProcList    # Wait for the children to die.
  744.         ProcList=""    # All the children are dead.
  745.         NumProcs=0
  746.     fi
  747.     #
  748.     # Start configuring a section in the background.
  749.     Config_Section $Section &
  750.     # Keep track of the PIDs of each background process.
  751.     ProcList="$ProcList $!"
  752.     NumProcs=`expr $NumProcs + 1`
  753. done
  754. #
  755. # If there are still some background processes active, wait for them.
  756. if [ $NumProcs -gt 0 ]
  757. then    wait $ProcList
  758.     ProcList=""
  759.     NumProcs=0
  760. fi
  761. #
  762. # All done with manpage sections, combine global data.
  763. find $MAN_DATA_DIR/$MAN_INDEX_DIR -type f -print | \
  764.     xargs cat | sort -u > index
  765. find $MAN_DATA_DIR/$MAN_WHATIS_DIR -type f -print | \
  766.     xargs cat | sort -u > whatis
  767. #
  768. # Perform language fallback for the whatis database.  The index database
  769. # does not need anything done to it because the man(1) command will do
  770. # language fallback by itself.
  771. WhatisLanguageFallback
  772. #
  773. # Run the Verity indexing process.
  774. CombineGlobalIndex
  775. #
  776. # Generate the REFhome file.
  777. MakeRefHome
  778. }
  779. #
  780. #
  781. ##### MAIN CODE
  782. #
  783. # Parse the command line.
  784. unset Lopt Dopt
  785. while getopts "nL:d:" Opt
  786. do      case "$Opt" in
  787.     L)    Lopt="$OPTARG";;
  788.     d)    Dopt="$OPTARG";;
  789.     n)    Nopt=1;;
  790.     \?)    Usage;;
  791.     esac
  792. done
  793. shift `expr $OPTIND - 1`
  794. #
  795. # Locate and load the ODSSI configuration file.
  796. if [ -f "$ODSSI_CONFIG" -a -r "$ODSSI_CONFIG" ]
  797. then    . "$ODSSI_CONFIG"
  798.     if [ -z "$BASE_PATH" ]
  799.     then    Error 14 "Invalid ODSSI configuration file: %s" "$ODSSI_CONFIG"
  800.         exit 1
  801.     fi
  802. else    Error 15 "Cannot locate ODSSI configuration file: %s" "$ODSSI_CONFIG"
  803.     exit 1
  804. fi
  805. #
  806. # Default the number of parallel processes if it is out of range.
  807. if [ "$MAX_PARALLEL_SECTIONS" -gt 0 ] 2>/dev/null
  808. then    :    # It is OK.
  809. else    MAX_PARALLEL_SECTIONS=1
  810. fi
  811. #
  812. # If a directory was given and it exists, use it instead of the BASE_PATH.
  813. if [ -n "$Dopt" ]
  814. then    if [ -d "$Dopt" ]
  815.     then    BASE_PATH="$Dopt"
  816.     else    Error 16 "No such directory: %s" "$Dopt"
  817.         exit 1
  818.     fi
  819. fi
  820. #
  821. # Change directories to the base path.
  822. if cd $BASE_PATH >/dev/null 2>&1
  823. then    :    # It exists.
  824. else    Error 17 "Cannot find documentation directory: %s" "$BASE_PATH"
  825.     exit 1
  826. fi
  827. #
  828. # Make sure this user can write into the documentation directories.
  829. if [ ! -w "." ]
  830. then    Error 18 "Cannot configure documentation: permission denied: %s" "$BASE_PATH"
  831.     exit 1
  832. fi
  833. #
  834. # Determine which languages to work on.
  835. if [ -n "$Lopt" ]
  836. then    Langs="$Lopt"
  837.     if [ ! -d "$Langs/$MAN_DIR" ]
  838.     then    Error 19 "No manual pages for language: %s" "$Lopt"
  839.         exit 1
  840.     fi
  841. elif [ -n "$Dopt" -a "`basename $Dopt`" = "man" ]
  842. then    Langs=".."
  843. else    # Get the lang list from the directory
  844.     LangList="`echo * | tr ' ' '\012'`" 
  845.     # Only language directories have Framework.
  846.     Langs=""
  847.     for dir in $LangList
  848.     do
  849.         test -d $dir/Framework -a $dir != $FALLBACK_LANG && Langs="$Langs $dir"
  850.     done
  851.     # Make sure we always do the fallback language first.
  852.     Langs="$FALLBACK_LANG $Langs"
  853. fi
  854. #
  855. # Generate the VBI script.
  856. VBIScript=$TMP-vbiscr
  857. GenerateVBIScript >$VBIScript
  858. #
  859. # Loop over all the languages specified.
  860. for Lang in $Langs
  861. do    # Configure documentation for this language.
  862.     if [ ! -d "$Lang/$MAN_DIR" ]; then continue; fi
  863.     Errs=0
  864.     if cd "$Lang/$MAN_DIR" >/dev/null 2>&1
  865.     then    if [ "$Lang" != ".." ]
  866.         then    # Use the language name for sorting, etc.
  867.             LANG="$Lang"
  868.         else    LANG="$USER_LANG"
  869.         fi
  870.         export LANG
  871.         Config_Language "$@"
  872.         Errs=`expr $Errs + $?`
  873.     else    Error 20 "No manual pages for language: %s" "$Lang"
  874.         Errs=1
  875.     fi
  876.     cd $BASE_PATH >/dev/null 2>&1
  877. done
  878. exit $Errs
  879. #
  880. ### EOF
  881.