home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume15 / hash8 / lcc.sh,v < prev    next >
Encoding:
Text File  |  1988-06-05  |  11.7 KB  |  613 lines
  1. head     1.5;
  2. access   ;
  3. symbols  ;
  4. locks    ; strict;
  5. comment  @# @;
  6.  
  7.  
  8. 1.5
  9. date     87.03.06.20.34.29;  author geoff;  state Exp;
  10. branches ;
  11. next     1.4;
  12.  
  13. 1.4
  14. date     87.02.28.00.56.50;  author geoff;  state Exp;
  15. branches ;
  16. next     1.3;
  17.  
  18. 1.3
  19. date     86.11.08.23.07.56;  author geoff;  state Exp;
  20. branches ;
  21. next     1.2;
  22.  
  23. 1.2
  24. date     86.11.08.22.15.24;  author geoff;  state Exp;
  25. branches ;
  26. next     1.1;
  27.  
  28. 1.1
  29. date     86.11.08.21.58.14;  author geoff;  state Exp;
  30. branches ;
  31. next     ;
  32.  
  33.  
  34. desc
  35. @Shell script to compile long-name C programs.
  36. @
  37.  
  38.  
  39. 1.5
  40. log
  41. @Make -p work correctly
  42. @
  43. text
  44. @: Use bin/sh
  45. #
  46. # $Header: lcc.sh,v 1.4 87/02/28 00:56:50 geoff Exp $
  47. #
  48. # $Log:    lcc.sh,v $
  49. # Revision 1.4  87/02/28  00:56:50  geoff
  50. # Major changes to handle things much better by running each compiler
  51. # pass separately.  Also add the -R switch, and support for -D and
  52. # library files.
  53. # 
  54. # Revision 1.3  86/11/08  23:07:56  geoff
  55. # Add error processing, not quite like cc's
  56. # 
  57. # Revision 1.2  86/11/08  22:15:24  geoff
  58. # Remove -HP, minor cleanup of output.  Working, except ignores errors
  59. # 
  60. # Revision 1.1  86/11/08  21:58:14  geoff
  61. # Works only if -HP specified
  62. # 
  63. #
  64. #    Replacement for the 'cc' command, with support for long
  65. #    identifiers.
  66. #
  67. #    Usage:
  68. #
  69. #    lcc [options] files
  70. #
  71. #    As with 'cc', the files mentioned can be .c, .s, or .o files.
  72. #
  73. #    All 'cc' options are support (or should be -- report bugs!).
  74. #
  75. #    There are some extra options.  All begin with H:
  76. #
  77. #    -HD    Don't preserve the encode/decode table.  (Normally, it is
  78. #        left in xxxx.t, where xxxx is the first file name encountered,
  79. #        or the -o file name if -o is specified.)
  80. #    -HA name The encode/decode table is put in <name>.  If it exists,
  81. #        the program will append to it.
  82. #    -HL    Only the C compiler itself is deficient;  the assembler
  83. #        and linker can handle long names.  Use this facility to
  84. #        generate long-name object files.  This is incompatible
  85. #        with -P and -S, but conflict is not checked.
  86. #    -R name    Add <name> to the reserved-word list.  Useful for
  87. #        library routines that have long names.
  88. #
  89. #    Options supported:
  90. #
  91. #    -I<dir>    Set include path for cpp
  92. #    -S    Generate .s files
  93. #    -c    Generate .o files;  don't load
  94. #    -n    Generate shared text (ld)
  95. #    -p    Generate profiled output
  96. #    -f*    Passed on to cc
  97. #
  98. TDIR=${TMPDIR:-/tmp}        # Where to put temp files
  99. TFILE=lcc$$            # Base name for encoded source files
  100. TMP=$TDIR/$TFILE        # Base name of cc's encoded input files
  101. TABLE=${TFILE}t            # Where the decode file goes
  102. c1sw=                # Switches for compiler pass 1
  103. ccsw=                # Switches for cc
  104. ldsw=                # Switches for ld
  105. suffix=o            # Suffix of output "object" files:  o, s, or i
  106. forceobj=-c            # How to force "objects":  -c, -P, or -S
  107. load=yes            # Yes to invoke loader
  108. numsrcfiles=            # If this is exactly one x, we kill objects
  109. ofiles=                # Files to be linked
  110. optimize=no            # -O switch specified
  111. optsw=                # Switches for optimizer
  112. preprocess=            # Preprocess option:  null, -P, or -E
  113. reserved=            # Reserved-word list
  114. rmfiles=            # List of object files to remove (only one)
  115. verbose=            # Verbose option:  -v or null
  116. killtable=no            # Yes if $TABLE is to be deleted
  117. tablename=            # Name of the output table
  118. madetable=no            # Yes if we added to the table
  119. dumbcc=no            # Yes if only cc is dumb about long names
  120.  
  121. if [ -x /lib/c ]
  122. then
  123.     COMPILER=/lib/c
  124. elif [ -x /usr/lib/c ]
  125. then
  126.     COMPILER=/usr/lib/c
  127. else
  128.     COMPILER=c
  129. fi
  130. if [ -x /lib/c2 ]
  131. then
  132.     OPTIMIZER=/lib/c2
  133. elif [ -x /usr/lib/c2 ]
  134. then
  135.     OPTIMIZER=/usr/lib/c2
  136. else
  137.     OPTIMIZER=c2
  138. fi
  139. trap '/bin/rm -f ${TFILE}.? ${TMP}* $TABLE; exit 1' 1 2 15
  140. # 7 is SIGEMT, a fairly obscure one
  141. failure=no
  142. trap "failure=yes" 7
  143. while [ $# -gt 0 ]
  144. do
  145.     case "$1" in
  146.     -HD)
  147.         TABLE=${TMP}t    # Put output table in $TMPDIR
  148.         killtable=yes
  149.         ;;
  150.     -HA)
  151.         tablename=$2
  152.         TABLE=$2
  153.         shift
  154.         ;;
  155.     -HL)
  156.         dumbcc=yes
  157.         ;;
  158.     -R)
  159.         reserved="$reserved -r $2"
  160.         shift
  161.         ;;
  162.     -n)
  163.         ldsw="$ldsw $1"
  164.         ;;
  165.     -v)
  166.         verbose=-v
  167.         ;;
  168.     -p)
  169.         ldsw="$ldsw $1"
  170.         c1sw="$c1sw -Xp"
  171.         ;;
  172.     -f*)
  173.         ldsw="$ldsw $1"
  174.         c1sw="$c1sw $1"
  175.         ;;
  176.     -o)
  177.         ldsw="$ldsw $1 $2"
  178.         tablename=$2.t
  179.         shift
  180.         ;;
  181.     -R)
  182.         ldsw="$ldsw $1 $2"
  183.         shift
  184.         ;;
  185.     -E|-P)
  186.         preprocess=$1
  187.         forceobj=$1
  188.         suffix=i
  189.         load=no
  190.         ;;
  191.     -O*)
  192.         optimize=yes
  193.         optsw=`echo $1 | tr -d O`
  194.         if [ "X$optsw" = "X-" ]
  195.         then
  196.         optsw=
  197.         fi
  198.         ;;
  199.     -C|-D*|-U*|-I*)
  200.         ccsw="$ccsw $1"
  201.         ;;
  202.     -S)
  203.         forceobj=-S
  204.         suffix=s
  205.         load=no
  206.         numsrcfiles=xx
  207.         ;;
  208.     -c)
  209.         load=no
  210.         numsrcfiles=xx
  211.         ;;
  212.     -l*)
  213.         ofiles="$ofiles $1"
  214.         ;;
  215.     *.o)
  216.         numsrcfiles=xx
  217.         ofiles="$ofiles $1"
  218.         if [ "$tablename" = "" ]
  219.         then
  220.         tablename=`basename $1 .o`.t
  221.         fi
  222.         ;;
  223.     *.s)
  224.         if  [ "$dumbcc" = "yes" -a "X$preprocess" = "X" ]
  225.         then
  226.         if cc $ccsw $verbose $forceobj $1
  227.         then
  228.             :
  229.         else
  230.             failure=yes
  231.             break
  232.         fi
  233.         elif [ "$suffix" != "s" -a "X$preprocess" = "X" ]
  234.         then
  235.         hash8 $reserved encode $TABLE < $1 > ${TMP}.s
  236.         madetable=yes
  237.         (cc $ccsw $forceobj $verbose ${TMP}.s 2> ${TMP}.e \
  238.             ||  kill -7 $$) \
  239.           | sed "s;${TMP}.s;$1;" | hash8 decode $TABLE
  240.         sed "s;${TMP}.s;$1;" ${TMP}.e | hash8 decode $TABLE 1>&2
  241.         if [ "$failure" = "yes" ]
  242.         then
  243.             break
  244.         fi
  245.         obj=`basename "$1" '.s'`.$suffix
  246.         ofiles="$ofiles $obj"
  247.         rmfiles="$rmfiles $obj"
  248.         mv ${TFILE}.$suffix $obj
  249.         numsrcfiles="x$numsrcfiles"
  250.         fi
  251.         if [ "$tablename" = "" ]
  252.         then
  253.         tablename=`basename $1 .s`.t
  254.         fi
  255.         ;;
  256.     *.c)
  257.         obj=`basename "$1" '.c'`.$suffix
  258.         ppfile=${TMP}.i
  259.         if [ "X$verbose" = "X-v" ]
  260.         then
  261.         echo "${1}:"
  262.         echo "  Preprocessing" 1>&2
  263.         fi
  264.         if [ "X$preprocess" = "X-E" ]
  265.         then
  266.         if cc $ccsw $preprocess $1
  267.         then
  268.             :
  269.         else
  270.             failure=yes
  271.         fi
  272.         elif [ "X$preprocess" = "X-P" ]
  273.         then
  274.         ppfile=$obj
  275.         fi
  276.         if cc $ccsw -E $1 > $ppfile
  277.         then
  278.         :
  279.         else
  280.         failure=yes
  281.         /bin/rm -f $ppfile
  282.         break
  283.         fi
  284.         if [ "X$preprocess" = "X-P" ]
  285.         then
  286.         break
  287.         fi
  288.         hash8 $reserved encode $TABLE < $ppfile > ${TMP}.c
  289.         madetable=yes
  290.         /bin/rm -f $ppfile
  291.         if [ "$optimize" = yes ]
  292.         then
  293.         unoptfile=${TMP}.s1
  294.         else
  295.         unoptfile=${TMP}.s
  296.         fi
  297.         if [ "X$verbose" = "X-v" ]
  298.         then
  299.         echo "  Compiling" 1>&2
  300.         fi
  301.         if $COMPILER $c1sw < ${TMP}.c > $unoptfile 2> ${TMP}.e
  302.         then
  303.         /bin/rm -f ${TMP}.c
  304.         else
  305.         hash8 decode $TABLE < ${TMP}.e 1>&2
  306.         /bin/rm $unoptfile ${TMP}.c ${TMP}.e
  307.         failure=yes
  308.         break
  309.         fi
  310.         if [ $optimize = yes ]
  311.         then
  312.         if [ "X$verbose" = "X-v" ]
  313.         then
  314.             echo "  Optimizing" 1>&2
  315.         fi
  316.         if $OPTIMIZER $optsw < $unoptfile > ${TMP}.s 2> ${TMP}.e
  317.         then
  318.             /bin/rm -f $unoptfile
  319.             unoptfile=${TMP}.s
  320.         else
  321.             hash8 decode $TABLE < ${TMP}.e 1>&2
  322.             /bin/rm -f $unoptfile ${TMP}.s ${TMP}.e
  323.             failure=yes
  324.             break
  325.         fi
  326.         fi
  327.         case "X$forceobj" in
  328.         X-S)
  329.             hash8 _decode $TABLE < $unoptfile > $obj
  330.             /bin/rm -f $unoptfile
  331.             ;;
  332.         *)
  333.             if [ "X$verbose" = "X-v" ]
  334.             then
  335.             echo "  Assembling" 1>&2
  336.             fi
  337.             if [ "$dumbcc" = "yes" ]
  338.             then
  339.             mv $unoptfile ${TMP}.s1
  340.             hash8 _decode $TABLE < ${TMP}.s1 > ${TMP}.s
  341.             /bin/rm -f ${TMP}.s1
  342.             if as -o $obj ${TMP}.s
  343.             then
  344.                 :
  345.             else
  346.                 /bin/rm -f ${TMP}.s $obj
  347.                 failure=yes
  348.                 break
  349.             fi
  350.             else
  351.             if as -o $obj $unoptfile 2> ${TMP}.e
  352.             then
  353.                 /bin/rm -f $unoptfile ${TMP}.e
  354.             else
  355.                 hash8 _decode $TABLE < ${TMP}.e 1>&2
  356.                 /bin/rm -f $unoptfile ${TMP}.e $obj
  357.                 failure=yes
  358.                 break
  359.             fi
  360.             fi
  361.             ofiles="$ofiles $obj"
  362.             rmfiles="$rmfiles $obj"
  363.             ;;
  364.         esac
  365.         numsrcfiles="x$numsrcfiles"
  366.         if [ "$tablename" = "" ]
  367.         then
  368.         tablename=`basename $1 .c`.t
  369.         fi
  370.         ;;
  371.     *)
  372.         echo "lcc:  unrecognized argument $1, passing to cc and ld" 1>&2
  373.         echo "type 'cat $0' to learn usage"
  374.         ccsw="$ccsw $1"
  375.         ldsw="$ldsw $1"
  376.         ;;
  377.     esac
  378.     shift
  379. done
  380. if [ "$load" = yes -a "$failure" = "no" ]
  381. then
  382.     if [ "X$verbose" = "X-v" ]
  383.     then
  384.     echo "  Loading" 1>&2
  385.     fi
  386.     (cc $ldsw $ofiles 2> ${TMP}.e  ||  kill -7 $$) \
  387.       | if [ "$madetable" = yes ]
  388.         then
  389.         hash8 _decode $TABLE
  390.         hash8 _decode $TABLE < ${TMP}.e 1>&2
  391.     elif [ -r "$tablename" ]
  392.     then
  393.         hash8 _decode $tablename
  394.         hash8 _decode $tablename < ${TMP}.e 1>&2
  395.     else
  396.         cat
  397.         cat ${TMP}.e 1>&2
  398.     fi
  399.     if [ "$numsrcfiles" = x ]
  400.     then
  401.     /bin/rm -f $rmfiles
  402.     fi
  403. fi
  404. /bin/rm -f ${TFILE}.? ${TMP}*
  405. if [ "$killtable" = "yes" -o "$tablename" = "" ]
  406. then
  407.     /bin/rm -f $TABLE
  408. elif [ "$madetable" = yes -a "$TABLE" != "$tablename" ]
  409. then
  410.     mv $TABLE $tablename
  411. fi
  412. if [ "$failure" = "yes" ]
  413. then
  414.     exit 1
  415. else
  416.     exit 0
  417. fi
  418. @
  419.  
  420.  
  421. 1.4
  422. log
  423. @Major changes to handle things much better by running each compiler
  424. pass separately.  Also add the -R switch, and support for -D and
  425. library files.
  426. @
  427. text
  428. @d3 1
  429. a3 1
  430. # $Header: lcc.sh,v 1.3 86/11/08 23:07:56 geoff Exp $
  431. d6 5
  432. d59 1
  433. d127 1
  434. a127 1
  435.         ccsw="$ccsw $1"
  436. d129 4
  437. d156 1
  438. a156 1
  439.     -f*|-C|-D*|-U*|-I*)
  440. d258 1
  441. a258 1
  442.         if $COMPILER < ${TMP}.c > $unoptfile 2> ${TMP}.e
  443. @
  444.  
  445.  
  446. 1.3
  447. log
  448. @Add error processing, not quite like cc's
  449. @
  450. text
  451. @d3 1
  452. a3 1
  453. # $Header: lcc.sh,v 1.2 86/11/08 22:15:24 geoff Exp $
  454. d6 3
  455. d37 3
  456. a39 1
  457. #        with -P and -S, but conflict is not cheked.
  458. d61 2
  459. d64 2
  460. d72 19
  461. a90 1
  462. trap "/bin/rm -f ${TFILE}.? ${TMP}* $TABLE; exit 1" 1 2 15
  463. a106 2
  464.         forceobj=-S
  465.         suffix=s
  466. d109 4
  467. d138 9
  468. a146 1
  469.     -f*|-O*|-C|-D*|-U*|-I*)
  470. d159 3
  471. d182 1
  472. a182 1
  473.         hash8 encode $TABLE < $1 > ${TMP}.s
  474. d194 1
  475. d204 32
  476. a235 1
  477.         hash8 encode $TABLE < $1 > ${TMP}.c
  478. d237 2
  479. a238 4
  480.         (cc $verbose $ccsw $forceobj ${TMP}.c 2> ${TMP}.e  ||  kill -7 $$) \
  481.           | sed "s;${TMP}.c;$1;" | hash8 decode $TABLE
  482.         sed "s;${TMP}.c;$1;" ${TMP}.e | hash8 decode $TABLE 1>&2
  483.         if [ "$failure" = "yes" ]
  484. d240 15
  485. d257 27
  486. a283 5
  487.         case "X${preprocess}Y$forceobj" in
  488.         X-P*|*Y-S)
  489.             obj=`basename "$1" '.c'`.$suffix
  490.             hash8 _decode $TABLE < ${TFILE}.$suffix > $obj
  491.             /bin/rm -f ${TFILE}.$suffix
  492. d286 4
  493. a289 1
  494.             if [ "X$verbose" = "X-v" ]
  495. d291 5
  496. a295 1
  497.                 echo "  Assembling" 1>&2
  498. d297 2
  499. a298 1
  500.             if cc $ccsw -c $obj
  501. d300 1
  502. a300 1
  503.                 :
  504. d302 2
  505. a306 2
  506.             /bin/rm -f $obj
  507.             obj=`basename "$1" '.c'`.o
  508. d309 1
  509. a310 7
  510.         X-E*)
  511.             ;;
  512.         *)
  513.             obj=`basename "$1" '.c'`.$suffix
  514.             ofiles="$ofiles $obj"
  515.             mv ${TFILE}.$suffix $obj
  516.             ;;
  517. d329 5
  518. a333 1
  519.     (cc $verbose $ldsw $ofiles 2> ${TMP}.e  ||  kill -7 $$) \
  520. d337 1
  521. d341 1
  522. d344 2
  523. a345 1
  524.     fi 1>&2
  525. d348 1
  526. a348 1
  527.     /bin/rm -f $ofiles
  528. @
  529.  
  530.  
  531. 1.2
  532. log
  533. @Remove -HP, minor cleanup of output.  Working, except ignores errors
  534. @
  535. text
  536. @d3 1
  537. a3 1
  538. # $Header: lcc.sh,v 1.1 86/11/08 21:58:14 geoff Exp $
  539. d6 3
  540. d64 3
  541. d133 7
  542. a139 1
  543.         cc $ccsw $verbose $forceobj $1
  544. d144 8
  545. a151 3
  546.         (cc $ccsw $forceobj $verbose ${TMP}.s 2>&1 ) \
  547.           | sed "s;${TMP}.s;$1;" \
  548.           | hash8 decode $TABLE 1>&2
  549. d165 1
  550. a165 1
  551.         (cc $verbose $ccsw $forceobj ${TMP}.c 2> ${TMP}.e ) \
  552. d168 4
  553. d183 7
  554. a189 1
  555.             cc $ccsw -c $obj
  556. d218 1
  557. a218 1
  558. if [ "$load" = yes ]
  559. d220 1
  560. a220 1
  561.     (cc $verbose $ldsw $ofiles 2>&1) \
  562. d243 6
  563. a248 1
  564. exit
  565. @
  566.  
  567.  
  568. 1.1
  569. log
  570. @Works only if -HP specified
  571. @
  572. text
  573. @d3 1
  574. a3 1
  575. # $Header$
  576. d5 4
  577. a8 1
  578. # $Log$
  579. a31 3
  580. #    -HP    Hash before passing information to the preprocessor, rather
  581. #        than after.  Useful if your preprocessor is dumb.  Conflicts
  582. #        with -E and -P.
  583. d53 1
  584. a53 1
  585. preprocess=            # Preprocess option:  null, -P, -E, or dumbpp
  586. a77 4
  587.     -HP)
  588.         preprocess=dumbpp
  589.         load=no
  590.         ;;
  591. d146 1
  592. a146 13
  593.         if [ "X$preprocess" = "X" ]
  594.         then
  595.         #
  596.         # We preprocess before hashing so that symbols in include
  597.         # files are picked up.  The disadvantage of this is that
  598.         # preprocessor names are not shortened, which gives trouble
  599.         # if your preprocessor is also dumb.  In this case,
  600.         # specify the -HP switch.
  601.         #
  602.         cc $ccsw -E $1 | hash8 encode $TABLE > ${TMP}.c
  603.         else
  604.         hash8 encode $TABLE < $1 > ${TMP}.c
  605.         fi
  606. d149 1
  607. a149 1
  608.           | hash8 decode $TABLE
  609. d193 1
  610. a193 1
  611.     (cc $ldsw $ofiles 2>&1) \
  612. @
  613.