Bolt Tightening Sequence

The recommended bolt torque for bolt gland bolts (3/4") is 105Nm when lead tipped and reinforced synthetic gaskets are used.

Sizes with 12 or more bolts should be tightened by two jointers working simultaneously on diametrically opposite bolts.


ECAL99

c_wte.gif (2005 bytes) a_wte.gif (2415 bytes) l_wte.gif (1930 bytes) e_wte.gif (2430 bytes)

By using this version of Software or Source code you are consenting to be bound
by agreement to the following:

DISCLAIMER

Since the Software is provided free of charge, I´m the Author Frederick Choi
shall not be held responsible for any damages arising from the use of the Software.
The Software is provided on an AS IS basis, without warranty of any kind, including without
limitation the warranties of merchantability, fitness for a particular
purpose and non-infringement. The entire risk as to the quality and
performance of the Software is borne by you. Should the Software prove
defective, you and not me , assume the entire cost of any
service and repair.

There are no security mechanisms implemented in the Software.

Your comment and bugs report are welcome.

Author - Frederick Choi e-mail: fredchoi@netvigator.com

Visit my web for new version and other things may interest to you


Coaxial Cable

The purpose of this program is to allow you to find the most economical coax that will suit your needs.
Adjust the lenth of the scroll bar to the lengthof coax you will need.
Pick the type of coax you will be using and pick the proper frequency from the frequency menu.

The amount of loss will be represented on the gauge and as a number.

Green means an insignificant amount of loss.

Yellow not noticable without test equipment.

Red means loss is beginning to approach unacceptable levels."


Chemical Preparation

1) Type in the chemical name in the "Starting Reagent" box.

2) Enter the molecular weight in the "MW" box, or look up the molecular weight in the chemical database by clicking on "Find MW" in the Starting Reagent box.. If the molecular weight is not required to perform the requested calculation then the "MW" box will not be shaded blue and you don't have to enter the molecular weight.

3) Click on one of the "Solution", "Solid" or "Liquid" buttons on the right side of the "Starting Reagent" box and fill in the boxes to the right of the selected button. Density and molar concentrations of reagents may also be stored in the chemical database, in which case the required data can be retrieved by clicking on "Find MW". (Note: If choosing "Liquid", the density may not be required to perform the requested calculation. In this case the "density" input box will not be shaded blue and no density information is required to be entered)

4) Enter the "Desired Solution" Information.
If the desired solution concentration is expressed as a molarity or weight per volume solution then click on "Solution" and enter the desired concentration in the boxes to the right of the selected button.
If the desired solution is expressed as a percentage then click on "Percentage" and enter the percent in the box to the right of the selected button. (Note: percent solutions are calculated as weight per volume unless the starting reagent is a liquid, in which case it is calculated as volume per volume.)

Click on "Total Amount" if the total amount of the desired reagent is known and the volume needs to be calculated. Enter the desired amount in the boxes to the right of the selected button.
Enter the volume of the solution you desire in the "Final Volume" boxes (if necessary).

5) Make sure all the blue boxes have valid information. The information needed for a calculation depends the selections made. Necessary information is indicated as a blue shaded box. Boxes which are not shaded are not used for the calculation and no information needs to be entered in them.

6) Click on the "Calculate" button in the "Results" section. The results will appear in the box above this button.


Earthing

1. Fault Levels

The size of earth conductors will be dependent upon the symmetrical short circuit current that may be experienced on any particular system within the station and ancillary buildings. The proposed grounding systen is based therefore on the fault time and current levels as given by GEC Turbine Gen. Ltd. and are as detailed below:

400kV System | 50K amps for 1 sec.
132kV System | 32.8K amps for 3 secs.
Generator System | 64K amps for 1 sec.
11kV System | 26.3 amps for 3 secs.
3.3kV System | 26.3 amps for 3 secs.
425V System | 43.2K amps for 3 secs.

2. Conductor Types

All earth conductors below ground and those to drives smaller than 5kW shall be type 6491X Cable with a single stranded copper conductor with a frame retardant PVC sheath. Larger drives and all major items of plant will be connected to the main station earth grid by means of a bare, plain soft drawn high conductivity electrolytic copper tape to BS1432/1970.

The sizes of earth tapes and cables to be used are as follows:

Earth Cable: | Single core | 500 sq.mm
 | Single core | 4 sq.mm
 | Single core | 2.5 sq.mm
Earth Tapes: | 3" x 1/2" |
 | 2" x 1/4" |
 | 1" x 1/8" |
 | 1/2" x 1/8" |

3. Method of Connection

All jointing of copper earth tape in the main station earth grid shall be brased using 'Silphos Foil'. (Silphos has a melting point of 644-700 degC). Branch connections to major items of plant are terminated at the equipment end by means of a bolted connection.

Earth cables are all to be terminated using a suitable sized crimp lug connector, to both the main earth grid and items of plant.


Media Sizes

Media Size

The Effective Size is that size such that 10% of the filter media by weight is smaller and 90% coarser. To assure that variation is not too great, the second measurement must be made. This is the size which 60% is finer and 40% coarser. This size divided by the dffective size is the Uniform Coefficient.

Type of Media

Type of filtering media used within the water treatment industry are listed below:

Media | Effective Size | Uniformity Coefficient | Bulk Density | Specific Gravity
Fine Gravel |  |  |  |
Coarse Sand | 0.85 - 0.95 mm | 1.6 | 1.5 t/cu.m | 2.65
Medium Sand | 0.55 - 0.65 mm | 1.6 | 1.5 t/cu.m | 2.65
Fine Sand | 0.45 - 0.6 mm | 1.6 | 1.5 t/cu.m | 2.65
Fine Anthracite | 0.65 - 0.76 mm | 1.85 | 0.65 - 0.75 t/cu.m | 1.4 - 1.6
Garnet | 0.2 - 0.6 mm |  | 2.38 t/cu.m | 4 - 4.2
Activated Carbon | 0.47 mm (0.35 - 0.5) | <2 (1.5 typical) |  |
Manganese Greensand | 0.3 - 0.35 mm | <1.6 | 1.358 t/cu.m | 2.4


Filter

Filters and Purifier

The following table shows the operating data pertinent to Filters and Purifiers:

Type and Application Service Backswash Rinse
Flow Rate (cu.m/h/sq.m) Duration of running Flow Rate (cu.m/h/sq.m)
Time
(min)
 Flow Rate (cu.m/h/sq.m)
Time
(min)
Pressure type Filter
Municipal and bottling plant use
Industrial use
4.9
7.34
 Pressure drop reaches 0.2-0.35kg/sq.cm
24.5
24.5
 10
4.9
7.34
 10
Conventional Gravity Filter
Municipal use
Inudtrial use
4.9
7.34
 When head loss reaches 1.8-2.4m
49
49
 10
4.9
7.34
 10
Automatic Valveless Gravity Filter
Municipal use
Industrial use
4.9
7.34
 When head loss reaches 1.2-1.5m
29
29
 5
4.9
7.34
 25
Activated Carbon Purifier
Bottling plant use
Industrial use
4.9
4.9
 Pressure drop reaches 0.2-0.35kg/sq.cm
14.7
14.7
 10
4.9
4.9
 5

The height of the will depend on the lower structure of the tank (Falls bottom, Double Dish or Hub and laterals) and the designed bed expansion during backwash.


Modem Initialization Strings

Modem Init String

3 A B C D E F G H I L M N O P R S T U V W X Z Generic and other

Windows 3.1x

The following initialization strings should work as-is for Trumpet, Chameleon, and other Windows PPP and SLIP dialer software.

Windows 95

As a rule, Windows 95 will set the proper string. To substitute the inits here for Windows 95 defaults, delete the leading "AT" and place the remainder of the string in the "Extra Settings" box of the Windows 95 Connections - Advanced window for your modem. Check the Flow Control - Hardware checkbox.

Macintosh

For Macintosh, substitute the string "&D0" for "&D2" or "&D3". Note that Global Village modems are set up for Macintosh as shown.

Connecting to 56K systems

  • If your modem is 56K compatible, you may need to get the from your manufacturer for reliable connections.
  • If your modem is not 56K compatible, and you are having trouble connecting to a 56K system, you may need to put three or four commas after the phone number in the dialing string to force your modem to ignore the 56K wake-up tone.
  • US Robotics X2 modems will connect to Lucent/Rockwell K56Flex systems at 33.6K or lower.
  • Lucent/Rockwell K56Flex modems will connect to US Robotics X2 systems at 33.6K or lower.

3COM 3C562 PCMCIA Modem

InitString=AT&FN1&B1&C1&D3&K3&Q6&U1\N7S7=60
BPS Rate=57600

3COM Impact

InitString=AT&F&C1&D2\Q3S60=64S70=0S71=1S80=0
BPS=57600

3COM Impact (MultiLink)

InitString=AT&F&C1&D2\Q3S60=64S70=0S71=1S80=1
BPS=57600

Adtran ISU 128 (ISDN)

InitString=AT&C1&D2&R0&S2\Q3S34=15
BPS=115200

Adtran ISU Express (ISDN)

InitString=AT&F8S54=12\Q3&C1&D2&R0&S2S34=15
BPS=115200

Adtran ISU Express (MultiLink)

InitString=AT&F8S54=12\Q3&C1&D2&R0&S2S34=15S53=3S27=1
BPS=115200

Amber Logic Mistral 9600

InitString=AT&FW2&C1&D3&E5&K1\C5\Q0
BPS=38400

Amber Logic Mistral 14400

InitString=AT&FW2&C1&D3&E5&K1\C5\Q0
BPS=38400

Amber Logic Mistral FX 14400i

InitString=AT&F&C1&D3S7=60
BPS=38400

Amquest 28.8 FaxModem

InitString=AT&F0F0X4N1W2&C1&D3&Q5&R0%C3%E2S7=60
BPS=57600

Angia Communications PCMCIA Fax Modem

InitString=AT&FW2&C1&D3\J0\N7\Q3\V2%C1S7=60
BPS=38400

Angia Communications 14.4 - TD (V.42 bis)

InitString=AT&FW1&C1&D2X4\J0\N7%C1S7=60
BPS=57600

Angia SafeJack Turbo PCMCIA

InitString=AT&F&C1&D3&K3S7=60
BPS=57600

Apex Data V.32/V.32bis Data/Fax

InitString=AT&FW2&C1&D3&K3&Q5\J0\N7\Q2\V2%C1S7=60
BPS=57600

Apex Data PCMCIA Modem Card

InitString=AT&FW2&C1&D3&K3&Q5\J0\N7\Q2\V2%C1S7=60
BPS=57600

Apex Data V.34 Internal Data/Fax

InitString=AT&FW2X4&C1&D3&K3&Q6\N7%C1S7=60
BPS=57600

ARN DX2 PCMCIA Modem

InitString=AT&FM1W2X4&C1&D2&K3&Q5%C3\N3-K0S7=90
BPS=38400

AST Premium Exec Internal Data/Fax (MNP 5)

InitString=AT&F&C1&D3\G0\J0\N3\Q2S7=60
BPS=9600

ATI Internal (V.42 bis)

InitString=AT&FW1&C1&D3&K3&N1&Q6&U1S7=60
BPS=57600

Austin Fax/Data Modem

InitString=AT&FW2X4&C1&D3&K3&Q5\J0\N3%C3S7=60
BPS=38400

ATi 2400etc/i and 2400etc/e (V.42bis)

InitString=AT&FW2&B1&C1&D3&K3&Q6&U1S7=60
BPS=9600

ATi 2400etc/Fax (V.42bis)

InitString=AT&FW2&B1&C1&D3&K3&Q6&U1S7=60
BPS=9600

ATi 9600etc/e (V.42bis)

InitString=AT&FW2&B1&C1&D3&K3&Q6&U1S7=60
BPS=38400

ATi 14400 ETC*Express PCMCIA Modem

InitString=AT&FW2&C1&D3&K3&Q5S7=60
BPS=57600

AT&T Globalyst TPC (v.42)

InitString=AT&FX4&C1&D2\N3%C1S7=60
BPS=38400

AT&T Safari NSX Internal 2400 BPS modem (V.42)

InitString=AT&FX4&C1&D3&M5\J0\Q2\V1S7=60
BPS=4800

AT&T Safari NSX Internal 2400 BPS modem (MNP 5)

InitString=AT&FX4&C1&D3&M4\J0\N3\Q2\V1%C1S7=60
BPS=4800

AT&T Paradyne 3825 Plus V.34

InitString=AT&FX4&C1&D3\N5\Q3S7=60
BPS=57600

AT&T Paradyne KeepInTouch Card Modem (V.42bis)

InitString=AT&FX6&C1&D3\N7\Q2%C1S7=60
BPS=57600

AT&T Keep in Touch 28.8

InitString=AT&F&C1&D2\N7\Q3%C1S7=60
BPS Rate=115200

AT&T ComSphere 3800 Series (V.42bis)

InitString=AT&FX6&C1&D2\N5\Q2%C1"H3S7=60
BPS=57600

AT&T ComSphere 3810 Plus

InitString=AT&FX6&C1&D2\N5\Q2%C1"H3S7=60
BPS=57600

AT&T Comsphere 3820 Plus

InitString=AT&F0X4Z3&C1&D3\D3\G1\N5%C1S7=60
BPS=57600

AT&T ComSphere 3830

InitString=AT&FX6&C1&D2\N5\Q2%C1"H3S7=60
BPS=57600

AT&T Dataport 288 V.34

InitString=AT&FX4&C1&D3S7=60
BPS=57600

AT&T DataPort Fax Modem (V.42bis)

InitString=AT&FX6&C1&D2\N7\Q2%C1S7=60
BPS=38400

AT&T Paradyne DataPort Express Modem

InitString=AT&F&C1&D2\J0\N7\Q3%C1S7=60
BPS=57600

AT&T Paradyne 3710 (V.42)

InitString=AT&FX4&D3&C1\N7\Q3%C1S7=60S10=30S76=0S78=0
BPS=57600

AT&T Paradyne 3811 Plus (V.34)

InitString=AT&FX4&C1&D3\N5\Q3S7=60
BPS=57600

AVM Fritz!Card (CAPI)

InitString=ATZ
BPS=115200
Port Driver=pdvcapi.386
Device Driver=fbase.386

AVM Fritz!Card PCMCIA (CAPI)

InitString=ATZ
BPS=115200
Port Driver=pdvcapi.386
Device Driver=fpcmbase.386

AVM ISDN-Controller PCMCIA A (CAPI)

InitString=ATZ
BPS=115200
Port Driver=pdvcapi.386
Device Driver=apcmbase.386

AVM ISDN-Controller A1 (CAPI)

InitString=ATZ
BPS=115200
Port Driver=pdvcapi.386
Device Driver=a1base.386

AVM ISDN-Controller A1 Plus (CAPI)

InitString=ATZ
BPS=115200
Port Driver=pdvcapi.386
Device Driver=a1pbase.386

AVM ISDN-Controller PCMCIA B (CAPI)

InitString=ATZ
BPS=115200
Port Driver=pdvcapi.386
Device Driver=bpcmbase.386

AVM ISDN-Controller B1 (CAPI)

InitString=ATZ
BPS=115200
Port Driver=pdvcapi.386
Device Driver=b1cbase.386

Banksia MyFastModem 28.8

InitString=AT&FE1Q0V1X4&C1&D3
BPS=57600

Banksia MyModem 14.4

InitString=AT&FE1Q0V1X4&C1&D3
BPS=57600

Banksia PCM144

InitString=AT&FE1Q0V1X4&C1&D3W2&K3&Q5\N3%C3S7=60
BPS=57600

Banksia PCM288

InitString=AT&F&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=115200

Best Data Smart One 28.8 w/fax

InitString=AT&FQ0V1X4W2&C1&D3&K3&Q5S7=50S46=138S48=7
BPS=57600

Best Data Smart One 2834FLX

InitString=AT&F\N3N1&C1W2&D3%C3M1S7=60
BPS=57600

BizComp 2400 Intellimodem (no MNP or V.42)

InitString=ATQ0V1X4&C1&D3S7=60
BPS=2400

BLUES VC 9624 Internal Fax Modem

InitString=AT&F&C1&D3&K3S7=50
BPS=2400

Boca Modem 14.4K/V.32bis (V.42bis)

InitString=AT&FW2&C1&D2&K3&Q5%C1\N3S7=60S36=7S46=138S95=47
BPS=57600

Boca V.Fast Class BocaModem

InitString=AT&F&C1&D3&K3&Q5\N3%C3S7=60S95=47
BPS=57600

Boca V.34 BocaModem

InitString=AT&FW1&C1&D3&K3\N3%C3S7=60S95=67
BPS=57600

Boca V.34 Office Communicator

InitString=AT&FW2&C1&D3&K3%C3\N3\J0S95=0S7=60
BPS=57600

CALCOM 14400 Fax & Data Modem

InitString=AT&F&C1&D3&K3&M5\N5\Q3\V1%C1S7=60S36=7S46=138S48=7S95=47
BPS=57600

CALPAK MXE-9600

InitString=AT&F&C1&D3S7=60S95=47
BPS=38400

Cardinal 2450MNP (MNP 5)

InitString=AT&F&C1&D3\J0\N3\Q2\V1%C1S7=60
BPS=9600

Cardinal 2400V42 (V.42bis)

InitString=AT&F&C1&D3\J0\N3\Q2\V2%C1"H3-J1S7=60
BPS=9600

Cardinal 9650V32 (MNP)

InitString=AT&F&B1&C1&D3&H1&I1&M6S7=60
BPS=19200

Cardinal 9600V42 (V.42bis)

InitString=AT&FW2&C1&D3&K3&Q5\N3%C1%M3S7=60S46=138S48=7S95=3
BPS=38400

Cardinal 14400 (V.42bis)

InitString=AT&F&C1&D3&K3&Q5\N3%C1%M3S7=60S46=138S48=7S95=47
BPS=57600

Cardinal Int 28.8 Modem (MVP288IV2)

InitString=AT&FW2&C1&D3&K3&Q5\N3%C3S7=60S46=138S95=47
BPS=115200

Cardinal MVP144DSP-C

InitString=AT&FW1&C1&D3&K3&Q5\N5%C1S7=60
BPS=57600

Cardinal MVP 28.8XF

InitString=AT&FW2&D3&K3&Q5\N3%C3S7=60S95=47
BPS=115200

Cardinal MVP 28.8XP V.FC/V.34

InitString=AT&FQ1W2&D3&K3S7=60S95=47
BPS=57600

COMPAQ Enhanced 9600 BPS Internal

InitString=AT&F&C1&D3&K3&Q5\J0\N3%C1S7=60S36=7S46=2S48=7S95=47
BPS=57600

Compaq PCMCIA 144 Data/Fax

InitString=AT&FW2X4&C1&D3\N3%C3\Q3S95=47
BPS=57600

Compaq Presario 972 (v.42)

InitString=AT&FX4&C1&D3\N3\Q3S7=60
BPS=38400

Compaq SpeedPAQ 144 (V.42bis)

InitString=AT&F&C1&D3&K3&Q5\J0\N3%C1S7=60S36=7S46=2S48=7S95=47
BPS=57600

Compaq SpeedPAQ 192 PCMCIA

InitString=AT&F0&C1&D3&K3\C1\N3S7=60
BPS=57600

Compaq SpeedPAQ 288 Internal Data/Fax

InitString=AT&FE1Q0V1W2X4&C1&D3&K3\Q3-J1"H3S7=60
BPS=57600

Compaq SpeedPAQ 288 PCMCIA Data/Fax

InitString=AT&FW2X4&C1&D3&K3%C1\J1\N3\V1"H3S7=60S37=17
BPS=57600

ControlWare Citam (ISDN)

InitString=ATZ&C0&D1&M0&R1&S0S8=1
BPS=38400

Datarace 24/96V Fax/Modem

InitString=AT&FW2&C1&D3&K3\J0\N5\Q2%C1S7=60
BPS=38400

Datarace RediMODEM V.32/V.32bis

InitString=AT&F&C1&D3&K3&Q6\J0\N7\Q3\V2%C1S7=60
BPS=38400

Dell NX20 Modem/Fax (MNP)

InitString=AT&F&C1&D3%C1\J0\N3\Q3\V1W2S7=60
BPS=9600

Dell v.34XJ PCMCIA Card

InitString=AT&FW2&C1&D3&K3\J0\N3\Q3\V1%C1"H3S7=60
BPS=115200

Diamond Supra Express 336i PnP

InitString=AT&F2W2&C1&D3%C3S7=60S95=32
BPS=115200

Digicom Systems (DSI) 9624LE/9624PC (MNP 5)

InitString=AT&F&C1&D3*E1*F3*S1S7=60
BPS=19200

Digicom Systems (DSI) 9624LE+ (V.42bis)

InitString=AT&F&C1&D3*E9*F3*N6*S1S7=60
BPS=38400

Digicom Systems Connection 14.4+FAX

InitString=AT&F&C1&D3&K3\N5%C1S48=7S7=60
BPS=38400

Digicom Systems PC Classic 14.4 fax (Internal)

InitString=AT&F&C1&D2&K3\N5%C1S48=7S7=50S46=138
BPS=38400

DoveFax 144E

InitString=AT&F&C1&D3*E1*E5*E9*F3*M2*N6*S1S7=60
BPS=38400

ECS 400

InitString=AT&F&C1&D3&K3&Q5\N3%C3S7=60
BPS=57600

Epson EFM 14.4 PCMCIA Card (V.42 bis)

InitString=AT&F0&C1&D3&K3\N3%C3S7=60
BPS=57600

Everex Evercom 24 and 24E (no MNP or V.42)

InitString=AT&F&C1&D3!S1S7=60
BPS=2400

Everex Evercom 24+ and 24E+ (MNP 5)

InitString=AT&F&C1&D3\J0\N3\Q2\V1%C1S7=60
BPS=19200

Everex EverFax 24/96 and 24/96E (MNP 5)

InitString=AT&F&C1&D3\J0\N3\Q2\V1%C1S7=60
BPS=9600

Everex Evercom 96+ and 96E+ (V.42bis)

InitString=AT&FW2&C1&D3\J0\N3\Q2\V2%C1S7=60
BPS=38400

EXP 14400 Data/Fax

InitString=AT&FW2X4&C1&D3&K3%C3\N3S7=60
BPS=57600

Freedom Series V.32bis Data/FAX Modem

InitString=AT&F&C1&D3&K3&Q6\J0\N7\Q3\V2%C1S7=60
BPS=38400

Gateway 2000 TelePath

InitString=AT&FW2&C1&D3&K3&Q5\N3%C1S7=60S36=7S46=138S48=7S95=47
BPS=38400

Gateway 2000 TelePath 550

InitString=AT&FX4&A3&B1&C1&D2&H1&K1&M4S7=60
BPS=38400

Gateway 2000 TelePath II Fax Modem

InitString=AT&FX4&A3&B1&C1&D2&H1&K1&M4&N0S7=60
BPS=38400

Gateway 2000 TelePath PCMCIA Fax Modem

InitString=AT&FX4&C1&D3&K3&Q5\N3%C3S7=60
BPS=57600

Gateway 2000 Nomad 9600 BPS Internal Modem

InitString=AT&F&C1&D3%C1\J0\N3\Q2S7=60
BPS=38400

General DataComm FastPro V.FC/V.34

InitString=AT&F0&C1%C1&D3&H0&U1\V1
BPS=57600

Global Village PowerPort Gold/Silver (for Macintosh)

InitString=AT&F\J0\Q3\N7%C1\V2W1
BPS=19200(Silver) BPS=38400(Gold)
FlowControl=CTS Only

Global Village PowerPort Mercury - 100 Series (for Macintosh)

InitString=AT&F1
BPS=57600
FlowControl=CTS Only

Global Village PowerPort Mercury - 200/500 Series (for Macintosh)

InitString=AT&F
BPS=57600
FlowControl=None

Global Village TelePort Bronze (for Macintosh)

InitString=AT&F
BPS=2400
FlowControl=None

Global Village TelePort Gold II (for Macintosh)

InitString=AT&F1&K3
BPS=38400
FlowControl=CTS Only

Global Village TelePort Mercury (for Macintosh)

InitString=AT&F1&K3
BPS=57600
FlowControl=CTS Only

Global Village TelePort Platinum (for Macintosh)

InitString=AT&F1W1S95=44
BPS=57600
FlowControl=CTS Only

GVC SM-96V (V.42bis)

InitString=AT&F&C1&D3%C1\J0\N6\Q2\V1S7=60
BPS=38400

GVC SM-144V (V.42bis)

InitString=AT&F&C1&D3%C1\J0\N6\Q2\V1S7=60
BPS=57600

GVC FM-288

InitString=AT&F&C1&D3%C1\J0\N6\Q3\V1S7=60
BPS=57600

Hayes Smartmodem 1200/1200B (and compatibles)

InitString=ATX4V1Q0S7=30
BPS=1200

Hayes Smartmodem 2400 (and compatibles)

InitString=AT&F&C1&D3S7=30
BPS=2400

Hayes Pocket Edition 2400 (no MNP or V.42)

InitString=AT&F&C1&D3S7=30
BPS=2400

Hayes Smartmodem Optima 9600 (V.42bis)

InitString=AT&FW2&C1&D3&K3&Q5S7=60S46=138S48=7S95=47
BPS=38400

Hayes Smartmodem Optima 14400 (V.42bis)

InitString=AT&FW2&C1&D3&K3&Q5S7=60S46=138S48=7S95=47
BPS=57600

Hayes Smartmodem Optima 144 Pocket Edition

InitString=AT&FW2&C1&D2&K3&Q9S7=60S46=138S48=7S95=47
BPS=57600

Hayes Smartmodem Optima 288 V.FC

InitString=AT&FW2&C1&D3&K3&Q9S7=60S46=138S48=7S95=47
BPS=57600

Hayes Smartmodem Optima 288 V.34

InitString=AT&FW2&C1&D3&K3&Q9S7=60S46=138S48=7S95=47
BPS=57600

Hayes Smartmodem Optima V.34 PCMCIA

InitString=AT&FW2&C1&D3&K3&Q9S7=60S46=138S48=7S95=47
BPS=57600

Hayes V-series Smartmodem 9600/9600B (V.42)

InitString=AT&F&C1&D3&K3&Q5S7=60
BPS=9600

Hayes V-series ULTRA Smartmodem 9600 (V.42bis)

InitString=AT&F&C1&D3&K3&Q5S7=60S46=2S48=7S95=63
BPS=38400

Hayes V-series ULTRA Smartmodem 14400 (V.42bis)

InitString=AT&FW2&C1&D3&K3&Q5S7=60S38=10S46=2S48=7S95=63
BPS=38400

Hayes ACCURA 24 EC (V.42bis)

InitString=AT&FW2&C1&D3&K3&Q5S7=60S36=7S46=138S48=7S95=47
BPS=19200

Hayes ACCURA 96 EC (V.42bis)

InitString=AT&FW2&C1&D3&K3&Q5S7=60S36=7S46=138S48=7S95=47
BPS=38400

Hayes ACCURA 144 EC (V.42bis)

InitString=AT&FW2&C1&D3&K3&Q5S7=60S36=7S46=138S48=7S95=47
BPS=57600

Hayes ACCURA 288 V.FC + FAX

InitString=AT&FW2&C1&D3&K3&Q5S7=60S36=7S46=138S48=7S95=47
BPS=57600

Hayes ACCURA 288 V.34 + FAX

InitString=AT&FW2&C1&D3&K3&Q5S7=60S36=7S46=138S48=7S95=47
BPS=57600

Hayes ISDN TA 2.0 (ISDN 56k)

InitString=AT&F%A1=0%A2=2%A4=1%A0=2W1&D2&K3
BPS=57600

Hayes ISDN TA 2.0 (ISDN 64k)

InitString=AT&F%A1=0%A2=2%A4=0%A0=2W1&D2&K3
BPS=57600

IBM 7851 14.4Kbps External Data/Fax Modem

InitString=AT&FW2&C1&D3&K3&Q5%C3\N3S7=60S36=7S46=138S95=47
BPS=57600

IBM 7852 Model 10 28.8Kbps External Data/Fax Modem

InitString=AT&FW2&C1&D3&K3&Q5%C3S7=60S36=7S46=138S48=7S95=44
BPS=115200

IBM 7852 Model 13 28.8Kbps External Data/Fax Modem

InitString=AT&F&C1&D3S7=30
BPS=115200

IBM 7855 Modem Model 10 (MNP)

InitString=AT&F&C1&D2\N3\Q2\V1%C1S7=60
BPS=19200

IBM Data/Fax Modem PCMCIA (V.42bis)

InitString=AT&F&C1&D3&K3&Q5%C3\N3S7=60S38=7S46=138S48=7S95=47
BPS=57600

IBM Mwave 14.4 Modem (V.42bis)

InitString=AT&F
BPS=57600

IBM Mwave 28.8 PCMCIA V3.0 (V.42bis)

InitString=AT&FX4&C1&D3\N7\Q3"H3S7=60
BPS=115200

IBM MWave V.34 DSP (2.0 FlashRom)

InitString=AT&F
BPS=57600

IBM Thinkpad 701C/701CS (V.42bis)

InitString=AT&FX4&C1&D3&K3&Q6\N7\Q3%C1S7=60
BPS=57600

IBM WaveRunner with Async-to-Sync driver

InitString=AT&FV1X4Y0&D3%C1
BPS=115200

IBM WaveRunner (WinISDN)

InitString=ATZ
BPS=115200
Port Driver=pdwisdn.386
WinISDN=ibmisdn.dll

Identity ID9632E

InitString=AT&F&C1&D3S7=60
BPS=9600

Identity FM144BR

InitString=AT&F&C1&D3Q0V1B8S7=60
BPS=57600

Infotel V.42X (V.42bis)

InitString=AT&F&C1&D3S7=30S36=7
BPS=9600

Infotel V.32 turbo (V.42bis)

InitString=AT&FW1&C1&D3&K3&Q5S7=60
BPS=38400

Infotel 144I (V.42bis)

InitString=AT&F&C1&D3&K3&Q5\N3%C1S7=60S36=7S46=138S48=7S95=47
BPS=38400

Infotel 1414QVE (V.32bis)

InitString=AT&F&D3&K3&Q5\J0\N3%C3S7=60S36=7
BPS=38400

Infotel V.34

InitString=AT&FQ0W2&C1&D3/N3S7=60S95=43
BPS=57600

Intel 2400 EX (no MNP or V.42)

InitString=AT&F&C1&D3S7=60
BPS=2400

Intel 2400 EX (MNP 5)

InitString=AT&F&C1&D3\N3%C1\J0\Q2S7=60
BPS=4800

Intel 9600 EX (V.42bis)

InitString=AT&F&C1&D3\J0\N3\Q2\V2%C1"H3S7=60
BPS=38400

Intel 144/144E Data/Fax

InitString=AT&F&D2E0\N3\V2\Q2\G0\J0M0S7=60
BPS=57600

Intel 14400 EX (V.42bis)

InitString=AT&F&C1&D3\J0\N3\Q2\V2%C1"H3S7=60
BPS=38400

Intel SatisFAXtion Modem/400 and 400e (V.42bis)

InitString=AT&F&C1&D3\J0\N3\Q1\V2%C1"H3S7=60
BPS=57600

Intel DM-2814H (v.34)

InitString=AT&FX4&C1&D3&N14&K3&Q5%C1\J0\N3\Q3S7=60S95=1
BPS=115200

Intel PCMCIA Faxmodem 96/96 (Release 2)

InitString=AT&F&C1&D3&Q5\N3\Q3%C3S7=60S36=7S46=138S48=7S95=47
BPS=57600

Intel PCMCIA Faxmodem 96/96 (Release 3)

InitString=AT&F&C1&D3&K3&Q5\N3%C3S7=60S36=7S46=138S48=7S95=47
BPS=57600

Intel PCMCIA Faxmodem 14.4/14.4 (Release 2)

InitString=AT&FW2&C1&D3\N3\Q3%C3S7=60S95=47
BPS=57600

Intel PCMCIA Faxmodem 14.4/14.4 (Release 3)

InitString=AT&FW2&C1&D3&K3\N3%C3S7=60S95=47
BPS=57600

IRE-AX400 Secure Notebook Modem (V.42 bis)

InitString=AT&F&C1&D3
BPS=19200

ISDN*tek CyberSpace Card (WinISDN)

InitString=ATZ
BPS=115200
Port Driver=pdvwisdn.386
Device Driver=vwinisdn.386

LASAT Credit Card 288 PCMCIA

InitString=AT&FW2X4&C1&D3&K3&Q5%C3\N3S7=60
BPS=57600

Logicode QuickTel 144

InitString=AT&F&C1&D3&K3&M0&Q5\N3%C3S7=60
BPS=57600

Logicode QuickTel 288

InitString=AT&F&C1&D3&K3&M0&Q5\N3%C3S7=60
BPS=57600

Macronix MaxFax 9624LT-S

InitString=AT&F&C1&D3&K3&Q9\J0\N3\Q3%C1S7=60S36=7S46=138S48=7S95=47
BPS=9600

Matra Com 814 V14e 57600 (ISDN)

InitString=ATZ
BPS=57600

Maestro 14.4

InitString=AT&FE1Q0V1X4&C1&D3&K3%C3&Q5S95=1S7=60
BPS=57600

Maestro 28.8

InitString=AT&FE1Q0V1X4&C1&D3&K3%C3&Q5S95=1S7=60
BPS=115200

Maxtech 14.4

InitString=AT&FX4&C1&D3%C1\N3\Q3S7=60
BPS=57600

Maxtech XM288e

InitString=AT&F&C1&D3\N6\Q3\J0\V1%C1S7=60
BPS=115200

Mayze 96/96R

InitString=AT&F&Q13&S2%R0-E3%K3"U17
BPS=19200

Megahertz CC4144

InitString=AT&FW1&X4&C1&D3*K3&M0&Q5\N3%C3S7=60S36=7
BPS=57600

Megahertz CC4188 PCMCIA card modem

InitString=AT&C1&D3&F6&K3\N3%C1S0=0S7=60
BPS=57600

Megahertz P2144 FAX/Modem (V.42bis)

InitString=AT&F&C1&D3%C1\J0\N7\Q2\V2S7=60
BPS=38400

Megahertz T3144 internal (V.42bis)

InitString=AT&F&C1&D3%C1\J0\N3\Q2\V2S7=60
BPS=57600

Megahertz T324FM internal (V.42bis)

InitString=AT&F&C1&D3%C1\J0\N3\Q2\V1S7=60S46=138S48=7
BPS=9600

Megahertz T396FM internal (V.42bis)

InitString=AT&FW2&C1&D3%C1\J0\N7\Q2\V2S7=60
BPS=38400

Megahertz CC3144 PCMCIA card modem (V.42bis)

InitString=AT&F&C1&D3&K3&Q5%C3\N3S7=60S38=7S46=138S48=7S95=47
BPS=57600

Megahertz XJ196FM PCMCIA card modem

InitString=AT&FX4&C1&D3&K3&Q5\N3%C3S7=60S95=47
BPS=38400

Megahertz XJ1144 PCMCIA card modem

InitString=AT&F&C1&D3&K3%C3\N3S7=60S46=138S95=47
BPS=57600

Megahertz XJ2144 PCMCIA card modem

InitString=AT&FW2X4&C1&D3&K3&Q5%C3\N3S7=60S36=7S95=0
BPS=57600

Megahertz XJ2288 PCMCIA card modem

InitString=AT&FW2&C1&D3&K3\J0\N3\Q3\V1%C1"H3S7=60
BPS=57600

Megahertz XJ3144 PCMCIA Card Modem

InitString=AT&F&C1&D2&K3%C3\N3S7=60
BPS=57600

Megahertz XJ4288 PCMCIA (v.34)

InitString=AT&FW1&C1&D3&K3V1%C3S7=60
BPS=115200

Megahertz CC4288 PCMCIA

InitString=AT&FW2&C1&D3&K3V1%C3S7=60+FCLASS=0
BPS=115200

Megahertz XJ4288/CC4288 PCMCIA (v.34)

InitString=AT&F0W2X4&C1&D3&K3&Q5%C3S7=60S36=7
BPS=115200

Micro Direct 28.8

InitString=AT&FW2X4&C1&D3&Q5\N3S7=60
BPS=57600

Microcom AX/1200 and AX/2400 (MNP 4)

InitString=AT&F&C1&D3\J0\N3\Q2S7=60
BPS=9600

Microcom AX/1200c and AX/2400c (MNP 5)

InitString=AT&F&C1&D3\J0\N3\Q2%C1S7=60
BPS=9600

Microcom AX/9624c (MNP 5)

InitString=AT&F&C1&D3\G0\J0\N3\Q2%C1S7=60
BPS=9600

Microcom AX/9600 Plus (MNP 5)

InitString=AT&F&C1&D3\J0\N3\Q2S7=60
BPS=19200

Microcom QX/V.32c (MNP 5)

InitString=AT&F&C1&D3\J0%C3\N3\Q2S7=60
BPS=38400

Microcom QX/4232hs (V.42bis)

InitString=AT&F&C1&D3\J0%C3\N3\Q2-K0\V2S7=60
BPS=38400

Microcom QX/4232bis (V.42bis)

InitString=AT&F&C1&D3\J0%C3\N3\Q2-K0\V2W2S7=60
BPS=38400

Microcom MicroPorte 542 (V.42bis)

InitString=AT&F&C1&D3&Q5S7=60S46=138S48=7S95=47
BPS=9600

Microcom MicroPorte 1042 (V.42bis)

InitString=AT&F&C1&D3%C3\J0-M0\N6\Q2\V2S7=60
BPS=9600

Microcom MicroPorte 4232bis (V.42bis)

InitString=AT&F&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=38400

Microcom DeskPorte V.32bis

InitString=AT&F&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=57600

Microcom DeskPorte FAST

InitString=AT&F&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=57600

Microcom DeskPorte FAST (57600 BPS)

InitString=AT&F$B57600&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=57600

Microcom DeskPorte FAST (115200 BPS)

InitString=AT&F$B115200&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=115200

Microcom DeskPorte FAST ES 28.8

InitString=AT&FW2&C1&D3&K3&Q5%C3\N3S7=60S95=47
BPS=57600

Microcom TravelCard 28.8

InitString=AT&F&C1&D2%C3%G0\J0\N3\Q3\X4S7=60
BPS=57600

Microcom TravelCard FAST

InitString=AT&F&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=57600

Microcom TravelPorte FAST

InitString=AT&F&C1&D3%C3%G0\J0-M0\N6\Q2\V2S7=60
BPS=57600

Motorola BitSurfer

InitString=AT&FW1&M&C1&D3%A2=95
BPS=57600

Motorola BitSurfer Pro

InitString=AT&F1W1&C1&D3@B0=1%A4=0%A2=95
BPS=115200

Motorola BitSurfer Pro (MultiLink)

InitString=AT&F1W1&C1&D3@B0=2%A4=0%A2=95
BPS=115200

Motorola/Codex 3220 (MNP)

InitString=AT&F&C1&D3*DC1*FL3*MF0*SM3*XC2S7=60
BPS=19200

Motorola/Codex 3220 Plus (V.42bis)

InitString=AT&F&C1&D3*DC1*EC0*MF0*SM3*XC2S7=60
BPS=38400

Motorola/Codex 326X Series (V.42bis)

InitString=AT&F&C1&D3*FL3*MF0*SM3*TT2*XC2S7=60
BPS=38400

Motorola/Codex 2264

InitString=AT&F&C1&D3*FL3*ML0*SM3*XC1
BPS=19200

Motorola DMPD (V.34)

InitString=AT&FX4&C1&D3\Q2%C1\N7S7=60
BPS=115200

Motorola V.34R

InitString=AT&FW2&C1&D3\N7\Q3\V1%C1S7=60
BPS=57600

Motorola Lifestyle 28.8

InitString=AT&F&C1&D3\Q3%R3\V2S7=60
BPS=57600

Motorola ModemSURFR 28.8

InitString=AT&FW2&C1&D3\J0\N3\Q3\V1%C1"H3S7=60
BPS=57600

Motorola Power 28.8

InitString=AT&F&C1&D3\Q3%R3\V2S7=60
BPS=57600

Motorola TA 210 (ISDN)

InitString=AT&FW1&M&C1
BPS=57600

Motorola UDS FastTalk II

InitString=AT&F&C1&D3E1V1X4Q0\J0\N6\Q3%C1S7=60
BPS=57600

Motorola UDS V.3400

InitString=AT&FX4W2&C1&D3&M0\J0\N7\Q3%C1
BPS=57600

Motorola UDS UTA 220K (ISDN)

InitString=AT&F&C1&D2&K3&M1@P2=13S0=1%A2=0&W
BPS=38400

MultiTech MultiModem 224 (no MNP or V.42)

InitString=AT&FX2&C1&D3&R1S7=60
BPS=2400

MultiTech MultiModem 224E (MNP 5)

InitString=AT&F&C1&D3&R0&E1&E4&E12&E15$BA0S7=60
BPS=4800

MultiTech MultiModem V32EC (V.42bis)

InitString=AT&FX4&C1&D3$BA0&E1&E4&E15#L0S7=60
BPS=38400

MultiTech MultiModem V32 (no MNP or V.42)

InitString=AT&F&C1&D3S7=60
BPS=9600

MultiTech MultiModem 696E (MNP)

InitString=AT&F&C1&D3$BA0&E1&E4&E15S7=60
BPS=19200

MultiTech MultiModem MT2834LT

InitString=AT&FX4&Q1&C1&D3#A0$BA0&E1&E4&E15#L0S7=60S48=0
BPS=115200

MultiTech MultiModem II MT932 (V.42bis)

InitString=AT&FX4&C1&D3$BA0&E1&E4&E15#L0S7=60
BPS=38400

MultiTech MultiModem II MT1432 (V.42bis)

InitString=AT&FX4&C1&D3#A0$BA0&E1&E4&E15#L0S7=60
BPS=57600

MultiTech MultiModem II MT1932ZDX

InitString=AT&FX4&C1&D3$BA0&E1&E4&E15#L0S7=60
BPS=38400

MultiTech MultiModem II MT2834BA

InitString=AT&F&C1&D3#A0$BA0E1&E1&E15#L0V1X4S7=60
BPS=57600

MultiTech MultiModem II MT2834BR

InitString=AT&FX4&C1&D3#A0$BA0&E1&E4&E15#L0V1S7=60
BPS=57600

MultiTech MultiModem II MT2834ZDX V.34

InitString=AT&F&D3#T0X4S7=60
BPS=57600

NEC I9632E

InitString=AT&F&C1&D3\J0\N3\Q2\V1%C1S7=60
BPS=38400

NEC PCMCIA 144 Modem

InitString=AT&F&C1&D3\N7\Q3%C1S7=60
BPS=57600

NEC UltraLite 14.4 Data/Fax Modem (V.42bis)

InitString=AT&F&C1&D3&K3&Q4\J0\N7\Q2W2%C1S7=60
BPS=38400

NetComm CardModem V.32bis

InitString=AT&FE1Q0V1X4&C1&D3W2&K3&Q5\N3%C3S7=60
BPS=57600

NetComm CardModem V.34

InitString=AT&FE1Q0V1X4&C1&D3W2&K3&Q5\N3%C3S7=60
BPS=115200

NetComm M11F 28.8

InitString=AT&FQ0V1X5&C1&D2&E2&K3&R0\J0\N3%C3%T0S7=60
BPS=57600

NetComm M34F 28.8

InitString=AT&FQ0V1X4&C1&D3&E2&K3&R0\J0\N3%C3%T0S7=60
BPS=115200

NetComm Smartmodem 288

InitString=AT&FQ0V1X4&C1&D3&E2&K3&R0\J0\N3%C3%T0S7=60
BPS=115200

NetComm Roadster 14.4

InitString=AT&FE1Q0V1X4&C1&D3
BPS=57600

NetComm Roadster 28.8

InitString=AT&FE1Q0V1X4&C1&D3
BPS=57600

New Media 144 PCMCIA Data/Fax

InitString=AT&F&C1&D3-J0\J0\N3\Q3"H3S7=60
BPS=57600

Nokia DTP-2 PCMCIA-Cellular (v.32)

InitString=AT&FX4&C1&D3S7=60S34=2
BPS=19200

Noteworthy NM288CR PCMCIA (V.34)

InitString=AT&FW1X4&C1&D3&K3&Q5%C1S7=60
BPS=38400

Noteworthy T144NWX

InitString=AT&FW2&C1&D3&Q5\N3\Q3\V2%C3S7=60S36=7S46=138S48=7
BPS=57600

Olicom GoCard Modem 28800

InitString=AT&F&C1&D2&K6%C3S7=60
BPS=57600

Pace MicroLin fx 32 Plus

InitString=AT&F&C1&D3&K3\J0\N3%C3S7=60S36=7S95=47
BPS=57600

Piiceon Dispatcher (V.42bis)

InitString=AT&F&C1&D3&K3&Q5%C3\J0\N3S7=60S36=7S48=7S95=47
BPS=57600

Practical Peripherals PM2400SA (no MNP or V.42)

InitString=AT&F&C1&D3S7=60
BPS=2400

Practical Peripherals PM2400SA (V.42bis)

InitString=AT&F&C1&D3&K3&Q5S7=60
BPS=9600

Practical Peripherals PM2400PPM (no MNP or V.42)

InitString=AT&F&C1&D3S7=60
BPS=2400

Practical Peripherals PM9600SA (V.42bis)

InitString=AT&F&C1&D3&K3&Q5S46=138S48=7S7=60
BPS=38400

Practical Peripherals PM144MT II MiniTower

InitString=AT&FW2X4&Q5&C1&D3S7=60S95=47
BPS=57600

Practical Peripherals PM14400FX (V.42bis)

InitString=AT&F&C1&D3&K3&Q5S7=60S36=7S46=2S48=7S95=47
BPS=57600

Practical Peripherals PM144HC II

InitString=AT&FW2&C1&D3&K3&Q5S7=60S36=7S46=2S48=7S95=47
BPS=57600

Practical Peripherals PM14400SA (V.42bis)

InitString=AT&F&C1&D3&K3&Q5S7=60S36=7S46=2S48=7S95=47
BPS=57600

Practical Peripherals PractiCard 144

InitString=AT&F&C1&D3&K3&Q5S7=60S36=7S46=2S48=7S95=47
BPS=57600

Practical Peripherals ProClass 28800 V.FC

InitString=AT&F&C1&D3E1Q0X4&K3S7=60
BPS=57600

Practical Peripherals ProClass 28800 V.34

InitString=AT&F&C1&D3E1Q0X4&K3S7=60
BPS=57600

Practical Peripherals ProClass PCMCIA (v.34)

InitString=AT&FX4W2&C1&D3&Q5S7=60
BPS=115200

Practical Peripherals MC144MT II

InitString=AT&FW2&C1&D3&K3&Q5S7=60
BPS=57600

Practical Peripherals MC288MT II V.34

InitString=AT&FW2&C1&D3&K3S7=60
BPS=57600

Practical Peripherals PM288MT II V.34

InitString=AT&F0W2&C1&D3S7=60
BPS=57600

Practical Peripherals PM288PKT

InitString=AT&FW2&K3&C1&D3S7=60
BPS=57600

Prometheus LineLink (V.42bis)

InitString=AT&F&C1&D3&R0\Q3\V1W1
BPS=38400

Prometheus ProModem 2400MNP/2400BMNP (MNP 5)

InitString=AT&F&C1&D3S7=60
BPS=4800

Prometheus ProModem 9600 Plus (V.42)

InitString=AT&F&C1&D3*E7*F3S7=60
BPS=19200

Prometheus ProModem 144e

InitString=AT&FW2&C1&D3&K3&Q5\N6\Q3\V1%C1S7=60
BPS=57600

Prometheus ProModem Ultima (V.42bis)

InitString=AT&F&C1&D3*E9*F3*S1S7=60
BPS=38400

Psion V.34 PCMCIA Modem

InitString=AT&F&C1&D2&K3&Q0%C3\J0\N2S7=60
BPS=57600

Racal Datacom ALM 3223 (V.42bis)

InitString=AT&F&C1&D3\M0\N3\P2\Q1\V1S7=60
BPS=38400

Racal Datacom ALM 3226

InitString=AT&F&C1&D3\N3W1S7=60S24=0S95=1
BPS=57600

Racal Datacom ALM 3239

InitString=AT&F&C1&D3\M0\N3\P2\Q1\V1S7=60
BPS=57600

Racal Datacom RMD 3264

InitString=AT&F&C1&D3\M0\N3\P2\Q1\V1S7=60
BPS=38400

Racal Datacom ALM 3268

InitString=AT&F&C1&D3\M0\N3\P2\Q1\V1S7=60
BPS=57600

S.A.T. 3202S V110 38400 (ISDN)

InitString=AT&FC2E1Q0V1X1&R0&C1S0=2
BPS=38400

S.A.T. 3202S V14e 57600 (ISDN)

InitString=AT&FC2E1Q0V1X1&R0&C1S0=2
BPS=57600

Sanyo Modem MBCNB

InitString=AT&F&C1&D3\J0\N3\Q2\V1%C1S7=60
BPS=9600

Scout 28.8 V.34e

InitString=AT&F&C1&D3&K3&Q5\N3%C3S7=60
BPS=115200

Simplemodem 288

InitString=AT&F&C1&D3&K3X3W0V1N1\N3%C3S7=60S95=2
BPS=115200

Smart ST1414L PCMCIA Data/Fax

InitString=AT&FX4&C1&D3\Q3\N3\V2\J0"H3S7=60
BPS=57600

Spirit II

InitString=AT&F&C1&D3*E9*F3*N6*S1S7=60
BPS=57600

Spirit Scorpion

InitString=AT&FE1Q0V1X4&C1&D3
BPS=57600

Spirit Viper V.34

InitString=AT&FE1Q0V1W2X4&C1&D3&K3&Q6\N3%C3S7=60
BPS=115200

Supra SupraModem 2400

InitString=AT&F&C1&D3\J0\N3\Q2\V1%C1S7=30
BPS=9600

Supra SupraModem 2400 MNP (MNP 5)

InitString=AT&F&C1&D3S7=60
BPS=2400

Supra SupraModem 2400 Plus (V.42bis)

InitString=AT&F&C1&D3\J0\N3\Q2\V2-J1%C1"H3S7=60
BPS=9600

Supra FAXModem V.32bis (V.42bis)

InitString=AT&F2N1W2&C1&D3&K3&Q5%C1S7=60
BPS=57600

Supra FAXModem 144 LC

InitString=AT&FN1W2&C1&D1&K3&Q5\N3%C1S7=60S36=7S48=7S95=45
BPS=57600

Supra FAXModem 28.8

InitString=AT&FN1W2&C1&D1&K3&Q5\N3%C1S7=60S36=7S48=7S95=45
BPS=57600

SupraExpress 144i

InitString=AT&F2W2X4&C1&D3W3\N3%C3S7=60S36=7S48=7S95=0
BPS=57600

Supra Express 28.8i

InitString=AT&F2W2&C1&D3%C3S7=60
BPS=115200

Synaptel Syncard 96 ISA/PCMCIA (WinISDN)

InitString=ATZ
BPS=115200
Port Driver=pdvwisdn.386
DeviceDriver=synwisdn.386

Telebit T1600 (V.42bis)

InitString=AT&FX2&C1&D3&R3S7=60S51=6S58=0S59=15S68=2S180=2S190=1
BPS=38400

Telebit T2500 (V.42bis)

InitString=AT~&FX2S7=60S51=5S52=2S66=1S68=2S97=1S98=3S106=1S131=1
BPS=19200

Telebit T3000 (V.42bis)

InitString=AT&FX2&C1&D3S51=6S58=2S59=7S68=2S7=60
BPS=38400

Telebit FastBlazer 8840/8840R

InitString=AT&F&C1&D3&E1&K3S7=60
BPS=57600

Telebit QBlazer (V.42bis)

InitString=AT&FX2&C1&D3S59=7S68=2S7=60
BPS=38400

Telebit QBlazer Plus

InitString=AT&FX2&C1&D3S7=60S59=7S68=2S180=2S190=1
BPS=57600

Telebit TeleBlazer 28.8 (V.34)

InitString=AT&FW2X4&C1&D3&K3%C3\N3S7=60
BPS=57600

Texas Instruments V.32bis Internal Modem

InitString=AT&F&C1&D3%C1\J0\N7\Q2\V2S7=60
BPS=38400

Toshiba T24/DF Internal

InitString=AT&F&C1&D3\J0\N3\Q2%C1S7=60S36=7S46=138S48=7
BPS=9600

Universal Data Systems FasTalk V.32/42b (V.42bis)

InitString=AT&F&C1&D3\J0\M0\N7\V1\Q2%C1S7=60
BPS=38400

Universal Data Systems V.32 (no MNP or V.42)

InitString=AT&F&C1&D2S7=60
BPS=9600

Universal Data Systems V.3224 (MNP 4)

InitString=AT&F&C1&D2\J0\N3\Q2S7=60
BPS=19200

Universal Data Systems V.3225 (MNP 5)

InitString=AT&F&C1&D2\J0\N3\Q2%C1S7=60
BPS=19200

Universal Data Systems V.3227 (V.42bis)

InitString=AT&F&C1&D2\J0\M0\N7\Q2%C1S7=60
BPS=38400

Universal Data Systems V.3229 (V.42bis)

InitString=AT&F&C1&D3\J0\M0\N7\Q2%C1S7=60
BPS=38400

US Robotics Sportster 2400 (no MNP or V.42)

InitString=AT&F&C1&D3S7=60
BPS=2400

US Robotics Sportster 2400 (MNP 5)

InitString=AT&F&C1&D3&B6&H1&I0&K1&M4S7=60
BPS=9600

US Robotics Sportster 2400 (V.42bis)

InitString=AT&FX4&A3&B1&H1&K2&M4S7=60
BPS=19200

US Robotics Sportster 9600 (V.42bis)

InitString=AT&FX4&A3&B1&D3&H1&I0&K1&M4S7=60
BPS=38400

US Robotics Sportster 14400 (V.42bis)

InitString=AT&FX4&A3&B1&D2&H1&I0&K1&M4S7=60
BPS=57600

US Robotics Sportster 14400 PCMCIA

InitString=AT&FE1Q0V1X4&C1&D2&H1&K2&M4S7=60
BPS=57600

US Robotics Sportster 28800

InitString=AT&FX4&A3&B1&D2&H1&I0&K1&M4S7=60
BPS=57600

US Robotics Sportster 28.8-33.6

InitString=AT&F1&B1&D2&H1&I0&K1&M4S13=1S27=48
BPS=115200

US Robotics Sportster PCMCIA 28800

InitString=AT&F&C1&D3&B1&M4&K2&A3S7=60
BPS=115200

US Robotics Sportster Voice 33.6 fax

InitString=AT&F&C1&D2&K1&H1S7=60
BPS=57600

US Robotics Sportster 128K (WinISDN)

InitString=ATZ
BPS=115200
Port Driver=pdvwisdn.386
DeviceDriver=vwinisdn.vxd

US Robotics Courier 2400 (no MNP or V.42)

InitString=ATZX4S7=60
BPS=2400

US Robotics Courier 2400e (MNP 4)

InitString=AT&F&M4&H1&I0&B6&N0S7=60
BPS=9600

US Robotics Courier V.32bis (V.42bis)

InitString=AT&FX4&A3&C1&D2&M4&H1&K1&B1
BPS=38400

US Robotics Courier HST Dual Standard (V.42bis)

InitString=AT&FB0X4&A3&C1&D2&M4&H1&K1&B1
BPS=38400

US Robotics Courier HST (V.42bis)

InitString=AT&FB0X4&A3&C1&D2&M1&H1&K1&B1
BPS=9600

US Robotics Courier V.FC/V.34

InitString=AT&FB0X4&A3&C1&D2&M4&H1&K1&B1S7=60
BPS=57600

US Robotics WorldPort 2400 (no MNP or V.42bis)

InitString=AT&FX4&C1&D3S7=60
BPS=2400

US Robotics WorldPort 2400 (V.42bis)

InitString=AT&FX4&C1&D3%C1"H3\J0-J1\N3\Q2\V2S7=60
BPS=9600

US Robotics WorldPort 2496 FAX/Data (V.42bis)

InitString=AT&FX4&C1&D3%C1"H3\J0-J1\N3\Q2\V2S7=60
BPS=9600

US Robotics WorldPort 9696 FAX/Data (MNP 5)

InitString=AT&FX4&C1&D3%C1\J0\N3\Q2\V2S7=60
BPS=19200

US Robotics WorldPort 9600 (MNP 5)

InitString=AT&FX4&C1&D3%C1\J0\N3\Q2\V2S7=60
BPS=19200

US Robotics WorldPort 14400 (V.42bis)

InitString=AT&FX4&A3&B1&C1&D3&H1&K1&M4S7=60
BPS=57600

US Robotics WorldPort FAX/Data PCMCIA 2.0

InitString=AT&FX4&C1&D3&K3\J0\N3%C3S7=60S95=47
BPS=57600

Ven-Tel EC2400-33 (MNP)

InitString=AT&F&C1&D3%C1\J0\N3\Q2S7=60
BPS=9600

Ven-Tel PCM 9600 Plus (MNP)

InitString=AT&FB0&C1&D3\N3\Q3%B0%C1%F1S7=60
BPS=19200

ViVa 9642e (V.42bis)

InitString=AT&F&C1&D3&K3&Q5\N3%C3S7=60S36=7S46=138S48=7S95=47
BPS=38400

ViVa 14.4/FAX (V.42bis)

InitString=AT&F&C1&D3&K3&Q5\N3%C3S7=60S36=7S46=138S48=7S95=47
BPS=38400

Wang 14/14i Data Fax Modem

InitString=AT&F&C1&D3&K3&Q5\N3%C1S7=60S36=7S46=138S48=7S95=37
BPS=38400

WinBook XP Internal Modem

InitString=AT&FX4&C1&D2\C2\J0\N3\Q3\V2%C1"H3S7=60
BPS=38400

Xircom CreditCard Ethernet+Modem II

InitString=AT&F&C1&D3&K3%C1%E1N1\N3Q0\Q3S7=60S36=7
BPS=57600

Xircom CreditCard Ethernet+Modem 28.8

InitString=AT&FW2&C1&D3&K3%C1%E1N1\N3Q0\Q3S7=60S36=7
BPS=115200

Xircom CreditCard Modem 28.8

InitString=AT&FW2&C1&D3&K3%C1%E1N1\N3Q0\Q3S7=60S36=7
BPS=57600

Xircom EtherNet/Modem CEM10BT 144 (V.42bis)

InitString=AT&F&C1&D3%C1%E1&K3N1\N3Q0\Q3S7=60S36=7
BPS=57600

Xircom EtherNet/Modem CEM2-10BT 144 (V.42bis)

InitString=AT&FE1&C1&D3%C1%E1&K3N1\N3Q0\Q3S7=60S36=7
BPS=57600

ZAT Modem 14.4/14.4-7

InitString=AT&F&C1+C1&D3\N3\Q3+Q3%C1+PC1S7=60
BPS=38400

ZOOM MX2400R (no MNP or V.42)

InitString=AT&F&C1&D3S7=30
BPS=2400

ZOOM 2400/V.42bis (V.42bis)

InitString=AT&F&C1&D3S7=30S36=7
BPS=9600

ZOOM V.32 turbo (V.42bis)

InitString=AT&FW1&C1&D3&K3&Q5%C1\N3S7=60S36=7S46=138S48=7S95=47
BPS=38400

ZOOM V.32bis (V.42bis)

InitString=AT&FW1&C1&D3&K3&Q9%C1\N3S7=60S36=7S95=47
BPS=38400

ZOOM V.34 Model 470

InitString=AT&FW2M0&C1&D3&K3%C3\N3S7=60S95=1
BPS=57600

ZOOM FaxModem 14.4 PC

InitString=AT&F&C1&D3&K3S7=60S36=7S46=138S48=7S95=47
BPS=57600

ZOOM FaxModem 14.4 EX (V.42bis)

InitString=AT&FW1&C1&D3&K3N1X4S7=60S95=47
BPS=57600

ZOOM FaxModem V.34X+ (2836)

InitString=AT&FW2&C1&D3&K3&Q5%C3\N3S7=60S46=138S95=8
BPS=115200

ZOOM FaxModem VFP 288

InitString=AT&FW2X4&C1&D3&S1%C3\N3S7=60S36=7S95=1
BPS=57600

ZOOM FaxModem VFX V.32bis

InitString=AT&F&C1&D3&K3&Q5%C3\N3S7=60S36=7S46=138S48=7S95=47
BPS=57600

ZOOM FaxModem VFX 24K

InitString=AT&F&C1&D3&K3&Q5%C3\N3S7=60S36=7S46=138S48=7S95=47
BPS=57600

Zoom VFX 28.8 FaxModem

InitString=AT&F&C1&D3&Q5W2\N3S7=60
BPS=57600

Zyxel Elite 2864I (ISDN)

InitString=ATB40&W&C1&D2&H3
BPS=57600

Zyxel Omni 288S

InitString=AT&FX6&D3&H3&K4&B1&C1&N0S7=60
BPS=57600

Zyxel U-1496 (V.42bis)

InitString=AT&FX6&B1&C1&D2&N0&K4&H3S7=60
BPS=57600

Generic and un-named modem strings

14400 bps Modem

InitString=AT&F&C1&D2S7=60
BPS=38400

19200 bps Modem

InitString=AT&F&C1&D2S7=60
BPS=38400

28800 bps Modem

InitString=AT&F&C1&D2S7=60
BPS=57600

Null Modem (Direct wire crossover)

InitString=None
Direct=Yes


PT100

PT100 is intended as an aid for anyone who uses platinum resistance
thermometers. It will calculate the resistance of a PRT at any temperature
within the specified range or will calculate the temperature if the
resistance is known. PRT Calc can, therefore, be used by people calibrating
or designing platinum resistance thermometers based on BS 1904, or people who
wish to use PRT sensors directly into a DVM or bridge without any intervening
electronics.


Modbus Protocol

Chapter 1 Modbus Protocol

Chapter 2 Data and Control Functions

Chapter 3 Diagnostic Subfunctions

Chapter 4 Exception Responses

Chapter 5 Application Notes

Chapter 6 LRC / CRC Generation


Modbus Protocol

Chapter 1
Modbus Protocol

V [image] Introducing Modbus Protocol

V [image] Two Serial Transmission Modes

V [image] Modbus Message Framing

V [image] Error Checking Methods

1.1 Introducing Modbus Protocol

Modicon programmable controllers can communicate with each other and with other devices over a variety of networks. Supported networks include the Modicon Modbus and Modbus Plus industrial networks, and standard networks such as MAP and Ethernet. Networks are accessed by built-in ports in the controllers or by network adapters, option modules, and gateways that are available from Modicon. For original equipment manufacturers, Modicon ModConnect partner programs are available for closely integrating networks like Modbus Plus into proprietary product designs.

The common language used by all Modicon controllers is the Modbus protocol. This protocol defines a message structure that controllers will recognize and use, regardless of the type of networks over which they communicate. It describes the process a controller uses to request access to another device, how it will respond to requests from the other devices, and how errors will be detected and reported. It establishes a common format for the layout and contents of message fields.

The Modbus protocol provides the internal standard that the Modicon controllers use for parsing messages. During communications on a Modbus network, the protocol determines how each controller will know its device address, recognize a message addressed to it, determine the kind of action to be taken, and extract any data or other information contained in the message. If a reply is required, the controller will construct the reply message and send it using Modbus protocol.

On other networks, messages containing Modbus protocol are imbedded into the frame or packet structure that is used on the network. For example, Modicon network controllers for Modbus Plus or MAP, with associated application software libraries and drivers, provide conversion between the imbedded Modbus message protocol and the specific framing protocols those networks use to communicate between their node devices.

This conversion also extends to resolving node addresses, routing paths, and error-checking methods specific to each kind of network. For example, Modbus device addresses contained in the Modbus protocol will be converted into node addresses prior to transmission of the messages. Error-checking fields will also be applied to message packets, consistent with each network's protocol. At the final point of delivery, however-for example, a controller-the contents of the imbedded message, written using Modbus protocol, define the action to be taken.

Figure 1 shows how devices might be interconnected in a hierarchy of networks that employ widely differing communication techniques. In message transactions, the Modbus protocol imbedded into each network's packet structure provides the common language by which the devices can exchange data.

Figure 1 Overview of Modbus Protocol Application

1.1.1 Transactions on Modbus Networks

Standard Modbus ports on Modicon controllers use an RS-232C compatible serial interface that defines connector pinouts, cabling, signal levels, transmission baud rates, and parity checking. Controllers can be networked directly or via modems.

Controllers communicate using a master-slave technique, in which only one device (the master) can initiate transactions (queries). The other devices (the slaves) respond by supplying the requested data to the master, or by taking the action requested in the query. Typical master devices include host processors and programming panels. Typical slaves include programmable controllers.

The master can address individual slaves, or can initiate a broadcast message to all slaves. Slaves return a message (response) to queries that are addressed to them individually. Responses are not returned to broadcast queries from the master.

The Modbus protocol establishes the format for the master's query by placing into it the device (or broadcast) address, a function code defining the requested action, any data to be sent, and an error-checking field. The slave's response message is also constructed using Modbus protocol. It contains fields confirming the action taken, any data to be returned, and an error-checking field. If an error occurred in receipt of the message, or if the slave is unable to perform the requested action, the slave will construct an error message and send it as its response.

1.1.2 Transactions on Other Kinds of Networks

In addition to their standard Modbus capabilities, some Modicon controller models can communicate over Modbus Plus using built-in ports or network adapters, and over MAP, using network adapters.

On these networks, the controllers communicate using a peer-to-peer technique, in which any controller can initiate transactions with the other controllers. Thus a controller may operate either as a slave or as a master in separate transactions. Multiple internal paths are frequently provided to allow concurrent processing of master and slave transactions.

At the message level, the Modbus protocol still applies the master-slave principle even though the network communication method is peer-to-peer. If a controller originates a message, it does so as a master device, and expects a response from a slave device. Similarly, when a controller receives a message it constructs a slave response and returns it to the originating controller.

1.1.3 The Query-Response Cycle

Figure 2 Master-Slave Query-Response Cycle

The Query

The function code in the query tells the addressed slave device what kind of action to perform. The data bytes contain any additional information that the slave will need to perform the function. For example, function code 03 will query the slave to read holding registers and respond with their contents. The data field must contain the information telling the slave which register to start at and how many registers to read. The error check field provides a method for the slave to validate the integrity of the message contents.

The Response

If the slave makes a normal response, the function code in the response is an echo of the function code in the query. The data bytes contain the data collected by the slave, such as register values or status. If an error occurs, the function code is modified to indicate that the response is an error response, and the data bytes contain a code that describes the error. The error check field allows the master to confirm that the message contents are valid.

1.2 Two Serial Transmission Modes

Controllers can be setup to communicate on standard Modbus networks using either of two transmission modes: ASCII or RTU. Users select the desired mode, along with the serial port communication parameters (baud rate, parity mode, etc), during configuration of each controller. The mode and serial parameters must be the same for all devices on a Modbus network.

The selection of ASCII or RTU mode pertains only to standard Modbus networks. It defines the bit contents of message fields transmitted serially on those networks. It determines how information will be packed into the message fields and decoded.

On other networks like MAP and Modbus Plus, Modbus messages are placed into frames that are not related to serial tranasmission. For example, a request to read holding registers can be handled between two controllers on Modbus Plus without regard to the current setup of either controller's serial Modbus port.

1.2.1 ASCII Mode

When controllers are setup to communicate on a Modbus network using ASCII (American Standard Code for Information Interchange) mode, each eight-bit byte in a message is sent as two ASCII characters. The main advantage of this mode is that it allows time intervals of up to one second to occur between characters without causing an error.

Coding System

V Hexadecimal, ASCII characters 0 ... 9, A ... F

V One hexadecimal character contained in each ASCII character of the message

Bits per Byte

V 1 start bit

V 7 data bits, least significant bit sent first

V 1 bit for even / odd parity-no bit for no parity

V 1 stop bit if parity is used-2 bits if no parity

Error Check Field

V Longitudinal Redundancy Check (LRC)

1.2.2 RTU Mode

When controllers are setup to communicate on a Modbus network using RTU (Remote Terminal Unit) mode, each eight-bit byte in a message contains two four-bit hexadecimal characters. The main advantage of this mode is that its greater character density allows better data throughput than ASCII for the same baud rate. Each message must be transmitted in a continuous stream.

Coding System

V Eight-bit binary, hexadecimal 0 ... 9, A ... F

V Two hexadecimal characters contained in each eight-bit field of the message

Bits per Byte

V 1 start bit

V 8 data bits, least significant bit sent first

V 1 bit for even / odd parity-no bit for no parity

V 1 stop bit if parity is used-2 bits if no parity

Error Check Field

V Cyclical Redundancy Check (CRC)

1.3 Modbus Message Framing

In either of the two serial transmission modes (ASCII or RTU), a Modbus message is placed by the transmitting device into a frame that has a known beginning and ending point. This allows receiving devices to begin at the start of the message, read the address portion and determine which device is addressed (or all devices, if the message is broadcast), and to know when the message is completed. Partial messages can be detected and errors can be set as a result.

On networks like MAP or Modbus Plus, the network protocol handles the framing of messages with beginning and end delimiters that are specific to the network. Those protocols also handle delivery to the destination device, making the Modbus address field imbedded in the message unnecessary for the actual transmission. (The Modbus address is converted to a network node address and routing path by the originating controller or its network adapter.)

1.3.1 ASCII Framing

In ASCII mode, messages start with a colon ( : ) character (ASCII 3A hex), and end with a carriage return-line feed (CRLF) pair (ASCII 0D and 0A hex).

The allowable characters transmitted for all other fields are hexadecimal 0 ... 9, A ... F. Networked devices monitor the network bus continuously for the colon character. When one is received, each device decodes the next field (the address field) to find out if it is the addressed device.

Intervals of up to one second can elapse between characters within the message. If a greater interval occurs, the receiving device assumes an error has occurred. A typical message frame is shown below.

Figure 3 ASCII Message Frame

Exception

With the 584 and 984A/B/X controllers, an ASCII message can normally terminate after the LRC field without the CRLF characters being sent. An interval of at least one second must then occur. If this happens, the controller will assume that the message terminated normally.

1.3.2 RTU Framing

In RTU mode, messages start with a silent interval of at least 3.5 character times. This is most easily implemented as a multiple of character times at the baud rate that is being used on the network (shown as T1-T2-T3-T4 in the figure below). The first field then transmitted is the device address.

The allowable characters transmitted for all fields are hexadecimal 0 ... 9, A ... F. Networked devices monitor the network bus continuously, including during the silent intervals. When the first field (the address field) is received, each device decodes it to find out if it is the addressed device.

Following the last transmitted character, a similar interval of at least 3.5 character times marks the end of the message. A new message can begin after this interval.

The entire message frame must be transmitted as a continuous stream. If a silent interval of more than 1.5 character times occurs before completion of the frame, the receiving device flushes the incomplete message and assumes that the next byte will be the address field of a new message.

Similarly, if a new message begins earlier than 3.5 character times following a previous message, the receiving device will consider it a continuation of the previous message. This will set an error, as the value in the final CRC field will not be valid for the combined messages. A typical message frame is shown below.

Figure 4 RTU Message Frame

1.3.3 How the Address Field is Handled

The address field of a message frame contains two characters (ASCII) or eight bits (RTU). Valid slave device addresses are in the range of 0 ... 247 decimal. The individual slave devices are assigned addresses in the range of 1 ... 247. A master addresses a slave by placing the slave address in the address field of the message. When the slave sends its response, it places its own address in this address field of the response to let the master know which slave is responding.

Address 0 is used for the broadcast address, which all slave devices recognize. When Modbus protocol is used on higher level networks, broadcasts may not be allowed or may be replaced by other methods. For example, Modbus Plus uses a shared global database that can be updated with each token rotation.

1.3.4 How the Function Field is Handled

The function code field of a message frame contains two characters (ASCII) or eight bits (RTU). Valid codes are in the range of 1 ... 255 decimal. Of these, some codes are applicable to all Modicon controllers, while some codes apply only to certain models, and others are reserved for future use.

When a message is sent from a master to a slave device the function code field tells the slave what kind of action to perform. Examples are to read the ON / OFF states of a group of discrete coils or inputs; to read the data contents of a group of registers; to read the diagnostic status of the slave; to write to designated coils or registers; or to allow loading, recording, or verifying the program within the slave.

When the slave responds to the master, it uses the function code field to indicate either a normal (error-free) response or that some kind of error occurred (called an exception response). For a normal response, the slave simply echoes the original function code. For an exception response, the slave returns a code that is equivalent to the original function code with its most significant bit set to a logic 1.

For example, a message from master to slave to read a group of holding registers would have the following function code:

0000 0011		(Hexadecimal 03)

If the slave device takes the requested action without error, it returns the same code in its response. If an exception occurs, it returns:

1000 0011		(Hexadecimal 83)

In addition to its modification of the function code for an exception response, the slave places a unique code into the data field of the response message. This tells the master what kind of error occurred, or the reason for the exception.

The master device's application program has the responsibility of handling exception responses. Typical processes are to post subsequent retries of the message, to try diagnostic messages to the slave, and to notify operators.

1.3.5 Contents of the Data Field

The data field is constructed using sets of two hexadecimal digits, in the range of 00 to FF hexadecimal. These can be made from a pair of ASCII characters, or from one RTU character, according to the network's serial transmission mode.

The data field of messages sent from a master to slave devices contains additional information which the slave must use to take the action defined by the function code. This can include items like discrete and register addresses, the quantity of items to be handled, and the count of actual data bytes in the field.

For example, if the master requests a slave to read a group of holding registers (function code 03), the data field specifies the starting register and how many registers are to be read. If the master writes to a group of registers in the slave (function code 10 hexadecimal), the data field specifies the starting register, how many registers to write, the count of data bytes to follow in the data field, and the data to be written into the registers.

If no error occurs, the data field of a response from a slave to a master contains the data requested. If an error occurs, the field contains an exception code that the master application can use to determine the next action to be taken.

The data field can be nonexistent (of zero length) in certain kinds of messages. For example, in a request from a master device for a slave to respond with its communications event log (function code 0B hexadecimal), the slave does not require any additional information. The function code alone specifies the action.

1.3.6 Contents of the Error Checking Field

Two kinds of error-checking methods are used for standard Modbus networks. The error checking field contents depend upon the method that is being used.

ASCII

When ASCII mode is used for character framing, the error checking field contains two ASCII characters. The error check characters are the result of a Longitudinal Redundancy Check (LRC) calculation that is performed on the message contents, exclusive of the beginning colon and terminating CRLF characters.

The LRC characters are appended to the message as the last field preceding the CRLF characters.

RTU

When RTU mode is used for character framing, the error checking field contains a 16-bit value implemented as two eight-bit bytes. The error check value is the result of a Cyclical Redundancy Check calculation performed on the message contents.

The CRC field is appended to the message as the last field in the message. When this is done, the low-order byte of the field is appended first, followed by the high-order byte. The CRC high-order byte is the last byte to be sent in the message.

Additional information about error checking is contained later in this chapter. Detailed steps for generating LRC and CRC fields can be found in Chapter .

1.3.7 How Characters are Transmitted Serially

When messages are transmitted on standard Modbus serial networks, each character or byte is sent in this order (left to right):

Least Significant Bit (LSB) ... Most Significant Bit
(MSB)

With ASCII character framing, the bit sequence is:

Figure 5 Bit Order (ASCII)

With RTU character framing, the bit sequence is:

Figure 6 Bit Order (RTU)

1.4 Error Checking Methods

Standard Modbus serial networks use two kinds of error checking. Parity checking (even or odd) can be optionally applied to each character. Frame checking (LRC or CRC) is applied to the entire message. Both the character check and message frame check are generated in the master device and applied to the message contents before transmission. The slave device checks each character and the entire message frame during receipt.

The master is configured by the user to wait for a predetermined timeout interval before aborting the transaction. This interval is set to be long enough for any slave to respond normally. If the slave detects a transmission error, the message will not be acted upon. The slave will not construct a response to the master. Thus the timeout will expire and allow the master's program to handle the error.

Note: A message addressed to a nonexistent slave device will also cause a timeout.

Other networks such as MAP or Modbus Plus use frame checking at a level above the Modbus contents of the message. On those networks, the Modbus message LRC or CRC check field does not apply. In the case of a transmission error, the communication protocols specific to those networks notify the originating device that an error has occurred, and allow it to retry or abort according to how it has been setup. If the message is delivered, but the slave device cannot respond, a timeout error can occur which can be detected by the master's program.

1.4.1 Parity Checking

Users can configure controllers for Even or Odd Parity checking, or for No Parity checking. This will determine how the parity bit will be set in each character.

If either Even or Odd Parity is specified, the quantity of 1 bits will be counted in the data portion of each character (seven data bits for ASCII mode, or eight for RTU). The parity bit will then be set to a 0 or 1 to result in an Even or Odd total of 1 bits. For example, these eight data bits are contained in an RTU character frame:

1100 0101

The total quantity of 1 bits in the frame is four. If Even Parity is used, the frame's parity bit will be a 0, making the total quantity of 1 bits still an even number (four). If Odd Parity is used, the parity bit will be a 1, making an odd quantity (five).

When the message is transmitted, the parity bit is calculated and applied to the frame of each character. The receiving device counts the quantity of 1 bits and sets an error if they are not the same as configured for that device (all devices on the Modbus network must be configured to use the same parity check method).

Note that parity checking can only detect an error if an odd number of bits are picked up or dropped in a character frame during transmission. For example, if Odd Parity checking is employed, and two 1 bits are dropped from a character containing three 1 bits, the result is still an odd count of 1 bits.

If No Parity checking is specified, no parity bit is transmitted and no parity check can be made. An additional stop bit is transmitted to fill out the character frame.

1.4.2 LRC Checking

In ASCII mode, messages include an error-checking field that is based on a LRC method. The LRC field checks the contents of the message, exclusive of the beginning colon and ending CRLF pair. It is applied regardless of any parity check method used for the individual characters of the message.

The LRC field is one byte, containing an eight-bit binary value. The LRC value is calculated by the transmitting device, which appends the LRC to the message. The receiving device calculates an LRC during receipt of the message, and compares the calculated value to the actual value it received in the LRC field. If the two values are not equal, an error results.

The LRC is calculated by adding together successive eight-bit bytes of the message, discarding any carries, and then two's complementing the result. It is performed on the ASCII message field contents excluding the colon character that begins the message, and excluding the CRLF pair at the end of the message.

In ladder logic, the CKSM function calculates a LRC from the message contents. For applications using host computers, a detailed example of LRC generation is contained in Appendix C.

1.4.3 CRC Checking

In RTU mode, messages include an error-checking field that is based on a CRC method. The CRC field checks the contents of the entire message. It is applied regardless of any parity check method used for the individual characters of the message.

The CRC field is two bytes, containing a 16-bit binary value. The CRC value is calculated by the transmitting device, which appends the CRC to the message. The receiving device recalculates a CRC during receipt of the message, and compares the calculated value to the actual value it received in the CRC field. If the two values are not equal, an error results.

The CRC is started by first preloading a 16-bit register to all 1's. Then a process begins of applying successive eight-bit bytes of the message to the current contents of the register. Only the eight bits of data in each character are used for generating the CRC. Start and stop bits, and the parity bit, do not apply to the CRC.

During generation of the CRC, each eight-bit character is exclusive ORed with the register contents. Then the result is shifted in the direction of the least significant bit (LSB), with a zero filled into the most significant bit (MSB) position. The LSB is extracted and examined. If the LSB was a 1, the register is then exclusive ORed with a preset, fixed value. If the LSB was a 0, no exclusive OR takes place.

This process is repeated until eight shifts have been performed. After the last (eighth) shift, the next eight-bit byte is exclusive ORed with the register's current value, and the process repeats for eight more shifts as described above. The final contents of the register, after all the bytes of the message have been applied, is the CRC value.

When the CRC is appended to the message, the low-order byte is appended first, followed by the high-order byte.

In ladder logic, the CKSM function calculates a CRC from the message contents. For applications using host computers, a detailed example of CRC generation is given on page .


Chapter 2
Data and Control Functions

V [image] Modbus Function Formats

V [image] Function Codes

V [image] Read Coil Status

V [image] Read Input Status

V [image] Read Holding Registers

V [image] Read Input Registers

V [image] Force Single Coil

V [image] Preset Single Register

V [image] Read Exception Status

V [image] Fetch Comm Event Counter

V [image] Fetch Comm Event Log

V [image] Force Multiple Coils

V [image] Preset Multiple Registers

V [image] Report Slave ID

V [image] Read General Reference

V [image] Write General Reference

V [image] Mask Write 4x Register

V [image] Read / Write 4x Registers

V [image] Read FIFO Queue

2.1 Modbus Function Formats

Note: Unless specified otherwise, numerical values (such as addresses, codes, or data) are expressed as decimal values in the text of this section. They are expressed as hexadecimal values in the message fields of the figures.

2.1.1 Data Addresses in Modbus Messages

All data addresses in Modbus messages are referenced to zero. The first occurrence of a data item is addressed as item number zero. For example:

V Coil 1 in a programmable controller is addressed as coil 0000 in the data address field of a Modbus message

V Coil 127 decimal is addressed as coil 007E hex (126 decimal)

V Holding register 40001 is addressed as register 0000 in the data address field of the message. The function code field already specifies a holding register operation. Therefore the 4x reference is implicit.

V Holding register 40108 is addressed as register 006B hex (107 decimal)

2.1.2 Field Contents in Modbus Messages

The following tables show examples of a Modbus query and normal response. Both examples show the field contents in hexadecimal, and also show how a message could be framed in ASCII or in RTU mode.

Query

Response

The master query is a Read Holding Registers request to slave device address 06. The message requests data from three holding registers, 40108 ... 40110.

Note: The message specifies the starting register address as 0107 (006B hex).

The slave response echoes the function code, indicating this is a normal response. The Byte Count field specifies how many eight-bit data items are being returned. It shows the count of eight-bit bytes to follow in the data, for either ASCII or RTU. With ASCII, this value is half the actual count of ASCII characters in the data. In ASCII, each four-bit hexadecimal value requires one ASCII character, therefore two ASCII characters must follow in the message to contain each eight-bit data item.

For example, the value 63 hex is sent as one eight-bit byte in RTU mode (01100011). The same value sent in ASCII mode requires two bytes, for ASCII 6 (0110110) and 3 (0110011). The Byte Count field counts this data as one eight-bit item, regardless of the character framing method (ASCII or RTU).

How to Use the Byte Count Field

When you construct responses in buffers, use a Byte Count value that equals the count of eight-bit bytes in your message data. The value is exclusive of all other field contents, including the Byte Count field.

2.1.3 Field Contents on Modbus Plus

Modbus messages sent on Modbus Plus networks are imbedded into the Logical Link Control (LLC) level frame. Modbus message fields consist of eight-bit bytes, similar to those used with RTU framing.

The Slave Address field is converted to a Modbus Plus routing path by the sending device. The CRC field is not sent in the Modbus message, because it would be redundant to the CRC check performed at the High-level Data Link Control (HDLC) level.

The rest of the message remains as in the standard serial format. The application software (e.g., MSTR blocks in controllers, or Modcom III in hosts) handles the framing of the message into a network packet.

Figure 7 shows how a Read Holding Registers query would be imbedded into a frame for Modbus Plus transmission.

Figure 7 Field Contents on Modbus Plus

2.2 Function Codes

The listing below shows the function codes supported by Modicon controllers. Codes are listed in decimal; Y indicates that the function is supported, and N indicates that it is not supported.

2.2.1 01 Read Coil Status

Reads the ON / OFF status of discrete outputs (0x references, coils) in the slave. Broadcast is not supported. The maximum parameters supported by various controller models are listed on page .

Query

The query message specifies the starting coil and quantity of coils to be read. Coils are addressed starting at zero-coils 1 ... 16 are addressed as 0 ... 15.

Here is an example of a query to read coils 20 ... 56 from slave device 17:

Response

The coil status in the response message is packed as one coil per bit of the data field. Status is indicated as: 1 = ON; 0 = OFF. The LSB of the first data byte contains the coil addressed in the query. The other coils follow toward the high order end of this byte, and from low order to high order in subsequent bytes.

If the returned coil quantity is not a multiple of eight, the remaining bits in the final data byte will be padded with zeros (toward the high order end of the byte). The Byte Count field specifies the quantity of complete bytes of data.

Here is an example of a response to the query:

The status of coils 27 ... 20 is shown as the byte value CD hex, or binary 1100 1101. Coil 27 is the MSB of this byte, and coil 20 is the LSB. Left to right, the status of coils 27 ... 20 is ON-ON-OFF-OFF-ON-ON-OFF-ON.

By convention, bits within a byte are shown with the MSB to the left, and the LSB to the right. Thus the coils in the first byte are 27 ... 20, from left to right. The next byte has coils 35 ... 28, left to right. As the bits are transmitted serially, they flow from LSB to MSB: 20 . . . 27, 28 . . . 35, and so on.

In the last data byte, the status of coils 56 ... 52 is shown as the byte value 1B hex, or binary 0001 1011. Coil 56 is in the fourth bit position from the left, and coil 52 is the LSB of this byte. The status of coils 56 ... 52 is: ON-ON-OFF-ON-ON.

Note: The three remaining bits (toward the high-order end) are zero-filled.

2.2.2 02 Read Input Status

Reads the ON / OFF status of discrete inputs (1x references) in the slave. Broadcast is not supported. The maximum parameters supported by various controller models are listed on page .

Query

The query message specifies the starting input and quantity of inputs to be read. Inputs are addressed starting at zero-inputs 1 ... 16 are addressed as 0 ... 15.

Here is an example of a request to read inputs 10197 ... 10218 from slave device 17:

Response

The input status in the response message is packed as one input per bit of the data field. Status is indicated as: 1 = ON; 0 = OFF. The LSB of the first data byte contains the input addressed in the query. The other inputs follow toward the high order end of this byte, and from low order to high order in subsequent bytes.

If the returned input quantity is not a multiple of eight, the remaining bits in the final data byte will be padded with zeros (toward the high order end of the byte). The Byte Count field specifies the quantity of complete bytes of data.

Here is an example of a response to the query:

The status of inputs 10204 ... 10197 is shown as the byte value AC hex, or binary 1010 1100. Input 10204 is the MSB of this byte, and input 10197 is the LSB. Left to right, the status of inputs 10204 ... 10197 is ON-OFF-ON-OFF-ON-ON-OFF-OFF.

The status of inputs 10218 ... 10213 is shown as the byte value 35 hex, or binary 0011 0101. Input 10218 is in the third bit position from the left, and input 10213 is the LSB. The status of inputs 10218 ... 10213 is: ON-ON-OFF-ON-OFF-ON.

Note: The two remaining bits (toward the high order end) are zero-filled.

2.2.3 03 Read Holding Registers

Reads the binary contents of holding registers (4x references) in the slave. Broadcast is not supported. The maximum parameters supported by various controller models are listed on page .

Query

The query message specifies the starting register and quantity of registers to be read. Registers are addressed starting at zero- registers 1 ... 16 are addressed as 0 ... 15.

Here is an example of a request to read registers 40108 ... 40110 from slave device 17:

Response

The register data in the response message are packed as two bytes per register, with the binary contents right justified within each byte. For each register, the first byte contains the high order bits and the second contains the low order bits.

Data is scanned in the slave at the rate of 125 registers per scan for 984-X8X controllers (984-685, etc), and at the rate of 32 registers per scan for all other controllers. The response is returned when the data is completely assembled.

Here is an example of a response to the query:

The contents of register 40108 are shown as the two byte values of 02 2B hex, or 555 decimal. The contents of registers 40109 ... 40110 are 00 00 and 00 64 hex, or 0 and 100 decimal.

2.2.4 04 Read Input Registers

Reads the binary contents of input registers (3X references) in the slave. Broadcast is not supported. The maximum parameters supported by various controller models are listed on page .

Query

The query message specifies the starting register and quantity of registers to be read. Registers are addressed starting at zero- registers 1 ... 16 are addressed as 0 ... 15.

Here is an example of a request to read register 30009 from slave device 17:

Response

The register data in the response message are packed as two bytes per register, with the binary contents right justified within each byte. For each register, the first byte contains the high-order bits and the second contains the low-order bits.

Data is scanned in the slave at the rate of 125 registers per scan for 984-X8X controllers (984-685, etc), and at the rate of 32 registers per scan for all other controllers. The response is returned when the data is completely assembled.

Here is an example of a response to the query on the opposite page:

The contents of register 30009 are shown as the two byte values of 00 0A hex, or 10 decimal.

2.2.5 05 Force Single Coil

Forces a single coil (0x reference) to either ON or OFF. When broadcast, the function forces the same coil reference in all attached slaves. The maximum parameters supported by various controller models are listed on page .

Note: The function will override the controller's memory protect state and the coil's disable state. The forced state will remain valid until the controller's logic next solves the coil. The coil will remain forced if it is not programmed in the controller's logic.

Query

The query message specifies the coil reference to be forced. Coils are addressed starting at zero-coil 1 is addressed as 0.

The reguested ON / OFF state is specified by a constant in the query data field. A value of FF 00 hex requests the coil to be ON. A value of 00 00 requests it to be OFF. All other values are illegal and will not affect the coil.

Here is an example of a request to force coil 173 ON in slave device 17:

Response

The normal response is an echo of the query, returned after the coil state has been forced.

Here is an example of a response to the query:

2.2.6 06 Preset Single Register

Presets a value into a single holding register (4x reference). When broadcast, the function presets the same register reference in all attached slaves. The maximum parameters supported by various controller models are listed on page .

Note: The function will override the controller's memory protect state. The preset value will remain valid in the register until the controller's logic next solves the register contents. The register's value will remain if it is not programmed in the controller's logic.

Query

The query message specifies the register reference to be preset. Registers are addressed starting at zero-register 1 is addressed as 0.

The reguested preset value is specified in the query data field. M84 and 484 controllers use a 10-bit binary value, with the six high order bits set to zeros. All other controllers use 16-bit values.

Here is an example of a request to preset register 40002 to 00 03 hex in slave device 17:

Response

The normal response is an echo of the query, returned after the register contents have been preset.

Here is an example of a response to the query:

2.2.7 07 Read Exception Status

Reads the contents of eight Exception Status coils within the slave controller. Certain coils have predefined assignments in the various controllers. Other coils can be programmed by the user to hold information about the contoller's status-e.g., machine ON/OFF, heads retracted, safeties satisfied, error conditions exist, or other user-defined flags. Broadcast is not supported.

The function provides a simple method for accessing this information, because the Exception Coil references are known (no coil reference is needed in the function). The predefined Exception Coil assignments are:

Query

Here is an example of a request to read the exception status in slave device 17:

Response

The normal response contains the status of the eight Exception Status coils. The coils are packed into one data byte, with one bit per coil. The status of the lowest coil reference is contained in the least significant bit of the byte.

Here is an example of a response to the query:

In this example, the coil data is 6D hex (0110 1101 binary). Left to right, the coils are OFF-ON-ON-OFF-ON-ON-OFF-ON. The status is shown from the highest to the lowest addressed coil.

If the controller is a 984, these bits are the status of coils 8 ... 1. If the controller is a 484, these bits are the status of coils 264 ... 257. In this example, coil 257 is ON, indicating that the controller's batteries are OK.

2.2.8 11 (0B Hex) Fetch Comm Event Counter

Returns a status word and an event count from the slave's communications event counter. By fetching the current count before and after a series of messages, a master can determine whether the messages were handled normally by the slave. Broadcast is not supported.

The controller's event counter is incremented once for each successful message completion. It is not incremented for exception responses, poll commands, or fetch event counter commands.

The event counter can be reset by means of the Diagnostics function (code 08), with a subfunction of Restart Communications Option (code 00 01) or Clear Counters and Diagnostic Register (code 00 0A).

Query

Here is an example of a request to fetch the communications event counter in slave device 17:

Response

The normal response contains a two-byte status word, and a two-byte event count. The status word will be all ones (FF FF hex) if a previously issued program command is still being processed by the slave (a busy condition exists). Otherwise, the status word will be all zeros.

Here is an example of a response to the query:

In this example, the status word is FF FF hex, indicating that a program function is still in progress in the slave. The event count shows that 264 (01 08 hex) events have been counted by the controller.

2.2.9 12 (0C Hex) Fetch Comm Event Log

Returns a status word, event count, message count, and a field of event bytes from the slave. Broadcast is not supported. The status word and event count are identical to that returned by the Fetch Communications Event Counter function (11, 0B hex).

The message counter contains the quantity of messages processed by the slave since its last restart, clear counters operation, or power-up. This count is identical to that returned by the Diagnostic function (code 08), subfunction Return Bus Message Count (code 11, 0B hex).

The event bytes field contains 0 ... 64 bytes, with each byte corresponding to the status of one Modbus send or receive operation for the slave. The events are entered by the slave into the field in chronological order. Byte 0 is the most recent event. Each new byte flushes the oldest byte from the field.

Query

Here is an example of a request to fetch the communications event log in slave device 17:

Response

The normal response contains a two-byte status word field, a two-byte event count field, a two-byte message count field, and a field containing 0 ... 64 bytes of events. A byte-count field defines the total length of the data in these four fields.

Here is an example of a response to the query:

In this example, the status word is 00 00 hex, indicating that the slave is not processing a program function. The event count shows that 264 (01 08 hex) events have been counted by the slave. The message count shows that 289 (01 21 hex) messages have been processed.

The most recent communications event is shown in the Event 0 byte. Its contents (20 hex) show that the slave has most recently entered the Listen Only Mode.

The previous event is shown in the Event 1 byte. Its contents (00 hex) show that the slave received a Communications Restart.

What the Event Bytes Contain

An event byte returned by the Fetch Communications Event Log function can be any one of four types. The type is defined by bit 7 (the high-order bit) in each byte. It may be further defined by bit 6.

Slave Modbus Receive Event

This type of event byte is stored by the slave when a query message is received. It is stored before the slave processes the message. This event is defined by bit 7 set to a logic 1. The other bits will be set to a logic 1 if the corresponding condition is TRUE. The bit layout is:

Slave Modbus Send Event

This type of event byte is stored by the slave when it finishes processing a query message. It is stored if the slave returned a normal or exception response, or no response. This event is defined by bit 7 set to a logic 0, with bit 6 set to a 1. The other bits will be set to a logic 1 if the corresponding condition is TRUE. The bit layout is:

Slave Entered Listen Only Mode

This type of event byte is stored by the slave when it enters the Listen Only Mode. The event is defined by a contents of 04 hex. The bit layout is:

Slave Initiated Communication Restart

This type of event byte is stored by the slave when its communications port is restarted. The slave can be restarted by the Diagnostics function (code 08), with subfunction Restart Communications Option (code 00 01).

That function also places the slave into a Continue on Error or Stop on Error mode. If the slave is placed into Continue on Error mode, the event byte is added to the existing event log. If the slave is placed into Stop on Error mode, the byte is added to the log and the rest of the log is cleared to zeros. The event is defined by a contents of zero. The bit layout is:

2.2.10 15 (0F Hex) Force Multiple Coils

Forces each coil (0x reference) in a sequence of coils to either ON or OFF. When broadcast, the function forces the same coil references in all attached slaves. The maximum parameters supported by various controller models are listed on page .

Note: The function will override the controller's memory protect state and a coil's disable state. The forced state will remain valid until the controller's logic next solves each coil. Coils will remain forced if they are not programmed in the controller's logic.

Query

The query message specifies the coil references to be forced. Coils are addressed starting at zero-coil 1 is addressed as 0.

The reguested ON / OFF states are specified by contents of the query data field. A logical 1 in a bit position of the field requests the corresponding coil to be ON. A logical 0 requests it to be OFF.

The following page shows an example of a request to force a series of ten coils starting at coil 20 (addressed as 19, or 13 hex) in slave device 17.

The query data contents are two bytes: CD 01 hex (1100 1101 0000 0001 binary). The binary bits correspond to the coils in the following way:

Bit: 1 1 0 0 1 1 0 1 0 0 0 0 0 0 0 1

Coil: 27 26 25 24 23 22 21 20 - - - - - - 29 28

The first byte transmitted (CD hex) addresses coils 27 ... 20, with the least significant bit addressing the lowest coil (20) in this set.

The next byte transmitted (01 hex) addresses coils 29 and 28, with the least significant bit addressing the lowest coil (28) in this set. Unused bits in the last data byte should be zero-filled.

Response

The normal response returns the slave address, function code, starting address, and quantity of coils forced. Here is an example of a response to the query shown above:

2.2.11 16 (10 Hex) Preset Multiple Registers

Presets values into a sequence of holding registers (4x references). When broadcast, the function presets the same register references in all attached slaves. The maximum parameters supported by various controller models are listed on page .

Note: The function will override the controller's memory protect state. The preset values will remain valid in the registers until the controller's logic next solves the register contents. The register values will remain if they are not programmed in the controller's logic.

Query

The query message specifies the register references to be preset. Registers are addressed starting at zero-register 1 is addressed as 0.

The requested preset values are specified in the query data field. M84 and 484 controllers use a 10-bit binary value, with the six high order bits set to zeros. All other controllers use 16-bit values. Data is packed as two bytes per register.

Here is an example of a request to preset two registers starting at 40002 to 00 0A and 01 02 hex, in slave device 17:

Response

The normal response returns the slave address, function code, starting address, and quantity of registers preset. Here is an example of a response to the query shown above.

2.2.12 17 (11 Hex) Report Slave ID

Returns a description of the type of controller present at the slave address, the current status of the slave Run indicator, and other information specific to the slave device. Broadcast is not supported.

Query

Here is an example of a request to report the ID and status of slave device 17:

Response

The format of a normal response is shown below. The data contents are specific to each controller type.

Summary of Slave IDs

These are the Slave ID codes returned by Modicon controllers in the first byte of the data field:

184 / 384

The 184 or 384 controller returns a byte count of either 4 or 74 (4A hexadecimal). If the controller's J347 Modbus Slave Interface is setup properly, and its internal PIB table is normal, the byte count will be 74. Otherwise the byte count will be 4. The four bytes that are always returned are:

Bytes 5 ... 10, returned for a correct J347 setup and normal PIB, are:

Bytes 11 ... 74 contain the PIB table. This data is valid only if the controller is running (as shown in Byte 2). The table is as follows:

584

The 584 controller returns a byte count of 9, as follows:

984

The 984 controller returns a byte count of 9, as follows:

Note: Bit 0 of the Machine State word defines the use of the memory downsize values in words 99, 100, and 175 (63, 64, and AF hexadecimal) of the configuration table. If bit 0 = logic 1, downsizing is calculated as follows:

Page 0 size (16-bit words) = (Word 99 * 4096) - (Word 175 lo byte * 16)

State table size (16-bit words) = (Word 100 * 1024) - (Word 175 hi byte * 16)

Micro 84

The Micro 84 controller returns a byte count of 8, as follows:

484

The 484 controller returns a byte count of 5, as follows:

884

The 884 controller returns a byte count of 8, as follows:

2.2.13 20 (14 Hex) Read General Reference

Returns the contents of registers in Extended Memory file (6x) references. Broadcast is not supported. The function can read multiple groups of references. The groups can be separate (noncontiguous), but the references within each group must be sequential.

Query

The query contains the standard Modbus slave address, function code, byte count, and error check fields. The rest of the query specifies the group or groups of references to be read. Each group is defined in a separate sub-request field which contains seven bytes:

V The reference type-one byte (must be specified as 6)

V The Extended Memory file number-two bytes (1 ... 10, 0001 ... 000A hex)

V The starting register address within the file-two bytes

V The quantity of registers to be read-two bytes

The quantity of registers to be read, combined with all other fields in the expected response, must not exceed the allowable length of Modbus messages-256 bytes.

The available quantity of Extended Memory files depends upon the installed size of Extended Memory in the slave controller. Each file except the last one contains 10,000 registers, addressed as 0000 ... 270F hexadecimal (0000 - ... 9999 decimal).

For controllers other than the 984-785 with Extended Registers, the last (highest) register in the last file is:

For the 984-785 with Extended Registers, the last (highest) register in the last file is shown in the two tables below.

Examples of a query and response follow. An example of a request to read two groups of references from slave device 17 is shown. Group 1 consists of two registers from file 4, starting at register 2 (address 0001). Group 2 consists of two registers from file 3, starting at register 10 (address 0009).

Response

The normal response is a series of sub-responses, one for each sub-request. The byte count field is the total combined count of bytes in all sub-responses. In addition, each sub-response contains a field that shows its own byte count.

2.2.14 21 (15 Hex) Write General Reference

Writes the contents of registers in Extended Memory file (6x) references. Broadcast is not supported.

The function can write multiple groups of references. The groups can be separate (noncontiguous), but the references within each group must be sequential.

Query

The query contains the standard Modbus slave address, function code, byte count, and error check fields. The rest of the query specifies the group or groups of references to be written, and the data to be written into them. Each group is defined in a separate sub-request field which contains seven bytes plus the data:

V The reference type-one byte (must be specified as 6)

V The Extended Memory file number-two bytes (1 ... 10, 0001 ... 000A hex)

V The starting register address within the file-two bytes

V The quantity of registers to be written-two bytes

V The data to be written-two bytes/register

The quantity of registers to be written, combined with all other fields in the query, must not exceed the allowable length of Modbus messages-256 bytes.

The available quantity of Extended Memory files depends upon the installed size of Extended Memory in the slave controller. Each file except the last one contains 10,000 registers, addressed as 0000 ... 270F hexadecimal (0000 - ... 9999 decimal).

For controllers other than the 984-785 with Extended Registers, the last (highest) register in the last file is:

For the 984-785 with Extended Registers, the last (highest) register in the last file is shown in the two tables below.

Examples of a query and response follow. An example of a request to write one group of references into slave device 17 is shown. The group consists of three registers in file 4, starting at register 8 (address 0007).

Response

The normal response is an echo of the query.

2.2.15 22 (16 Hex) Mask Write 4x Register

Modifies the contents of a specified 4x register using a combination of an AND mask, an OR mask, and the register's current contents. The function can be used to set or clear individual bits in the register. Broadcast is not supported.

Note: This function is supported in the 984-785 controller only.

Query

The query specifies the 4x reference to be written, the data to be used as the AND mask, and the data to be used as the OR mask.

The function's algorithm is:

Result = (Current Contents AND And_Mask) OR (Or_Mask AND And_Mask )

For example,

Note: If the Or_Mask value is zero, the result is simply the logical ANDing of the current contents and And_Mask. If the And_Mask value is zero, the result is equal to the Or_Mask value.

Note: The contents of the register can be read with the Read Holding Registers function (function code 03). They could, however, be changed subsequently as the controller scans its user logic program.

Here is an example of a Mask Write to register 5 in slave device 17, using the above mask values:

Response

The normal response is an echo of the query. The response is returned after the register has been written.

2.2.16 23 (17 Hex) Read / Write 4x Registers

Performs a combination of one read and one write operation in a single Modbus transaction. The function can write new contents to a group of 4x registers, and then return the contents of another group of 4x registers. Broadcast is not supported.

Note: This function is supported in the 984-785 controller only.

Query

The query specifies the starting address and quantity of registers of the group to be read. It also specifies the starting address, quantity of registers, and data for the group to be written. The byte count field specifies the quantity of bytes to follow in the write data field.

Here is an example of a query to read six registers starting at register 5, and to write three registers starting at register 16, in slave device 17:

Response

The normal response contains the data from the group of registers that were read. The byte count field specifies the quantity of bytes to follow in the read data field.

Here is an example of a response to the query:

2.2.17 24 (18 Hex) Read FIFO Queue

Reads the contents of a first-in first-out (FIFO) queue of 4x registers. The function returns a count of the registers in the queue, followed by the queued data. Up to 32 registers can be read-the count, plus up to 31 queued data registers. The queue count register is returned first, followed by the queued data registers.

The function reads the queue contents, but does not clear them. Broadcast is not supported.

Note: This function is supported in the 984-785 controller only.

Query

The query specifies the starting 4x reference to be read from the FIFO queue. This is the address of the pointer register used with the controller's FIN and FOUT function blocks. It contains the count of registers currently contained in the queue. The FIFO data registers follow this address sequentially.

An example of a Read FIFO Queue query to slave device 17 is shown below. The query is to read the queue starting at the pointer register 41247 (04DE hex).

Response

In a normal response, the byte count shows the quantity of bytes to follow, including the queue count bytes and data register bytes (but not including the error check field).

The queue count is the quantity of data registers in the queue (not including the count register).

If the queue count exceeds 31, an exception response is returned with an error code of 03 (Illegal Data Value).

Here is an example of a normal response to the previous query:

In this example, the FIFO pointer register (41247 in the query) is returned with a queue count of 3. The three data registers follow the queue count. These are:

V 41248 (contents 440 decimal, 01B8 hex)

V 41249 (contents 4740, 1284 hex)

V 41250 (contents 4898, 1322 hex)


Chapter 3
Diagnostic Subfunctions

V [image] Modbus Function 08-Diagnostics

V [image] Diagnostic Codes Supported by Controllers

V [image] Return Query Data

V [image] Restart Communications Option

V [image] Return Diagnostic Register

V [image] Change ASCII Input Delimiter

V [image] Force Listen Only Mode

V [image] Clear Counters and Diagnostic Register

V [image] Return Bus Message Count

V [image] Return Bus Communication Error Count

V [image] Return Bus Exception Error Count

V [image] Return Slave Message Count

V [image] Return Slave No Response Count

V [image] Return Slave NAK Count

V [image] Return Slave Busy Count

V [image] Return Bus Character Overrun Count

V [image] Return IOP Overrun Count (884)

V [image] Clear Overrun Counter and Flag (884)

V [image] Get / Clear Modbus Plus Statistics

V [image] Modbus Plus Network Statistics

3.1 Function 08-Diagnostics

Modbus function 08 provides a series of tests for checking the communication system between the master and slave, or for checking various internal error conditions within the slave. Broadcast is not supported.

The function uses a two-byte subfunction code field in the query to define the type of test to be performed. The slave echoes both the function code and subfunction code in a normal response.

Most of the diagnostic queries use a two-byte data field to send diagnostic data or control information to the slave. Some of the diagnostics cause data to be returned from the slave in the data field of a normal response.

Diagnostic Effects on the Slave

In general, issuing a diagnostic function to a slave device does not affect the running of the user program in the slave. User logic, like discretes and registers, is not accessed by the diagnostics. Certain functions can optionally reset error counters in the slave.

A slave device can, however, be forced into `Listen Only Mode' in which it will monitor the messages on the communications system but not respond to them. This can affect the outcome of your application program it it depends upon any further exchange of data with the slave device. Generally, the mode is forced to remove a malfunctioning slave device from the communications system.

How This Information is Organized in Your Guide

An example diagnostics query and response are shown on the opposite page. These show the location of the function code, subfunction code, and data field within the messages.

A list of subfunction codes supported by the controllers is shown on the pages after the example response. Each subfunction code is then listed with an example of the data field contents that would apply for that diagnostic.

Query

Here is an example of a request to slave device 17 to Return Query Data. This uses a subfunction code of zero (00 00 hex in the two-byte field). The data to be returned is sent in the two-byte data field (A5 37 hex).

Response

The normal response to the Return Query Data request is to loopback the same data. The function code and subfunction code are also echoed.

The data fields in responses to other kinds of queries could contain error counts or other information requested by the subfunction code.

3.2 Diagnostic Codes Supported by Controllers

Subfunction codes are listed in decimal; Y indicates that the subfunction is supported, and N indicates that it is not supported.

3.2.1 00 Return Query Data

The data passed in the query data field is to be returned (looped back) in the response. The entire response message should be identical to the query.

3.2.2 01 Restart Communications Option

The slave's peripheral port is to be initialized and restarted, and all of its communications event counters are to be cleared. If the port is currently in Listen Only Mode, no response is returned. This function is the only one that brings the port out of Listen Only Mode. If the port is not currently in Listen Only Mode, a normal response is returned. This occurs before the restart is executed.

When the slave receives the query, it attempts a restart and executes its power-up confidence tests. Successful completion of the tests will bring the port online.

A query data field contents of FF 00 hex causes the port's Communications Event Log to be cleared also. Contents of 00 00 leave the log as it was prior to the restart.

3.2.3 02 Return Diagnostic Register

The contents of the slave's 16-bit diagnostic register are returned in the response.

3.2.4 How the Register Data is Organized

The assignment of diagnostic register bits for Modicon controllers is listed below. In each register, bit 15 is the high-order bit. The description is TRUE when the corresponding bit is set to logic 1.

3.2.5 03 Change ASCII Input Delimiter

The character CHAR passed in the query data field becomes the end of message delimiter for future messages (replacing the default LF character). This function is useful in cases where a Line Feed is not wanted at the end of ASCII messages.

3.2.6 04 Force Listen Only Mode

Forces the addressed slave to its Listen Only Mode for Modbus communications. This isolates it from the other devices on the network, allowing them to continue communicating without interruption from the addressed slave. No response is returned.

When the slave enters its Listen Only Mode, all active communication controls are turned off. The Ready watchdog timer is allowed to expire, locking the controls off. While in this mode, any Modbus messages addressed to the slave or broadcast are monitored, but no actions will be taken and no responses will be sent.

The only function that will be processed after the mode is entered will be the Restart Communications Option function (function code 8, subfunction 1).

3.2.7 10 (0A Hex) Clear Counters and Diagnostic Register

For controllers other than the 584 or 984, clears all counters and the diagnostic register. For the 584 or 984, clears the counters only. Counters are also cleared upon power-up.

3.2.8 11 (0B Hex) Return Bus Message Count

The response data field returns the quantity of messages that the slave has detected on the communications system since its last restart, clear counters operation, or power-up.

3.2.9 12 (0C Hex) Return Bus Communication Error Count

The response data field returns the quantity of CRC errors encountered by the slave since its last restart, clear counters operation, or power-up.

3.2.10 13 (0D Hex) Return Bus Exception Error Count

The response data field returns the quantity of Modbus exception responses returned by the slave since its last restart, clear counters operation, or power-up. For a description of exception responses, see page .

3.2.11 14 (0E Hex) Return Slave Message Count

The response data field returns the quantity of messages addressed to the slave, or broadcast, that the slave has processed since its last restart, clear counters operation, or power-up.

3.2.12 15 (0F Hex) Return Slave No Response Count

The response data field returns the quantity of messages addressed to the slave for which it returned no response (neither a normal response nor an exception response), since its last restart, clear counters operation, or power-up.

3.2.13 16 (10 Hex) Return Slave NAK Count

The response data field returns the quantity of messages addressed to the slave for which it returned a Negative Acknowledge (NAK) exception response, since its last restart, clear counters operation, or power-up. For a description of exception responses, see page .

3.2.14 17 (11 Hex) Return Slave Busy Count

The response data field returns the quantity of messages addressed to the slave for which it returned a Slave Device Busy exception response, since its last restart, clear counters operation, or power-up. For a description of exception responses, see page .

3.2.15 18 (12 Hex) Return Bus Character Overrun Count

The response data field returns the quantity of messages addressed to the slave that it could not handle due to a character overrun condition, since its last restart, clear counters operation, or power-up. A character overrun is caused by data characters arriving at the port faster than they can be stored, or by the loss of a character due to a hardware malfunction.

3.2.16 19 (13 Hex) Return IOP Overrun Count (884)

The response data field returns the quantity of messages addressed to the slave that it could not handle due to an 884 IOP overrun condition, since its last restart, clear counters operation, or power-up. An IOP overrun is caused by data characters arriving at the port faster than they can be stored, or by the loss of a character due to a hardware malfunction.

Note: This function is specific to the 884.

3.2.17 20 (14 Hex) Clear Overrun Counter and Flag (884)

Clears the 884 overrun error counter and resets the error flag. The current state of the flag is found in bit 0 of the 884 diagnostic register (see subfunction 02).

Note: This function is specific to the 884.

3.2.18 21 (15 Hex) Get / Clear Modbus Plus Statistics

Returns a series of 54 16-bit words (108 bytes) in the data field of the response (this function differs from the usual two-byte length of the data field). The data contains the statistics for the Modbus Plus peer processor in the slave device.

In addition to the Function code (08) and Subfunction code (00 15 hex) in the query, a two-byte Operation field is used to specify either a Get Statistics or a Clear Statistics operation. The two operations are exclusive-the Get operation cannot clear the statistics, and the Clear operation cannot return statistics prior to clearing them. Statistics are also cleared on power-up of the slave device.

The operation field immediately follows the subfunction field in the query:

V -- A value of 00 03 specifies the Get Statistics operation.

V -- A value of 00 04 specifies the Clear Statistics operation.

Query

This is the field sequence in the query:

Get Statistics Response

This is the field sequence in the normal response to a Get Statistics query:

Clear Statistics Response

The normal response to a Clear Statistics query is an echo of the query:

3.2.19 Modbus Plus Network Statistics

Note: Word 07 bitmaps are used internally by the peer processor to determine which paths have already had a command sent to them during the current token ownership. This limits the number of commands per path to one during a single token ownership.

Note: Words 08 ... 12 are token owner work tables. They are bitmaps representing work that needs to be done by the node the next time it gets the token. Each byte is a bitmap corresponding to work requested of each of the eight paths of the indicated type.

Note: Words 13 ... 22 contain pairs of 8-bit counters that pertain to certain types of error conditions as well as to successful transactions. Under normal operating conditions, the only bytes that change are word 20 LO and HI. Word 14 HI could also increment because of an MSTR or similar programming error in the application. If any other bytes increments, a possible problem exists on the network-e.g., in a single station or wiring connection.

Note: Words 23 ... 26 contain the active station bitmaps. An active station is any one that has sent packets of data over the network.

Note: Words 27 ... 30 contain the token station table bitmaps. A token station is any one that has token-passing capabilities.

Note: Words 31 ... 34 contain the global data present table bitmaps. Each time a station passes a token, it also passes the global data, even if there are zero bytes of global data. When one station sees another pass the token with global data, it sets its bit in its table for that other station. The bit remains set until the station reads the global data from that other station, after which the bit is cleared. A second read of global data indicates that no global data is present.

Note: In screen 2 of the MBPSTAT program, the number of global data words present is indicated under the station number. If this field is filled with spaces, then MBPSTAT has requested the global data from a second time before the other station passed the token.

Note: The LO bytes of words 35 ... 37 indicate the use of the internal receive buffers within the peer processor.


Chapter 4
Exception Responses

V [image] Exception Responses

V [image] Exception Codes

4.1 Exception Responses

Except for broadcast messages, when a master device sends a query to a slave device it expects a normal response. One of four possible events can occur from the master's query:

V If the slave device receives the query without a communication error, and can handle the query normally, it returns a normal response.

V If the slave does not receive the query due to a communication error, no response is returned. The master program will eventually process a timeout condition for the query.

V If the slave receives the query, but detects a communication error (parity, LRC, or CRC), no response is returned. The master program will eventually process a timeout condition for the query.

V If the slave receives the query without a communication error, but cannot handle it (for example, if the request is to read a nonexistent coil or register), the slave will return an exception response informing the master of the nature of the error.

The exception response message has two fields that differentiate it from a normal response:

Function Code Field

In a normal response, the slave echoes the function code of the original query in the function code field of the response. All function codes have a most significant bit (MSB) of 0 (their values are all below 80 hexadecimal). In an exception response, the slave sets the MSB of the function code to 1. This makes the function code value in an exception response exactly 80 hexadecimal higher than the value would be for a normal response.

With the function code's MSB set, the master's application program can recognize the exception response and can examine the data field for the exception code.

Data Field

In a normal response, the slave may return data or statistics in the data field (any information that was requested in the query). In an exception response, the slave returns an exception code in the data field. This defines the slave condition that caused the exception. Here is an example of a master query and slave exception response. The field examples are shown in hexadecimal.

In this example, the master addresses a query to slave device 10 (0A hex). The function code (01) is for a Read Coil Status operation. It requests the status of the coil at address 1245 (04A1 hex).

Note: Only one coil is to be read, as specified by the number of coils field (0001).

If the coil address is nonexistent in the slave device, the slave will return the exception response with the exception code shown (02). This specifies an illegal data address for the slave. For example, if the slave is a 984-385 with 512 coils, this code would be returned.

4.2 Exception Codes


Chapter 5
Application Notes

V [image] Maximum Query / Response Parameters

V [image] Estimating Serial Transaction Timing

V [image] Application Notes for the 584 and 984A / B / X

5.1 Maximum Query / Response Parameters

The listings show the maximum amount of data that each controller can request or send in a master query, or return in a slave response. All function codes and quantities are in decimal.

184/384

484

These values are for an 8K controller. See the 484 User's Guide for limits of smaller controllers.

584

884

M84

984

5.2 Estimating Serial Transaction Timing

The following sequence of events occurs during a Modbus serial transaction. Letters in parentheses ( ) refer to the timing notes at the end of the listing.

1 The Modbus master composes the message.

2 The master device modem RTS and CTS status are checked. ( [image] A)

3 The query message is transmitted to the slave. ( [image] B)

4 The slave processes the query message. ( [image] C, [image] D)

5 The slave calculates an error check field. ( [image] E)

6 The slave device modem RTS and CTS status are checked. ( [image] A)

7 The response message is transmitted to the master. ( [image] B)

8 The master application acts upon the response and its data.

Timing Notes

A If the RTS and CTS pins are jumpered together, this time is negligible. For J478 modems, the time is about 5 ms.

B Use the following formula to estimate the transmission time:

Time (ms) = 1000 * (character count) * (bits/character)
Baud Rate

C The Modbus message is processed at the end of the controller scan. The worst-case delay is one scan time, which occurs if the controller has just begun a new scan. The average delay is half the scan time.

The time allotted for servicing Modbus ports at the end of the controller scan (before beginning a new scan) depends upon the controller model. Timing for each model is described on the next page.

For 484 controllers the time is approximately 1.5 ms. The Modbus port is available on a contention basis with any J470 / J474 / J475 that is present.

For 584 and 984 controllers the time is approximately 1.5 ms for each Modbus port. The ports are serviced sequentially, starting with port 1.

For 184 / 384 controllers the time varies according to the amount of data being handled. It ranges from a minimum of 0.5 ms to a maximum of about 6.0 ms (for 100 registers), or 7.0 ms (for 800 coils). If a programming panel is currently being used with the controller, the Modbus port is locked out.

D Modbus functions 1 through 4, 15, and 16 permit the master to request more data than can be processed during the time alloted for servicing the slave's Modbus port. If the slave cannot process all of the data, it will buffer the data and process it at the end of subsequent scans.

The amount of data that can be processed during one service period at the Modbus port is as follows:

Note: 984-X8X refers to 984 slot mount models (984-385, -685, etc).

For the 884, the processing time for multiple data is as follows:

E LRC calculation time is less than 1 ms. CRC calculation time is about 0.3 ms for each eight bits of data to be returned in the response.

5.3 Notes for the 584 and 984A / B / X

Baud Rates

When using both Modbus ports 1 and 2, the maximum allowable combined baud rate is 19,200 baud.

Port Lockups

When using ASCII, avoid sending zero-data-length messages or messages with no device address. For example, this is an illegal message:

:  CR  LF			(colon, CR, LF)
Random port lockups can occur this kind of message is used.

Terminating ASCII Messages

ASCII messages should normally terminate with a CRLF pair. With the 584 and 984A/B/X controllers, an ASCII message can terminate after the LRC field (without the CRLF characters being sent), if an interval of at least 1 s is allowed to occur after the LRC field. If this happens, the controller will assume that the message has terminated normally.


Chapter 6
LRC / CRC Generation

V [image] LRC Generation

V [image] CRC Generation

6.1 LRC Generation

The Longitudinal Redundancy Check (LRC) field is one byte, containing an eight-bit binary value. The LRC value is calculated by the transmitting device, which appends the LRC to the message. The receiving device recalculates an LRC during receipt of the message, and compares the calculated value to the actual value it received in the LRC field. If the two values are not equal, an error results.

The LRC is calculated by adding together successive eight-bit bytes in the message, discarding any carries, then two's complementing the result. The LRC is an eight-bit field, therefore each new addition of a character that would result in a value higher than 255 decimal simply rolls over the field's value through zero. Because there is no ninth bit, the carry is discarded automatically.

Generating an LRC

Step 1 Add all bytes in the message, excluding the starting colon and ending CRLF. Add them into an eight-bit field, so that carries will be discarded.

Step 2 Subtract the final field value from FF hex (all 1's), to produce the ones-complement.

Step 3 Add 1 to produce the two's-complement.

Placing the LRC into the Message

When the the eight-bit LRC (two ASCII characters) is transmitted in the message, the high order character will be transmitted first, followed by the low order character-e.g., if the LRC value is 61 hex (0110 0001):

Figure 8 LRC Character Sequence

Example

An example of a C language function performing LRC generation is shown below. The function takes two arguments:

unsigned char *auchMsg ;	A pointer to the message buffer
con-
                                     taining binary data to be used for
                                     generating the LRC

unsigned short usDataLen ;	The quantity of bytes in the
                                    message buffer.
The function returns the LRC as a type unsigned char.

LRC Generation Function

static unsigned char LRC(auchMsg, usDataLen)

unsigned char *auchMsg ;		/* message to calculate  */
unsigned short usDataLen ;		/* LRC upon quantity of  */
                                        /* bytes in message      */

{
    unsigned char uchLRC = 0 ;	/* LRC char initialized   */

    while (usDataLen--)		/* pass through message  */
        uchLRC += *auchMsg++ ;	/* buffer add buffer byte*/
                                        /* without carry         */

    return ((unsigned char)(-((char_uchLRC))) ;
                                        /* return twos complemen */
}
6.2 CRC Generation

The Cyclical Redundancy Check (CRC) field is two bytes, containing a 16-bit binary value. The CRC value is calculated by the transmitting device, which appends the CRC to the message. The receiving device recalculates a CRC during receipt of the message, and compares the calculated value to the actual value it received in the CRC field. If the two values are not equal, an error results.

The CRC is started by first preloading a 16-bit register to all 1's. Then a process begins of applying successive eight-bit bytes of the message to the current contents of the register. Only the eight bits of data in each character are used for generating the CRC. Start and stop bits, and the parity bit, do not apply to the CRC.

During generation of the CRC, each eight-bit character is exclusive ORed with the register contents. The result is shifted in the direction of the least significant bit (LSB), with a zero filled into the most significant bit (MSB) position. The LSB is extracted and examined. If the LSB was a 1, the register is then exclusive ORed with a preset, fixed value. If the LSB was a 0, no exclusive OR takes place.

This process is repeated until eight shifts have been performed. After the last (eighth) shift, the next eight-bit character is exclusive ORed with the register's current value, and the process repeats for eight more shifts as described above. The final contents of the register, after all the characters of the message have been applied, is the CRC value.

Generating a CRC

Step 1 Load a 16-bit register with FFFF hex (all 1's). Call this the CRC register.

Step 2 Exclusive OR the first eight-bit byte of the message with the low order byte of the 16-bit CRC register, putting the result in the CRC register.

Step 3 Shift the CRC register one bit to the right (toward the LSB), zerofilling the MSB. Extract and examine the LSB.

Step 4 If the LSB is 0, repeat Step 3 (another shift). If the LSB is 1, Exclusive OR the CRC register with the polynomial value A001 hex (1010 0000 0000 0001).

Step 5 Repeat Steps 3 and 4 until eight shifts have been performed. When this is done, a complete eight-bit byte will have been processed.

Step 6 Repeat Steps 2 ... 5 for the next eight-bit byte of the message. Continue doing this until all bytes have been processed.

Result The final contents of the CRC register is the CRC value.

Step 7 When the CRC is placed into the message, its upper and lower bytes must be swapped as described below.

Placing the CRC into the Message

When the 16-bit CRC (two eight-bit bytes) is transmitted in the message, the low order byte will be transmitted first, followed by the high order byte-e.g., if the CRC value is 1241 hex (0001 0010 0100 0001):

Figure 9 CRC Byte Sequence

Example

An example of a C language function performing CRC generation is shown on the following pages. All of the possible CRC values are preloaded into two arrays, which are simply indexed as the function increments through the message buffer. One array contains all of the 256 possible CRC values for the high byte of the 16-bit CRC field, and the other array contains all of the values for the low byte.

Indexing the CRC in this way provides faster execution than would be achieved by calculating a new CRC value with each new character from the message buffer.

Note: This function performs the swapping of the high/low CRC bytes internally. The bytes are already swapped in the CRC value that is returned from the function. Therefore the CRC value returned from the function can be directly placed into the message for transmission.

The function takes two arguments:

unsigned char *puchMsg ; 	A pointer to the message buffer
                                    containing binary data to be used
                                    for generating the CRC

unsigned short usDataLen ;	The quantity of bytes in the
                                    message buffer.
The function returns the CRC as a type unsigned short.

CRC Generation Function

unsigned short CRC16(puchMsg, usDataLen)

unsigned char *puchMsg ;		/* message to calculate CRC
upon */
unsigned short usDataLen ;		/* quantity of bytes in message
*/

{
    unsigned char uchCRCHi = 0xFF ;	/* high CRC byte
initialized */
    unsigned char uchCRCLo = 0xFF ;	/* low CRC byte
initialized  */
    unsigned uIndex ;				/* will index into CRC
lookup*/
                                            /* table
  */

    while (usDataLen--)		/* pass through message buffer
  */
        {
        uIndex = uchCRCHi ^ *puchMsgg++ ;	/* calculate the CRC
 */
        uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex} ;
        uchCRCLo = auchCRCLo[uIndex] ;
        }

    return (uchCRCHi << 8 | uchCRCLo) ;
}
High Order Byte Table

/* Table of CRC values for high-order byte */

static unsigned char auchCRCHi[] = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40,
0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1,
0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40
} ;
Low Order Byte Table

/* Table of CRC values for low-order byte */

static char auchCRCLo[] = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD,
0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A,
0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4,
0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3,
0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4,
0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29,
0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED,
0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60,
0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67,
0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68,
0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E,
0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71,
0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92,
0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B,
0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B,
0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42,
0x43, 0x83, 0x41, 0x81, 0x80, 0x40
} ;


Oxygen Transfer in Clean Water

Definitions and Nomenclature:

Oxygen Transfer Rate (OTR) - Mass of Oxygen per unit time dissolved in a volume of water by an oxygen transfer system operating under given conditions of temperature, barometric pressure, power, gas rate and dissolved oxygen concentration.
Standard Oxygen Transfer Rate (SOTR) - OTR in clean water when the DO concentration is zero at all points in the water volume, the water temperature is 20°C, and the barometric pressure is 1.00 atm (101kPa).
Aeration Efficiency (AE) - OTR per unit total power input. Power input may be based on either delivered brake or wire power, and this basis must be stated.
Standard Aeration Efficiency (SAE) - SOTR per unit total power input. Power input may be based on either delivered, brake, or wire power, and this basis must be stated.
Oxygen Transfer Efficiency (OTE) - Fraction of oxygen in an injected gas stream dissolved under given conditions of temperature, barometric pressure, gas rate, and DO concentration.
Standard Oxygen Transfer Efficiency (SOTE) - OTE in clean water when DO concentration is zero at all points in the water volume, the water temperature is 20°C, aand the barometric pressure is 1.00 atm (101kPa).


Resistor

resist.jpg (14447 bytes)

Standard Resistance Table:

Resistance Value Resistance Code
10
20
50
100
200
500
100
200
500
101
201
501
1K
2K
5K
102
202
502
10K
20K
25K
50K
103
203
253
503
100K
200K
250K
500K
750K
104
204
254
504
754
1M
2M
5M
105
205
505


Settlement of solid

SETTLEMENT OF SOLIDS

Table 1 - Typical operating critiria for settlement tanks in a temperature climate at maximum hourly flowrates,

Function
Retention time
(h)
Loading rate
(cu.m/sq.mday)
Weir overflow rate
(cu.m/mday)
Solids loading
(kg/sq.mday)
PRIMARY SELTTLEMENT
Large Scale
prior to activated sludge
prior to percolating filters
Small Scale
1 - 1-1/2
1-1/2 - 2
> 15
30 - 45
"
-
< 220
"
-
-
-
-
HUMUS TANK
Large scale
Small scale
1-1/3 - 1-2/3
> 4
35 - 40
-
< 200
-
-
-
ACTIVATED SLUDGE
Large Scale
Small Scale

45 - 60
< 22
< 250
< 100
< 180
< 100

Circular Tanks

Fig1 Radial flow tank

Rectangular Tanks

Table 2 - Dimensional reatios for rectangular tanks

(Length/Depth) approximate 12/1 : length < 90m
(Length/Depth) approximate 4/1
Depth using 3 - 3.5m; maximum 5m
Retention time 1-1/2 to 2h at maximum flow
Minimum number of tanks = 2


¡Special HTML Characters!
Otherwise known as iso8859-1.

Entity Name | Numeric Code | Descriptive Code | Character
quotation mark | &#34; | &quot; | "
ampersand | &#38; | &amp; | &
less-than sign | &#60; | &lt; | <
greater-than sign | &#62; | &gt; | >
non-breaking space | &#160; | &nbsp; |
inverted exclamation | &#161; | &iexcl; | ¡
cent sign | &#162; | &cent; | ¢
pound sterling | &#163; | &pound; | £
general currency sign | &#164; | &curren; | ¤
yen sign | &#165; | &yen; | ¥
broken vertical bar | &#166; | &brvbar; | ¦
section sign | &#167; | &sect; | §
umlaut(dieresis) | &#168; | &uml; | ¨
copyright | &#169; | &copy; | ©
feminineordinal | &#170; | &ordf; | ª
left angle quote, guillemotleft | &#171; | &laquo; | «
not sign | &#172; | &not; | ¬
soft hyphen | &#173; | &shy; |
registered trademark | &#174; | &reg; | ®
macron accent | &#175; | &macr; | ¯
degree sign | &#176; | &deg; | °
plus or minus | &#177; | &plusmn; | ±
superscript two | &#178; | &sup2; | ²
superscript three | &#179; | &sup3; | ³
acute accent | &#180; | &acute; | ´
micro sign (Mu) | &#181; | &micro; | µ
paragraph sign | &#182; | &para; | ¶
middle dot | &#183; | &middot; | ·
cedilla | &#184; | &cedil; | ¸
superscript one | &#185; | &sup1; | ¹
masculine ordinal | &#186; | &ordm; | º
right angle quote, guillemotright | &#187; | &raquo; | »
fraction one-fourth | &#188; | &frac14; | ¼
fraction one-half | &#189; | &frac12; | ½
fraction three-fourths | &#190; | &frac34; | ¾
inverted question mark | &#191; | &iquest; | ¿
capital A, grave accent | &#192; | &Agrave; | À
capital A, acute accent | &#193; | &Aacute; | Á
capital A, circumflex accent | &#194; | &Acirc; | Â
capital A, tilde | &#195; | &Atilde; | Ã
capital A, dieresis or umlaut mark | &#196; | &Auml; | Ä
capital A, ring (Angstrom) | &#197; | &Aring; | Å
capital AE diphthong (ligature) | &#198; | &AElig; | Æ
capital C, cedilla | &#199; | &Ccedil; | Ç
capital E, grave accent | &#200; | &Egrave; | È
capital E, acute accent | &#201; | &Eacute; | É
capital E, circumflex accent | &#202; | &Ecirc; | Ê
capital E, dieresis or umlaut mark | &#203; | &Euml; | Ë
capital I, grave accent | &#204; | &Igrave; | Ì
capital I, acute accent | &#205; | &Iacute; | Í
capital I, circumflex accent | &#206; | &Icirc; | Î
capital I, dieresis or umlaut mark | &#207; | &Iuml; | Ï
capital Eth, Icelandic | &#208; | &ETH; | Ð
capital N, tilde | &#209; | &Ntilde; | Ñ
capital O, grave accent | &#210; | &Ograve; | Ò
capital O, acute accent | &#211; | &Oacute; | Ó
capital O, circumflex accent | &#212; | &Ocirc; | Ô
capital O, tilde | &#213; | &Otilde; | Õ
capital O, dieresis or umlaut mark | &#214; | &Ouml; | Ö
multiply sign | &#215; | &times; | ×
capital O, slash | &#216; | &Oslash; | Ø
capital U, grave accent | &#217; | &Ugrave; | Ù
capital U, acute accent | &#218; | &Uacute; | Ú
capital U, circumflex accent | &#219; | &Ucirc; | Û
capital U, dieresis or umlaut mark | &#220; | &Uuml; | Ü
capital Y, acute accent | &#221; | &Yacute; | Ý
capital THORN, Icelandic | &#222; | &THORN; | Þ
small sharp s, German (sz ligature) | &#223; | &szlig; | ß
small a, grave accent | &#224; | &agrave; | à
small a, acute accent | &#225; | &aacute; | á
small a, circumflex accent | &#226; | &acirc; | â
small a, tilde | &#227; | &atilde; | ã
small a, dieresis or umlaut mark | &#228; | &auml; | ä
small a, ring | &#229; | &aring; | å
small ae diphthong (ligature) | &#230; | &aelig; | æ
small c, cedilla | &#231; | &ccedil; | ç
small e, grave accent | &#232; | &egrave; | è
small e, acute accent | &#233; | &eacute; | é
small e, circumflex accent | &#234; | &ecirc; | ê
small e, dieresis or umlaut mark | &#235; | &euml; | ë
small i, grave accent | &#236; | &igrave; | ì
small i, acute accent | &#237; | &iacute; | í
small i, circumflex accent | &#238; | &icirc; | î
small i, dieresis or umlaut mark | &#239; | &iuml; | ï
small eth, Icelandic | &#240; | &eth; | ð
small n, tilde | &#241; | &ntilde; | ñ
small o, grave accent | &#242; | &ograve; | ò
small o, acute accent | &#243; | &oacute; | ó
small o, circumflex accent | &#244; | &ocirc; | ô
small o, tilde | &#245; | &otilde; | õ
small o, dieresis or umlaut mark | &#246; | &ouml; | ö
division sign | &#247; | &divide; | ÷
small o, slash | &#248; | &oslash; | ø
small u, grave accent | &#249; | &ugrave; | ù
small u, acute accent | &#250; | &uacute; | ú
small u, circumflex accent | &#251; | &ucirc; | û
small u, dieresis or umlaut mark | &#252; | &uuml; | ü
small y, acute accent | &#253; | &yacute; | ý
small thorn, Icelandic | &#254; | &thorn; | þ
small y, dieresis or umlaut mark | &#255; | &yuml; | ÿ

Please note that similar characters (e.g. « & ») are ordered by their numeric-based code on this page and might not be located near each other. If you have difficulty recreating special characters that appear on this page, you can always resort to "viewing" this document source. Have fun!
Special Note: I have noticed that Netscape 2.02 for MacOS and Unix incorrectly render some of the letter-based descriptive codes. For maximum compatibility (i.e. professionalism) use the numeric codes for these special characters.

Especially Useful Special Characters |  | Examples
&#60 | < | <BLINK>
&#62 | > | </BLINK>
&#176 | ° | 273°K
&#183 | · | CuSO4·5 H2O


Thermocouple

Thermocouple is intended as an aid for anyone who uses thermocouples. It
will calculate the EMF generated by any of the standard thermocouples at any
temperature within their specified ranges; or will calculate the temperature
if the EMF is known. This can, therefore, be used by people
calibrating or designing thermometers based on thermocouples, or people who
wish to use thermocouples directly into a voltmeter without any intervening
electronics.
The formulae used by Thermocouple are based on BS 4937, for which full
credit is acknowledged. The formulae are claimed to give errors no greater
than the least significant digit in the BS 4937 tables. This should, in
theory, ensure that any results obtained by this program can be considered to
be correct for all practical purposes. (If anyone discovers otherwise PLEASE
let me know).


Plug Types by Country

WORLD WIDE PHONE GUIDE

What you need to hook up your modem just about anywhere!

Telephone Plug Types by Country

COUNTRY | PLUG TYPE
AFGHANISTAN | Russian
ALBANIA | Greek, Russian
ALGERIA | French
ANDORRA | US RJ-11
ANGOLA | Portuguese, US RJ-11
ANTIGUA & BARBUDA | US RJ-11
ARGENTINA | Argentinean (2 types), US RJ-11
ARMENIA | Russian
ARUBA | Venezuela/Colombia/US RJ-11
AUSTRALIA | RJ-45/Australian/US RJ-11
AUSTRIA | Austrian (Tax impulses)
AZERBAIJAN | Russian
AZORES | Portuguese, US RJ-11
BAHAMAS | US RJ-11
BAHRAIN | British
BALI | US RJ-11
BALEARIC ISLANDS | US RJ-11
BANGLADESH | British, US RJ-11
BARBADOS | US RJ-11
BELARUS | British, US RJ-11
BELGIUM | Belgian, US RJ-11 (Tax impulses)
BELIZE | British, US RJ-11
BENIN | French, South African
BERMUDA | US RJ-11
BHUTAN | French, US RJ-11
BOLIVIA | US RJ-11
BORNEO | US RJ-11
BOSNIA/HERZEGOVINA | Yugoslavian, US RJ-11 (maybe)
BOTSWANA | British
BRAZIL | US RJ-11, Brazilian, French
BRUNEI | British, US RJ-11
BULGARIA | US RJ-11 , Yugoslavian (?)
BURKINA FASO | French
BURMA (MYANMAR) | US RJ-11
BURUNDI | South African
CAMBODIA | US RJ-11
CAMEROON | South African
CANADA | US RJ-11
CANARY ISLANDS | US RJ-11
CAPE VERDE ISLANDS | US RJ-11
CAYMAN ISLANDS | US RJ-11
CENTRAL AFRICAN REPUBLIC | South African
CHAD | French
CHILE | US RJ-11
CHINA | US RJ-11
COLOMBIA | Colombian/US RJ-11
CIS | Russian
COMOROS | French
CONGO | French
CONGO, DEM. REP. (ZAIRE) | Belgian, South African
COOK ISLANDS | Australian
COSTA RICA | US RJ-11
CROATIA | Yugoslavian
CÔTE D'IVOIRE (IVORY COAST) | French
CUBA | Russian, US RJ-11
CYPRUS | British, US RJ-11
CZECH REPUBLIC | Czech, Germany (old), (Tax impulses)
DENMARK | Danish
DIEGO GARCIA | US RJ-11
DJIBOUTI | French
DOMINICA | US RJ-11
DOMINICAN REPUBLIC | US RJ-11
ECUADOR | US RJ-11
EGYPT | US RJ-11
EL SALVADOR | US RJ-11
ENGLAND | British
EQUATORIAL GUINEA | French, US RJ-11
ERITREA | British , US RJ-11
ESTONIA | Russian
ETHIOPIA | Italian
FAEROE ISLANDS | Danish
FALKLAND ISLANDS | British
FIJI | Australian
FINLAND | Finnish/Norwegian
FRANCE | French
FRENCH ANTILLES | French, US RJ-11
FRENCH GUIANA | French, US RJ-11
FRENCH POLYNESIA | French
GABON | French
GAMBIA | French
GEORGIA | Russian
GERMANY | US RJ-11, German (5 types) (Tax impulses)
GHANA | British (old), US RJ-11
GIBRALTAR | British
GREECE | US RJ-11, Greek (2 types)
GREENLAND | Danish
GRENADA | US RJ-11
GRENADINES | French, US RJ-11
GUADELOUPE | French
GUAM | US RJ-11
GUATEMALA | US RJ-11
GUINEA | US RJ-11
GUINEA-BISSAU | US RJ-11
GUYANA | US RJ-11
HAITI | US RJ-11
HONDURAS | US RJ-11
HONG KONG | British , US RJ-11
HUNGARY | Hungarian, Austrian, US RJ-11
ICELAND | US RJ-11
INDIA | British (old), US RJ-11
INDONESIA | Australian, US RJ-11
IRAN | US RJ-11, Turkish, Jordan/Saudi
IRAQ | US RJ-11, Turkish, Jordan/Saudi
IRELAND, NORTHERN | British
IRELAND, REPUBLIC OF | US RJ-11
ISLE OF MAN | British
ISRAEL | Israeli (2 types)
ITALY | Italian (2 types), US RJ-11
JAMAICA | US RJ-11
JAPAN | Japanese, US RJ-11
JORDAN | British , Jordan/Middle East, US RJ-11
KAMPUCHEA | US RJ-11
KAZAKHSTAN | Russian
KENYA | British , British (old), US RJ-11
KIRIBATI | US RJ-11
KOREA (NORTH) | Korean
KOREA (SOUTH) | Korean, US RJ-11
KUWAIT | British , Jordan/Middle East, US RJ-11
LAOS | US RJ-11
LATVIA | Russian
LEEWARD ISLANDS | Dutch, French, US RJ-11
LEBANON | US RJ-11
LESOTHO | British, South African, US RJ-11
LIBERIA | US RJ-11
LIECHTENSTEIN | German (5 types), Swiss (2 types)
LITHUANIA | Russian
LUXEMBOURG | German (old)
MACAO | Portuguese, US RJ-11
MACEDONIA | British , US RJ-11
MADAGASCAR | French
MADEIRA | Portuguese, US RJ-11
MALAWI | British , Danish, US RJ-11
MALAYSIA | US RJ-11
MALDIVE ISLANDS | US RJ-11
MALI | French
MALTA | British
MARTINIQUE | French
MAURITANIA | French
MAURITIUS | French, US RJ-11
MEXICO | US RJ-11
MICRONESIA | British , French, US RJ-11
MOLDOVA | US RJ-11
MONACO | French
MONGOLIA | Russian
MONTSERRAT | US RJ-11
MOROCCO | French
MOZAMBIQUE | Portuguese, US RJ-11
MYANMAR (BURMA) | British , US RJ-11
NAMIBIA | South African
NETHERLANDS | Dutch, US RJ-11
NETHERLANDS ANTILLES | Dutch
NEW CALEDONIA | French
NEW HEBRIDES | British , US RJ-11
NEW ZEALAND | British
NICARAGUA | US RJ-11
NIGER | French
NIGERIA | British, British (old)
NORFOLK ISLAND | Australian
NORWAY | Finnish/Norwegian, RJ-45
OKINAWA | Japan, US RJ-11
OMAN | British, US RJ-11
PAKISTAN | US RJ-11
PALAU | Australian
PANAMA | US RJ-11
PAPUA NEW GUINEA | Australian, US RJ-11
PARAGUAY | US RJ-11
PERU | US RJ-11
PHILIPPINES | US RJ-11
POLAND | Russian
PORTUGAL | US RJ-11, Portuguese, Danish
PUERTO RICO | US RJ-11
QATAR | British , US RJ-11
RÉUNION | Australian, French
ROMANIA | US RJ-11
RUSSIA | Russian
RWANDA | French
SAINT KITTS & NEVIS | US RJ-11
SAINT LUCIA | US RJ-11
SAINT MARTIN | French
ST. PIERRE/MIQUELON | French
ST. VINCENT | British
SAMOA, AMERICAN | US RJ-11
SAMOA, WESTERN | Australian, US RJ-11
SAN MARINO | Italian
SÃO TOMÉ & PRINCIPE | US RJ-11
SAUDI ARABIA | US RJ-11, British, French, Jordan/Saudi, US (old)
SCOTLAND | British
SENEGAL | French, South African
SEYCHELLES | US RJ-11
SIERRA LEONE | British (old)
SINGAPORE | US RJ-11
SLOVAKIA | Russian
SLOVENIA | Yugoslavian
SOLOMON ISLANDS | Australian
SOMALIA | French
SOUTH AFRICA | South African, US RJ-11
SPAIN | US RJ-11 (Tax impulses)
SRI LANKA | British , US RJ-11
SUDAN | Italian
SURINAM | Dutch
SWAZILAND | British
SWEDEN | Swedish, US RJ-11
SWITZERLAND | Swiss (2 types) (Tax impulses)
SYRIA | Turkish, US RJ-11
TAHITI | French, US RJ-11
TAIWAN | US RJ-11
TAJIKISTAN | Russian
TANZANIA | British
THAILAND | US RJ-11
TIBET | Russian , US RJ-11
TOGO | French
TONGA | Australian
TRINIDAD & TOBAGO | US RJ-11
TUNISIA | French
TURKEY | Turkish, US RJ-11
TURKMENISTAN | Turkish, Russian , US RJ-11
TURKS & CAICOS | US RJ-11
TUVALU | British , US RJ-11
UNITED ARAB EMIRATES | British (Ajman and Abu Dhabi), US RJ-11
UGANDA | US RJ-11
UKRAINE | Russian
UNITED STATES | US RJ-11
URUGUAY | US RJ-11
UZBEKISTAN | Russian
VANUATU | British , US RJ-11
VENEZUELA | Venezuelan, US RJ-11
VIETNAM | US RJ-11
VIRGIN ISLANDS | US RJ-11
WALES | British
YEMEN | US RJ-11
YUGOSLAVIA (FORMER) | Yugoslavian
ZAMBIA | British
ZIMBABWE | British, South African

Argentina phone plugs

Argentina phone adapter - 1 Argentina phone adaptor - 2

Australian phone plug (with RJ-11 adapter)

Australian phone plug

Austrian phone plug

Austria phone adapter

Belgium phone plug (with RJ-11 adapter)

Czech phone plug

Czech phone adapter

Denmark phone plug (with RJ-11 adapter)

Finland/Norway phone plug (with RJ-11 adapter)

French phone plug

French phone adapter

German phone plugs

German phone adapter - 1 German phone adapter - 2 German phone adapter - 3

German phone adapter - 1 German phone adapter - Old

Greece phone plug

Greek phone adapter

Greek phone plugs

Greek phone adapter Israel/Greek (old) phone adapter

Netherlands phone plug (with RJ-11 adapter)

Hungary phone plug

Hungarian phone adapter

Italian phone plugs

Italian phone adapter IT_PH_ADAPTOR_OLD.GIF (1089 bytes)

Japanese phone plug

Japanese phone adapter

Jordan/Saudi Arabia phone plug

Jordan/Saudi phone adapter

Korea phone plug (with RJ-11 adapter)

Danish/Portuguese phone plug

Denmark/Portugal phone adapter

US RJ-11 phone plug

RJ-45 phone plug

Russian phone plug (with RJ-11 adapter)

South African phone plug (with RJ-11 adapter)

Sweden phone plug (with RJ-11 adapter)

Switzerland phone plugs

Swiss Phone Adapter Swiss Phone Adapter (old)

Turkish phone plug

Turkish phone adapter

United Kingdom (British) phone plug

British phone plug

British (old) phone plug

British (old) phone adapter

Columbia/Venezuela phone plug

Venezuela phone adapter


TTL Name

bi-polar TTL (54/74)integrated circuits

7400 Quadruple 2-Input Positive-NAND Gates

7401 Quadruple 2-Input Positive-NAND Gates With Open Collector Outputs

7402 Quadruple 2-Input Positive-NOR Gates

7403 Quadruple 2-Input Positive-NAND Gates With Open-Collector Outputs

7404 Hex Inverters

7405 Hex Inverters With Open-Collector Outputs

7406 Hex Inverter Buffers/Drivers With Open-Collector High-Voltage Outputs

7407 Hex Buffers/Drivers With Open-Collector High-Voltage Outputs

7408 Quadruple 2-Input Positive-AND Gates

7409 Quadruple 2-Input Positive-AND Gates With Open-Collector Outputs

7410 Triple 3-Input Positive-NAND Gates

7411 Triple 3-Input Positive-AND Gates

7412 Triple 3-Input Positive-NAND Gates With Open-Collector Outputs

7413 Dual 4-Input Positive-NAND Schmitt Triggers

7414 Hex Schmitt-Trigger Inverters

7415 Triple 3-Input Positive-AND Gates With Open-Collector Outputs

7416 Hex Inverter Buffers/Drivers With Open-Collector High-Voltage Outputs

7417 Hex Buffers/Drivers With Open-Collector High-Voltage Outputs

7418 Dual 4-Input Positive-NAND Schmitt Triggers With Totem-Pole Outputs

7419 Hex Schmitt-Trigger Inverters With Totem-Pole Outputs

7420 Dual 4-Input Positive-NAND Gates

7421 Dual 4-Input Positive-AND Gates

7422 Dual 4-Input Positive-NAND Gates With Open Collector Outputs

7423 Dual 4-Input NOR Gates With Strobe

7424 Quadruple 2-Input Positive-NAND Schmitt Triggers With Totem-Pole Outputs

7425 Dual 4-Input NOR Gates With Strobe

7426 High-Voltage Interface Positive-NAND Gates

7427 Triple 3-Input Positive-NOR Gates

7428 Quadruple 2-Input Positive-NOR Buffers

7430 8-Input Positive-NAND Gate

7431 Delay Elements

7432 Quadruple 2-Input Positive-OR Gates

7433 Quadruple 2-Input Positive-NOR Buffers With Open-Collector Outputs

7434 Hex Noninverters

7435 Hex Noninverters With Open-Collector Outputs

7437 Quadruple 2-Input Positive-NAND Buffers

7438 Quadruple 2-Input Positive-NAND Buffers With Open-Collector Outputs

7439 Quadruple 2-Input Positive-NAND Buffers With Open-Collector Outputs

7440 Dual 4-Input Positive-NAND Buffers

7442 4-Line to 10-Line Decoder BCD-To-Decimal

7443 4-Line to 10-Line Decoder Excess 3-To-Decimal

7444 4-Line to 10-Line Decoder Gray-To-Decimal

7445 BCD To Decimal Decoders/Drivers

7446 BCD To Seven-Segment Decoder/Driver With Open Collector Outputs

7447 BCD To Seven-Segment Decoder/Driver With Open Collector Outputs

7448 BCD To Seven-Segment Decoder/Driver With Internal Pull-Ups

7449 BCD To Seven-Segment Decoder/Driver With Open Collector Outputs

7450 Dual 2-Wide 2-Input AND-OR-INVERT Gates (One Gate Expandable)

7451 Two 2-Wide 2-Input AND-OR-INVERT Gates

7452 Expandable 4-Wide AND-OR Gates

7453 Expandable 4-Wide AND-OR-INVERT Gate

7454 4-Wide AND-OR-INVERT Gate

7455 2-Wide 4-Input AND-OR-INVERT Gate (Expandable)

7456 Frequency Divider (50:1)

7457 Frequency Divider (60:1)

7460 Dual 4-Input Expanders

7461 Triple 3-Input Expanders

7462 4-Wide AND-OR Expander

7463 Hex Current-Sensing Interface Gates With Totem-Pole Outputs

7464 4-2-3-2 Input AND-OR-INVERT Gate (Totem-Pole Outputs)

7465 4-2-3-2 Input AND-OR-INVERT Gate (Open-Collector Outputs)

7468 Dual 4-Bit Decade Counters

7469 Dual 4-Bit Binary Counters

7470 AND-Gated J-K Positive-Edge-Triggered Flip-Flops With Preset And Clear

7471 AND-OR Gated J-K Master-Slave Flip-Flops With Preset

7472 AND-Gated J-K Master-Slave Flip-Flops With Preset And Clear

7473 Dual J-K Flip-Flops With Clear

7474 Dual D-Type Positive-Edge-Triggered Flip-Flops With Preset And Clear

7475 4-Bit Bistable Latches

7476 Dual J-K Flip-Flops With Preset And Clear

5477 4-Bit Bistable Latches

7478 Dual J-K Flip-Flops With Preset, Common Clock, And Common Clear

7480 Gated Full Adder

7482 2-Bit Binary Full Adder

7483 4-Bit Binary Full Adder With Fast Carry

7485 4-Bit Magnitude Comparator

7486 Quadruple 2-Input EXCLUSIVE-OR Gates

7487 4-Bit True/Complement, Zero/One Elements

7490 Decade Counter

7491 8-Bit Shift Register

7492 Divide-By-Twelve Counter

7493 4-Bit Binary Counter

7494 4-Bit Shift Register

7495 4-Bit Parallel-Access Shift Registers

7496 5-Bit Shift Register

7497 Synchronous 6-Bit Rate Multiplier

5498 4-Bit Data Selector/Storage Register

5499 4-Bit Right-Shift Left-Shift Register

74100 8-Bit Bistable Latches

74101 AND-OR-Gated J-K Negative-Edge-Triggered Flip-Flops With Preset

74102 AND-Gated J-K Negative-Edge-Triggered Flip-Flops With Preset

74103 Dual J-K Negative-Edge-Triggered Flip-Flops With Clear

74104 Gated J-K Master-Slave Flip-Flops

74105 Gated J-K Master-Slave Flip-Flops

74106 Dual J-K Negative-Edge-Triggered Flip-Flops With Preset and Clear

74107 Dual J-K Flip Flops With Clear

74108 Dual J-K Negative-Edge-Triggered Flip-Flops With Preset Common Clear And Clock

74109 Dual J-K Positive-Edge-Triggered Flip-Flops With Preset And Clear

74110 AND-Gated J-K Master-Slave Flip-Flops With Data Lockout

74111 Dual J-K Master-Slave Flip-Flops With Data Lockout

74112 Dual J-K Negative-Edge-Triggered Flip-Flops With Preset And Clear

74113 Dual J-K Negative-Edge-Triggered Flip-Flops With Preset

74114 Dual J-K Negative-Edge-Triggered Flip-Flops With Preset Common Clear And Clock

74116 Dual 4-Bit Latches With Clear

74120 Dual Pulse Synchronizers/Drivers

74121 Monostable Multivibrator With Schmitt-Trigger Inputs

74122 Retriggerable Monostable Multivibrator

74123 Dual Retriggerable Monostable Multivibrators

74124 Dual Voltage-Controlled Oscillators

74125 Quad Bus Buffers With 3-State Outputs

74126 Quad Bus Buffers With 3-State Outputs

74128 Line Drivers

74130 Dual Retriggerable Monostable Multivibrators

74131 3-Line To 8-Line Decoder/Demultiplexer With Address Registers

74132 Quadruple 2-Input Positive-NAND Schmitt Triggers

74133 13-Input Positive-NAND Gate

74134 12-Input Positive-NAND Gate With 3-State Output

74135 Quadruple EXCLUSIVE-OR/NOR Gates

74136 Quadruple 2-Input EXCLUSIVE-OR Gates With Open-Collector Outputs

74137 3-Line To 8-Line Decoders/Demultiplexers With Address Latches

74138 3-Line To 8-Line Decoders/Demultiplexers

74139 Dual 2-Line To 4-Line Decoders/Demultiplexers

74140 Dual 4-Input Positive-NAND 50-Ohm Line Drivers

74141 BCD-To-Decimal Decoder/Driver

74142 BCD Counter/4-Bit Latch/BCD Decoder/Driver

74143 4-Bit Counter/Latch, Seven-Segment LED/Lamp Drivers

74144 4-Bit Counter/Latch, Seven-Segment LED/Lamp Drivers

74145 BCD-To-Decimal Decoder/Driver

74147 10-Line To 4- Line Priority Encoder

74148 8-Line To 3- Line Priority Encoder

74150 1 Of 16 Data Selectors/Multiplexers

74151 1 Of 8 Data Selectors/Multiplexers

54152 1 Of 8 Data Selectors/Multiplexers

74153 Dual 4-Line To 1-Line Data Selectors/Multiplexers

74154 4-Line To 16-Line Decoder/Demultiplexer

74155 Dual 2-Line To 4-Line Decoders/Demultiplexers With Totem Pole Outputs

74156 Dual 2-Line To 4-Line Decoders/Demultiplexers With Open-Collector Outputs

74157 Quadruple 2-Line To 1-Line Data Selector/Multiplexer

74158 Quadruple 2-Line To 1-Line Data Selector/Multiplexer

74159 4-Line To 16-Line Decoder/Demultiplexer With Open-Collector Outputs

74160 Synchronous 4-Bit Counter With Direct Clear

74161 Synchronous 4-Bit Counter With Direct Clear

74162 Fully Synchronous 4-Bit Counter

74163 Fully Synchronous 4-Bit Counter

74164 8-Bit Parallel-Out Serial Shift Register

74165 Parallel-Load 8-Bit Shift Register

74166 Parallel-Load 8-Bit Shift Register

74167 Synchronous Decade Rate Multiplier

74168 Synchronous 4-Bit Up/Down Decade Counter

74169 Synchronous 4-Bit Up/Down Binary Counter

74170 4-By-4 Register File With Open-Collector Outputs

74171 Quadruple D-Type Flip-Flops With Clear

74172 16-Bit Multiple-Port Register File With 3-State Outputs

74173 4-Bit D-Type Registers With 3-State Outputs

74174 Hex D-Type Flip-Flops With Clear

74175 Quadruple D-Type Flip-Flops With Clear

74176 35-MHz Presettable Decade And Binary Counters/Latches

74177 35-MHz Presettable Decade And Binary Counters/Latches

74178 4-Bit Parallel-Access Shift Registers

74179 4-Bit Parallel-Access Shift Registers

74180 9-Bit Odd/Even Parity Generators/Checkers

74181 Arithmetic Logic Unit/Function Generator

74182 Look-Ahead Carry Generator

74183 Dual Carry-Save Full Adders

74184 BCD To Binary Converter

74185 Binary To BCD Converter

74190 Synchronous BCD Up/Down Counters With Down/Up Mode Control

74191 Synchronous Binary Up/Down Counters With Down/Up Mode Control

74192 Synchronous BCD 4-Bit Up/Down Counters (Dual Clock With Clear)

74193 Synchronous Binary 4-Bit Up/Down Counters (Dual Clock With Clear)

74194 4-Bit Bidirectional Universal Shift Register

74195 4-Bit Parallel-Access Shift Register

74196 50 MHz Presettable BCD Counter/Latch

74197 50 MHz Presettable Binary Counter/Latch

74198 8-Bit Shift Register

74199 8-Bit Shift Register

74221 Dual Monostable Multivibrators With Schmitt-Trigger Inputs

74222 16 X 4 Synchronous First-In First-Out Memory With 3-State Outputs

74224 16 X 4 Synchronous First-In First-Out Memory With 3-State Outputs

74225 16 X 5 Asynchronous First-In First-Out Memory

74226 4-Bit Parallel Latched Bus Transceiver

74227 16 X 4 Synchronous First-In First-Out Memory With Open-Collector Outputs

74228 16 X 4 Synchronous First-In First-Out Memory With Open-Collector Outputs

74229 16 X 5 Asynchronous First-In First-Out Memory

74230 Octal Buffers And Line Drivers With 3-State Outputs

74231 Octal Buffers And Line Drivers With 3-State Outputs

74232 16 X Asynchronous First-In First-Out Memory

74233 16 X 5 Asynchronous First-In First-Out Memory

74240 Octal Buffers And Line Drivers With 3-State Outputs

74241 Octal Buffers And Line Drivers With 3-State Outputs

74242 Quadruple Bus Transceiver

74243 Quadruple Bus Transceiver

74244 Octal Buffers And Line Driver With 3-State Outputs

74245 Octal Bus Transceivers With 3-State Outputs

74246 BCD-To-Seven-Segment Decoder/Driver

74247 BCD-To-Seven-Segment Decoder/Driver

74248 BCD-To-Seven-Segment Decoder/Driver

74249 BCD-To-Seven-Segment Decoder/Driver

74250 1-Of-16 Data Generator/Multiplexer With 3-State Outputs

74251 1 Of 8 Data Selector/Multiplexer With 3-State Outputs

74253 Dual 4-Line To 1-Line Data Selector/Multiplexer With 3-State Outputs

74257 Quadruple 2-Line To 1-Line Data Selector/Multiplexer

74258 Quadruple 2-Line To 1-Line Data Selector/Multiplexer

74259 8-Bit Addressable Latch

74260 Dual 5-Input Positive NOR Gate

74261 2-Bit By 4-Bit Parallel Binary Multiplexer

74264 Look-Ahead Carry Generator For Counters

74265 Quadruple Complementary-Output Elements

74266 Quadruple 2-Input EXCLUSIVE-NOR Gates With Open-Collector Outputs

74268 Hex D-Type Transparent Latches With 3-State Outputs

74273 Octal D-Type Flip-Flop With Clear

74275 7-Bit-Slice Wallace Trees

74276 Quadruple J-K Flip-Flops

74278 4-Bit Cascadable Priority Register

74279 Quadruple S-R Latches

74280 9-Bit Odd/Even Parity Generator/Checker

74281 4-Bit Parallel Binary Accumulator

74282 Look-Ahead Carry Generator With Selectable Carry Inputs

74283 4-Bit Binary Full Adder With Fast Carry

74284 4-Bit By 4-Bit Parallel Binary Multiplier

74285 4-Bit By 4-Bit Parallel Binary Multiplier

74286 9-Bit Parity Generator/Checker With Bus Driver Parity I/O Port

74290 Decade Counter

74292 Programmable Frequency Divider/Digital Timer

74293 4-Bit Binary Counter

74294 Programmable Frequency Divider/Digital Timer

74295 4-Bit Right-Shift Left-Shift Register With 3-State Outputs

74297 Digital Phase-Locked-Loop Filter

74298 Quadruple 2-Input Multiplexer With Storage

74299 8-Bit Universal Shift/Storage Register With 3-State Outputs

74320 Crystal-Controlled Oscillator

74321 Crystal-Controlled Oscillator

74322 8-Bit Shift Register With Sign Extend

74323 8-Bit Universal Shift/Storage Register With 3-State Outputs

74347 BCD-To-Seven-Segment Decoder/Driver

74348 8-Line To 3-Line Priority Encoder With 3-State Outputs

74350 4-Bit Shifter With 3-State Outputs

74351 Dual Data Selector/Multiplexer With 3-State Outputs

74352 Dual 4-Line To 1-Line Data Selector/Multiplexer

74353 Dual 4-Line To 1-Line Data Selector/Multiplexer With 3-State Outputs

74354 8-Line To 1-Line Data Selector/Multiplexer/Register With 3-State Outputs

74355 8-Line To 1-Line Data Selector/Multiplexer/Register With Open-Collector Outputs

74356 8-Line To 1-Line Data Selector/Multiplexer/Register With 3-State Outputs

74357 8-Line To 1-Line Data Selector/Multiplexer/Register With Open-Collector Outputs

74365 Hex Bus Drivers With 3-State Outputs

74366 Hex Bus Drivers With 3-State Outputs

74367 Hex Bus Drivers With 3-State Outputs

74368 Hex Bus Drivers With 3-State Outputs

74373 Octal D-Type Transparent Latches And Edge-Triggered Flip-Flops

74374 Octal D-Type Transparent Latches And Edge-Triggered Flip-Flops

74375 4-Bit Bistable Latches

74376 Quadruple J-K Flip-Flops

54377 Octal D-Type Flip-Flops With Enable

74378 Hex D-Type Flip-Flops With Enable

74379 Quad D-Type Flip-Flops With Enable

74381 Arithmetic Logic Unit/Function Generator

74382 Arithmetic Logic Unit/Function Generator

74384 8-Bit By 1-Bit Two's-Complement Multipliers

74385 Quadruple Serial Adder/Subtractor

74386 Quadruple 2-Input EXCLUSIVE-OR Gates

74390 Dual 4-Bit Decade Counters

74393 Dual 4-Bit Binary Counters

74395 4-Bit Cascadable Shift Register With 3-State Outputs

74396 Octal Storage Register

74398 Quadruple 2-Input Multiplexer With Storage

74399 Quadruple 2-Input Multiplexer With Storage

74412 Multi-Mode Buffered Latches

74422 Retriggerable Monostable Multivibrator

74423 Retriggerable Monostable Multivibrators

74424 Clock Elements

74425 Quadruple Bus Buffers With 3-State Outputs

74426 Quadruple Bus Buffers With 3-State Outputs

74436 Line Driver/Memory Driver Circuit

74437 Line Driver/Memory Driver Circuit

74440 Quadruple Tridirectional Bus Transceiver

With Open-Collector Outputs

74441 Quadruple Tridirectional Bus Transceiver With Open-Collector Outputs

74442 Quadruple Tridirectional Bus Transceiver With 3-State Outputs

74443 Quadruple Tridirectional Bus Transceiver With 3-State Outputs

74444 Quadruple Tridirectional Bus Transceiver With 3-State Outputs

74445 BCD-To-Decimal Decoder/Driver

74446 Quadruple Bus Transceiver With Individual Direction Controls

74447 BCD-To-Seven Decoder/Driver

74448 Quadruple Tridirectional Bus Transceiver With Open-Collector Outputs

74449 Quadruple Bus Transceiver With Individual Direction Controls

74465 Octal Buffers With 3-State Outputs

74466 Octal Buffers With 3-State Outputs

74467 Octal Buffers With 3-State Outputs

74468 Octal Buffers With 3-State Outputs

74490 Dual 4-Bit Decade Counter

74518 8-Bit Identity Comparator With Open-Collector Outputs

74519 8-Bit Identity Comparator With Open-Collector Outputs

74520 8-Bit Identity Comparator With Totem-Pole Outputs

74521 8-Bit Identity Comparator With Totem-Pole Outputs

74522 8-Bit Identity Comparator With Open-Collector Outputs

74526 16-Bit Fuse-Programmable Identity Comparator

74527 8-Bit Fuse-Programmable Identity Comparator And 4-Bit Comparator

74528 12-Bit Fuse-Programmable Identity Comparator

74533 Octal D-Type Transparent Latches With 3-State Outputs

74534 Octal D-Type Edge-Triggered Flip-Flops With 3-State Outputs

74538 3 - To 8 - Line Decoder/Demultiplexer

74539 2 - To 4 - Line Decoder/Demultiplexer

74540 Octal Buffers And Line Drivers With 3-State Outputs

74541 Octal Buffers And Line Drivers With 3-State Outputs

74560 Synchronous 4-Bit Counter With 3-State Outputs

74561 Synchronous 4-Bit Counter With 3-State Outputs

74563 Octal D-Type Transparent Latches With 3-State Outputs

74564 Octal D-Type Edge-Triggered Flip-Flops With 3-State Outputs

74568 Synchronous 4-Bit Decade Up/Down Counter With 3-State Outputs

74569 Synchronous 4-Bit Binary Up/Down Counter With 3-State Outputs

74573 Octal D-Type Transparent Latches With 3-State Outputs

74574 Octal D-Type Edge-Triggered Flip-Flops With 3-State Outputs

74575 Octal D-Type Edge-Triggered Flip-Flops With 3-State Outputs

74576 Octal D-Type Edge-Triggered Flip-Flops With 3-State Outputs

74577 Octal D-Type Edge-Triggered Flip-Flops With 3-State Outputs

74580 Octal D-Type Transparent Latches With 3-State Outputs

74589 8-Bit Shift Register With Input Latches And 3-State Outputs

74590 8-Bit Binary Counter With Output Register And 3-State Outputs

74591 8-Bit Binary Counter With Output Register And Open-Collector Outputs

74592 8-Bit Binary Counter With Input Registers

74593 8-Bit Binary Counter With Input Registers And 3-State I/O

74594 8-Bit Shift Register With Buffered Output Latches

74595 8-Bit Shift Register With 3-State Output Latches

74596 8-Bit Shift Register With Open-Collector Output Latches

74597 8-Bit Shift Register With Input Latches

74598 8-Bit Shift Register With 3-State Input Latches

74599 8-Bit Shift Register With Open-Collector Output Latches

74600 Memory Refresh Controller

74601 Memory Refresh Controller

74602 Memory Refresh Controller

74603 Memory Refresh Controller

74604 Octal 2-Input Multiplexed Latches With 3-State Outputs

74605 Octal 2-Input Multiplexed Latches With Open-Collector Outputs

74606 Octal 2-Input Multiplexed Latches With 3-State Outputs

74607 Octal 2-Input Multiplexed Latches With Open-Collector Outputs

74608 Memory Cycle Controller

74610 Memory Mapper With 3-State Outputs

74611 Memory Mapper With Open-Collector Outputs

74612 Memory Mapper With 3-State Outputs

74613 Memory Mapper With Open-Collector Outputs

74614 Octal Bus Transceiver And Register With Open-Collector Outputs

74615 Octal Bus Transceiver And Register With Open-Collector Outputs

74616 16-Bit Parallel Error Detection And Correction Circuit With 3-State Outputs

74617 16-Bit Parallel Error Detection And Correction Circuit With Open-Collector Outputs

74620 Octal Bus Transceiver With 3-State Outputs

74621 Octal Bus Transceiver With Open-Collector Outputs

74622 Octal Bus Transceiver With Open-Collector Outputs

74623 Octal Bus Transceiver With 3-State Outputs

74624 Voltage-Controlled Oscillator

74625 Dual Voltage-Controlled Oscillator

74626 Dual Voltage-Controlled Oscillator

74627 Dual Voltage-Controlled Oscillator

74628 Voltage-Controlled Oscillator

74629 Dual Voltage-Controlled Oscillator

74630 16-Bit Parallel Error Detection And Correction Circuit With 3-State Outputs

74631 16-Bit Parallel Error Detection And Correction Circuit With Open-Collector Outputs

74632 32-Bit Parallel Error Detection And Correction Circuit With 3-State Outputs

74633 32-Bit Parallel Error Detection And Correction Circuit With Open-Collector Outputs

74634 32-Bit Parallel Error Detection And Correction Circuit With 3-State Outputs

74635 32-Bit Parallel Error Detection And Correction Circuit With Open-Collector Outputs

74636 8-Bit Parallel Error Detection And Correction Circuit With 3-State Outputs

74637 8-Bit Parallel Error Detection And Correction Circuit With Open-Collector Outputs

74638 Octal Bus Transceiver

74639 Octal Bus Transceiver

74640 Octal Bus Transceiver With 3-State Outputs

74641 Octal Bus Transceiver With Open-Collector Outputs

74642 Octal Bus Transceiver With Open-Collector Outputs

74643 Octal Bus Transceiver With 3-State Outputs

74644 Octal Bus Transceiver With Open-Collector Outputs

74645 Octal Bus Transceiver With 3-State Outputs

74646 Octal Bus Transceiver And Register With 3-State Outputs

74647 Octal Bus Transceiver And Register With Open-Collector Outputs

74648 Octal Bus Transceiver And Register With 3-State Outputs

74649 Octal Bus Transceiver And Register With Open-Collector Outputs

74651 Octal Bus Transceiver And Register

74652 Octal Bus Transceiver And Register

74653 Octal Bus Transceiver And Register

74654 Octal Bus Transceiver And Register

74666 8-Bit D-Type Transparent Read-Back Latches With 3-State Outputs

74667 8-Bit D-Type Transparent Read-Back Latches With 3-State Outputs

74668 Synchronous 4-Bit Up/Down Decade Counter

74669 Synchronous 4-Bit Up/Down Binary Counter

74670 4-By-4 Register File With 3-State Outputs

74671 4-Bit Universal Register/Latch With 3-State Outputs

74672 4-Bit Universal Register/Latch With 3-State Outputs

74673 16-Bit Shift Register

74674 16-Bit Shift Register

74677 16-Bit Address Comparator With Enable

74678 16-Bit Address Comparator With Latch

74679 12-Bit Address Comparator With Enable

74680 12-Bit Address Comparator With Latch

74681 4-Bit Parallel Binary Accumulator

74682 8-Bit Magnitude/Identity Comparator With Totem-Pole Outputs

74683 8-Bit Magnitude/Identity Comparator With Open-Collector Outputs

74684 8-Bit Magnitude/Identity Comparator With Totem-Pole Outputs

74685 8-Bit Magnitude/Identity Comparator With Open-Collector Outputs

74686 8-Bit Magnitude/Identity Comparator With Totem-Pole Outputs

74687 8-Bit Magnitude/Identity Comparator With Open-Collector Outputs

74688 8-Bit Magnitude/Identity Comparator With Totem-Pole Outputs

74689 8-Bit Magnitude/Identity Comparator With Open-Collector Outputs

74690 Synchronous Decade Counter With Output Registers And Multiplexed 3-State Outputs

74691 Synchronous Binary Counter With Output Registers And Multiplexed 3-State Outputs

74692 Synchronous Decade Counter With Output Registers And Multiplexed 3-State Outputs

74693 Synchronous Binary Counter With Output Registers And Multiplexed 3-State Outputs

74696 Synchronous Up/Down Decade Counter With Output Registers And Multiplexed 3-State Outputs

74697 Synchronous Up/Down Binary Counter With Output Registers And Multiplexed 3-State Outputs

74698 Synchronous Up/Down Decade Counter With Output Registers And Multiplexed 3-State Outputs

74699 Synchronous Up/Down Binary Counter With Output Registers And Multiplexed 3-State Outputs

74746 Octal Buffers and Line Drivers With Input Pull-Up Resistors

74747 Octal Buffers and Line Drivers With Input Pull-Up Resistors

74756 Octal Buffers and Line Drivers With Open-Collector Outputs

74757 Octal Buffers and Line Drivers With Open-Collector Outputs

74758 Quadruple Bus Transceivers With Open-Collector Outputs

74759 Quadruple Bus Transceivers With Open-Collector Outputs

74760 Octal Buffers And Line Drivers With Open-Collector Outputs

74762 Octal Buffers And Line Drivers With Open-Collector Outputs

74763 Octal Buffers And Line Drivers With Open-Collector Outputs

74804 Hex 2-Input NAND Drivers

74805 Hex 2-Input NOR Drivers

74808 Hex 2-Input AND Drivers

74810 Quadruple 2-Input Exclusive-NOR Gates

74811 Quadruple 2-Input Exclusive-NOR Gates With Open-Collector Outputs

74821 10-Bit Bus Interface Flip-Flops With 3-State Outputs

74822 10-Bit Bus Interface Flip-Flops With 3-State Outputs

74823 9-Bit Bus Interface Flip-Flops With 3-State Outputs

74824 9-Bit Bus Interface Flip-Flops With 3-State Outputs

74825 8-Bit Bus Interface Flip-Flops With 3-State Outputs

74826 8-Bit Bus Interface Flip-Flops With 3-State Outputs

74832 Hex 2-Input OR Driver

74841 10-Bit Bus Interface D-Type Latches With 3-State Outputs

74842 10-Bit Bus Interface D-Type Latches With 3-State Outputs

74843 9-Bit Bus Interface D-Type Latches With 3-State Outputs

74844 9-Bit Bus Interface D-Type Latches With 3-State Outputs

74845 8-Bit Bus Interface D-Type Latches With 3-State Outputs

74846 8-Bit Bus Interface D-Type Latches With 3-State Outputs

74850 1 Of 16 Data Selectors/Multiplexers With 3-State Outputs

74851 1 Of 16 Data Selectors/Multiplexers With 3-State Outputs

74852 8-Bit Universal Transceiver Port Controllers

74856 8-Bit Universal Transceiver Port Controllers

74857 Hex 2-To-1 Universal Multiplexers

74866 8-Bit Magnitude Comparators

74867 Synchronous 8-Bit Up/Down Counter

74869 Synchronous 8-Bit Up/Down Counter

74870 Dual 16-By-4 Register Files

74871 Dual 16-By-4 Register Files

74873 Dual 4-Bit D-Type Latches With 3-State Outputs

74874 Dual 4-Bit D-Type Edge-Triggered Flip-Flops True Outputs

74876 Dual 4-Bit D-Type Edge-Triggered Flip-Flops Inverting Outputs

74877 8-Bit Universal Transceiver Port Controller

74878 Dual 4-Bit D-Type Edge-Triggered Flip-Flops With 3-State Outputs True Outputs

74879 Dual 4-Bit D-Type Edge-Triggered Flip-Flops With 3-State Outputs Inverting Outputs

74880 Dual 4-Bit D-Type Latches With 3-State Outputs

74881 Arithmetic Logic Unit/Function Generator

74882 32-Bit Look-Ahead Carry Generator

74885 8-Bit Magnitude Comparator

74887 8-Bit Processors

74888 8-Bit Processor Slices

74890 Microsequencer

74895 8-Bit Memory Address Generator

74897 16-Bit Parallel/Serial Barrel Shifters

74963 Dual-Rank 8-Bit Shift Register With 3-State Outputs

74964 Dual-Rank 8-Bit Shift Register With 3-State Outputs

74990 8-Bit D-Type Transparent Read-Back Latches True Outputs

74991 8-Bit D-Type Transparent Read-Back Latches Inverting Outputs

74992 9-Bit D-Type Transparent Read-Back Latches With 3-State True Outputs

74993 9-Bit D-Type Transparent Read-Back Latches With 3-State Inverting Outputs

74994 10-Bit D-Type Transparent Read-Back Latches True Outputs

74995 10-Bit D-Type Transparent Read-Back Latches Inverting Outputs

74996 8-Bit D-Type Edge-Triggered Read-Back Latches

741000 Quadruple 2-Input Positive-NAND Buffers/Drivers

741002 Quadruple 2-Input Positive-NOR Buffers

741003 Quadruple 2-Input Positive-NAND Buffers With Open-Collector Outputs

741004 Hex Inverting Drivers

741005 Hex Inverting Buffers With Open-Collector Outputs

741008 Quadruple 2-Input Positive-AND Buffers/Drivers

741010 Triple 3-Input Positive-NAND Buffers

741011 Triple 3-Input Positive-AND Buffers

741020 Dual 4-Input Positive-NAND Buffers

741032 Quadruple 2-Input Positive-OR Buffers/Drivers

741034 Hex Drivers

741035 Hex Noninverting Buffers With Open-Collector Outputs

741036 Quadruple 2-Input Positive-NOR Drivers

741181 Arithmetic Logic Unit/Function Generator

741240 Octal Buffers And Line Drivers With 3-State Outputs

741242 Quadruple Bus Transceivers With 3-State Outputs

741244 Octal Buffer And Driver With 3-State Outputs

741245 Octal Bus Transceiver With 3-State Outputs

741640 Octal Bus Transceiver With 3-State Outputs

741645 Octal Bus Transceiver With 3-State Outputs

741804 Hex 2-Input NAND Drivers

741805 Hex 2-Input NOR Drivers

741808 Hex 2-Input AND Drivers

741832 Hex 2-Input OR Drivers

742240 Octal Buffers And Line Drivers/MOS Drivers With 3-State Outputs

742242 Quadruple Bus Transceivers/MOS Driver

742540 Octal Line Drivers/MOS Drivers With 3-State Outputs

742541 Octal Line Drivers/MOS Drivers With 3-State Outputs

742620 Octal Buss Transceivers/MOS Driver

742623 Octal Buss Transceivers/MOS Driver

742640 Octal Buss Transceivers/MOS Driver

742645 Octal Buss Transceivers/MOS Driver

742967 Dynamic Memory Controller

742968 Dynamic Memory Controller

746301 Dynamic Memory Controller

746302 Dynamic Memory Controller

748000 Expandable Error Checker And Corrector

748003 Dual 2-Input Positive-NAND Gates

748834 40-Bit Register File

748838 32-Bit Barrel Shifter

7429806 Comparator And 2- To 4-Bit Decoder 6-Bit

7429809 Comparator And 2- To 4-Bit Decoder 9-Bit

7429818 8-Bit Diagnostics/Pipeline Registers

7429819 8-Bit Diagnostics/Pipeline Registers

7429821 10-Bit Bus Interface Flip-Flops With 3-State Outputs

7429822 10-Bit Bus Interface Flip-Flops With 3-State Outputs

7429823 9-Bit Bus Interface Flip-Flops With 3-State Outputs

7429824 9-Bit Bus Interface Flip-Flops With 3-State Outputs

7429825 8-Bit Bus Interface Flip-Flops With 3-State Outputs

7429826 8-Bit Bus Interface Flip-Flops With 3-State Outputs

7429827 10-Bit Buffers And Bus Drivers With 3-State Outputs

7429828 10-Bit Buffers And Bus Drivers With 3-State Outputs

7429841 10-Bit Bus Interface D-Type Latches With 3-State Outputs

7429842 10-Bit Bus Interface D-Type Latches With 3-State Outputs

7429843 9-Bit Bus Interface D-Type Latches With 3-State Outputs

7429844 9-Bit Bus Interface D-Type Latches With 3-State Outputs

7429845 8-Bit Bus Interface D-Type Latches With 3-State Outputs

7429846 8-Bit Bus Interface D-Type Latches With 3-State Outputs

7429861 10-Bit Bus Transceivers With 3-State Outputs

7429862 10-Bit Bus Transceivers With 3-State Outputs

7429863 9-Bit Bus Transceivers With 3-State Outputs

7429864 9-Bit Bus Transceivers With 3-State Outputs


Commonly Used UNIX Commands

v16-04/12/96
To obtain information about a particular command or program, log into a UNIX system and, at the UNIX prompt, enter the command man followed by the name of the command. For example, if you want to find out information about the command cd, that allows you to change directories, you would enter:
$ man cd
Below are some of the more commonly used UNIX commands. Clicking on a particular command will provide man information from the PARAGON XP/S 5 computer. However, to obtain the latest man pages, you should log into the UNIX system, and use the man command.

  • apropos - Locates reference pages by keyword
  • cat - Concatenates or displays files
  • cc - C compiler
  • cd - Changes the current working directory
  • chmod - Changes permission codes
  • chsh - Changes default shell in password file information
  • clear - Clears terminal screen
  • cmp - Compares two files
  • cp - Copies files
  • csh - C shell command interpreter
  • date - Displays or sets the date
  • diff - Compares text files
  • f77 - invokes the Fortran 77 compiler
  • fsplit - splits a multi-routine Fortran file into individual files
  • gcc, g++ - GNU project C and C++ Compiler
  • grep - Searches a file for a pattern
  • head - Displays the beginning of files
  • hostname - Displays the name of the current host system
  • kill - Sends a signal to a running process
  • ksh - Korn shell
  • lint - a C program checker
  • lp - Sends a printing request
  • lpq - Examines the spool queues
  • lpr - Sends files to spooling daemon for printing
  • lprm - Removes requests from the line printer spooling queue
  • lpstat - Displays line printer status information
  • ls - Lists and generates statistics for files
  • make - Maintains up-to-date versions of target files and performs shell commands
  • man - Displays reference pages
  • mkdir - Makes a directory
  • more - Displays a file one screenful at a time
  • mv - Moves files and directories
  • pexec - Execute a compute partition program within a SAFE partition
  • pmake - Parallel make utility that maintains up-to-date versions of target files and performs shell commands
  • pg - Formats files for a terminal display
  • printenv -Displays the current environment, or displays the values of environment variables
  • ps - Displays current process status
  • pspart - Shows status of the applications in a partition
  • pwd - Displays the pathname of the current (working) directory
  • qstat - Displays the status of NQS requests and queues
  • qsub - Submit an NQS batch request
  • rm - Removes (unlinks) files or directories
  • rmdir - Removes a directory
  • sed - Provides a stream line editor
  • sh - The Bourne shell, an interactive command interpreter and command programming language
  • showpart - Displays a partition's characteristics
  • sort - Sorts or merges files
  • split - Splits a file into pieces
  • tail - Writes a file to standard output, beginning at a specified point
  • vi - Edits files with a full screen display
  • wc - Counts the lines, words, characters, and bytes in a file
  • who - Identifies users currently logged in
  • whoami - Displays the user's name


Viscosity

Viscosity Convertion

Stoke = c.g.s. unit of kinematic viscosity
Centipoise = 0.01 poise
Centistoke = 0.01 stoke
Centipoises = centistokes x density (at tempurature under consideration)
Reyn (1lb.sec/sq.in) = 69 x 10^5 centipoises

Viscous Liquids

Saybolt Universal SSU | Stokes | Poises | Engler Seconds | Redwood No.1 seconds | Typical Liquids at 70F
31 | 0.010 | 0.008 | 54 | 29 | Water
35 | 0.025 | 0.02 | 59 | 32.1 | Kerosene
50 | 0.074 | 0.059 | 80 | 44.3 | No. 2 Fuel Oil
80 | 0.157 | 0.126 | 125 | 69.2 | No. 4 Fuel Oil
100 | 0.202 | 0.162 | 150 | 85.6 | Transformer Oil
200 | 0.432 | 0.346 | 295 | 170 | Hydraulic Oil
300 | 0.654 | 0.522 | 470 | 254 | SAE 10W Oil
500 | 1.10 | 0.88 | 760 | 423 | SAE 10 Oil
1,000 | 2.16 | 1.73 | 1,500 | 896 | SAE 20 Oil
2,000 | 4.40 | 3.52 | 3,000 | 1,690 | SAE 30 Oil
5,000 | 10.8 | 8.80 | 7,500 | 4,230 | SAE 50 Oil
10,000 | 21.6 | 17.0 | 15,000 | 8,460 | SAE 60-70 Oil
50,000 | 108 | 88 | 75,000 | 43,660 | Molasses B
100,000 | 216 | 173 | 150,000 | 88,160 | Molasses C


V-belt

V-Belt Tension

Although the tension on a V-Belt drive is usually not critical, it is certainly an important facet.

Undertensioning creates slippage, generating excessive heat in the belts, resulting in premature failure. Overtensioning generates higher tensions in the belts than these used for calculating, which reults in short belt life and increased bearing loads. To keep V-belt tension under control and to tension the drives properly we can use a tension-deflection method.

vbelt.bmp (8686 bytes)

Deflection force must always be directed perpendicular to the span.
deflection 1mm per 100mm of span.

Find the required tension per strand of belt (Static tension):

Ts (daN) = 45 * [(2.5-G) / G] * [Design kW / (N * S)] + M * S^2 . . . . . . . . . . . . . . . . . . . . (1daN = 1.02Kg)

G - Arc correction factor.
N - Number of belts
S - Belt speed (m/sec).
M - Constant (Refer to Table 1 Below)

Find the span length:

t (mm) = A * {1 - 0.125 * [(D - d) / A]^2}

A - Center distance (mm).
D - Large sheave or pulley pitch diameter (mm).
d - Small sheave pitch diameter (mm).

Calculate the deflection:

Deflection (mm) = t / 100

If your drive uses two or more Power Bands or individual belts, calculate the minimum and maximum recommended deflection forces by these formulars:

Min. recommended deflection force (daN) = (Ts + Y) / 25

Max. recommended deflection force (daN) = (1.5 * Ts + Y) / 25

Individual V-Belt Cross Section | M | Y | Power Band Cross Section | M
SPZ | 0.006 | 1.5 |  |
SPA | 0.012 | 2.0 |  |
SPB | 0.017 | 2.6 |  |
SPC | 0.032 | 4.1 |  |
3V | 0.006 | 1.5 | 3V-9J | 0.008
5V | 0.017 | 2.6 | 5V-15J | 0.021
8V | 0.046 | 6.0 | 8V-25J | 0.053

Table 1 - Factor M and factor Y.

Cross section | Small pulley diameter (mm) | Recommended deflection force daN
min. | max.
SPZ/3V
71
75-80
85-95
100-125
132-180
0.8
0.9
1.0
1.2
1.3
1.1
1.3
1.5
1.7
1.9
SPA
100-125
132-200
212-250
1.4
1.9
2.0
2.1
2.8
3.0
SPB/5V
160-200
212-280
300-400
2.9
3.6
3.8
4.4
5.0
5.8
SPC
250-355
375-530
5.1
6.0
7.5
9.0
XPZ/3VX
56
60-63
67-71
75-80
85-95
100-125
132-180
0.7
0.8
0.9
1.0
1.1
1.3
1.6
1.1
1.3
1.4
1.5
1.6
1.9
2.4
XPA
80-125
132-200
1.8
2.2
2.7
3.1
XPB/5VX
112-118
125-140
150-170
180-200
212-280
300-400
2.4
2.7
3.0
3.6
3.8
4.1
3.6
4.1
4.7
5.3
5.5
6.4
8V
317-431
457-610
7.6
8.8
11.3
13.3
8VK
380-437
450-600
9.7
11.2
14.5
16.6
A
85-90
95-106
112-180
0.9
1.0
1.3
1.3
1.5
2.0
B
112-118
125-140
150-170
180-250
1.4
1.5
1.9
2.2
2.0
2.3
2.7
3.3
C
180
190
200-212
224-265
280-400
2.4
2.6
3.0
3.3
3.8
3.5
3.8
4.5
5.0
5.8
D
300-335
355-400
425-560
5.1
5.6
6.5
7.3
8.2
9.9
AX
60-80
85-90
95-106
112-180
1.0
1.1
1.2
1.3
1.5
1.6
1.7
2.0
BX
85-118
125-132
137-142
150-170
180-250
1.9
2.0
2.0
2.1
2.1
2.8
3.0
3.0
3.0
3.3
CX
150-190
200-212
224-265
280-400
3.3
3.5
3.5
3.5
5.0
5.0
5.2
5.2

Table 2 - Gates PowerBand deflection force.


Watch Escapement Database

The escapement information is stored in file /calfe/horology/escname.dat use a text editor like notepad to edit the information in the file. The structure is like this Name of escapement, File name, Number of picture, Number of video.

  • Name of escapement - This will shows in the List box.
  • File name - The name of your text file (Name1.txt), your picture file (Name1.jpg) and your video file (Name1.mpg).
  • Number of picture - if you put 3 in this position, you must have 3 picture files (Name1.jpg, Name2.jpg, Name3.jpg). The program will switch between them when you press Next button.
  • Number of video - Now only one video file is allowed, just put 1 in this position if you have one video file (name1.mpg).

Below is the sample:

Cylinder,cylind,1,1
Ruby Cylinder,rcylind,1,0
M. B. Pray Cylinder,mbcylin,1,0


Weir & Flume

V-NOTCH, RECTANGULAR WEIR & FLUME

V-notch weir details (BS3680 part 4a)

Q (cu.m/s) = Ch^2.5
where C = 1.4 * tan (Weir Angle/2)

Partial width rectangular weir (BS3680 part 4a)

a) Full width or suppressed weir
Q = 2.95 * B * [0.602 + 0.083 * (h / P)] * (h + 0.0012)^1.5
b) Partial width weirs
Q = 1.82 * [1 - 0.1 * (h / b)] * b * b^(3/2)


Return to Commonly Used UNIX Commands.

apropos(1)                                                         apropos(1)

NAME

  apropos - Locates reference pages by keyword

SYNOPSIS

  apropos keyword ...

  The apropos command shows which reference pages contain instances of any of
  the given keywords in their purpose lines.

DESCRIPTION

  In looking for keywords, apropos considers each word separately and ignores
  the case of letters. Words that are part of other words are also con-
  sidered; thus, when looking for the word compile, apropos will also find
  all instances of compiler.  The keyword argument can also be a POSIX regu-
  lar expression.  For more information, see the grep reference page.

  If the output of the apropos command begins with a name and reference sec-
  tion number, you can enter man section name.  For example, if the output of
  the apropos command is printf(3), you can enter man 3 printf to obtain the
  reference page on the printf() subroutine.

  The apropos command works just like the man command with the -k flag.

EXAMPLES

  To find reference pages with the keyword password in the purpose line,
  enter:
  apropos password
FILES

  /usr/share/man/whatis
              Keyword database.

RELATED INFORMATION

  Commands:  catman(1), man(1), whatis(1).


cat(1)                                                                 cat(1)

NAME

  cat - Concatenates or displays files

SYNOPSIS

  cat [-benrstuv] file ...  | -

  The cat command reads each specified file in sequence and writes it to
  standard output.

FLAGS

  -b  Omits line numbers from blank lines when -n is specified.

  -e  Same as the -v flag with a $ (dollar sign) character displayed at the
      end of each line.

  -n  Displays output lines preceded by line numbers, numbered sequentially
      from 1.

  -r  Replaces multiple consecutive empty lines with one empty line, so that
      there is never more than one empty line between lines containing char-
      acters.

  -s  Does not display a message if cat cannot find an input file. (Silent
      option.)

  -t  Same as the -v flag, with the tab character printed as <Ctrl-i> (^I).

  -u  Does not buffer output.

  -v  Displays nonprinting characters so that they are visible.

DESCRIPTION

  The cat command is frequently used with > (redirection symbol) to concaten-
  ate the specified files and write them to the specified destination.  (See
  CAUTIONS.)  cat is also used with >> to append a file to another file.

  If you do not specify a file or if you specify - (dash) instead of file,
  cat reads from standard input.

EXAMPLES

   1.  To display the file notes, enter:
       cat notes

       If the file is longer than one screenful, it scrolls by too quickly to
       read.  To display a file one page at a time, use the more command.

   2.  To concatenate several files, enter:
       cat  section1.1  section1.2  section1.3  > section1

       This creates a file named section1 that is a copy of section1.1 fol-
       lowed by section1.2 and section1.3.

   3.  To suppress error messages about files that do not exist, enter:
       cat -s section2.1 section2.2 section2.3 > section2

       If section2.1 does not exist, this command concatenates section2.2 and
       section2.3.  Note that the message goes to standard error, so it does
       not appear in the output file.  The result is the same if you do not
       use the -s flag, except that cat displays the error message:
       cat: cannot open section2.1

       You may want to suppress this message with the -s flag when you use
       the cat command in shell procedures.

   4.  To append one file to the end of another, enter:
       cat section1.4 >> section1

       The >> in this command specifies that a copy of section1.4 be added to
       the end of section1.  If you want to replace the file, use a single >
       symbol.

   5.  To add text to the end of a file, enter:
       cat >> notes
       Get milk on the way home
       <Ctrl-d>

       Get milk on the way home is added to the end of notes.  With this syn-
       tax, the cat command does not display a prompt; it waits for you to
       enter text.  Press the End-of-File key sequence (<Ctrl-d> above) to
       indicate you are finished.

   6.  To concatenate several files with text entered from the keyboard,
       enter:
       cat section3.1 - section3.3 > section3

       This concatenates section3.1, text from the keyboard, and section3.3
       to create the file section3.

   7.  To concatenate several files with output from another command, enter:
       ls  |  cat section4.1 - > section4

       This copies section4.1, and then the output of the ls command to the
       file section4.

CAUTIONS
  Do not redirect output to one of the input files using the > (redirection
  symbol).  If you do this, you lose the original data in the input file
  because the shell truncates it before cat can read it.  (See also the sh
  command.)

RELATED INFORMATION

  Commands:  cp(1), dd(1), more(1), pack(1)/pcat(1)/unpack(1), pg(1), pr(1),
  sh(1).


ICC(1)                             Paragon                             ICC(1)

NAME
  ICC - icc, cc: Driver for compiling, assembling, and linking C programs for
  the Paragon OSF/1 operating system.

CROSS-DEVELOPMENT SYNTAX
  icc [switches] sourcefile...

NATIVE SYNTAX
  cc [switches] sourcefile...

DESCRIPTION

  The icc command invokes the Paragon OSF/1 C compiler, assembler, and linker
  with switches derived from icc's command line arguments.

  icc bases its processing on the suffixes of the files it is passed:

  file.c      is a C program. It is preprocessed, compiled, and assembled.
              The resulting object file is placed in the current directory.

  file.s      is an i860 assembly language file. It is assembled and the
              resulting object file is placed in the current directory.

  file.o      is an object file. It is passed directly to the linker if
              linking is requested.

  file.a      is an ar library. It is passed directly to the linker if
              linking is requested.

  file.f or file.F                                           is a Fortran
              program. It is passed to the Fortran compiler.

  All other files are taken as object files and passed to the linker (if
  linking is requested) with a warning message. If a file's suffix does not
  match its actual contents, unexpected results may occur.

  If a single C program is compiled and linked with one icc command, then the
  intermediate object and assembly files are deleted.

                                     NOTE

       ANSI C predefined macros can be defined and undefined on the command
       line, but not with #define and #undefine directives in the source
       file.

SWITCHES

  -B          Allows C++-style comments (// to end of line) in source code.

  -c          Skips link step; compiles and assembles only. Leaves the output
              from the assemble step in a file named file.o for each file
              named file.c (unless you also use the -o switch).

  -C          Preserves comments in preprocessed C source files. Also enables
              -E.

  -Dname[=def]                                               Defines name to
              be def in the preprocessor. If def is missing, it is assumed to
              be empty. If the = sign is also missing, then name is defined
              to be the string 1.

  -E          Preprocesses each ``.c'' file and sends the result to stdout.
              No compilation, assembly, or linking is performed.

  -ES         Preprocesses every file and sends the result to stdout. No
              compilation, assembly, or linking is performed.

  -g          Equivalent to -Mdebug -O0 -Mframe.

  -I-         Accepted, but has no effect.

  -Idirectory                                                Adds directory
              to the compiler's search path for include files. If you use
              more than one -I switch, the specified directories are searched
              in the order they were specified (left to right). For include
              files surrounded by angle brackets (<...>), each directory is
              searched followed by the default location. For include files
              surrounded by double quotes ("..."), the directory containing
              the file containing the #include directive is searched,
              followed by the -I directories, followed by the default
              location.

  -Koption    Requests special mathematical semantics. The option values are:

              ieee (default)                                 If used while
                          linking, links in a math library that conforms with
                          the IEEE 754 standard.

                          If used while compiling, tells the compiler to
                          perform float and double divides in conformance
                          with the IEEE 754 standard.

              ieee=enable                                    If used while
                          linking, has the same effects as -Kieee, and also
                          enables floating point traps and underflow traps.
                          If used while compiling, has the same effects as
                          -Kieee.

              ieee=strict                                    If used while
                          linking, has the same effects as -Kieee=enable, and
                          also enables inexact traps. If used while
                          compiling, has the same effects as -Kieee.

              noieee      If used while linking, produces a program that
                          flushes denormals to 0 on creation, which reduces
                          underflow traps. If used together with -lm, also
                          links in a version of libm.a that is not as
                          accurate as the standard library, but offers
                          greater performance. This library offers little or
                          no support for exceptional data types such as INF
                          and NaN, and will trap on such values when
                          encountered.

                          If used while compiling, tells the compiler to
                          perform float and double divides using an inline
                          divide algorithm that offers greater performance
                          than the standard algorithm. This algorithm
                          produces results that differ from the results
                          specified by the IEEE standard by no more than
                          three units in the last place.

              trap=fp     If used while linking, disables kernel handling of
                          floating point traps. Has no effect if used while
                          compiling.

              trap=align  If used while linking, disables kernel handling of
                          alignment traps. Has no effect if used while
                          compiling.

  -llibrary   Load the library liblibrary.a. The library is loaded from the
              first library directory in the library search path (see the -L
              switch) in which a file of that name is encountered. (Passed to
              the linker.)

  -Ldirectory                                                Adds directory
              to beginning of the library search path. Also see the nostdlib
              and nostartup options of the -M switch. (Passed to the linker;
              see the ld860 manual page for more information on the library
              search path.)

  -m          Produces a link map. (Passed to the linker.)

  -M          Outputs a list of include files to the standard output (used
              for makefile construction).

  -MD         Outputs a list of include files to file.d (used for makefile
              construction).

  -Moption    Requests specific actions from the compiler. The option values
              are as follows (an unrecognized -M option is passed directly to
              the compiler):

              allow_spacing                                  Allows spacing
                          around tokens such as ``.'' and ``@'' when used
                          with -ES.

              alpha       Activate alpha-release compiler features.

              anno        Produce annotated assembly files, where source code
                          is intermixed with assembly language. -Mkeepasm or
                          -S should be used as well.

              [no]asmkeyword
                          [Don't] allow the asm keyword in C source code
                          (default -Masmkeyword). The format is: asm("text")

              beta        Activate beta-release compiler features.

              [no]bounds  [Don't] enable array bounds checking (default
                          -Mnobounds). With -Mbounds enabled, bounds checking
                          is not applied to subscripted pointers or to
                          externally-declared arrays whose dimensions are
                          zero (extern arr[ ]). Bounds checking is not
                          applied to an argument even if it is declared as an
                          array. If an array bounds checking violation occurs
                          when a program is executed, an error message
                          describing where the error occurred is printed and
                          the program terminates. The text of the error
                          message includes the name of the array, where the
                          error occurred (the source file and line number in
                          the source), and the value, upper bound, and
                          dimension of the out-of-bounds subscript. The name
                          of the array is not included if the subscripting is
                          applied to a pointer.

              [no]dalign  [Don't] align doubles in structures on
                          double-precision boundaries (default -Mdalign).
                          -Mnodalign may lead to data alignment exceptions.

              [no]debug   [Don't] generate symbolic debug information
                          (default -Mnodebug). If -Mdebug is specified with
                          an optimization level greater than zero, line
                          numbers will not be generated for all program
                          statements.

              [no]depchk  [Don't]check for potential data dependencies
                          (default -Mdepchk). This is especially useful in
                          disambiguating unknown data dependencies between
                          pointers that cannot be resolved at compile time.
                          For example, if two floating point array pointers
                          are passed to a function and the pointers never
                          overlap and thus never conflict, then this switch
                          may result in better code. The granularity of this
                          switch is rather coarse, and hence the user must
                          use precaution to ensure that other necessary data
                          dependencies are not overridden. Do not use this
                          switch if such data dependencies do exist.
                          -Mnodepchk may result in incorrect code; the
                          -Msafeptr switch provides a less dangerous way to
                          accomplish the same thing.

              dollar,char                                    Set the
                          character used to replace dollar signs in names to
                          be char. Default is an underscore (_).

              extract=[option[,option...]]
                          Pass options to the function extractor (see the
                          inline option for more information). The options
                          are:

                          [name:]function-Extract the specified function.
                          name: must be used if the function name contains a
                          period.

                          [size:]number-Extract functions containing less
                          than approximately number statements.

                          If both number(s) and function(s) are specified,
                          then functions matching the given name(s) or
                          meeting the size requirements are extracted.

                          The -ofile switch must be used with -Mextract to
                          tell the compiler where to place the extracted
                          functions. The name of the specified file must
                          contain a period.

              fcon        Treat non-suffixed floating point constants as
                          float, rather than double. This may improve the
                          performance of single-precision code.

              [no]frame   [Don't] include the frame pointer (default
                          -Mnoframe). -Mnoframe can improve execution time
                          and decrease code, but makes it impossible to get a
                          call stack traceback when using a debugger.

              [no]func32  [Don't] align functions on 32-byte boundaries
                          (default -Mfunc32). -Mfunc32 may improve cache
                          performance for programs with many small functions.

              info=[option[,option...]]
                          Produce useful information on the standard error
                          output. The options are:

                          time or stat-Output compilation statistics.

                          loop-Output information about loops. This includes
                          information about vectorization and software
                          pipelining.

                          inline-Output information about functions extracted
                          and inlined.

                          cycles or block or size-Output block size in
                          cycles. Useful for comparing various optimization
                          levels against each other. The cycle count produced
                          is the compiler's static estimate of freeze-free
                          cycles for the block.

                          ili-Output intermediate language as comments in
                          assembly file.

                          all-All of the above.

              inline=[option[,option...]]
                          Pass options to the function inliner. The options
                          are:

                          [lib:]library-Inline functions in the specified
                          inliner library (produced by -Mextract). If lib: is
                          not used, the library name must contain a period.
                          If no library is specified, functions are extracted
                          from a temporary library created during an extract
                          prepass.

                          [name:]function-Inline the specified function. If
                          name: is not used, the function name must not
                          contain a period.

                          [size:]number-Inline functions containing less than
                          approximately number statements.

                          levels:number-Perform number levels of inlining
                          (default 1).

                          If both number(s) and function(s) are specified,
                          then functions matching the given name(s) or
                          meeting the size requirements are inlined.

              keepasm     Keep the assembly file for each C source file, but
                          continue to assemble and link the program. This is
                          mainly for use in compiler performance analysis and
                          debugging.

              list[=name] Create a source listing in the file name. If name
                          is not specified, the listing file has the same
                          name as the source file except that the ``.c''
                          suffix is replaced by a ``.lst'' suffix. If name is
                          specified, the listing file has that name; no
                          extension is appended.

              nolist      Don't create a listing file (this is the default).

              [no]longbranch                                 [Don't] allow
                          compiler to generate bte and btne instructions
                          (default -Mlongbranch). -Mnolongbranch should be
                          used only if an assembly error occurs.

              nostartup   Don't link the usual start-up routine (crt0.o),
                          which contains the entry point for the program.

              nostddef    Don't predefine any system-specific macros to the
                          preprocessor when compiling a C program. (Does not
                          affect ANSI-standard preprocessor macros.) The
                          system-specific predefined macros are __i860,
                          __i860__, __PARAGON__, __OSF1__, __PGC__, _PGC_,
                          _COFF, unix, MACH, CMU, __I860__, _I860_, __I860,
                          _i860_, OSF1_ADFS, OSF1AD,and __NODE (__NODE is
                          only defined when compiling with -nx). See also -U.

              nostdinc    Remove the default include directory (/usr/include
                          for cc, $(PARAGON_XDEV)/paragon/include for icc)
                          from the include files search path.

              nostdlib    Don't link the standard libraries (libpm.o,
                          guard.o, libc.a, libic.a, and libmach3.a) when
                          linking a program.

              [no]perfmon                                    [Don't] link the
                          performance monitoring module (libpm.o) (default
                          -Mperfmon). See the Paragon(tm) Application Tools
                          User's Guide for information on performance
                          monitoring.

              prof=x      This option is ignored.

              [no]quad    [Don't] force top-level objects (such as local
                          arrays) of size greater than or equal to 16 bytes
                          to be quad-aligned (default -Mquad). Note that
                          -Mquad does not affect items within a top-level
                          object; such items are quad-aligned only if
                          appropriate padding is inserted.

              reloc_libs  Causes -l switches that appear before source or
                          object file names on the compiler command line to
                          appear after these file names on the ld command
                          line.

              [no]reentrant                                  [Don't] generate
                          reentrant code (default -Mreentrant). -Mreentrant
                          disables certain optimizations that can improve
                          performance but may result in code that is not
                          reentrant. Even with -Mreentrant, the code may
                          still not be reentrant if it is improperly written
                          (e.g., declares static variables). -Mnoreentrant is
                          currently ignored by the compiler.

              safeptr=[option[,option...]]
                          Override data dependence between C pointers and
                          arrays. This is a potentially very dangerous option
                          since the potential exists for code to be generated
                          that will result in unexpected or incorrect results
                          as is defined by ANSI C. However, when used
                          properly, this option has the potential to greatly
                          enhance the performance of the resulting code,
                          especially floating point oriented loops.
                          Combinations of the options may be used and
                          interact appropriately.

                          dummy or arg-C dummy arguments (pointers and
                          arrays) are treated with the same copyin/copyout
                          semantics as Fortran dummy arguments.
                          auto-C local or auto variables (pointers and
                          arrays) are assumed not to overlap or conflict with
                          each other and are independent.

                          static-C static variables (pointers and arrays) are
                          assumed to not overlap or conflict with each other
                          and to be independent.

                          global-C global or extern variables (pointers and
                          arrays) are assumed to not overlap or conflict with
                          each other and to be independent.

              schar       Treat ordinary char declarations as signed char.
                          This is the default condition.

              [no]signextend                                 [Don't] sign
                          extend when a narrowing conversion overflows
                          (default -Msignextend). For example, if
                          -Msignextend is in effect and an integer containing
                          the value 65535 is converted to a short, the value
                          of the short will be -1. This option is provided
                          for compatibility with other compilers, even though
                          ANSI C specifies that the result of such
                          conversions are undefined. -Msignextend will
                          decrease performance on such conversions.

              [no]single  [Don't] suppress the ANSI-specified conversion of
                          float to double when passing arguments to a
                          function with no prototype in scope (default
                          -Mnosingle). -Msingle may result in faster code
                          when single precision is used a lot, but is
                          non-ANSI compliant.

              split_loop_ops=n
                          Set a threshold of n floating-point operations
                          within a loop. Innermost loops whose number of
                          floating-point operations exceeds n are split. Each
                          floating-point operation counts as two. The default
                          for n is 40 when -Mvect is used.

              nosplit_loop_ops
                          Do not split loops when the floating-point
                          operation threshold is exceeded. When -Mvect is
                          specified, innermost loops whose number of floating
                          point operations exceed 40 are split by default.
                          This switch turns the default off.

              split_loop_refs=n
                          Set a threshold of n array element loads and stores
                          within a loop. Innermost loops whose number of
                          loads and stores exceeds n are split. The default
                          for n is 20 when -Mvect is used

              nosplit_loop_refs
                          Do not split loops when the array element loads and
                          stores threshold is exceeded. When -Mvect is
                          specified, innermost loops whose number of array
                          element loads and stores exceeds 20 are split by
                          default. This switch turns the default off.

              [no]streamall                                  [Don't] stream
                          all vectors to and from cache in a vector loop
                          (default -Mstreamall). When -Mnostreamall is in
                          effect, the compiler chooses one vector to come
                          directly from or go directly to main memory,
                          without being streamed into or out of cache.

              [no]stride0                                    [Don't] inhibit
                          certain optimizations and allow for stride 0 array
                          references. -Mstride0 may degrade performance, and
                          should only be used if zero stride induction
                          variables are possible. (default -Mnostride0).

              uchar       Treat ordinary char declarations as unsigned char.

              vect[=option[,option...]]
                          Perform vectorization (also enables -Mvintr). If no
                          options are specified, then all vector
                          optimizations are enabled. The available options
                          are:

                          cachesize:number-This sets the size of the portion
                          of the cache used by the vectorizer to number
                          bytes. Number must be a multiple of 16, and less
                          than the cache size of the microprocessor (16384
                          for the i860 XP, 8192 for the i860 XR). In most
                          cases the best results occur when number is set to
                          4096, which is the default (for both
                          microprocessors).

                          noassoc-When scalar reductions are present (for
                          example, dot product), and loop unrolling is turned
                          on, the compiler may change the order of operations
                          so that it can generate better code. This
                          transformation can change the result of the
                          computation due to round-off error. The use of
                          noassoc prevents this transformation.

                          recog-Recognize certain loops as simple vector
                          loops and call a special routine.

                          smallvect[:number]-This option allows the
                          vectorizer to assume that the maximum vector length
                          is no greater than number. Number must be a
                          multiple of 10. If number is not specified, the
                          value 100 is used. This option allows the
                          vectorizer to avoid stripmining in cases where it
                          cannot determine the maximum vector length. In
                          doubly-nested, non-perfectly nested loops, this
                          option can allow invariant vector motion that would
                          not otherwise have been possible. Incorrect code
                          will result if this option is used, and a vector
                          takes on a length greater than specified.

                          streamlim:n This sets a limit for application of
                          the vectorizer data streaming optimization. If data
                          streaming requires cache vectors of length less
                          than n, the optimization is not performed. Other
                          vectorizer optimizations are still performed. The
                          data streaming optimization has a high overhead
                          compared to other loop optimizations, and can be
                          counter-productive when used for short vectors. The
                          n specifier is not optional. The default limit is
                          32 elements if streamlim is not used.

                          transform-Perform high-level transformations such
                          as loop splitting and loop interchanging. This is
                          normally not useful without -Mvect=recog.

                          -Mvect with no options means
                          -Mvect=recog,transform,cachesize:4096.

              [no]vintr   [Don't] perform recognition of vector intrinsics
                          (default -Mnovintr, unless -Mvect is used).

              [no]xp      [Don't] use i860 XP microprocessor features
                          (default -Mxp).

  -nostdinc   Equivalent to -Mnostdinc.

  -nx         Creates an executable Paragon OSF/1 application for multiple
              nodes.

              o Using -nx while compiling defines the preprocessor symbol
                __NODE.

              o Using -nx while linking creates an application that
                automatically copies itself into multiple nodes. It also
                links in libnx.a, the library that contains the calls in the
                Paragon(tm) C System Calls Reference Manual. In addition, it
                links in libmach.a and options/autoinit.o. You can control
                the execution of an application linked with -nx by using
                command-line switches and environment variables, as described
                in the Paragon(tm) User's Guide.

              -node is currently accepted as a synonym for -nx, but this
              support may be dropped in a future release.

  -ofile      Uses file for the output file, instead of the default a.out (or
              file.o if used with the -c switch).

  -O[level]   Set the optimization level:

              0           A basic block is generated for each C statement. No
                          scheduling is done between statements. No global
                          optimizations are performed.

              1           Scheduling within extended basic blocks is
                          performed. Some register allocation is performed.
                          No global optimizations are performed.

              2           All level 1 optimizations are performed. In
                          addition, traditional scalar optimizations such as
                          induction recognition and loop invariant motion are
                          performed by the global optimizer.

              3           All level 2 optimizations are performed. In
                          addition, software pipelining is performed.

              4           All level 3 optimizations are performed, but with
                          more aggressive register allocation for software
                          pipelined loops. In addition, code for pipelined
                          loops is scheduled several ways, with the best way
                          selected for the assembly file.

              If a level is not supplied with -O, the optimization level is
              set to 2. If -O is not specified, the default level is 1.
              Setting optimization to levels higher than 0 may reduce the
              effectiveness of symbolic debuggers.

  -p          This option is ignored.

  -P          Preprocesses each file and leaves the output in a file named
              file.i for each file named file.c.

  -r          Generates a relinkable object file. (Passed to the linker.)
  -s          Strips symbol table information. (Passed to the linker.)

  -S          Skips the link and assemble step. Leaves the output from the
              compile step in a file named file.s for each file named file.c.
  -Uname      Removes any initial definition of name in the preprocessor.
              (See also the nostddef option of the -M switch.) Since all -D
              switches are processed before all -U switches, the -U switch
              can be used to override the -D switch.

              The following macro names are predefined: __LINE__, __FILE__,
              __DATE__, __TIME__, __STDC__, __i860, __i860__, __PARAGON__,
              __OSF1__, __PGC__, _PGC_, _COFF, unix, MACH, CMU, __I860__,
              _I860_, __I860, _i860_, OSF1_ADFS, OSF1AD, and __NODE (__NODE
              is only defined when compiling with -nx or -node). Note that
              some of these macro names begin and/or end with two
              underscores.

  -v          Prints the entire command line for each tool as it is invoked,
              and invokes each tool in verbose mode (if it has one).

  -V          Prints the version banner for each tool (assembler, linker,
              etc.) as it is invoked.

  -VV         Displays the driver version number and the location of the
              online release notes. No compilation is performed.

  -Wpass,option[,option...]
              Passes the specified options to the specified pass:

              0 (zero)    Compiler.

              a           Assembler.

              l           Linker.

              Each comma-delimited string is passed as a separate argument.

  -X(a | c | s | t | l | o)
              Specify the degree of ANSI C conformance.

              a           ANSI mode. The compiled language conforms to all
                          ANSI features. _ _STDC_ _ is defined to be zero.

              c           Conformance mode. The compiled language conforms to
                          ANSI C, but warnings may be produced about some
                          extensions. _ _STDC_ _ is defined to be one.

              s           Pre-ANSI mode. The compiled language includes all
                          features compatible with the C language as defined
                          in The C Programming Language, by Kernighan and
                          Ritchie (pre-ANSI C). The compiler warns about all
                          language constructs that differ between ANSI C and
                          pre-ANSI C.

              t           Transition mode. This is ANSI C plus pre-ANSI C
                          compatibility extensions without the semantic
                          changes required by ANSI C. Where ANSI C and
                          pre-ANSI C specify different semantics for the same
                          construct, the compiler issues a warning and uses
                          the pre-ANSI C interpretation.

              l           Treat [un]signed int and [un]signed long as the
                          same data type. When you use this switch, debug
                          records for [un]signed long are type [un]signed
                          int.

              o           Execute the R4.1.1 version of ic.

              By default _ _STDC_ _ is defined to be one and ANSI conformance
              is relaxed.

  -Ypass,directory
              Looks for the specified pass in the specified directory (rather
              than in the default location), where pass is one of the
              following:

              0 (zero)    Compiler executable file.

              a           Assembler executable file.

              l           Linker executable file.

              S           Startup object files.

              I           Standard include files.

              L           Standard libraries (passes -YLdirectory to the
                          linker).

              U           Secondary libraries (passes -YUdirectory to the
                          linker).

              P           All libraries (passes -YPdirectory to the linker).

              See the ld860 manual page for more information on the -YL, -YU,
              and -YP switches.

FILES

  a.out                       Executable output file.

  file.a                      Library of object files.

  file.c                      C source file.

  file.d                      List of include files produced by -MD.

  file.i                      C source file after preprocessing.

  file.lst                    Listing file produced by -Mlist.

  file.o                      Object file.

  file.s                      Assembler source file.

  The following files and directories are used in the cross-development
  environment (icc). PARAGON_XDEV is an environment variable that can be set
  to the root of the compiler installation directory. If PARAGON_XDEV is not
  set, the default is /usr/paragon/XDEV. The directory where the driver,
  compiler, and tools are located must be included in your path. For Sun4
  users, for example, $PARAGON_XDEV/paragon/bin.sun4 would be included in the
  path.

  $(PARAGON_XDEV)/paragon/bin.arch                           Directory
                              containing executables for system arch (arch
                              identifies the architecture of the system, e.g.
                              sgi or sun4).

  $(PARAGON_XDEV)/paragon/bin.arch/icc                       C compiler
                              driver.

  $(PARAGON_XDEV)/paragon/bin.arch/ic                        C compiler.

  $(PARAGON_XDEV)/paragon/bin.arch/as860                     Intel (COFF)
                              assembler.

  $(PARAGON_XDEV)/paragon/bin.arch/ld860                     Intel (COFF)
                              linker.

  $(PARAGON_XDEV)/paragon/include                            Standard include
                              directory.

  $(PARAGON_XDEV)/paragon/lib-coff                           Standard library
                              directory.

  $(PARAGON_XDEV)/paragon/lib-coff/crt0.o                    C start-up
                              routine.

  $(PARAGON_XDEV)/paragon/lib-coff/libpm.o                   Performance
                              monitoring module.

  $(PARAGON_XDEV)/paragon/lib-coff/guard.o                   Barrier between
                              user and system code.

  $(PARAGON_XDEV)/paragon/lib-coff/libc.a                    Standard C
                              library.

  $(PARAGON_XDEV)/paragon/lib-coff/libic.a                   C built-in
                              intrinsic library.

  $(PARAGON_XDEV)/paragon/lib-coff/libmach.a
                              Mach operating system library.

  $(PARAGON_XDEV)/paragon/lib-coff/noieee                    Library
                              directory used when linking with -Knoieee
                              (contains non-IEEE version of libm.a).

  $(PARAGON_XDEV)/paragon/lib-coff/options/autoinit.o
                              Routine linked in when -nx is used.

  The following files and directories are used by default in the native
  environment (cc). If / is not the root of the compiler installation
  directory, you must set PARAGON_XDEV to this directory and add
  $PARAGON_XDEV/usr/ccs/bin to your path.

  /usr/ccs/bin                Directory containing executables.

  /usr/ccs/bin/cc             C compiler driver.

  /usr/ccs/bin/ic             C compiler.

  /usr/ccs/bin/as             Assembler.

  /usr/ccs/bin/ld             Linker.

  /usr/include                Standard include directory.

  /usr/lib                    Standard library directory.

  /usr/lib/crt0.o             C start-up routine.

  /usr/lib/libpm.o            Performance monitoring module.

  /usr/lib/guard.o            Barrier between user and system code.
  /usr/lib/libc.a             Standard C library.

  /usr/lib/libic.a            C built-in intrinsic library.

  /usr/lib//libmach.a         Mach operating system library.

  /usr/lib/noieee             Library directory used when linking with
                              -Knoieee (contains non-IEEE version of libm.a).

  /usr/lib/options/autoinit.o                                Routine linked
                              in when -nx is used.

ENVIRONMENT VARIABLES

  The environment variable MAKECPP is supported. MAKECPP is a colon-separated
  list of directories that is added to the compiler search path for include
  files.

  If you use the -Knoieee switch and define LPATH or PARAGON_LPATH, be sure
  that the directory containing the noieee versions of libf.a and libm.a is
  listed before a directory containing the ieee versions of these libraries.
  If in doubt, compile with the -v switch to see which libraries are linked
  in. See the ld860 manual page for more information.

DIAGNOSTICS

  The compiler produces information and error messages as it translates the
  input program. The linker and assembler may generate their own error
  messages.

SEE ALSO

  ar860, as860, dump860, if77, ifixlib, ld860, nm860, size860, strip860


cd(1)                                                                   cd(1)

NAME

  cd - Changes the current working directory

SYNOPSIS

  cd [directory]

DESCRIPTION

  The cd command moves you from your present directory to another directory.
  You must have execute (search) permission in the specified directory.

  If you do not specify a directory, cd moves you to your login directory
  ($HOME in ksh and sh environments, or $home in csh environment).  If the
  specified directory name is a full pathname, it becomes the current working
  directory.  A full pathname begins with a / (slash) for the root directory,
  with a .  (dot) for the current working directory, or with a ..  (dot dot)
  for the parent directory.  If the directory name is not a full pathname, cd
  searches for it relative to one of the paths specified by the $CDPATH shell
  variable (or $cdpath csh variable).  This variable has the same syntax as,
  and similar semantics to, the $PATH shell variable (or $path csh variable).

EXAMPLES

   1.  To change to your home directory, enter:
       cd
   2.  To change to a new directory, enter:
       cd  /usr/include

       This changes the current working directory to /usr/include.  Now file
       pathnames that do not begin with / or ../ specify files located in
       /usr/include.

   3.  To go down one level of the directory tree, enter:
       cd  sys

       If the current working directory is /usr/include and if it contains a
       subdirectory named sys, then /usr/include/sys becomes the current
       working directory.

   4.  To go up one level of the directory tree, enter:
       cd  ..

       The special filename .. (dot dot) always refers to the directory
       immediately above the current working directory.

RELATED INFORMATION

  Commands:  csh(1), ksh(1), pwd(1), sh(1).

  Functions:  chdir(2).


chmod(1)                                                             chmod(1)

NAME

  chmod - Changes permission codes

SYNOPSIS

  chmod [-fR] absolute_mode file ...

  chmod [-fR] [who] +permission ...  file ...

  chmod [-fR] [who] -permission ...  file ...

  chmod [-fR] [who] =[permission ...] file ...

  The chmod command modifies the read, write, and execute permissions of
  specified files and the search permissions of specified directories.

FLAGS

  -f  Does not report an error if chmod fails to change the mode on a file.

  -R  Causes chmod to recursively descend its directory arguments, setting
      the mode for each file as described in the sections Symbolic Mode and
      Absolute Mode.  When symbolic links are encountered, their mode is not
      changed and they are not traversed.

DESCRIPTION

  You can use either symbolic or absolute mode to specify the desired permis-
  sion settings.  You can change the permission code of a file or directory
  only if you own it or if you have superuser authority.

  Symbolic Mode
  A symbolic mode has the form:

  [who] operation permission [operation permission] ...

  The who argument specifies whether you are defining permissions for a user,
  group, or all others, or any combination of these.  The operation argument
  specifies whether the permission is being added, taken away, or assigned
  absolutely.  The permission argument identifies the operation that the
  specified users can perform on file.

  Valid options for the who argument are as follows:

  u   User (owner)

  g   Group

  o   All others

  a   User, group, and all others (same effect as the combination ugo)

  If the who argument is omitted, the default is a, but the setting of the
  file creation mask, umask (see csh, ksh, sh), is applied.
  Valid options for the operation argument are as follows:

  -   Removes specified permissions.

  +   Adds specified permissions.

  =   Clears the selected permission field and sets it to the code specified.
      If you do not specify a permission code following =, chmod removes all
      permissions from the selected field.

  Valid options for the permission argument are as follows:

  r   Read permission.

  w   Write permission.

  x   Execute permission for files, search permission for directories.

  X   Execute permission only if file is a directory or at least one execute
      bit is set.

  s   Set-user-ID or set-group-ID permission.
      This permission bit sets the effective user ID or group ID to that of
      the owner or group owner of file whenever the file is run.  Use this
      permission setting in combination with the u or g option to allow tem-
      porary or restricted access to files not normally accessible to other
      users.  An s appears in the user or group execute position of a long
      listing (see ls) to show that the file runs with set-user-ID or set-
      group-ID permission.

  t   Save text permission.
      In earlier versions of the UNIX system, setting this permission bit
      caused the text segment of a program to remain in virtual memory after
      its first use.  The system thus avoided having to transfer the program
      code of frequently accessed programs into the paging area.  You can
      specify this permission, but in OSF/1 it has no effect.  A t appears in
      the execute position of the all others option to indicate that the file
      has this bit (the sticky bit) set.
      If a directory has this bit set, then deletion in it is restricted.  An
      entry in a sticky directory can only be removed or renamed by a user if
      the user has write permission for the directory and the user is the
      owner of the file, the owner of the directory, or the superuser.

  The u, g, and o options indicate that permission is to be taken from the
  current mode.  Omitting permission is only useful with = to take away all
  permissions.

  All permission bits not explicitly specified are cleared.

  You can specify multiple symbolic modes, separated with commas.  Do not
  separate items in this list with spaces.  Operations are performed in the
  order they appear from left to right.

  Absolute Mode
  Absolute mode lets you use octal notation to set each bit in the permission
  code.  The chmod command sets the permissions to the permission_code you
  provide.  permission_code is constructed by combining (the logical OR of)
  the following values:

  4000
      Sets user ID on execution.

  2000
      Sets group ID on execution.

  1000
      Sets sticky bit (see chmod(2)):

        o
        Retains memory image after execution (executable file).  Has no
        effect in OSF/1.

        o
        Restricts file removal (directory).

  0400
      Permits read by owner.

  0200
      Permits write by owner.

  0100
      Permits execute or search by owner.

  0040
      Permits read by group.

  0020
      Permits write by group.

  0010
      Permits execute or search by group.

  0004
      Permits read by others.

  0002
      Permits write by others.

  0001
      Permits execute or search by others.

EXAMPLES

   1.  To add a type of permission to several files, enter:
       chmod  g+w  chap1 chap2

       This adds write permission for group members to the files chap1 and
       chap2.

   2.  To make several permission changes at once, enter:
       chmod  go-w+x  mydir

       This denies group members and others the permission to create or
       delete files in mydir (go-w).  It allows them to search mydir or use
       it in a pathname (go+x).  This is equivalent to the following command
       sequence:
       chmod  g-w  mydir
       chmod  o-w  mydir
       chmod  g+x  mydir
       chmod  o+x  mydir
   3.  To permit only the owner to use a shell procedure as a command, enter:
       chmod  u=rwx,go=  cmd

       This gives read, write, and execute permission to the user who owns
       the file (u=rwx).  It also denies the group and others the permission
       to access cmd in any way (go=).
       If you have permission to execute the cmd shell command file, you can
       run it by entering:
       cmd

       or
       ./cmd
   4.  To use set-ID modes, enter:
       chmod  ug+s  cmd

       When cmd is executed, this causes the effective user and group IDs to
       be set to those that own the file cmd.  Only the effective IDs associ-
       ated with the subprocess that runs cmd are changed.  The effective IDs
       of the shell session remain unchanged.
       This feature allows you to permit restricted access to important
       files.  Suppose that the file cmd has the set-user-ID mode enabled and
       is owned by a user called dbms.  dbms is not actually a person, but
       might be associated with a database management system.  The user betty
       does not have permission to access any of dbms's data files.  However,
       she does have permission to execute cmd.  When she does so, her effec-
       tive user ID is temporarily changed to dbms, so that the cmd program
       can access the data files owned by dbms.
       This way betty can use cmd to access the data files, but she cannot
       accidentally damage them with the standard shell commands.

   5.  To use the absolute mode form of the chmod command, enter:
       chmod  644  text

       This sets read and write permission for the owner, and it sets read-
       only mode for the group and all others.

RELATED INFORMATION

  Commands:  chgrp(1), chown(1), csh(1), ksh(1), ls(1), sh(1).

  Functions:  chown(2), chmod(2), stat(2), umask(2).


passwd(1)                                                           passwd(1)

NAME

  passwd, chfn, chsh - Changes password file information

SYNOPSIS

  passwd [-f | -s] [username]

  chfn [username]

  chsh [username]

  The passwd command changes (or installs) the password associated with your
  username (by default) or the specified username.  The chfn command changes
  GECOS information associated with your username or the specified username.
  The chsh command changes the login shell of your username or of the speci-
  fied username.

FLAGS

  -f  Invokes the chfn command when given with the passwd command.

  -s  Invokes the chsh command when given with the passwd command.

DESCRIPTION

  When altering a password, the program prompts for the current password and
  then for the new one.  The caller must supply both.  The new password must
  be typed twice to forestall mistakes.

  The maximum length of a password is eight characters.  If you enter more
  than eight characters when creating a password, passwd ignores any charac-
  ters after the eighth.

  When altering the GECOS information field, chfn displays the current infor-
  mation, broken into fields, as interpreted by by the finger program, among
  others, and prompts for new values.  These fields include a user's proper
  name, office room number, office phone number, and home phone number.
  Included in each prompt is a default value, which is enclosed in [ ]
  (brackets).  The default value is accepted simply by pressing <Return>.  To
  enter a blank field, the word none can be entered.

  The chfn command allows phone numbers to be entered with or without dashes.
  It is a good idea to run finger after changing the GECOS information to
  make sure everything is set up properly.

  A superuser can change anyone's GECOS information; other users can only
  change their own.

  When altering a login shell, chsh displays the current login shell and then
  prompts for the new one.  The new login shell must be one of the approved
  shells listed in /etc/shells unless you have superuser privileges.  If
  /etc/shells does not exist, the only shells that can be specified are
  /usr/bin/sh and /usr/bin/csh.

  A superuser can change anyone's login shell; normal users can only change
  their own login shell.
EXAMPLES

   1.  To change your password, enter:
       passwd

       You are prompted for your old password (if it exists).  You are then
       prompted twice for the new password.

   2.  To change the office number and building values in your GECOS

       information, enter:
       chfn

       Your current GECOS values are displayed.  Follow the instructions and
       change your office number.  For example, enter:
       Name [Huan Kim]:
       Room Number [3A-41]: 4A-43
       Office Phone [3-1234]:
       Home Phone [555-1234]:
FILES

  /etc/passwd
             Contains user information.

  /etc/shells
             The list of approved shells.

RELATED INFORMATION

  Commands: finger(1), login(1).

  Files: passwd(4).


clear(1)                                                             clear(1)

NAME

  clear - Clears terminal screen

SYNOPSIS

  clear

DESCRIPTION

  The clear command clears your screen, if possible.  It looks in the
  environment for the terminal type and then in the terminfo database to
  determine how to perform this operation.

FILES

  /usr/lib/terminfo/?/*
                Terminal information database.

RELATED INFORMATION

  Commands:  tput(1).

  Files:  terminfo(4).


cmp(1)                                                                 cmp(1)

NAME

  cmp - Compares two files

SYNOPSIS

  cmp [-l | -s] file1 file2

  The cmp command compares two files.

FLAGS

  -l  Prints the byte number (decimal) and the differing bytes (octal) for
      each difference.

  -s  Does not print data for differing files; returns only an exit value.

DESCRIPTION

  If file1 or file2 is specified as a - (dash), standard input is used.  By
  default, the cmp command prints no information if the files are the same.
  If the files differ, cmp prints the byte and line number where the differ-
  ence occurred.  The cmp command also specifies whether one file is an ini-
  tial subsequence of the other (that is, if the cmp command reads an End-
  of-File character in one file before finding any differences).  Normally,
  you use the cmp command to compare nontext files and the diff command to
  compare text files.

  Note that bytes and lines reported by cmp are numbered from 1.

EXAMPLES

   1.  To determine whether two files are identical, enter:
       cmp prog.o.bak prog.o

       The preceding command compares the files prog.o.bak and prog.o.  If
       the files are identical, a message is not displayed.  If the files
       differ, the location of the first difference is displayed.  For
       instance:
       prog.o.bak prog.o differ:  byte 5, line 1

       If the message cmp: EOF on prog.o.bak is displayed, then the first
       part of prog.o is identical to prog.o.bak, but there is additional
       data in prog.o.  If the message cmp: EOF on prog.o is displayed, it is
       prog.o.bak that is the same as prog.o but also contains addition data.

   2.  To display each pair of bytes that differ, enter:
       cmp -l prog.o.bak prog.o

       This compares the files and then displays the byte number (in decimal)
       and the differing bytes (in octal) for each difference.  For example,
       if the fifth byte is octal 101 in prog.o.bak and 141 in prog.o, then
       the cmp command displays:
       5 101 141
       .
       .

EXIT VALUES

  Exit value 0 (zero) is returned for identical files, 1 for differing files,
  and 2 for an inaccessible file or a missing argument.

RELATED INFORMATION

  Commands:  comm(1), bdiff(1), diff(1), diff3(1).


cp(1)                                                                   cp(1)

NAME

  cp - Copies files

SYNOPSIS

  cp [-fhip] [--] source_file destination_file

  cp [-fhip] [--] source_file ...  destination_directory

  cp [-fhip] [-R | -r] [--] [source_file | source_directory] ...
  destination_directory

  The cp command copies a source file or the files in a source directory to a
  destination file or directory.  If your source and destination are direc-
  tories, the source is copied to the destination and created with the same
  name.

FLAGS

  -f  Overrides the i option; cp does not prompt you when an existing file is
      to be overwritten.  (If both -f and -i are specified on the command
      line  for example, because an alias includes one of them  whichever
      appears last overrides the other.)

  -h  Forces cp to follow symbolic links; useful with with the -R option,
      which does not follow symbolic links by default.

  -i  Prompts you with the name of the file whenever the copy causes an old
      file to be overwritten.  An answer beginning with y, or the locale's
      equivalent of y, causes cp to continue.  Any other answer prevents it
      from overwriting the file.  (If both -f and -i are specified on the
      command line  for example, because an alias includes one of them
      whichever appears last overrides the other.)

  -p  Preserves for the copy the modification time, access time, file mode,
      user ID, and group ID of the original, as allowed by permissions.  If
      the user ID and group ID cannot be preserved, no error message is
      displayed and the exit value is not altered.  If the original is set-
      user-ID or set-group -D, and either the user ID or the group ID cannot
      be preserved, the set-user-ID and set-group-ID bits are not preserved
      in the copy's permissions.

  -R  When the source is a directory, copies the directory and the entire
      subtree connected at that point.  Special file types, such as symbolic
      links and block and character devices, are recreated instead of being
      copied.  Created directories have the same mode as the corresponding
      source directory, unmodified by the process's file mode creation mask
      (umask).

  -r  Identical to -R except that special files are not treated differently
      from regular files (follows symbolic links).  The -R option is pre-
      ferred.

  --  Indicates that the arguments following this flag are to be interpreted
      as filenames.  This null flag allows the specification of filenames
      that start with a minus.
DESCRIPTION

  If a destination file already exists, its contents are overwritten if per-
  missions allow, but cp does not change its mode, user ID, or group ID.
  However, if the file is not being copied by the root user, writing the file
  may clear the set-user-ID or set-group-ID permission bits.

  If the destination file does not exist, the mode of the source file is
  used, as modified by the file mode creation mask (umask).  If the source
  file is either set-user-ID or set-group-ID, those bits are removed unless
  the source file and the destination file are owned by the same user and
  group.

  Appropriate permissions are always required for file creation or overwrit-
  ing.

  You can also copy special device files.  If the file is a named pipe, the
  data in the pipe is copied into a regular file.  If the file is a device,
  the file is read until the end of file, and that data is copied into a reg-
  ular file.

  The LC_MESSAGES variable determines the locale's equivalent of y or n (for
  yes/no queries).

EXAMPLES

   1.  To copy one file to another, enter:
       cp file1 file2

       If file2 exists (and is writable), it is replaced by file1.

   2.  To copy files to a directory, enter:
       cp file1 file2 dir1

       dir1 must exist.

   3.  To copy all files in a directory and preserve their modification
       times, enter:
       cp -p dir1/* dir2
   4.  To copy a directory tree to another directory, enter:
       cp -R dir1 dir2

       The dir1 tree is created in dir2.

NOTES

   1.  Do not give the destination the same name as one of the source files.

   2.  If you specify a directory as the destination, the directory must
       already exist.

   3.  If you are using the -r option to copy the contents of one directory
       to another, and source_directory contains subdirectories that do not
       exist in destination_directory, the subdirectories will be created.
EXIT VALUES
  The cp command returns 0 (zero) upon successful completion and greater than
  0 (zero) if an error occurs.

RELATED INFORMATION

  Commands: cpio(1), link(1)/unlink(1), ln(1), mv(1).


csh(1)                                                                 csh(1)

NAME

  csh - C shell command interpreter

SYNOPSIS

  csh [-bcefinstvVxX] [argument ...]

  The csh command invokes the C shell and interprets C shell commands.

FLAGS

  -b  Forces a break from option processing, causing any further shell argu-
      ments to be treated as nonoption arguments.  This can be used to pass
      options to a shell script without confusion or possible subterfuge.
      The shell cannot run a set-user-ID script without this flag.

  -c  Reads commands from the following single argument, which must be
      present.  Any remaining arguments are placed in argv.

  -e  Causes the shell to exit if any invoked command terminates abnormally
      or yields a nonzero exit status.

  -f  Causes the shell to start faster, because it neither searches for nor
      executes the .cshrc file in the invoker's home directory.

   -i Causes the shell to be interactive, even if the input does not come
      from a terminal.  Shells are always interactive when invoked from a
      terminal.

  -n  Parses commands, but does not execute them.  This aids in syntactic
      checking of shell scripts.

  -s  Takes command input from the standard input.

  -t  Reads and executes a single line of input.  You can use a \ (backslash)
      to escape the newline character at the end of the current line to con-
      tinue onto another line.

  -v  Sets the verbose shell variable, with the effect that command input is
      echoed to the standard output after history substitution.

  -V  Sets the verbose shell variable, even before .cshrc is executed.

  -x  Sets the echo shell variable, so that commands are echoed to the stan-
      dard error after all substitutions and immediately before execution.

  -X  Sets the echo shell variable, even before .cshrc is executed.

  After processing of flag arguments, if arguments remain but none of the -c,
  -i, -s, or -t flags was given, the first argument is taken as the name of a
  file of commands to be executed (i.e., a shell script).  The shell opens
  this file, and saves its name for possible resubstitution by $0.  If the
  first characters of the shell script are #!shell_pathname or #csh, csh runs
  the specified shell to process the script.  Otherwise, csh runs.  Remaining
  parameters initialize the argv variable.

DESCRIPTION

  The C shell is an interactive command interpreter and a command programming
  language that uses a syntax similar to the C programming language.  The
  shell carries out commands either from a file (called a shell script or
  procedure) or interactively from a terminal keyboard.

  When you run csh, it begins by executing commands from the file .cshrc in
  your home directory, if it exists.  If the shell is invoked with a name
  that starts with -, as when started by login, the shell runs as a login
  shell.  If csh runs as a login shell, it executes commands from your
  $HOME/.cshrc file and your $HOME/.login file in that order.  (If argument
  zero ($0) to the shell is a - (dash), then the shell is a login shell.)

  In the normal case, the shell begins reading commands from the terminal,
  prompting with % (percent sign) or # (number sign) for the superuser.  Pro-
  cessing of arguments and the use of the shell to process files containing
  command scripts is described later.

  The shell then repeatedly performs the following actions:

   1.  A line of command input is read and broken into words.

   2.  This sequence of words is placed on the command history list and then
       parsed.

   3.  Each command in the current line is executed.

  When a login shell terminates, it executes commands from the file .logout
  in your home directory.

  Shell Features
    o  Job control and status reporting

    o  Filename completion

    o  History substitution

    o  Command aliasing

    o  Variable substitution

    o  Command substitution

    o  Filename substitution

    o  Input/output redirection and control flow

    o  Built-in commands

  Lexical Structure
  A simple command is a sequence of words separated by spaces or tabs.  The
  shell splits input lines into words at spaces and tabs with the following
  exceptions:

    o  The characters &, |, ;, <, >, (, ), and # form separate words.  If
       doubled in &&, ||, <<, or >>, these pairs form single words.

    o  Preceding parser metacharacters with a \ (backslash) prevents the
       shell from interpreting them as special characters.  A newline pre-
       ceded by a \ (backslash) is equivalent to a space.

    o  Strings enclosed in " " (double quotes), ` ` (grave accents), or ' '
       (single quotes) form parts of a word; metacharacters in these strings,
       including spaces and tabs, do not form separate words.  For more
       information, see the section "Quoting with Single and Double Quotes".
       Within pairs of ' or " characters, you can include the newline charac-
       ter by preceding it with a \ (backslash).

    o  When the shell is not reading input from a terminal, it treats any
       word that begins with a # (number sign) character as a comment and
       ignores that word and all characters following up to the next newline
       character.  This special meaning is prevented when the # character is
       preceded by a \ (backslash) or when the string is enclosed in quotes
       using `, ', or ".

  Shell Commands
  A simple command is a sequence of words, the first of which (numbered 0)
  specifies the command to be executed.  Any remaining words, with a few
  exceptions, are passed to that command.  If the command specifies an exe-
  cutable file that is a compiled program, the shell immediately runs that
  program.  If the file is marked executable but is not a compiled program,
  the shell assumes that it is a shell script.  In this case, it starts
  another shell to read the file and execute the commands included in it.
  (See the section NonBuilt-In Command Execution for information about using
  the $shell variable to determine which shell is executed.)

  A pipeline is a sequence of one or more commands separated by either the |
  (vertical bar) or |& (vertical bar and ampersand) characters.  With |, the
  standard output of the preceding command is redirected to the standard
  input of the command that follows.  With |&, both the standard error and
  the standard output are redirected.  A list is a sequence of pipelines
  separated by a ; (semicolon), & (ampersand), && (two ampersands), or ||
  (two vertical bars) and optionally ended by a ; (semicolon) or an & (amper-
  sand).  These separators and terminators have the following effects:

  ;   Causes sequential execution of the preceding pipeline (the shell waits
      for the pipeline to finish).

  &   Causes asynchronous execution of the preceding pipeline (the shell does
      not wait for the pipeline to finish).

  &&  Causes the list following it to be executed only if the preceding pipe-
      line returns a 0 (zero) exit value.

  ||  Causes the list following it to be executed only if the preceding pipe-
      line returns a nonzero exit value.

  The ; (semicolon) and & (ampersand) separators have equal precedence, as do
  && and ||.  The single-character separators have lower precedence than the
  double-character separators.  A newline character without quotes following
  a pipeline functions the same as a ; (semicolon).  A pipeline or sequence
  can be enclosed in () (parentheses) to form a simple command.

  Job Control
  The shell associates a job with each pipeline.  It keeps a table of current
  jobs and assigns them small integer numbers.  When you start a job asyn-
  chronously by terminating the command with &, the shell displays a line
  that looks like this:
  [1] 1234
  This line indicates that the job number is 1 and that the job is composed
  of one process with the process ID of 1234.  Use the built-in jobs command
  to see the table of current jobs.

  If you are running a job and want to do something else, you can enter the
  Suspend key sequence (normally <Ctrl-z>, which sends a SIGINT signal to the
  current job.  The shell then normally indicates that the job has been
  stopped, and it prints another prompt.  You can then manipulate the state
  of this job, putting it in the background with the bg command, or run some
  other commands and then eventually bring the job back into the foreground
  with the foreground command fg.  The job suspension takes effect immedi-
  ately, and corresponds to the Interrupt key sequence in that pending output
  and unread input are discarded.  A special key sequence, <Ctrl-y>, does not
  generate a SIGINT signal until a program attempts to read it.  (See the
  read() system call for more information.)  This key sequence can usefully
  be typed ahead when you have prepared some commands for a job that you wish
  to stop after it has read them.

  A job being run in the background stops if it tries to read from the termi-
  nal.  Background jobs are normally allowed to produce output, but this can
  be disabled by entering the stty tostop command.  If you set this tty
  option, background jobs stop when they try to produce output like they do
  when they try to read input.

  There are several ways to refer to jobs in the shell.  Use the % (percent
  sign) with the fg and bg built-in commands to control the job.  This name
  can be either the job number or a prefix of the string that started the
  job, if this name is unique.  (% can be used to refer to both background
  and foreground jobs.)

  For example, if a make process is running as job number 1, you can refer to
  it as %1.  You can also refer to it as %make, if there is only one job with
  a name that begins with the string make.  You can also use the following
  characters to specify a job whose name contains string, if there is only
  one such job:
  %?string

  Just naming a job brings it to the foreground; thus %1 is a synonym for fg
  %1, bringing job 1 back into the foreground.  Similarly, entering %1 &
  resumes job 1 in the background.  Thus, %ex normally restarts a suspended
  ex job, if there were only one suspended job whose name began with the
  string ex.

  The shell maintains a notion of the current and previous jobs.  In output
  produced by the built-in command jobs, the current job is marked with a +
  (plus sign) and the previous job with a - (dash).  The abbreviation %+
  refers to the current job and %- refers to the previous job.  For close
  analogy with the syntax of the history mechanism (described later), %% is
  also a synonym for the current job.

  Status Reporting
  The shell tracks the state of each job and reports whenever a job finishes
  or becomes blocked.  The shell prints the status information just before it
  prints the prompt to avoid disturbing the appearance of the terminal
  screen.  If, however, you set the notify shell variable, the shell notifies
  you immediately of changes of status in background jobs.  There is also a
  notify shell command that marks a single process so that its status changes
  are immediately reported.  By default notify marks the current process.
  Simply enter notify after starting a background job to mark the job.

  When you try to leave the shell while jobs are stopped, you are warned that
  you have stopped jobs.  You can use the built-in jobs command to see what
  they are.  If you then immediately exit the shell, or use jobs and then
  exit, the shell does not warn you a second time, and the suspended jobs are
  terminated.

  Filename Completion
  The filename completion feature is enabled by setting the shell variable
  filec.  The csh interactively completes filenames and usernames from unique
  prefixes when they are input from the terminal followed by the escape char-
  acter (the <ESC> key or <Ctrl-[>)).  For example, assume the current direc-
  tory looks like this:
  DSC.OLD  bench  chaos  cmd     dev  mail  xmpl.c  xmpl.out
  DSC.NEW  bin    class  cmtest  lib  mbox  xmpl.o
  The input is as follows:
  % vi ch<ESC>
  csh completes the prefix ch to the only matching filename chaos:
  vi chaos
  However, given the following command line:
  vi D<ESC>
  csh only expands the input as follows:
  vi DSC.
  csh sounds the terminal bell to indicate that the expansion is incomplete,
  because two filenames match the prefix D.

  If a partial filename is followed by the End-of-File character (shown here
  as <Ctrl-d>), then instead of completing the name, csh lists all filenames
  matching the prefix.  For example, the following input causes all files
  beginning with D to be listed:
  vi D<Ctrl-d>

  DSC.NEW DSC.OLD
  The input line is then echoed again for you to complete.

  The same system of <ESC> and <EOF> can also be used to expand partial user-
  names, if the word to be completed (or listed) begins with ~ (tilde).  For
  example, entering the following command line
  cd ~ro<ESC>
  can produce the following expansion:
  cd ~root
  The use of the terminal bell to signal errors or multiple matches can be
  inhibited by setting the variable nobeep.

  Normally, all files in the particular directory are candidates for name
  completion.  Files with certain suffixes can be excluded from consideration
  by setting the variable fignore to the list of suffixes to be ignored.
  Thus, if fignore is set by the following command:
  % set fignore = (.o .out)
  typing
  % vi x<ESC>
  results in the completion to
  % vi xmpl.c
  ignoring the files xmpl.o and xmpl.out.  However, if the only completion
  possible requires not ignoring these suffixes, then they are not ignored.
  In addition, fignore does not affect the listing of filenames by <Ctrl-d>.
  All files are listed regardless of their suffixes.

  History Substitution
  History substitution places words from previous command input as portions
  of new commands, making it easy to repeat commands, repeat arguments of a
  previous command in the current command, or fix spelling mistakes in the
  previous command with little typing.  History substitutions begin with the
  ! (exclamation point) character and can begin anywhere on the command line,
  provided they do not nest (in other words, a history substitution cannot
  contain another history substitution).  You can precede the ! with a \
  (backslash) to prevent the exclamation point's special meaning.  In addi-
  tion, if you place an ! (exclamation point) before a space, tab, newline, =
  (equal sign), or ( (left parenthesis), the exclamation point is passed to
  the parser unchanged.  (History substitutions also occur when you begin an
  input line with a ^ (circumflex).  This special abbreviation is described
  later.) The shell echoes any input line containing history substitutions
  before it executes that command line.

  Commands input from the terminal that consist of one or more words are
  saved on the history list.  The history substitutions reintroduce sequences
  of words from these saved commands into the input stream.

  The history shell variable controls the size of the history list.  You must
  set the history shell variable either in the .cshrc file or on the command
  line with the built-in set command.  The previous command is always
  retained, however, regardless of the value of history.  Commands in the
  history list are numbered sequentially, starting from 1.  The built-in his-
  tory command produces output of the type:
   9  write michael
  10  ex write.c
  11  cat oldwrite.c
  12  diff *write.c
  The command strings are shown with their event numbers.  It is not usually
  necessary to use event numbers to refer to events, but you can have the
  current event number displayed as part of your system prompt by placing an
  ! (exclamation point) in the prompt string assigned to the prompt variable.

  A full history reference contains an event specification, a word designa-
  tor, and one or more modifiers in the following general format:

  event[:]word:modifier[:modifier]...

  Note that only one word can be modified.  A string that contains spaces is
  not allowed.

  In the previous sample of history command output, the current event number
  is 13.  Using this example, the following refer to previous events:

  !10 Refers to event number 10.

  !-2 Refers to event number 11 (the current event minus 2).

  !d  Refers to a command word beginning with d (in this case, event number
      12).

  !?mic?
      Refers to a command word that contains the string mic (in this case,
      event number 9).

  These forms, without further modification, simply reintroduce the words of
  the specified events, each separated by a single space.  As a special case,
  !! refers to the previous command.  (The !! command alone on an input line
  reruns the previous command.)

  To select words from an event, follow the event specification by a :
  (colon) and one of the following word designators.  The words of an input
  line are numbered sequentially, starting from 0 (zero), with the first
  (usually command) word being 0 (zero), the second word (first argument)
  being 1, and so on.  The basic word designators are as follows:

  0   First word (command).

  n   nth argument, where n > 0.

  ^   First word (word 1).

  $   Last word.

  %   Word matched by (the immediately preceding) ?string? history search.

  x-y Range of words from x through y.

  -y  Words 0-y.

  *   The second through the last words, or nothing if only one word in
      event.

  x*  Words x- $

  x-  Like x*, but omits the last word ($).

  You can omit the : (colon) separating the event specification from the word
  designator if the word designator begins with a ^, $, *, -, or %.  You can
  also place a sequence of modifiers, each preceded by a : (colon), after the
  optional word designator.  The following modifiers are defined:

  &   Repeats the previous substitution.

  e   Removes all but the trailing extension .xxx.

  g   Applies the change globally, prefixing another modifer e.g. g&.

  h   Removes a trailing pathname extension, leaving the head.

  p   Prints the new command, but does not execute it.

  q   Quotes the substituted words, thus preventing further substitutions.

  r   Removes a trailing .xxx component, leaving the root name.

  s/l/r/
      Substitutes r for l.  It is an error for no word to be applicable.

  t   Removes all leading pathname components, leaving the tail.

  x   Like q, but breaks into words at space, tab or newline.

  Unless the modifier is preceded by a g, the change is applied only to the
  first modifiable word.
  The l (left) side of a substitution is not a pattern in the sense of a
  string recognized by an editor; rather, it is a word, a single unit without
  spaces. Normally, a / (slash) delimits the word (l) and its replacement
  (r). However, you can use any character as the delimiter.  Thus, in the
  following example the = character becomes the delimiter, allowing you to
  include the / in your word:
  s=/usr/myfile=/usr/yourfile=
  If you include an & (ampersand) in the replacement (r), it is replaced by
  the text from the left-hand side (l).  A null l side is replaced by either
  the last l string or by the last string used in the contextual scan
  !?string?.  You can omit the trailing delimiter (/) if a newline character
  follows immediately.

  A history reference can be given without an event specification.  For exam-
  ple, !$ refers to the last argument of the previous command.  If a history
  reference without an event specification is not the first history reference
  on the line, it refers to the previous history reference on the line and
  not to a previous event.  For example, in !?foo?^ !$, !?foo?^ gives the
  first argument of the command matching ?foo?, and the !$ gives the last
  argument of that same command, not the last argument of the previous com-
  mand (as it would if it were on a line by itself).

  A special abbreviation of a history reference occurs when the first non-
  space character of an input line is a ^ (circumflex).  This is equivalent
  to !:s^, providing a convenient shorthand for substitutions on the text of
  the previous line.  Thus, ^lb^lib corrects the spelling of lib in the pre-
  vious command.  Finally, a history substitution can be enclosed in { }
  (braces) to insulate it from the characters that follow.  Thus, after ls
  -ld ~paul you might specify !{l}a to do ls -ld ~paula, or !la to rerun a
  command starting with la.

  Quoting with Single and Double Quotes
  Enclose strings in single and double quotes to prevent all or some of the
  substitutions that remain.  Enclosing strings in ' ' (single quotes)
  prevents any further interpretation.  Enclosing strings in " " (double
  quotes) allows further variable and command expansion. In both cases, the
  text that results becomes (all or part of) a single word.  Only in one spe-
  cial case does a string quoted by " " yield parts of more than one word;
  strings quoted by ' ' never do (see Command Substitution).

  Alias Substitution
  The shell maintains a list of aliases that the alias and unalias built-in
  commands can establish, display, and modify.  After the shell scans a com-
  mand line, it divides the line into distinct commands and checks the first
  word of each command, left to right, to see if it has an alias.  If an
  alias exists, the text defined as the alias for that command is reread with
  the history mechanism, as if the alias were the previous input line.  The
  words that result replace the command and argument list.  If no reference
  is made to the history list, the argument list is left unchanged.

  Thus, if the alias for ls is ls -l, the shell replaces the command ls /usr
  with ls -l /usr.  The argument list is left unchanged because there is no
  reference to the history list in the command with an alias.  Similarly, if
  the alias for lookup is grep !^ /etc/passwd, then lookup bill maps to grep
  bill /etc/passwd.

  Here !^ refers to the history list and the shell replaces it with the first
  argument in the input line, in this case bill.  Note that you can use spe-
  cial pattern-matching characters in an alias.  Thus, the line:
  alias lprint 'pr \!* | lpr'
  makes a command that formats its arguments to the line printer.  The !
  (exclamation point) is protected from the shell in the alias so that it is
  not expanded until pr runs.

  If an alias is found, the word transformation of the input text is per-
  formed and the aliasing process begins again on the reformed input line.
  If the first word of the new text is the same as the old, looping is
  prevented by flagging it to terminate the alias process.  Other loops are
  detected and cause an error.

  Variable Substitution
  The shell maintains a set of variables, each of which has as its value a
  list of zero or more words.  Some of these variables are set by the shell
  or referred to by it.  For instance, the argv variable is an image of the
  shell variable list, and words that comprise the value of this variable are
  referred to in special ways.

  You can display and change the values of variables by using the set and
  unset commands.  Of the variables referred to by the shell, a number are
  toggles (variables that turn on and off); the shell does not care what
  their value is, only whether they are set or unset.  For instance, the ver-
  bose variable is a toggle that causes the words of each command to be
  echoed.  The setting of this variable results from the -v flag on the com-
  mand line.

  Other operations treat variables numerically.  The @ command performs
  numeric calculations and the result is assigned to a variable.  Variable
  values are, however, always represented as (zero or more) strings.  For the
  purposes of numeric operations, the null string is considered to be 0
  (zero), and the second and subsequent words of multiword values are
  ignored.

  After the input line is parsed and alias substitution is performed, and
  before each command is executed, variable substitution is performed, keyed
  by $ (dollar sign) characters.  You can prevent this expansion by preceding
  the $ with a \ (backslash) except within " " (double quotes), where it
  always occurs, or by using ' ' (single quotes), where it never occurs.
  Strings quoted by ` ` (grave accents) are interpreted later (see Command
  Substitution), so variable substitution does not occur there until later,
  if at all.  A $ is passed unchanged if followed by a space, tab, or new-
  line.

  Input/output redirection is recognized and expanded before variable expan-
  sion occurs.  Otherwise, the command name and complete argument list are
  expanded together.  Therefore, it is possible for the first (command) word
  to this point to generate more than one word, the first of which becomes
  the command name, and the rest of which become arguments.

  Unless enclosed in " " or given the :q modifier, the results of variable
  substitution can themselves eventually be command and filename substituted.
  Within pairs of double quotes, a variable whose value consists of multiple
  words expands to a (portion of a) single word, with the words of the
  variable's value separated by spaces.  When you apply the :q modifier to a
  substitution, the variable expands to multiple words.  The individual words
  are separated by spaces and quoted to prevent later command or filename
  substitution.

  The following notation allows you to introduce variable values into the
  shell input.  Except as noted, it is an error to reference a variable that
  is not set.

  $name

  ${name}
      Are replaced by the words assigned to the variable name, each separated
      by a space.  Braces insulate name from following characters that would
      otherwise be part of it.  Shell variable names begin with a letter and
      consist of up to 20 letters and digits, including the underscore char-
      acter.
      If name is not a shell variable but is set in the environment, then
      that value is returned.  Be aware that the : (colon) modifiers and the
      other forms given below are not available in this case.

  $name[selector]

  ${name[selector]}
      Can be used to select only some of the words from the value of name.
      The selector is subjected to variable substitution and can consist of a
      single number or two numbers separated by a - (dash).  The first word
      of a variable's string value is numbered 1.  If the first number of a
      range is omitted, it defaults to 1.  If the last member of a range is
      omitted, it defaults to $#name (the total number of words in the vari-
      able).  The * (asterisk) selects all words.  It is not an error for a
      range to be empty if the second argument is omitted or in range.

  $#name

  ${#name}
      Gives the number of words in the variable.  This can be used as a
      [selector] (see previous notation).

  $0  Substitutes the name of the file from which command input is being
      read.  An error occurs if the name is not known.

  $number

  ${number}
      Equivalent to $argv[number].

  $*  Equivalent to $argv[*].

  You can apply the modifiers :gh, :gt, :gr, :h, :t, :r, :q and :x to the
  preceding substitutions.  If { } (braces) appear in the command form, the
  modifiers must appear within the braces.  Note that the current implementa-
  tion allows only one : (colon) modifier on each $ variable expansion.

  The following substitutions cannot be changed with : modifiers.

  $?name

  ${?name}
      Substitutes the string 1 if name is set, 0 if it is not.

  $?0 Substitutes 1 if the current input filename is known, 0 (zero) if it is
      not.

  $$  Substitutes the (decimal) process number of the (parent) shell.

  $<  Substitutes a line from the standard input, with no further interpreta-
      tion.  Use it to read from the keyboard in a shell script.
  Command and Filename Substitution
  The shell performs command and filename substitution selectively on the
  arguments of built-in commands.  This means that it does not expand those
  parts of expressions that are not evaluated.  For commands that are not
  internal (i.e., built in) to the shell, the shell substitutes the command
  name separately from the argument list.  This occurs very late, after the
  shell performs input/output redirection, and in a child of the main shell.

  Command Substitution
  The shell performs command substitution on a command string enclosed in ` `
  (grave accents).  The shell normally breaks the output from such a command
  into separate words at spaces, tabs and newline characters, with null words
  being discarded; this text then replaces the original command string.
  Within strings surrounded by " " (double quotes), the shell treats only the
  newline character as a word separator, thus preserving spaces and tabs.

  In any case, the single final newline character does not force a new word.
  Note that it is therefore possible for a command substitution to yield only
  part of a word, even if the command outputs a complete line.

  Filename Substitution
  If a word contains any of the characters *, ?, [, or { or begins with a ~
  (tilde), then that word is a candidate for filename substitution, also
  known as globbing.  This word is then regarded as a pattern, and replaced
  with a sorted list of filenames that match the pattern.  The current col-
  lating sequence is used, which can be specified by the LC_COLLATE or LANG
  environment variable.

  In a list of words specifying filename substitution, it is an error for no
  pattern to match an existing filename, but it is not required that each
  pattern match.  Only the character-matching symbols (metacharacters) *, ?
  and [ imply pattern matching; the characters ~ and { are more like abbrevi-
  ations.

  In matching filenames, the . (dot) character at the beginning of a filename
  or immediately following a / (slash), as well as the / character, must be
  matched explicitly.  The * (asterisk) character matches any string of char-
  acters, including the null string.  The ? (question mark) character matches
  any single character.  The sequence [abcd] matches any one of the enclosed
  characters.  Within [ ], a lexical range of characters can be indicated by
  two characters separated by a - (dash), as in [a-z].  The characters that
  match this pattern are defined by the current collating sequence.  The col-
  lating sequence is determined by the value of the LC_COLLATE or LANG
  environment variable.

  The ~ (tilde) character at the beginning of a filename is used to refer to
  home directories.  Standing alone, the ~ expands to your home directory as
  reflected in the value of the home shell variable.  When followed by a name
  that consists of letters, digits, and - (dash) characters, the shell
  searches for a user with that name and substitutes that user's home direc-
  tory.  Thus, ~ken might expand to /users/ken and ~ken/chmach to
  /users/ken/chmach.  If the ~ (tilde) character is followed by a character
  other than a letter or / (slash) or does not appear at the beginning of a
  word, it is left undisturbed.

  The pattern a{b,c,d}e is a shorthand for abe ace ade.  Left-to-right order
  is preserved, with the results of the matches being sorted separately at a
  low level to preserve this order.  This construct can be nested.  Thus, the
  shell expands:
  ~source/s1/{oldls,ls}.c
  to the filenames:
  /usr/source/s1/oldls.c /usr/source/s1/ls.c
  The preceding example assumes the home directory for source is /usr/source.
  (Note that these files may or may not exist.)

  Similarly, the shell expands:
  ../{memo,*box}
  to the paths:
  ../memo ../box ../mbox
  (Note that memo was not sorted with the results of matching *box.)  As a
  special case, {, }, and {} are passed undisturbed.

  Redirecting Input and Output
  You can redirect the standard input and standard output of a command with
  the following syntax:

  < file
      Opens file (which is first variable, command and filename expanded) as
      the standard input.

  << word
      Reads the shell input up to a line that is identical to word. word is
      not subjected to variable, filename or command substitution; each input
      line is compared to word before any substitutions are done on this
      input line.  Unless a quoting character (\, ", `, or ') appears in
      word, the shell performs variable and command substitution on the
      intervening lines, allowing \ to quote $, \, and `.  Commands that are
      substituted have all spaces, tabs, and newline characters preserved,
      except for the final newline character, which is dropped.  The result-
      ing text is placed in an anonymous temporary file and given to the com-
      mand as standard input.

  > file

  >! file

  >& file

  >&! file
      Uses file as standard output.  If the file does not exist, it is
      created; if the file exists, it is truncated, and its previous contents
      are lost.
      If the noclobber shell variable is set, then the file must not exist or
      be a character special file (for example, a terminal or /dev/null) or
      an error results.  This helps prevent the accidental destruction of
      files.  In this case, use the ! (exclamation point) forms to suppress
      this check.
      The forms involving & (ampersand) route the diagnostic output into the
      specified file as well as the standard output.  file is expanded in the
      same way as < input filenames.

  >> file

  >>& file

  >>! file

  >>&! file
      Uses file as standard output like > but places output at the end of the
      file.  If the noclobber shell variable is set, it is an error for the
      file not to exist unless one of the ! forms is given.  Otherwise, it is
      similar to >.

  A command receives the environment in which the shell was invoked, as
  changed by the input/output parameters and the presence of the command in a
  pipeline.  Thus, unlike some previous shells, commands run from a shell
  script have no access to the text of the commands by default; rather they
  receive the original standard input of the shell.  Use the << mechanism to
  present inline data.  This lets shell scripts function as components of
  pipelines and lets the shell read its input in blocks.

  To redirect diagnostic output through a pipe with the standard output, use
  the form |& (vertical bar, ampersand) rather than | (vertical bar) alone.

  Control Flow
  The shell contains a number of commands that can be used to regulate the
  flow of control in command files (shell scripts) and (in limited but useful
  ways) from terminal input.  These commands all operate by forcing the shell
  to reread or skip in its input and, because of the implementation, restrict
  the placement of some of the commands.

  The foreach, switch, and while statements, and the if-then-else form of the
  if statement, require that the major keywords appear in a single simple
  command on an input line.

  If the shell input is not seekable, the shell buffers input whenever a loop
  is being read and performs seeks in the internal buffer to do the rereading
  implied by the loop.  (To the extent that this allows, backward gotos
  succeed on non-seekable inputs.)

  Built-In Commands
  Built-in commands are executed within the shell.  If a built-in command
  occurs as any component of a pipeline except the last, it is executed in a
  subshell.  The csh searches for a csh built-in command first.  If a built-
  in does not exist, the csh searches through the directories specified by
  the environment variable path for a system-level command to execute.

  alias [name [word_list]]
      If no arguments are specified, displays all aliases.  If name is speci-
      fied, displays the alias for name.  If a word_list is also specified,
      alias assigns the specified word_list as the alias of name.  Command
      and filename substitution are performed on word_list.

  alloc
      Shows the amount of dynamic memory acquired broken down into used and
      free memory.  With an argument, shows the number of free and used
      blocks in each size category.  The categories start at size 8 and dou-
      ble at each step.

  bg [%job ...]
      Puts the current (if %job is not specified) or specified jobs into the
      background, continuing them if they were stopped.

  break
      Causes execution to resume after the end of the nearest enclosing
      foreach or while.  The remaining commands on the current line are exe-
      cuted.  Multilevel breaks are therefore possible by writing them all on
      one line.

  breaksw
      Causes a break from a switch; resumes after the endsw.

  case label:
      Defines a label in a switch statement.  (See switch.)

  cd [directory]

  chdir [directory]
      Changes the shell's working directory to directory.  If no argument is
      given, it changes to your home directory.
      If directory is not found as a subdirectory of the current directory
      (and does not begin with /, ./ or ../), then each component of the
      cdpath shell variable is checked to see if it has a subdirectory direc-
      tory.  Finally, if all else fails, but directory is a shell variable
      whose value begins with /, this is tried to see if it is a directory.

  continue
      Continues execution of the nearest enclosing while or foreach.  The
      rest of the commands on the current line are executed.

  default:
      Labels the default case in a switch statement.  The default should come
      after all case labels.

  dirs
      Displays the directory stack; the top of the stack is at the left, the
      first directory in the stack being the current directory.

  echo [-n] word_list
      Writes the specified words to the shell's standard output, separated by
      spaces, and terminated with a newline character, unless the -n flag is
      specified.

  else

  end

  endif

  endsw
      See the description of foreach, if, switch, and while below.

  eval argument ...
      Reads arguments as input to the shell and executes the resulting com-
      mands.  This is usually used to execute commands generated as the
      result of command or variable substitution, since parsing occurs before
      these substitutions.

  exec command
      Executes the specified command in place of the current shell.

  exit [(expression)]
      Exits the shell with either the value of the status shell variable, if
      no expression is specified, or with the value of the specified expres-
      sion.

  fg [%job ...]
      Brings the current (if %job is not specified) or specified job into the
      foreground, continuing them if they were stopped.

  foreach name (word_list)

  ...

  end Sets the variable name to each member of word_list successively and
      executes the sequence of commands between the foreach command and the
      matching end.  (foreach and end commands must appear alone on separate
      lines.)
      Use the built-in continue command to continue the loop and the built-in
      break command to terminate it prematurely.  When this command is read
      from the terminal, the loop is read once, prompting with ? before any
      statement in the loop is executed.  If you make a mistake in entering a
      loop at the terminal, it can be corrected before you run the loop.
      Commands within loops prompted for by ? are not placed in the history
      list.

  glob word_list
      Functions like echo, but does not recognize \ (backslash) escapes and
      delimits words by null characters in the output.  Useful if you want to
      use the shell to perform filename substitution to expand a list of
      words.

  goto word
      Performs filename and command expansion on the specified word to yield
      a string of the form label:.  The shell rewinds its input as much as
      possible and searches for a line of the form label:, possibly preceded
      by spaces or tabs.  Execution continues after the line specified by
      word.

  history [-h] [-r] [number]
      Displays the history event list; by default, the oldest events are
      displayed first.  If you specify a number, only the number most recent
      events are displayed.  The -r flag reverses the display order to the
      most recent first, rather than the oldest first.  The -h flag displays
      the history list without leading numbers.  Use this to produce files
      suitable for sourcing using the source command.

  if (expression) command
      Executes the single command (including its arguments) if the specified
      expression evaluates TRUE.  Variable substitution on command happens
      early, at the same time it does for the rest of the if command.  The
      command argument must be a simple command (rather than a pipeline, com-
      mand list, alias, or parenthesized command list).  Note that
      input/output redirection occurs even if expression is FALSE and command
      is not executed.

  if (expression) then

  ...

  else if (expression2) then

  ...

  else

  ...

  endif
      If expression is TRUE, executes the commands following the first then
      up to the first else; otherwise, if expression2 is TRUE, executes the
      commands following the second then up to the second else.  Any number
      of else-if pairs are possible; only one endif is needed.  The else part
      is optional.  (The words else and endif must appear at the beginning of
      input lines.  The if command must appear alone on its input line or
      after an else.)

  inlib library_name
      Installs the specified shared library into the shell's private table of
      installed libraries.  This makes the library available for resolution
      of unresolved symbols in commands subsequently executed from this
      shell.

  jobs [-l]
      Lists the active jobs; with the -l flag, lists process IDs in addition
      to job numbers, status, and the command.

  kill [-l] [-sig] [%job ...] | [-sig] [PID ...]
      Sends either the TERM (terminate) signal or the specified signal to the
      jobs or processes that you specify.  Signals are either given by number
      or by name (as given in /usr/include/sys/signal.h, stripped of the pre-
      fix SIG).  The signal names are listed by kill -l.  There is no default
      job; specifying kill with no job or PID does not send a signal to the
      current job.  If the signal being sent is SIGTERM (terminate) or SIGHUP
      (hangup), then the job or process is sent a SIGCONT (continue) signal
      as well.

  limit [-h] [resource] [maximum_use]
      Limits the usage by the current process and each process it creates not
      to (individually) exceed maximum_use on the specified resource.  If no
      maximum_use is given, then the current limit is displayed; if no
      resource is given, then all limitations are given.
      If the -h flag is given, the hard limits are used instead of the
      current limits.  The hard limits impose a ceiling on the values of the
      current limits.  Only the superuser can raise the hard limits, but a
      user can lower or raise the current limits within the legal range.
      Controllable resources currently include addresspace (the maxmimum
      address space in bytes for a process), coredumpsize (the size of the
      largest core dump that is created), cputime (the maximum number of CPU
      seconds to be used by each process), datasize (the maximum growth of
      the data region allowed beyond the end of the program text), descrip-
      tors (the maximum number of open files for each process), filesize (the
      largest single file that can be created), memoryuse (the maximum size
      to which a process's resident set size can grow), and stacksize (the
      maximum size of the automatically extended stack region).
      The maximumuse can be specified as a floating-point or integer number
      followed by a scale factor: k or kilobytes (1024 bytes), m or mega-
      bytes, or b or blocks (the units used by the ulimit system call).  For
      both resource names and scale factors, unambiguous prefixes of the
      names suffice.  filesize can be lowered by an instance of csh, but can
      only be raised by an instance whose effective user ID is root.  For
      more information, refer to the documentation for the ulimit system
      call.

  login
      Terminates a login shell and replaces it with an instance of
      /usr/bin/login.  This is one way to log out (included for compatibility
      with sh).

  logout
      Terminates a login shell.  Especially useful if ignoreeof is set.

  newgrp [-] [group]
      Changes the primary group identification of the current shell process
      to group.  If you specify a - (dash), newgrp changes the login environ-
      ment to the login environment of the new group.  If you do not specify
      a group, newgrp changes the group identification to that specified for
      the current user in the /etc/passwd file.  newgrp recognizes group
      names only; it does not recognize group ID numbers.
      Only a user with superuser authority can change the primary group of
      the shell to one to which that user does not belong.  Any active user-
      generated shell is terminated when the newgrp command is used.

  nice [+number] [command]
      Without arguments, nice sets the priority of commands run in this shell
      to 4.  The +number arguments sets the priority to the specified number.
      The command argument causes command to run at priority 4 (without the
      +number argument) or at priority number (if +number is specified).  The
      greater the number, the less CPU the process gets.  The superuser can
      raise the priority by using nice with a negative number.  The command
      is always executed in a subshell, and the restrictions placed on com-
      mands in simple if statements apply.

  nohup [command]
      The first form causes hangups to be ignored for the remainder of the
      shell script.  The second form causes the specified command to be run
      with hangups ignored.  To run a pipeline or list of commands with this
      form, put the pipeline or list in a shell script, give the script exe-
      cute permission, and use the shell script as the command.  All
      processes run in the background with & are effectively protected from
      being sent a hangup signal when you log out, but are still subject to
      explicitly sent hangups unless nohup is used.

  notify [%job ...]
      Causes the shell to notify you asynchronously when the status of the
      current (if %job is not specified) or specified jobs changes.  Nor-
      mally, notification is presented immediately before the shell prompt.
      This is automatic if the notify shell variable is set.

  onintr [-] [label]
      Controls the action of the shell on interrupts.  The first form
      restores the default action of the shell on interrupts, which is to
      terminate shell scripts or to return to the terminal command input
      level.  The second form causes all interrupts to be ignored.  The third
      form causes the shell to execute a goto label when it receives an
      interrupt or when a child process terminates due to an interruption.
      In any case, if the shell is running in the background and interrupts
      are being ignored, all forms of onintr have no meaning and interrupts
      continue to be ignored by the shell and all invoked commands.

  popd [+number]
      Pops the directory stack (removes the top entry), changing directories
      to the new top directory.  With a +number argument, popd discards the
      number entry in the stack.  The elements of the directory stack are
      numbered from the top, starting at 0 (zero).

  pushd [name] [+n]
      Changes to the directory that comes to the top of the stack.  With no
      arguments, pushd exchanges the top two elements of the directory stack.
      With a name argument, pushd changes to the new directory (that is, cd)
      and pushes the old current working directory (given in the cwd shell
      variable) onto the directory stack.  With a numeric argument, pushd
      rotates the number argument of the directory stack around to be the top
      element and changes directory to it.  The members of the directory
      stack are numbered from the top, starting at 0 (zero).

  rehash
      Causes the internal hash table of the contents of the directories in
      the path shell variable to be recomputed.  This is needed if new com-
      mands are added to directories in path while you are logged in.  This
      should be necessary only if commands are added to one of your own
      directories, or if someone changes the contents of one of the system
      directories.

  repeat count command
      Executes the specified command, which is subject to the same restric-
      tions as in the simple if statement, count times.  Note that
      input/output redirections occur exactly once, even if count is 0
      (zero).

  rmlib library_name
      Removes the specified shared library from the shell's private table of
      installed libraries.  This library is no longer available for resolu-
      tion of unresolved symbols in commands executed from this shell.

  set

  set name

  set name=word

  set name[index]=word

  set name=(word_list)
      The first form of the command displays the value of all shell vari-
      ables.  Variables that have values other than a single word are
      displayed as a parenthesized word list.  The second form sets name to
      the null string.  The third form sets name to the single word.  The
      fourth form sets the indexth component of name to word; this component
      must already exist.  The final form sets name to the list of words in
      word_list.  In all cases, the value is command and filename expanded.
      These arguments can be repeated to set multiple values in a single set
      command.  Note however, that variable expansion happens for all argu-
      ments before any setting occurs.

  setenv name value
      Sets the value of the environment variable name to be value, a single
      string.  The most commonly used environment variables USER, TERM, HOME,
      and PATH are automatically imported to and exported from the csh vari-
      ables user, term, home, and path, so there is no need to use setenv for
      these common environment variables.
      If you modify the LC_COLLATE or LANG environment variables, the current
      international character support environment and collating sequence are
      changed as specified for subsequent commands executed from the shell.

  shift [variable]
      Shifts to the left the members of argv (discarding argv[1]) or the
      specified variable.  An error occurs if argv is not set or has fewer
      than two strings assigned to it.

  source [-h] name
      Causes the shell to read commands from name.  You can nest source com-
      mands.  However, if they are nested too deeply, the shell can run out
      of file descriptors.  An error in a source at any level terminates all
      nested source commands.  Normally, input during source commands is not
      placed on the history list.  The -h flag causes the commands to be
      placed in the history list without being executed.

  stop [%job ...]
      Stops the current (if %job is not specified) or specified job that is
      executing in the background.

  suspend
      Causes the shell to suspend execution, by sending itself a SIGINT sig-
      nal.  This command gives an error message if attempted from a login
      shell.

  switch (string)

  case string1: ...

  breaksw ...

  default: ...

  breaksw

  endsw
      Successively matches each case label (string1) against string, which is
      first command and filename expanded.  Use the pattern-matching charac-
      ters *, ?, and [...] in the case labels, which are variable expanded.
      If none of the labels match before a default label is found, then exe-
      cution begins after the default label.  Each case label and the default
      label must appear at the beginning of a line.
      The breaksw command causes execution to continue after the endsw com-
      mand.  Otherwise, control can fall through case labels and the default
      labels, as in C.
      If no label matches and there is no default, execution continues after
      the endsw command.

  time [command]
      With no argument, displays a summary of time used by this shell and its
      children.  If arguments are given, the specified command is timed and a
      time summary (as described under the time shell variable) is displayed.
      If necessary, an extra shell is created to display the time when the
      command completes.

  umask [value]
      Displays the file creation mask (first form) or sets it to the speci-
      fied value (second form).  The mask is given as an octal value.  Common
      values for the mask are 002, giving all access to the owner and group,
      and assigning read and execute access to others, or 022, giving all
      access to the owner, and assigning read and execute access to users in
      the group and others.

  unalias pattern
      Discards all aliases with names that match pattern.  Thus, all aliases
      are removed by unalias *.  The absence of aliases that match pattern
      does not cause an error.

  unhash
      Disables the use of the internal hash table to speed location of exe-
      cuted programs.

  unlimit [-h] [resource]
      Removes the limitation on resource.  If no resource is specified, then
      all resource limitations are removed.
      If -h is given, the corresponding hard limits are removed.  Only the
      superuser can do this.

  unset pattern
      Removes all variables with names that match pattern.  Use unset * to
      remove all variables.  The absence of variables that match pattern is
      not an error.

  unsetenv pattern
      Removes all variables with names that match pattern from the environ-
      ment.  See also the setenv command (discussed earlier in this list).

  wait
      Waits for all background jobs to terminate.  If the shell is interac-
      tive, an interrupt can disrupt the wait, at which time the shell
      displays the names and job numbers of all jobs known to be outstanding.

  while (expression)

  ...

  end While expression evaluates as nonzero, executes the commands between
      the while and the matching end.  You can use the break command to ter-
      minate the loop prematurely and the continue command to continue the
      loop.  (The while and end must appear alone on their input lines.) If
      the input is a terminal, prompting occurs the first time through the
      loop, as for the foreach statement.

  %job
      Brings the specified job into the foreground.

  %job &
      Continues the specified job in the background.

  @

  @ name = expression

  @ name[index] = expression
      The first form displays the values of all the shell variables.  The
      second form sets the specified name to the value of expression.  If the
      expression contains <, >, &, or |, at least this part of the expression
      must be placed within (  ) (parentheses).  The third form assigns the
      value of expression to the indexth argument of name.  Both name and its
      indexth component must already exist.
      C operators, such as *= and +=, are available.  White space separating
      the name from the assignment operator is optional.  Spaces are, how-
      ever, mandatory in separating components of expression, which would
      otherwise be single words.
      Special postfix ++ and - - operators increment and decrement name,
      respectively, e.g. @ i++.

  Expressions
  The built-in commands @, exit, if, and while accept expressions that
  include operators similar to those of C, with the same precedence.  The
  following operators are available:
  ( )
  ~
  !
  *       /       %
  +       -
  <<      >>
  <=      >=      <       >
  ==      !=      =~      !~
  &
  ^
  |
  &&
  ||
  In the preceding list, operators of equal precedence appear on the same
  line, below those lines containing operators (if any) that have greater
  precedence, and above those lines containing operators having lesser pre-
  cedence.  The ==, !=, =~, and !~ operators compare their arguments as
  strings; all others operate on numbers.  The =~ and !~ operators are simi-
  lar to != and ==, except that the rightmost side is a pattern against which
  the left-hand operand is matched.  This reduces the need for use of the
  switch statement in shell scripts when all that is really needed is pattern
  matching.

  Strings that begin with 0 (zero) are considered octal numbers.  Null or
  missing arguments are considered 0 (zero).  The result of all expressions
  are strings, which represent decimal numbers.  It is important to note that
  no two components of an expression can appear in the same word.  Except
  when next to components of expressions that are syntactically significant
  to the parser (&, |, <, >, -, (, and ) ) expression components should be
  surrounded with spaces.

  Also available in expressions as primitive operands are command executions
  enclosed in { and } and file inquiries of the form -l name where l is one
  of the following:

  r   Read access

  w   Write access

  x   Execute access

  e   Existence

  o   Ownership

  z   Zero size

  f   Plain file

  d   Directory

  The specified file is command and filename expanded and then tested to see
  if it has the specified relationship to the real user.  If the file does
  not exist or is inaccessible, then all enquiries return FALSE, that is, 0
  (zero).  Command executions succeed, returning TRUE (1), if the command
  exits with status 0 (zero); otherwise, they fail, returning FALSE (0).  If
  more detailed status information is required, execute the command outside
  of an expression and examine the status shell variable.

  Predefined and Environment Variables
  The following variables have special meaning to the shell.  Of these, argv,
  cwd, home, path, prompt, shell, and status are always set by the shell.
  Except for cwd and status, this setting occurs only at initialization; the
  remaining variables maintain their settings unless you explicitly reset
  them.

  The csh command copies the USER environment variable into the variable
  user, TERM into term, and HOME into home, and copies these back into the
  environment whenever the normal shell variables are reset.  The PATH
  environment variable is handled similarly; it is not necessary to worry
  about their settings other than in the .cshrc file.  csh subprocesses
  import the definition of path from the environment, and export it again if
  you then change it.

  argv
      Is set to the arguments to the shell.  It is from this variable that
      positional parameters are substituted, for example, $1 is replaced by
      $argv[1], and so on.

  cdpath
      Gives a list of alternate directories to be searched to find subdirec-
      tories in chdir commands.

  cwd Is set to the full pathname of the current directory.

  echo
      Causes each command and its arguments to be echoed to standard output
      just before it is executed.  It is set when the -x command line flag is
      specified.  For nonbuilt-in commands, all expansions occur before echo-
      ing.  Built-in commands are echoed before command and filename substi-
      tution, since these substitutions are then done selectively.

  filec
      Enables filename completion.

  histchars
      Changes the characters used in history substitution when given a string
      value.  The first character of its value is used as the history substi-
      tution character, replacing the default character ! (exclamation
      point).  The second character of its value replaces the character ^
      (circumflex) in quick substitutions.

  history
      Controls the existence and size of the history buffer. All commands
      (executable or not) are saved in the history buffer.  Values of history
      that are too large can run the shell out of memory.  The last executed
      command is always saved on the history list even if history is left
      unset.

  home
      Contains the absolute pathname to the home directory of the user, ini-
      tialized from the environment.  The filename expansion of ~ (tilde)
      refers to this variable.

  ignoreeof
      Causes the shell to ignore End-of-File characters from input devices
      that are terminals.  This prevents shells from accidentally being
      killed when they read an End-of-File character.

  LANG
      Specifies the locale of your system, which is comprised of three parts:
      language, territory, and codeset.  The default locale is the C locale,
      which specifies the value English for language, U.S. for territory, and
      ASCII for codeset.

  LC_COLLATE
      Specifies the collating sequence to use when sorting names and when
      character ranges occur in patterns.  The default value is the collating
      sequence for American English.

  LC_CTYPE
      Specifies the character classification information to use on your sys-
      tem.  The default value is American English.

  LC_MESSAGES
      Specifies the language in which system messages appear, and the
      language that the system expects for user input of yes and no strings.
      The default value is American English.

  LC_MONETARY
      Specifies the monetary format for your system.  The default value is
      the monetary format for American English.

  LC_NUMERIC
      Specifies the numeric format for your system.  The default value is the
      numeric format for American English.

  LC_TIME
      Specifies the date and time format for your system.  The default value
      is the date and time format for American English.

  mail
      Specifies the files where the shell checks for mail.  This is done
      after each command completion that results in a prompt, if a specified
      interval has elapsed.  The shell displays the message You have new mail
      if the file has been modified since the last check.
      If the first word of the value of mail is numeric, it specifies a dif-
      ferent mail checking interval (in seconds) than the default (10
      minutes).
      If you specify multiple mail files, the shell displays the message New
      mail in file when there is mail in file.

  NLSPATH
      Specifies a list of directories to search to find message catalogs.

  noclobber
      If set, places restrictions on output redirection to ensure that files
      are not accidentally destroyed, and that >> redirections refer to
      existing files.  (See also Redirecting Input and Output.)

  noglob
      If set, inhibits filename expansion.  This is most useful in shell
      scripts that do not deal with filenames, or after a list of filenames
      is obtained and further expansions are not desirable.

  nonomatch
      If set, does not return an error for a filename expansion that does not
      match any existing files; rather, the primitive pattern is returned.
      It is still an error for the primitive pattern to be malformed, for
      example, echo [ still gives an error.

  notify
      If set, causes the shell to notify you asynchronously of background job
      completion.  The default is to present job status changes immediately
      before printing a prompt.

  path
      Each word of the path variable specifies a directory in which commands
      are to be sought for execution.  A null word specifies the current
      directory.  If no path variable is set, then only full pathnames are
      executed.  The usual search path is the current directory and /usr/bin,
      but this can vary from system to system.  A shell that is given neither
      the -c nor the -t flag normally hashes the contents of the directories
      in the path variable after reading .cshrc and each time the path vari-
      able is reset.  If new commands are added to these directories while
      the shell is active, it is necessary to execute the rehash command in
      order to access the new commands.

  prompt
      The string that is printed before each command is read from an interac-
      tive terminal input.  If a ! (exclamation point) appears in the string,
      it is replaced by the current event number, unless it is preceded by a
      \ (backslash).  The default prompt is %, # for the superuser.

  savehist
      When given a numeric value, controls the number of entries of the his-
      tory list that are saved in ~/.history when you log out.  All commands
      (executable or not) that are in the history list are saved.  During
      startup, the shell sources ~/.history into the history list, enabling
      history to be saved across logins.  Very large values of savehist slow
      down the shell during startup.

  shell
      The file in which the shell resides.  This is used in forking shells to
      interpret files that have execute bits set, but that are not executable
      by the system.  (See Nonbuilt-In Command Execution.) This is initial-
      ized to the (system-dependent) location of the shell.

  status
      The status returned by the last command.  If it terminated abnormally,
      then 0200 is added to the status.  Built-in commands that fail return
      exit status 1; all other built-in commands set status 0 (zero).

  time
      Controls automatic timing of commands, and the line displayed by a
      built-in time command.  The value can consist of zero, one, or two
      words.
      The first word is the threshhold for automatic timing, measured in CPU
      seconds; for any command that takes at least that many CPU seconds, the
      shell displays a line showing the timing information when that command
      finishes.
      The second word is a string, enclosed in ' ' (single quotes) or " "
      (double quotes), specifying the timing line to be displayed; it con-
      trols both the automatic display and the output of the time command.
      The string can contain any combination of text as well as the following
      specifiers, which must be uppercase characters and preceded by a %
      (percent sign) as shown.  Sequences such as \n are not treated as spe-
      cial characters in the string.

      %D  Kilobytes of data space.

      %E  Elapsed time, measured in seconds.

      %F  Number of page faults.

      %I  Number of blocks read during I/O operations.

      %K  Kilobytes of stack space.

      %M  Total kilobytes of memory.

      %O  Number of blocks written during I/O operations.

      %P  CPU time (both system and user) as a percentage of elapsed time.

      %S  System time: CPU seconds used by system calls.

      %U  User time: CPU seconds used by the process outside of system calls.

      %W  Number of times the process was swapped.

      %X  Kilobytes of text space.
      If the first word is zero or if the time variable is set with no value,
      every command is timed.  The default string displayed, when the second
      word is not supplied, is as follows:
      %Uu %Ss %E %P% %X+%Dk %I+%Oio %Fpf+%Ww

  verbose
      Causes the words of each command to be displayed on the standard output
      after history substitution.  Set by the -v command line flag.

  Nonbuilt-In Command Execution
  When a command to be executed is found not to be a built-in command, the
  shell attempts to execute the command with the execv() system call.

  Each word in the path shell variable names a directory from which the shell
  attempts to execute the command (if the command does not begin with a /
  (slash)).  If it is given neither a -c nor a -t flag, the shell hashes the
  names in these directories into an internal table so that it only tries an
  execv in a directory if there is a possibility that the command resides
  there.  This greatly speeds command location when a large number of direc-
  tories are present in the search path.  If this mechanism was turned off
  (with unhash), or if the shell was given a -c or -t argument (and in any
  case, for each directory component of path that does not begin with a /),
  the shell concatenates the directory name with the given command name to
  form a pathname of a file, which it then attempts to execute.

  Commands in parentheses are always executed in a subshell.  Thus, (cd ;
  pwd) ; pwd displays the home directory and then the current directory,
  without changing the current directory location; whereas, cd ; pwd changes
  the current directory location to the home directory, and prints the home
  directory.  Commands in parentheses are most often used to prevent chdir
  from affecting the current shell.

  If the file has execute permissions but is not an executable binary to the
  system, then it is assumed to be a file containing shell commands and a new
  shell is created to read it.
  If there is an alias for shell, then the words of the alias are prefixed to
  the argument list to form the shell command.  The first word of the alias
  should be the full pathname of the shell (e.g. $shell).  Note that this is
  a special, late-occurring case of alias substitution and only allows words
  to be prefixed to the argument list without modification.

  Signal Handling
  The shell normally ignores SIGQUIT signals.  Jobs running in the background
  (either by & or the bg or %...& commands) are immune to signals generated
  from the keyboard (SIGINT, SIGQUIT, and SIGHUP).  Other signals have the
  values the shell inherited from its parent.  You can control the shell's
  handling of interrupts and terminate signals in shell scripts with onintr.
  Login shells catch the SIGTERM (terminate) signal; otherwise, this signal
  is passed on to children from the state in the shell's parent.  In no case
  are interrupts allowed when a login shell is reading the .logout file.

  Limitations
  The following are csh limitations:

    o  Words can be no longer than 1024 bytes.

    o  Argument lists are limited to 5120 bytes.

    o  The number of arguments to a command that involves filename expansion
       is limited to 1/6th the number of characters allowed in an argument
       list.

    o  Command substitutions can substitute no more characters than are
       allowed in an argument list.

    o  To detect looping, the shell restricts the number of alias substitu-
       tions on a single line to 20.

    o  Words can also be separated by double spaces.

  Character Classes
  You can use the following notation to match filenames within a range indi-
  cation:
  [:charclass:]

  This format instructs the system to match any single character belonging to
  charclass; the defined classes correspond to ctype() subroutines as fol-
  lows:
  alnum
  alpha
  cntrl
  digit
  graph
  lower
  print
  punct
  space
  upper
  xdigit

  Your locale might define additional character properties, such as the fol-
  lowing:
  [:vowel:]
  The preceding character class could be TRUE for a, e, i, o, u, or y.  You
  could then use [:vowel] inside a set construction to match any vowel.
  Refer to The LC_CTYPE Category section of the locale file format reference
  page for more information.

FILES

  $HOME/.cshrc
             C shell startup file; read at beginning of execution by each C
             shell.

  $HOME/.login
             Read by login shell (after .cshrc) at login.

  $HOME/.logout
             Read by login shell at logout.

  /usr/bin/sh
             The path to the default shell.

  /tmp/sh*   Temporary file for <<.

  /etc/passwd
             Contains user information.

EXIT VALUES

  For information about exit values, see the following sections: Shell Com-
  mands, Expressions, Predefined and Environment Variables, and FLAGS.

RELATED INFORMATION

  Commands: ksh(1), sh(1).

  Functions:  access(2), exec(2), fork(2), ldr_install(2), ldr_remove(2),
  pipe(2), umask(2), wait(2).

  Files:  locale(4), osf_rose(4), null(7).

  "Using Internationalization Features" in the OSF/1 User's Guide.


date(1)                                                               date(1)

NAME

  date - Displays or sets the date

SYNOPSIS

  With Superuser Authority
  date [-nu] [MMddhhmm.ssyy | alternate_date_format] [+field_descriptor ...]

  Without Superuser Authority
  date [-u] [+field_descriptor ...]

  The date command writes the current date and time to standard output.

FLAGS

  -n  Does not set the time globally on all machines in a local area network
      that have their clocks synchronized (superuser only).

  -u  Performs operations as if the TZ environment variable was set to the
      string GMT0.  Otherwise, date uses the time zone indicated by the TZ
      environment variable or the system default if that variable is not set.

DESCRIPTION

  The date command writes the current date and time to standard output if
  called with no flags or with a flag list that begins with a + (plus sign).
  Only a user operating with superuser authority can change the date and
  time.  The LC_TIME variable, if it is defined, controls the ordering of the
  day and month numbers in the date specifications.  The default order is
  MMddhhmm.ssyy where:

    o  MM is the month number (01=January).

    o  dd is the number of the day in the month.

    o  hh is the hour in the day (using a 24-hour clock).

    o  mm is the minute number.

    o  ss is the number of seconds.

    o  yy is the last two numbers of the year.

  The alternative ordering is either ddMMhhmm.ssyy, yyMMddhhmm.ss, or
  yyddMMhhmm.ss.  If format yyMM...  is specified, the value of yy must be 88
  to 99.
  The current month, day, hour, and year are default values.  The system
  operates in Coordinated Universal Time (UTC).

  If you follow date with a + (plus sign) and a field descriptor, you can
  control the output of the command.  You must precede each field descriptor
  with a % (percent sign).  The system replaces the field descriptor with the
  specified value.  Enter a literal % as %%.  The date command copies any
  other characters to standard output without change.  date always ends the
  string with a newline character.  Output fields are fixed size (zero padded
  if necessary).

  Do not change the date when the system is in any run mode other than
  single-user mode.

  The date command prints out a usage message on any unrecognized flags or
  input.

  Field Descriptors
  a   Displays the locale's abbreviated weekday name (Sun to Sat or the non-
      English equivalent).

  A   Displays the locale's full weekday name.

  b   Displays the locale's abbreviated month name.

  B   Displays the locale's full month name.

  c   Displays the locale's appropriate time and date representation.

  C   Displays the locale's century (the year divided by 100 and truncated to
      an integer) as a decimal number (00 to 99).

  d   Displays the day of month as a decimal number (01 to 31).

  D   Displays the date in the format mm/dd/yy (the default), or as specified
      by the LC_TIME environment variable, if defined.

  e   Displays the day of the month as a decimal number (1 to 31 in a 2-digit
      field with leading space fill).

  h   A synonym for %b.

  H   Displays the hour as a decimal number (00 to 23).

  I   Displays the hour as a decimal number (01 to 12).

  j   Displays the day of year as a decimal number (001 to 366).

  m   Displays the month of year as a decimal number (01 to 12).

  M   Displays the minute as a decimal number (00 to 59).

  n   Inserts a newline character.

  p   Displays the locale's equivalent of either AM or PM.

  r   Displays the time (12-hour clock) using AM/PM notation (or the non-
      English equivalent) in the format hh:mm:ss AM or hh:mm:ss PM.

  S   Displays the second as a decimal number (00 to 61).

  t   Inserts a tab character.

  T   Displays the time in 24-hour clock format as hh:mm:ss (the default), or
      as specified by the LC_TIME environment variable, if defined.

  U   Displays the week number of the year (Sunday is the first day of the
      week) as a decimal number (00 to 53).

  w   Displays the day of the week as a decimal number (Sunday = 0).

  W   Displays the week number of the year (Monday is the first day of the
      week) as a decimal number (00 to 53).

  x   Displays the locale's appropriate date representation.

  X   Displays the locale's appropriate time representation.

  y   Displays the last two numbers of the year as a decimal number (00 to
      99).

  Y   Displays the full year as a decimal number.

  Z   Displays the time zone name, or no characters if the time zone cannot
      be determined.

  %%  Inserts a % character.

EXAMPLES

   1.  To display current date and time, enter:
       date

       Depending on your current locale, the output might look like one of
       the following:
       Thu Apr 12  13:21:30 EDT  1992

       jeu 12 avr  17:21:30 CUT  1992

       tor 12 apr  17:21:30 CUT  1992

       The first output line is for an American English locale, the second is
       for a French locale, and the third is for a Danish locale.

   2.  To set the date and time, enter:
       date  02171425.45

       This sets the date and time to 14:25:45 (45 seconds after 2:25 p.m.)
       February 17 of the current year.

   3.  To display the date and time in a specified format, enter:
       date  +"%r  %d  %h  %y  (%a)"

       This displays the date (assume current year is 1992) shown in Example
       2 as:
       02:25:03  PM  17  Feb  90  (Fri)
CAUTIONS

  Do not change the date while the system is running with more than one user.

RELATED INFORMATION

  Functions:  getclock(3), gettimeofday(2), setclock(3).

  "Using Internationalization Features" in the OSF/1 User's Guide.


diff(1)                                                               diff(1)

NAME

  diff - Compares text files

SYNOPSIS

  diff [-c | -C number | -e | -f | -h | -n] [-bilrstw] [-Sfile] directory1
  directory2

  diff [-c | -C number | -e | -f | -h | -n] [-bitw] file1 file2

  diff [-Dstring] [-bitw] file1 file2

FLAGS

  The -c, -C, -e, -f, -h, and -n flags are mutually exclusive.

  The -r, -s, and -S flags can be specified with directory comparisons only.

  The -b, -i, -l, -t, and -w flags can be used in combination with any others
  and in both file and directory comparisons.

  -b  Causes trailing spaces and tabs (blanks) to be ignored, and other
      strings of spaces and tabs to be considered identical by diff.

  -c  Produces a listing with the default number of lines of context (3
      lines).  The output lists the files being compared and their last
      modification dates, then lists the differing lines.  Lines that are
      changed from one file to the other are marked in both files with an !
      (exclamation point).  Changes that lie within the specified number of
      lines of each other are grouped together on output.

  -C number
      Produces output that provides number lines of context (where number is
      a positive decimal integer).

  -Dstring
      Causes diff to create a merged version of file1 and file2 on the stan-
      dard output, with C preprocessor controls included so that a compila-
      tion of the result without defining string is equivalent to compiling
      file1, while defining string yields file2.

  -e  Produces a script of a, c and d commands for the editor ed, which can
      recreate file2 from file1.  In connection with -e, the following shell
      program can help maintain multiple versions of a file.  Only an ances-
      tral file ($1) and a chain of version-to-version ed scripts ($2, $3,
      ...) made by diff need be on hand.  A "latest version" appears on the
      standard output.
      (shift; cat $*; echo '1,$p') | ed - $1

      Extra commands are added to the output when comparing directories with
      -e; the result is a sh script for converting text files common to the
      directories from their state in directory1 to their state in
      directory2.

  -f  Produces a script similar to that of -e, not useful with ed, and in the
      opposite order.

  -h  Performs a faster comparison.  This flag only works when the changed
      sections are short and well separated, but it does work on files of any
      length.  The -e and -f flags are not available when you use the -h
      flag.

  -i  Ignores the case of letters.  For example, A is considered identical to
      a.

  -l  Specifies long output format; each text file diff listing is piped
      through pr to paginate it, other differences are remembered and summar-
      ized after all text file differences are reported.  (Directory com-
      parisons only.)

  -n  Produces a script similar to that of -e, but in the opposite order and
      with a count of changed lines on each insert or delete command.  This
      is the form used by the revision control system (RCS).

  -r  Checks files in common subdirectories recursively.

  -s  Reports files that are the same, which are otherwise not mentioned.

  -Sfile
      Starts a directory diff in the middle, beginning with file.  (Directory
      comparisons only.)

  -t  Expands tabs in output lines.  Normal or -c output adds characters to
      the front of each line that can affect the indentation of the original
      source lines and make the output listing difficult to interpret.  This
      flag preserves the original source's indentation.

  -w  Is similar to -b, but causes whitespace (spaces and tabs) to be
      ignored.  For example, if ( a == b ) is considered identical to
      if(a==b).

DESCRIPTION

  Input Options
  If neither file1 nor file2 is a directory, then either can be given as -
  (dash), in which case the standard input is used.  If file1 is a directory
  and file2 is a file, or vice versa, a file in the specified directory with
  the same name as the specified file is used.

  If both arguments are directories, diff sorts the contents of the direc-
  tories by name, and then runs the regular diff file algorithm on text files
  that are different.  Binary files that differ, common subdirectories, and
  files that appear in only one directory are also listed.

  Output Options
  There are several choices for output format.  The default output format
  contains lines of these forms:
  number1 a number2,number3
  number1,number2 d number3
  number1,number2 c number3,number4
  These lines resemble ed commands to convert file1 into file2.  a indicates
  that a line or lines were added to one of the files; d indicates that a
  line or lines were deleted; and c indicates that a line or lines were
  changed.  The numbers after the letters pertain to file2.  In fact, by
  exchanging a for d and reading backward one can ascertain equally how to
  convert file2 into file1.  As in ed, identical pairs where number1 =
  number2 or number3 = number4 are abbreviated as a single number.

  Following each of these lines come all the lines that are affected in the
  first file, flagged by < (left angle bracket), then all the lines that are
  affected in the second file, flagged by > (right angle bracket).

  Except in rare circumstances, diff finds the smallest sufficient set of
  file differences.

EXAMPLES

   1.  To compare two files, enter:
       diff chap1.bak chap1

       This displays the differences between the files chap1.bak and chap1.

   2.  To compare two files, ignoring differences in the amount of white
       space, enter:
       diff -b prog.c.bak prog.c

       If two lines differ only in the number of spaces and tabs between
       words, then the diff command considers them to be the same.

   3.  To create a file containing commands that the ed command can use to
       reconstruct one file from another, enter:
       diff -e ch2 ch2.old > new.old.ed

       This creates a file named new.to.old.ed that contains the ed subcom-
       mands to change chap2 back into the version of the text found in
       chap2.old.  In most cases, new.to.old.ed is a much smaller file than
       chap2.old.

   4.  You can save disk space by deleting chap2.old, and you can reconstruct
       it at any time by entering:
       (cat new.old.ed ; echo '1,$p') | ed - ch2 > ch2.old

       The commands in parentheses add 1,$p to the end of the editing com-
       mands sent to the ed editor.  The 1,$p causes the ed command to write
       the file to standard output after editing it.  This modified command
       sequence is then piped to the ed command ( | ed ), and the editor
       reads it as standard input.  The - flag causes the ed command not to
       display the file size and other extra information, since it would be
       mixed with the text of chap2.old.

FILES

  /usr/lbin/diffh
             For the -h flag.

  /usr/bin/pr
             For the -l flag.

NOTES

   1.  Editing scripts produced by the -e or -f flags cannot create lines
       consisting of a single . (dot) character.

   2.  Block, character, or FIFO special files cannot be used with diff
       because they cause the command to exit.

EXIT VALUES

  An exit value of 0 (zero) indicates no differences, 1 indicates differences
  found, and a number greater than 1 indicates an error.
RELATED INFORMATION

  Commands:  bdiff(1), cmp(1), comm(1), diff3(1), ed(1)/red(1).


IF77(1)                            Paragon                            IF77(1)

NAME
  IF77 - if77, f77: Driver for compiling, assembling, and linking Fortran
  programs for the Paragon OSF/1 operating system.

CROSS-DEVELOPMENT SYNTAX
  if77 [switches] sourcefile...

NATIVE SYNTAX
  f77 [switches] sourcefile...

DESCRIPTION

  The if77 command invokes the Paragon OSF/1 Fortran compiler, assembler, and
  linker with switches derived from if77's command line switches.

  if77 bases its processing on the suffixes of the files it is passed:

  file.F      is a Fortran program with preprocessor directives. It is
              preprocessed, compiled and assembled. The resulting object file
              is placed in the current directory.

  file.f      is a Fortran program. It is compiled and assembled. The
              resulting object file is placed in the current directory.

  file.s      is an i860 assembly language file. It is assembled and the
              resulting object file is placed in the current directory.

  file.o      is an object file. It is passed directly to the linker if
              linking is requested.

  file.a      is an ar library. It is passed directly to the linker if
              linking is requested.

  file.c      is a C program. It is passed to the C compiler.

  All other files are taken as object files and passed to the linker (if
  linking is requested) with a warning message. If a file's suffix does not
  match its actual contents, unexpected results may occur.

  If a single Fortran program is compiled and linked with one if77 command,
  then the intermediate object and assembly files are deleted.

  By default, Fortran local variables are placed on the stack. Some Fortran
  programs assume that all variables are allocated statically. Static
  allocation can be forced with the -Msave switch.

SWITCHES

  -c          Skips the link step; compiles and assembles only. Leaves the
              output from the assemble step in a file named file.o for each
              file named file.f (unless you also use the -o switch).
  -Dname[=def]                                               Defines name to
              be def in the preprocessor. If def is missing, it is assumed to
              be empty. If the = sign is also missing, then name is defined
              to be the string 1.
  -E          Preprocesses each ``.F'' file and sends the result to stdout.
              No compilation, assembly, or linking is performed.

  -F          Preprocesses each ``.F'' file and leaves the output in a file
              named file.f for each file named file.F.

  -g          Equivalent to -Mdebug -O0 -Mframe.

  -I-         Accepted, but has no affect.

  -Idirectory                                                Adds directory
              to the compiler's search path for include files. If you use
              more than one -I switch, the specified directories are searched
              in the order they were specified (left to right). For include
              files surrounded by angle brackets (<...>), each directory is
              searched followed by the default location. For include files
              surrounded by double quotes ("..."), the directory containing
              the file containing the INCLUDE statement is searched, followed
              by the -I directories, followed by the default location.

  -Koption    Requests special mathematical semantics. The option values are:

              ieee (default)                                 If used while
                          linking, links in a math library that conforms with
                          the IEEE 754 standard.

                          If used while compiling, tells the compiler to
                          perform real and double precision divides in
                          conformance with the IEEE 754 standard.

              ieee=enable                                    If used while
                          linking, has the same effects as -Kieee, and also
                          enables floating point traps and underflow traps.
                          If used while compiling, has the same effects as
                          -Kieee.

              ieee=strict                                    If used while
                          linking, has the same effects as -Kieee=enable, and
                          also enables inexact traps. If used while
                          compiling, has the same effects as -Kieee.

              noieee      If used while linking, produces a program that
                          flushes denormals to 0 on creation (which reduces
                          underflow traps) and links in a math library that
                          is not as accurate as the standard library, but
                          offers greater performance. This library offers
                          little or no support for exceptional data types
                          such as INF and NaN, and will trap on such values
                          when encountered.

                          If used while compiling, tells the compiler to
                          perform real and double precision divides using an
                          inline divide algorithm that offers greater
                          performance than the standard algorithm. This
                          algorithm produces results that differ from the
                          results specified by the IEEE standard by no more
                          than three units in the last place.

              trap=fp     If used while linking, disables kernel handling of
                          floating point traps. Has no effect if used while
                          compiling.

              trap=align  If used while linking, disables kernel handling of
                          alignment traps. Has no effect if used while
                          compiling.

  -llibrary   Load the library liblibrary.a. The library is loaded from the
              first library directory in the library search path (see the -L
              switch) in which a file of that name is encountered. (Passed to
              the linker.)

  -Ldirectory                                                Adds directory
              to beginning of the library search path. Also see the nostdlib
              and nostartup options of the -M switch. (Passed to the linker;
              see the ld860 manual page for more information on the library
              search path.)

  -m          Produces a link map. (Passed to the linker.)

  -Moption    Requests specific actions from the compiler. The option values
              are as follows (an unrecognized -M option is passed directly to
              the compiler):

              alpha       Activate alpha-release compiler features.

              anno        Produce annotated assembly files, where source code
                          is intermixed with assembly language. -Mkeepasm or
                          -S should be used as well.

              beta        Activate beta-release compiler features.

              [no]bounds  [Don't] enable array bounds checking (default
                          -Mnobounds).

              [no]dclchk  [Don't] require that all variables be declared
                          (default -Mnodclchk).

              [no]debug   [Don't] generate symbolic debug information
                          (default -Mnodebug). If -Mdebug is specified with
                          an optimization level greater than zero, line
                          numbers will not be generated for all program
                          statements.

              [no]depchk  [Don't] check for potential data dependencies
                          (default -Mdepchk). -Mnodepchk is especially useful
                          in disambiguating unknown data dependencies arising
                          from use of array subscripts that cannot be derived
                          at compile time. For example, if an array is
                          referenced in a loop using the induction variable
                          plus some other unknown non-induction-based
                          variable as a subscript, the compiler must assume
                          that the array conflicts with a similar array
                          reference based on the induction variable alone. If
                          it is known that the two array references do not
                          conflict, then this switch may result in better
                          code. Do not use this switch if such data
                          dependencies do exist, because incorrect code may
                          result.

              [no]dlines  [Don't] treat lines beginning with D in column 1 as
                          executable statements, ignoring the D (default
                          -Mnodlines).

              extend      Allow 132-column source lines (normally only 72
                          columns are allowed).

              extract=[option[,option...]]
                          Pass options to the subprogram extractor (see the
                          inline option for more information). The options
                          are:
                          [name:]subprogram-Extract the specified subprogram.
                          name: must be used if the subprogram name contains
                          a period.

                          [size:]number-Extract subprograms containing less
                          than approximately number statements.

                          If both number(s) and subprogram(s) are specified,
                          then subprograms matching the given name(s) or
                          meeting the size requirements are extracted.

                          The -ofile switch must be used with -Mextract to
                          tell the compiler where to place the extracted
                          subprograms. The name of the specified file must
                          contain a period.

              [no]frame   [Don't] include the frame pointer (default
                          -Mnoframe). -Mnoframe can improve execution time
                          and decrease code, but makes it impossible to get a
                          call stack traceback when using a debugger.

              [no]i4      [Don't] treat integer as integer*4 (default -Mi4).
                          -Mnoi4 treats integer as integer*2.

              info=[option[,option...]]
                          Produce useful information to the standard error
                          output. The options are:

                          time or stat-Output compilation statistics.

                          loop-Output information about loops. This includes
                          information about vectorization and software
                          pipelining.

                          inline-Output information about subprograms
                          extracted and inlined.

                          cycles or block or size-Output block size in
                          cycles. Useful for comparing various optimization
                          levels against each other. The cycle count produced
                          is the compiler's static estimate of freeze-free
                          cycles for the block.

                          ili-Output intermediate language as comments in
                          assembly file.

                          all-All of the above.

              inline=[option[,option...]]
                          Pass options to the subprogram inliner. The options
                          are:

                          [lib:]library-Inline subprograms in the specified
                          inliner library (produced by -Mextract). If lib: is
                          not used, the library name must contain a period.
                          If no library is specified, subprograms are
                          extracted from a temporary library created during
                          an extract prepass.
                          [name:]subprogram-Inline the specified subprogram.
                          If name: is not used, the subprogram name must not
                          contain a period.

                          [size:]number-Inline subprograms containing less
                          than approximately number statements.

                          levels:number-Perform number levels of inlining
                          (default 1).

                          If both number(s) and subprogram(s) are specified,
                          then subprograms matching the given name(s) or
                          meeting the size requirements are inlined.

              keepasm     Keep the assembly file for each Fortran source
                          file, but continue to assemble and link the
                          program. This is mainly for use in compiler
                          performance analysis and debugging.

              list[=name]                                    Create a source
                          listing in the file name. If name is not specified,
                          the listing file has the same name as the source
                          file except that the ``.f'' suffix is replaced by a
                          ``.lst'' suffix. If name is specified, the listing
                          file has that name; no extension is appended.

              [no]longbranch                                 [Don't] allow
                          compiler to generate bte and btne instructions
                          (default -Mlongbranch). -Mnolongbranch should be
                          used only if an assembly error occurs.

              nolist      Don't create a listing file (this is the default).

              nostartup   Don't link the usual start-up routines (crt0.o and
                          ifmain.o), which contain the entry point for the
                          program.

              nostdinc    Remove the default include directory (/usr/include
                          for f77, $(PARAGON_XDEV)/paragon/include for if77)
                          from the include files search path.

              nostdlib    Don't link the standard libraries (libpm.o,
                          guard.o, libf.a, libm.a, libc.a, libic.a, and
                          libmach3.a) when linking a program.

              onetrip     Force each do loop to be iterated at least once.

              [no]perfmon                                    [Don't] link the
                          performance monitoring module (libpm.o) (default
                          -Mperfmon). See the Paragon(tm) Application Tools
                          User's Guide for information on performance
                          monitoring.

              prof=x      This option is ignored.

              [no]quad    [Don't] force top-level objects (such as local
                          arrays) of size greater than or equal to 16 bytes
                          to be quad-aligned (default -Mquad). Note that
                          -Mquad does not affect items within a top-level
                          object; such items are quad-aligned only if
                          appropriate padding is inserted. Common blocks are
                          always quad-aligned.

              [no]r8      [Don't] treat real as double precision and real
                          constants as double precision constants (default
                          -Mnor8).

              [no]r8intrinsics                               [Don't] treat
                          intrinsics as follows (default -Mnor8intrinsics):

                             cmplx as dcmplx
                             real as dble
                             alog as dlog
                             amax1 as dmax1
                             amin1 as dmin1
                             amod as dmod
                             csqrt as cdsqrt
                             clog as cdlog
                             cexp as cdexp
                             csin as cdsin
                             ccos as cdcos

              [no]recursive                                  [Don't] allocate
                          local variables on the stack, thus allowing
                          recursion (default -Mnorecursive). SAVEd,
                          data-initialized, or namelist members are always
                          allocated statically, regardless of the setting of
                          this switch.

              [no]reentrant                                  [Don't] generate
                          reentrant code (default -Mnoreentrant). -Mreentrant
                          disables certain optimizations that can improve
                          performance but may result in code that is not
                          reentrant. Even with -Mreentrant, the code may
                          still not be reentrant if it is improperly written
                          (e.g., declares static variables). You may need to
                          increase the stacksize before executing programs
                          compiled with -Mreentrant. A segmentation violation
                          occurs if stacksize is too low.

              reloc_libs  Causes -l switches that appear before source or
                          object file names on the compiler command line to
                          appear after these file names on the ld command
                          line.

              safealloc   Informs the compiler that all allocatable commons
                          are allocated once and can be treated as ordinary
                          commons for optimization purposes. This option can
                          improve performance for some applications, but
                          should be used with caution.

              [no]save    [Don't] allocate all local data in static locations
                          instead of on the stack (default -Mnosave). The
                          effect is similar to using the save statement for
                          all local variables. Recursion is not allowed with
                          this switch in effect. -Msave may allow some older
                          Fortran programs to run, but may decrease
                          performance.

              [no]signextend                                 [Don't]
                          sign-extend the result of a conversion of a signed
                          integer to a smaller signed type (default
                          -Mnosignextend). For example, if -Msignextend is in
                          effect and an integer*4 containing the value 65535
                          is converted to an integer*2, the value of the
                          integer*2 will be -1. This option is provided for
                          compatibility with other compilers. -Msignextend
                          will decrease performance.

              split_loop_ops=n
                          Set a threshold of n floating-point operations
                          within a loop. Innermost loops whose number of
                          floating-point operations exceeds n are split. Each
                          floating-point operation counts as two. The default
                          for n is 40 when -Mvect is used.

              nosplit_loop_ops
                          Do not split loops when the floating-point
                          operation threshold is exceeded. When -Mvect is
                          specified, innermost loops whose number of floating
                          point operations exceed 40 are split by default.
                          This switch turns the default off.

              split_loop_refs=n
                          Set a threshold of n array element loads and stores
                          within a loop. Innermost loops whose number of
                          loads and stores exceeds n are split. The default
                          for n is 20 when -Mvect is used

              nosplit_loop_refs
                          Do not split loops when the array element loads and
                          stores threshold is exceeded. When -Mvect is
                          specified, innermost loops whose number of array
                          element loads and stores exceeds 20 are split by
                          default. This switch turns the default off.

              standard    Flag non-ANSI-Fortran77 usage.

              [no]streamall                                  [Don't] stream
                          all vectors to and from cache in a vector loop
                          (default -Mstreamall). When -Mnostreamall is in
                          effect, the compiler chooses one vector to come
                          directly from or go directly to main memory,
                          without being streamed into or out of cache.

              [no]stride0                                    [Don't] inhibit
                          certain optimizations and allow for stride 0 array
                          references. -Mstride0 may degrade performance, and
                          should only be used if zero stride induction
                          variables are possible. (default -Mnostride0).

              unixlogical                                    Set the value of
                          a logical expression to one if the result is
                          .TRUE..

              [no]upcase  [Don't] preserve case in names (default
                          -Mnoupcase). -Mnoupcase causes all names to be
                          converted to lower case. Note that, if -Mupcase is
                          used, then variable name Q is different than
                          variable name q, and keywords must be in lower
                          case.

              vect[=option[,option...]]
                          Perform vectorization (also enables -Mvintr). If no
                          options are specified, then all vector
                          optimizations are enabled. The available options
                          are:

                          cachesize:number-This sets the size of the portion
                          of the cache used by the vectorizer to number
                          bytes. Number must be a multiple of 16, and less
                          than the cache size of the microprocessor (16384
                          for the i860 XP, 8192 for the i860 XR). In most
                          cases the best results occur when number is set to
                          4096, which is the default (for both
                          microprocessors).
                          noassoc-When scalar reductions are present (for
                          example, dot product), and loop unrolling is turned
                          on, the compiler may change the order of operations
                          so that it can generate better code. This
                          transformation can change the result of the
                          computation due to round-off error. The use of
                          noassoc prevents this transformation.

                          recog-Recognize certain loops as simple vector
                          loops and call a special routine.

                          smallvect[:number]-This option allows the
                          vectorizer to assume that the maximum vector length
                          is no greater than number. Number must be a
                          multiple of 10. If number is not specified, the
                          value 100 is used. This option allows the
                          vectorizer to avoid stripmining in cases where it
                          cannot determine the maximum vector length. In
                          doubly-nested, non-perfectly nested loops this
                          option can allow invariant vector motion that would
                          not otherwise have been possible. Incorrect code
                          may result if this option is used, and a vector
                          takes on a length greater than specified.

                          streamlim:n This sets a limit for application of
                          the vectorizer data streaming optimization. If data
                          streaming requires cache vectors of length less
                          than n, the optimization is not performed. Other
                          vectorizer optimizations are still performed. The
                          data streaming optimization has a high overhead
                          compared to other loop optimizations, and can be
                          counter-productive when used for short vectors. The
                          n specifier is not optional. The default limit is
                          32 elements if streamlim is not used.

                          transform-Perform high-level transformations such
                          as loop splitting and loop interchanging. This is
                          normally not useful without -Mvect=recog.

                          -Mvect with no options means
                          -Mvect=recog,transform,cachesize:4096.

              [no]vintr   [Don't] perform recognition of vector intrinsics
                          (default -Mnovintr, unless -Mvect is used).

              [no]xp      [Don't] use i860 XP microprocessor features
                          (default -Mxp).

  -nostdinc   Equivalent to -Mnostdinc.

  -nx         Creates an executable Paragon OSF/1 application for multiple
              nodes.

              o Using -nx while compiling has no effect.

              o Using -nx while linking creates an application that
                automatically copies itself into multiple nodes. It also
                links in libnx.a, the library that contains the calls in the
                Paragon(tm) Fortran System Calls Reference Manual. You can
                control the execution of an application linked with -nx by
                using command-line switches and environment variables, as
                described in the Paragon(tm) User's Guide.

              To link in libnx.a without creating an application that
              automatically copies itself into multiple nodes, use -lnx
              instead. An application linked with -lnx can use Paragon OSF/1
              system calls to create node processes under program control.

              -node is currently accepted as a synonym for -nx, but this
              support may be dropped in a future release.
  -ofile      Uses file for the output file, instead of the default a.out (or
              file.o if used with the -c switch).

  -O[level]   Set the optimization level:

              0           A basic block is generated for each Fortran
                          statement. No scheduling is done between
                          statements. No global optimizations are performed.

              1           Scheduling within extended basic blocks is
                          performed. Some register allocation is performed.
                          No global optimizations are performed.

              2           All level 1 optimizations are performed. In
                          addition, traditional scalar optimizations such as
                          induction recognition and loop invariant motion are
                          performed by the global optimizer.

              3           All level 2 optimizations are performed. In
                          addition, software pipelining is performed.

              4           All level 3 optimizations are performed, but with
                          more aggressive register allocation for software
                          pipelined loops. In addition, code for pipelined
                          loops is scheduled several ways, with the best way
                          selected for the assembly file.

              If a level is not supplied with -O, the optimization level is
              set to 2. If -O is not specified, the default level is 1.
              Setting optimization to levels higher than 0 may reduce the
              effectiveness of symbolic debuggers.

  -p          This option is ignored.

  -r          Generates a relinkable object file. (Passed to the linker.)

  -s          Strips symbol table information. (Passed to the linker.)

  -S          Skips the link and assemble steps. Leaves the output from the
              compile step in a file named file.s for each file named file.f.

  -Uname      Remove any initial definition of name in the preprocessor.
              Since all -D switches are processed before all -U switches, the
              -U switch can be used to override the -D switch.

  -v          Prints the entire command line for each tool as it is invoked,
              and invokes each tool in verbose mode (if it has one).

  -V          Prints the version banner for each tool (assembler, linker,
              etc.) as it is invoked.

  -VV         Display the driver version number and the location of the
              online release notes. No compilation is performed.

  -Wpass,option[,option...]
              Passes the specified options to the specified pass:

              0 (zero)    Compiler.
              a           Assembler.

              l           Linker.

              Each comma-delimited string is passed as a separate argument.

  -Ypass,directory
              Looks for the executable file for the specified pass in the
              specified directory (rather than in the default location),
              where pass is one of the following:

              0 (zero)    Compiler executable file.

              a           Assembler executable file.

              l           Linker executable file.

              S           Startup object files.

              I           Standard include files.

              L           Standard libraries (passes -YLdirectory to the
                          linker).

              U           Secondary libraries (passes -YUdirectory to the
                          linker).

              P           All libraries (passes -YPdirectory to the linker).

              See the ld860 manual page for more information on the -YL, -YU,
              and -YP switches.

FILES

  a.out                       Executable output file.

  file.a                      Library of object files.

  file.f                      Fortran source file.

  file.F                      Fortran source file for preprocessing.

  file.lst                    Listing file produced by -Mlist.

  file.o                      Object file.

  file.s                      Assembler source file.

  The following files and directories are used in the cross-development
  environment (if77). PARAGON_XDEV is an environment variable that can be set
  to the root of the compiler installation directory. If PARAGON_XDEV is not
  set, the default is /usr/paragon/XDEV. The directory where the driver,
  compiler, and tools are located must be included in your path. For Sun4
  users, for example, $PARAGON_XDEV/paragon/bin.sun4 would be included in the
  path.

  $(PARAGON_XDEV)/paragon/bin.arch                           Directory
                              containing executables for system arch (arch
                              identifies the architecture of the system, e.g.
                              sgi or sun4).

  $(PARAGON_XDEV)/paragon/bin.arch/if77                      Fortran compiler
                              driver.

  $(PARAGON_XDEV)/paragon/bin.arch/iftn                      Fortran
                              compiler.

  $(PARAGON_XDEV)/paragon/bin.arch/as860                     Intel (COFF)
                              assembler.

  $(PARAGON_XDEV)/paragon/bin.arch/ld860                     Intel (COFF)
                              linker.

  $(PARAGON_XDEV)/paragon/include                            Standard include
                              directory.

  $(PARAGON_XDEV)/paragon/lib-coff                           Standard library
                              directory.

  $(PARAGON_XDEV)/paragon/lib-coff/crt0.o                    C start-up
                              routine.

  $(PARAGON_XDEV)/paragon/lib-coff/ifmain.o                  Fortran initial
                              routine.

  $(PARAGON_XDEV)/paragon/lib-coff/libpm.o                   Performance
                              monitoring module.

  $(PARAGON_XDEV)/paragon/lib-coff/guard.o                   Barrier between
                              user and system code.

  $(PARAGON_XDEV)/paragon/lib-coff/libf.a                    Fortran runtime
                              library.

  $(PARAGON_XDEV)/paragon/lib-coff/libm.a                    Math library.

  $(PARAGON_XDEV)/paragon/lib-coff/libc.a                    Standard C
                              library.

  $(PARAGON_XDEV)/paragon/lib-coff/libic.a                   C built-in
                              intrinsic library.

  $(PARAGON_XDEV)/paragon/lib-coff/libmach.a
                              Mach operating system library.

  $(PARAGON_XDEV)/paragon/lib-coff/noieee                    Library
                              directory used when linking with -Knoieee
                              (contains non-IEEE versions of libf.a and
                              libm.a).

  $(PARAGON_XDEV)/paragon/lib-coff/options/autoinit.o
                              Routine linked in when -nx is used.

  The following files and directories are used by default in the native
  environment (f77). If / is not the root of the compiler installation
  directory, you must set PARAGON_XDEV to this directory and add
  $PARAGON_XDEV/usr/ccs/bin to your path.

  /usr/ccs/bin                Directory containing executables.

  /usr/ccs/bin/f77            Fortran compiler driver.

  /usr/ccs/bin/iftn           Fortran compiler.

  /usr/ccs/bin/as             Assembler.

  /usr/ccs/bin/ld             Linker.

  /usr/include                Standard include directory.

  /usr/lib                    Standard library directory.

  /usr/lib/crt0.o             C start-up routine.

  /usr/lib/ifmain.o           Fortran initial routine.

  /usr/lib/libpm.o            Performance monitoring module.

  /usr/lib/guard.o            Barrier between user and system code.

  /usr/lib/libf.a             Fortran runtime library.

  /usr/lib/libm.a             Math library.

  /usr/lib/libc.a             Standard C library.

  /usr/lib/libic.a            C built-in intrinsic library.

  /usr/lib//libmach.a         Mach operating system library.

  /usr/lib/noieee             Library directory used when linking with
                              -Knoieee (contains non-IEEE versions of libf.a
                              and libm.a).

  /usr/lib/options/autoinit.o                                Routine linked
                              in when -nx is used.

ENVIRONMENT VARIABLES

  The environment variable MAKECPP is supported. MAKECPP is a colon-separated
  list of directories that is added to the compiler search path for include
  files.

  If you use the -Knoieee switch and define LPATH or PARAGON_LPATH, be sure
  that the directory containing the noieee versions of libf.a and libm.a is
  listed before a directory containing the ieee versions of these libraries.
  If in doubt, compile with the -v switch to see which libraries are linked
  in. See the ld860 manual page for more information.

DIAGNOSTICS

  The compiler produces information and error messages as it translates the
  input program. The linker and assembler may generate their own error
  messages.

SEE ALSO

  ar860, as860, dump860, icc, ifixlib, ld860, nm860, size860, strip860


FSPLIT(1)                       Paragon OSF/1                       FSPLIT(1)

NAME
  FSPLIT - Splits one file containing several Fortran program units into
  several files containing one program unit each.

SYNTAX
  fsplit [ filename ]

ARGUMENTS

  filename  Identifies the file that you want to split into individual files.
            If you omit this argument, fsplit reads standard input.

DESCRIPTION

  Use fsplit to split a single file containing several Fortran program units
  (program, subroutine, function, or block data) into several files, each of
  which contains only one program unit. The first non-comment line of each
  program unit (usually a program, subroutine, function, or block data
  statement) marks the beginning of each kind of program unit; the end
  statement marks the end.

  The original file remains unchanged; the new files are named as follows:

  o Each named program unit (one that specifies a name in its program,
    subroutine, function, or block data statement) is put in a file named
    name.f, where name is the name of the program unit.

  o An unnamed block data subprogram is put in a file named blockdataXXX.f,
    where XXX is a number that corresponds to the order of the unnamed block
    data subprogram in the original file.

  o A main program that does not contain a program statement is put in a file
    named mainXXX.f, where XXX is a number that corresponds to the order of
    the unnamed main program in the original file.

  o A file with the same name as a program unit that already exists in the
    current directory is put in a file named zzzXXX.f, where XXX is a number
    that corresponds to the order of the duplicate program unit in the
    original file.

                                    WARNING

       If your file defines multiple program units with the same name, the
       resulting name.f file will contain only the first program unit
       defined.

EXAMPLES

  Consider the following source file (named file.f):

          program a
    c  This is the first main program named a.

          end

          program a
    c  This is the second main program named a.
          end
          integer a-m
    c  This is the first unnamed main program unit.
          end

    c  This is the second unnamed main program unit.
          integer n-z
          end

          subroutine b
    c  This is the first subroutine named b.
          end

          subroutine b
    c  This is the second subroutine named b.
          end

    c  This is the function named c.
          function c
          end

          block data d
    c  This is the block data program unit named d.
          end

          block data
    c  This is the first unnamed block data program unit.
          end

          block data
    c  This is the second unnamed block data program unit.
          end

  Before using fsplit, the directory contains the following:

    % ls
    file.f

  After using fsplit, the directory contains the following:

    % fsplit file.f
    a.f
    a.f already exists, put in zzz000.f
    main000.f
    main001.f
    b.f
    b.f already exists, put in zzz001.f
    c.f
    d.f
    blkdta000.f
    blkdta001.f
    zzz002.f
    % ls
    a.f blkdta000.f c.f file.f main001.f zzz001.f
    b.f blkdta001.f d.f main000.f zzz000.f zzz002.f

  Examining the various files reveals the following:

    % cat blockdata000.f

          block data
    c  This is the first unnamed block data program unit.
          end
    % cat blockdata001.f
          block data

    c  This is the second unnamed block data program unit.
          end
    % cat main000.f
          integer n-m
          end
    % cat main001.f
          integer n-z
          end
    % cat a.f
          program a
    c  This is the first main program named a.
          end
    % cat b.f
          subroutine b
    c  This is the first subroutine named b.
          end
    % cat c.f
          function c
          end
    % cat d.f
          block data d
    c  This is the block data program unit named d.
          end
    % cat zzz000.f
          program a
    c  This is the second main program named a.
          end
    % cat zzz001.f
          subroutine b
    c  This is the second subroutine named b.
          end

  The files a.f, b.f, and main000.f contain the first program units defined
  in the original source file. The file main000.f contains the second unnamed
  program unit. The file zzz000.f contains the first duplicate unit and the
  file zzz001.f contains the second duplicate unit. This example highlights
  some of the problems in using the fsplit command.

LIMITATIONS AND WORKAROUNDS

  For information about limitations and workarounds, see the release notes
  files in /usr/share/release_notes.


GCC(1)                      GNU Tools                      GCC(1)

NAME
     gcc, g++ - GNU project C and C++ Compiler (v2.6)

SYNOPSIS
     gcc [ option | filename ]...
     g++ [ option | filename ]...

WARNING
     The information in this man page is an extract from the full
     documentation of the GNU C compiler, and is limited to the
     meaning of the options.

     This man page is not kept up to date except when volunteers
     want to maintain it.  If you find a discrepancy between the
     man page and the software, please check the Info file, which
     is the authoritative documentation.

     If we find that the things in this man page that are out of
     date cause significant confusion or complaints, we will stop
     distributing the man page.  The alternative, updating the
     man page when we update the Info file, is impossible because
     the rest of the work of maintaining GNU CC leaves us no time
     for that.  The GNU project regards man pages as obsolete and
     should not let them take time away from other things.

     For complete and current documentation, refer to the Info
     file `gcc' or the manual Using and Porting GNU CC (for ver-
     sion 2.0).  Both are made from the Texinfo source file
     gcc.texinfo.

DESCRIPTION
     The C and C++ compilers are integrated.  Both process input
     files through one or more of four stages: preprocessing,
     compilation, assembly, and linking.  Source filename suf-
     fixes identify the source language, but which name you use
     for the compiler governs default assumptions:

     gcc  assumes preprocessed (.i) files are C and assumes C
          style linking.

     g++  assumes preprocessed (.i) files are C++ and assumes C++
          style linking.

     Suffixes of source file names indicate the language and kind
     of processing to be done:

     .c    C source; preprocess, compile, assemble
     .C    C++ source; preprocess, compile, assemble
     .cc   C++ source; preprocess, compile, assemble
     .cxx  C++ source; preprocess, compile, assemble
     .m    Objective-C source; preprocess, compile, assemble
     .i    preprocessed C; compile, assemble
     .ii   preprocessed C++; compile, assemble
     .s    Assembler source; assemble
     .S    Assembler source; preprocess, assemble
     .h    Preprocessor file; not usually named on command line

     Files with other suffixes are passed to the linker.  Common
     cases include:

     .o    Object file
     .a    Archive file

     Linking is always the last stage unless you use one of the
     -c, -S, or -E options to avoid it (or unless compilation
     errors stop the whole process).  For the link stage, all .o
     files corresponding to source files, -l libraries, unrecog-
     nized filenames (including named .o object files and .a
     archives) are passed to the linker in command-line order.

OPTIONS
     Options must be separate: `-dr' is quite different from `-d
     -r '.

     Most `-f' and `-W' options have two contrary forms: -fname
     and -fno-name (or -Wname and -Wno-name).  Only the non-
     default forms are shown here.

     Here is a summary of all the options, grouped by type.
     Explanations are in the following sections.

     Overall Options
          -c -S -E -o file -pipe -v -x language

     Language Options
          -ansi -fall-virtual -fcond-mismatch
          -fdollars-in-identifiers -fenum-int-equiv
          -fexternal-templates -fno-asm -fno-builtin
          -fno-strict-prototype -fsigned-bitfields -fsigned-char
          -fthis-is-variable -funsigned-bitfields -funsigned-char
          -fwritable-strings -traditional -traditional-cpp
          -trigraphs

     Warning Options
          -fsyntax-only -pedantic -pedantic-errors -w -W -Wall
          -Waggregate-return -Wcast-align -Wcast-qual
          -Wchar-subscript -Wcomment -Wconversion -Wenum-clash
          -Werror -Wformat -Wid-clash-len -Wimplicit -Winline
          -Wmissing-prototypes -Wmissing-declarations
          -Wnested-externs -Wno-import -Wparentheses
          -Wpointer-arith -Wredundant-decls -Wreturn-type
          -Wshadow -Wstrict-prototypes -Wswitch
          -Wtemplate-debugging -Wtraditional -Wtrigraphs
          -Wuninitialized -Wunused -Wwrite-strings

     Debugging Options
          -a -dletters -fpretend-float -g -glevel -gcoff -gxcoff
          -gxcoff+ -gdwarf -gdwarf+ -gstabs -gstabs+ -ggdb -p -pg
          -save-temps -print-file-name=library
          -print-libgcc-file-name -print-prog-name=program

     Optimization Options
          -fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
          -fdelayed-branch -felide-constructors
          -fexpensive-optimizations -ffast-math -ffloat-store
          -fforce-addr -fforce-mem -finline-functions
          -fkeep-inline-functions -fmemoize-lookups
          -fno-default-inline -fno-defer-pop -fno-function-cse
          -fno-inline -fno-peephole -fomit-frame-pointer
          -frerun-cse-after-loop -fschedule-insns
          -fschedule-insns2 -fstrength-reduce -fthread-jumps
          -funroll-all-loops -funroll-loops -O -O2

     Preprocessor Options
          -Aassertion -C -dD -dM -dN -Dmacro[=defn] -E -H
          -idirafter dir -include file -imacros file -iprefix
          file -iwithprefix dir -M -MD -MM -MMD -nostdinc -P
          -Umacro -undef

     Assembler Option
          -Wa,option

     Linker Options
          -llibrary -nostartfiles -nostdlib -static -shared
          -symbolic -Xlinker option -Wl,option -u symbol

     Directory Options
          -Bprefix -Idir -I- -Ldir

     Target Options
          -b  machine -V version

     Configuration Dependent Options
          M680x0 Options
          -m68000 -m68020 -m68020-40 -m68030 -m68040 -m68881
          -mbitfield -mc68000 -mc68020 -mfpa -mnobitfield -mrtd
          -mshort -msoft-float

          VAX Options
          -mg -mgnu -munix

          SPARC Options
          -mepilogue -mfpu -mhard-float -mno-fpu -mno-epilogue
          -msoft-float -msparclite -mv8 -msupersparc -mcypress

          Convex Options
          -margcount -mc1 -mc2 -mnoargcount

          AMD29K Options
          -m29000 -m29050 -mbw -mdw -mkernel-registers -mlarge
          -mnbw -mnodw -msmall -mstack-check -muser-registers

          M88K Options
          -m88000 -m88100 -m88110 -mbig-pic -mcheck-zero-division
          -mhandle-large-shift -midentify-revision
          -mno-check-zero-division -mno-ocs-debug-info
          -mno-ocs-frame-position -mno-optimize-arg-area
          -mno-seriazlize-volatile -mno-underscores
          -mocs-debug-info -mocs-frame-position
          -moptimize-arg-area -mserialize-volatile
          -mshort-data-num -msvr3 -msvr4 -mtrap-large-shift
          -muse-div-instruction -mversion-03.00
          -mwarn-passed-structs

          RS6000 Options
          -mfp-in-toc -mno-fop-in-toc

          RT Options
          -mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs
          -mfull-fp-blocks -mhc-struct-return -min-line-mul
          -mminimum-fp-blocks -mnohc-struct-return

          MIPS Options
          -mcpu=cpu type -mips2 -mips3 -mint64 -mlong64
          -mlonglong128 -mmips-as -mgas -mrnames -mno-rnames
          -mgpopt -mno-gpopt -mstats -mno-stats -mmemcpy
          -mno-memcpy -mno-mips-tfile -mmips-tfile -msoft-float
          -mhard-float -mabicalls -mno-abicalls -mhalf-pic
          -mno-half-pic -G num -nocpp

          i386 Options
          -m486 -mno-486 -msoft-float -mno-fp-ret-in-387

          HPPA Options
          -mpa-risc-1-0 -mpa-risc-1-1 -mkernel -mshared-libs
          -mno-shared-libs -mlong-calls -mdisable-fpregs
          -mdisable-indexing -mtrailing-colon

          i960 Options
          -mcpu-type -mnumerics -msoft-float -mleaf-procedures
          -mno-leaf-procedures -mtail-call -mno-tail-call
          -mcomplex-addr -mno-complex-addr -mcode-align
          -mno-code-align -mic-compat -mic2.0-compat
          -mic3.0-compat -masm-compat -mintel-asm -mstrict-align
          -mno-strict-align -mold-align -mno-old-align

          DEC Alpha Options
          -mfp-regs -mno-fp-regs -mno-soft-float -msoft-float

          System V Options
          -G -Qy -Qn -YP,paths -Ym,dir

     Code Generation Options
          -fcall-saved-reg -fcall-used-reg -ffixed-reg
          -finhibit-size-directive -fnonnull-objects -fno-common
          -fno-ident -fno-gnu-linker -fpcc-struct-return -fpic
          -fPIC -freg-struct-returno -fshared-data -fshort-enums
          -fshort-double -fvolatile -fvolatile-global
          -fverbose-asm

OVERALL OPTIONS
     -x language
          Specify explicitly the language for the following input
          files (rather than choosing a default based on the file
          name suffix) .  This option applies  to  all  following
          input  files  until  the  next  `-x'  option.  Possible
          values of language are `c', `objective-c',  `c-header',
          `c++',       `cpp-output',       `assembler',       and
          `assembler-with-cpp'.

     -x none
          Turn off any specification of a language, so that  sub-
          sequent  files are handled according to their file name
          suffixes (as they are if `-x'  has  not  been  used  at
          all).

     If you want only some of the four stages  (preprocess,  com-
     pile,  assemble,  link),  you can use `-x' (or filename suf-
     fixes) to tell gcc where to start, and one  of  the  options
     `-c',  `-S', or `-E' to say where gcc is to stop.  Note that
     some combinations (for example, `-x cpp-output -E') instruct
     gcc to do nothing at all.

     -c   Compile or assemble the source files, but do not  link.
          The  compiler output is an object file corresponding to
          each source file.

          By default, GCC makes the object file name for a source
          file  by  replacing  the suffix `.c', `.i', `.s', etc.,
          with `.o'.  Use -o to select another name.

          GCC ignores any unrecognized input files (those that do
          not  require  compilation  or assembly) with the -c op-
          tion.

     -S   Stop after the stage of compilation proper; do not  as-
          semble.   The output is an assembler code file for each
          non-assembler input file specified.

          By default, GCC makes the assembler  file  name  for  a
          source  file  by replacing the suffix `.c', `.i', etc.,
          with `.s'.  Use -o to select another name.

          GCC ignores any input files that don't require compila-
          tion.

     -E   Stop after the preprocessing stage; do not run the com-
          piler  proper.  The output is preprocessed source code,
          which is sent to the standard output.

          GCC ignores input files which don't require preprocess-
          ing.

     -o file
          Place output in file file.  This applies regardless  to
          whatever sort of output GCC is producing, whether it be
          an executable file, an object file, an  assembler  file
          or preprocessed C code.

          Since only one output file can be  specified,  it  does
          not make sense to use `-o' when compiling more than one
          input file, unless you are producing an executable file
          as output.

          If you do not specify `-o', the default is  to  put  an
          executable   file  in  `a.out',  the  object  file  for
          `source.suffix' in `source.o', its  assembler  file  in
          `source.s',  and  all preprocessed C source on standard
          output.

     -v   Print (on standard error output) the commands  executed
          to  run the stages of compilation.  Also print the ver-
          sion number of the compiler driver program and  of  the
          preprocessor and the compiler proper.

     -pipe
          Use pipes rather than temporary files for communication
          between  the various stages of compilation.  This fails
          to work on some systems where the assembler cannot read
          from a pipe; but the GNU assembler has no trouble.

LANGUAGE OPTIONS
     The following options control the dialect of C that the com-
     piler accepts:

     -ansi
          Support all ANSI standard C programs.

          This turns off certain features of GNU C that  are  in-
          compatible  with  ANSI  C,  such as the asm, inline and
          typeof keywords, and predefined macros such as unix and
          vax that identify the type of system you are using.  It
          also enables the undesirable and rarely used ANSI  tri-
          graph  feature,  and  disallows `$' as part of identif-
          iers.

          The alternate keywords  __asm__,  __extension__,  __in-
          line__ and __typeof__ continue to work despite `-ansi'.
          You would not want to use them in an ANSI C program, of
          course,  but  it  is useful to put them in header files
          that  might  be  included  in  compilations  done  with
          `-ansi'.   Alternate predefined macros such as __unix__
          and  __vax__  are  also  available,  with  or   without
          `-ansi'.

          The `-ansi' option does not cause non-ANSI programs  to
          be rejected gratuitously.  For that, `-pedantic' is re-
          quired in addition to `-ansi'.

          The preprocessor  predefines  a  macro  __STRICT_ANSI__
          when you use the `-ansi' option.  Some header files may
          notice this macro and refrain  from  declaring  certain
          functions  or  defining  certain  macros  that the ANSI
          standard doesn't call for; this is to avoid interfering
          with  any programs that might use these names for other
          things.

     -fno-asm
          Do not recognize asm, inline or typeof  as  a  keyword.
          These  words  may then be used as identifiers.  You can
          use  __asm__,  __inline__   and   __typeof__   instead.
          `-ansi' implies `-fno-asm'.

     -fno-builtin
          Don't recognize built-in functions that  do  not  begin
          with two leading underscores.  Currently, the functions
          affected include _exit, abort, abs, alloca, cos,  exit,
          fabs,  labs, memcmp, memcpy, sin, sqrt, strcmp, strcpy,
          and strlen.

          The `-ansi' option prevents alloca and _exit from being
          builtin functions.

     -fno-strict-prototype
          Treat a function declaration with no arguments, such as
          `int  foo  ();',  as C would treat it-as saying nothing
          about the number  of  arguments  or  their  types  (C++
          only).   Normally, such a declaration in C++ means that
          the function foo takes no arguments.

     -trigraphs
          Support ANSI C trigraphs.  The `-ansi'  option  implies
          `-trigraphs'.

     -traditional
          Attempt to support some aspects of traditional  C  com-
          pilers.   For details, see the GNU C Manual; the dupli-
          cate list here has been deleted so that  we  won't  get
          complaints when it is out of date.

          But one note about C++ programs only (not C).  `-tradi-
          tional'  has  one additional effect for C++: assignment
          to this is permitted.  This is the same as  the  effect
          of `-fthis-is-variable'.

     -traditional-cpp
          Attempt  to  support  some  aspects  of  traditional  C
          preprocessors.   This  includes the items that specifi-
          cally mention the preprocessor above, but none  of  the
          other effects of `-traditional'.

     -fdollars-in-identifiers
          Permit the use of `$' in identifiers (C++  only).   You
          can also use `-fno-dollars-in-identifiers' to explicit-
          ly prohibit use of `$'.  (GNU C++ allows `$' by default
          on some target systems but not others.)

     -fenum-int-equiv
          Permit implicit conversion of int to enumeration  types
          (C++ only).  Normally GNU C++ allows conversion of enum
          to int, but not the other way around.

     -fexternal-templates
          Produce smaller code for template declarations, by gen-
          erating  only  a  single copy of each template function
          where it is defined (C++ only).   To  use  this  option
          successfully,  you  must  also  mark all files that use
          templates with either `#pragma implementation' (the de-
          finition) or `#pragma interface' (declarations).

          When your code is compiled with `-fexternal-templates',
          all template instantiations are external.  You must ar-
          range for all necessary instantiations to appear in the
          implementation  file;  you  can  do this with a typedef
          that references each instantiation needed.  Conversely,
          when    you    compile   using   the   default   option
          `-fno-external-templates', all template  instantiations
          are explicitly internal.

     -fall-virtual
          Treat all possible member functions as virtual,  impli-
          citly.   All  member  functions (except for constructor
          functions and  new  or  delete  member  operators)  are
          treated  as  virtual  functions of the class where they
          appear.

          This does not mean that all calls to these member func-
          tions will be made through the internal table of virtu-
          al functions.  Under some circumstances,  the  compiler
          can  determine  that a call to a given virtual function
          can be made directly; in  these  cases  the  calls  are
          direct in any case.

     -fcond-mismatch
          Allow conditional expressions with mismatched types  in
          the  second  and third arguments.  The value of such an
          expression is void.

     -fthis-is-variable
          Permit assignment to this (C++ only).   The  incorpora-
          tion of user-defined free store management into C++ has
          made assignment to `this' an  anachronism.   Therefore,
          by  default  it  is  invalid to assign to this within a
          class member function.  However, for backwards compati-
          bility,   you   can  make  it  valid  with  `-fthis-is-
          variable'.

     -funsigned-char
          Let the type char be unsigned, like unsigned char.

          Each kind of machine has a default for what char should
          be.  It is either like unsigned char by default or like
          signed char by default.

          Ideally, a portable program should  always  use  signed
          char or unsigned char when it depends on the signedness
          of an object.  But many programs have been  written  to
          use plain char and expect it to be signed, or expect it
          to be unsigned, depending on  the  machines  they  were
          written  for.   This  option,  and its inverse, let you
          make such a program work with the opposite default.

          The type char is always a distinct type  from  each  of
          signed char and unsigned char, even though its behavior
          is always just like one of those two.

     -fsigned-char
          Let the type char be signed, like signed char.

          Note that this is equivalent  to  `-fno-unsigned-char',
          which is the negative form of `-funsigned-char'.  Like-
          wise,    `-fno-signed-char'    is     equivalent     to
          `-funsigned-char'.

     -fsigned-bitfields

     -funsigned-bitfields

     -fno-signed-bitfields

     -fno-unsigned-bitfields
          These options control whether a bitfield is  signed  or
          unsigned,  when  declared  with no explicit `signed' or
          `unsigned' qualifier.  By default, such a  bitfield  is
          signed,  because  this is consistent: the basic integer
          types such as int are signed types.

          However, when you specify `-traditional', bitfields are
          all unsigned no matter what.

     -fwritable-strings
          Store string constants in the writable data segment and
          don't  uniquize  them.   This is for compatibility with
          old programs which assume they can  write  into  string
          constants.  `-traditional' also has this effect.

          Writing into string constants is a very bad idea; "con-
          stants" should be constant.

PREPROCESSOR OPTIONS
     These options control the C preprocessor, which  is  run  on
     each C source file before actual compilation.

     If you use the `-E' option, GCC does nothing except  prepro-
     cessing.   Some  of  these  options make sense only together
     with `-E' because they cause the preprocessor output  to  be
     unsuitable for actual compilation.

     -include file
          Process file as input before processing the regular in-
          put file.  In effect, the contents of file are compiled
          first.  Any `-D' and `-U' options on the  command  line
          are always processed before `-include file', regardless
          of the order in which they are written.  All the  `-in-
          clude' and `-imacros' options are processed in the ord-
          er in which they are written.

     -imacros file
          Process file as input, discarding the resulting output,
          before  processing the regular input file.  Because the
          output generated from file is discarded, the  only  ef-
          fect  of  `-imacros file' is to make the macros defined
          in file available for  use  in  the  main  input.   The
          preprocessor evaluates any `-D' and `-U' options on the
          command line before processing `-imacrosfile',  regard-
          less  of  the order in which they are written.  All the
          `-include' and `-imacros' options are processed in  the
          order in which they are written.

     -idirafter dir
          Add the directory dir to the second include path.   The
          directories  on  the  second  include path are searched
          when a header file is not found in any  of  the  direc-
          tories in the main include path (the one that `-I' adds
          to).

     -iprefix prefix
          Specify prefix as the prefix for subsequent `-iwithpre-
          fix' options.

     -iwithprefix dir
          Add a  directory  to  the  second  include  path.   The
          directory's  name  is  made by concatenating prefix and
          dir, where prefix was specified previously with `-ipre-
          fix'.

     -nostdinc
          Do not  search  the  standard  system  directories  for
          header  files.  Only the directories you have specified
          with `-I' options (and the current  directory,  if  ap-
          propriate) are searched.

          By using both `-nostdinc' and `-I-', you can limit  the
          include-file  search file to only those directories you
          specify explicitly.

     -nostdinc++
          Do not search for  header  files  in  the  C++-specific
          standard  directories,  but  do  still search the other
          standard directories.  (This option is used when build-
          ing `libg++'.)

     -undef
          Do not predefine any  nonstandard  macros.   (Including
          architecture flags).

     -E   Run only the C  preprocessor.   Preprocess  all  the  C
          source  files specified and output the results to stan-
          dard output or to the specified output file.

     -C   Tell the preprocessor not to  discard  comments.   Used
          with the `-E' option.

     -P   Tell the preprocessor not to generate `#line' commands.
          Used with the `-E' option.

     -M  [ -MG ]
          Tell the preprocessor to output  a  rule  suitable  for
          make  describing  the dependencies of each object file.
          For each source  file,  the  preprocessor  outputs  one
          make-rule whose target is the object file name for that
          source file and whose dependencies are  all  the  files
          `#include'd  in  it.  This rule may be a single line or
          may be continued with `'-newline if it is  long.   The
          list  of rules is printed on standard output instead of
          the preprocessed C program.

          `-M' implies `-E'.

          `-MG' says to treat missing header files  as  generated
          files and assume they live in the same directory as the
          source file.  It must be specified in addition to `-M'.

     -MM  [ -MG ]
          Like `-M' but the output mentions only the user  header
          files  included  with  `#include file"'.  System header
          files included with `#include <file>' are omitted.

     -MD  Like `-M' but the dependency information is written  to
          files  with  names  made by replacing `.o' with `.d' at
          the end of the output file names.  This is in  addition
          to compiling the file as specified-`-MD' does not inhi-
          bit ordinary compilation the way `-M' does.

          The Mach utility `md' can be used  to  merge  the  `.d'
          files  into a single dependency file suitable for using
          with the `make' command.

     -MMD Like `-MD' except mention only user header  files,  not
          system header files.

     -H   Print the name of each header file used, in addition to
          other normal activities.

     -Aquestion(answer)
          Assert the answer answer for question, in  case  it  is
          tested  with  a  preprocessor  conditional such as `#if
          #question(answer)'.  `-A-' disables the standard asser-
          tions that normally describe the target machine.

     -Aquestion
          (answer) Assert the answer answer for question, in case
          it  is  tested  with a preprocessor conditional such as
          `#if #question(answer)'.  `-A-' disables  the  standard
          assertions that normally describe the target machine.

     -Dmacro
          Define macro macro with the string `1' as  its  defini-
          tion.

     -Dmacro=defn
          Define macro macro as defn.    All instances of `-D' on
          the command line are processed before any `-U' options.

     -Umacro
          Undefine macro macro.  `-U' options are evaluated after
          all `-D' options, but before any `-include' and `-imac-
          ros' options.

     -dM  Tell the preprocessor to output only a list of the mac-
          ro definitions that are in effect at the end of prepro-
          cessing.  Used with the `-E' option.

     -dD  Tell the preprocessor to  pass  all  macro  definitions
          into  the  output, in their proper sequence in the rest
          of the output.

     -dN  Like `-dD' except that the macro arguments and contents
          are  omitted.   Only  `#define name' is included in the
          output.

ASSEMBLER OPTION
     -Wa,option
          Pass option as an option to the assembler.   If  option
          contains  commas,  it is split into multiple options at
          the commas.

LINKER OPTIONS
     These options come into play when the compiler links  object
     files  into an executable output file.  They are meaningless
     if the compiler is not doing a link step.

     object-file-name
          A file name that does not end in a  special  recognized
          suffix is considered to name an object file or library.
          (Object files are distinguished from libraries  by  the
          linker  according to the file contents.)  If GCC does a
          link step, these object files are used as input to  the
          linker.

     -llibrary
          Use the library named library when linking.

          The linker searches a standard list of directories  for
          the   library,   which   is   actually   a  file  named
          `liblibrary.a'.  The linker then uses this file  as  if
          it had been specified precisely by name.

          The directories searched include several standard  sys-
          tem directories plus any that you specify with `-L'.

          Normally the files found this way  are  library  files-
          archive  files  whose  members  are  object files.  The
          linker handles an archive file by scanning  through  it
          for  members which define symbols that have so far been
          referenced but not defined.   However,  if  the  linker
          finds  an  ordinary  object file rather than a library,
          the object file is linked in the  usual  fashion.   The
          only difference between using an `-l' option and speci-
          fying a file name is that `-l' surrounds  library  with
          `lib' and `.a' and searches several directories.

     -lobjc
          You need this special case of the -l option in order to
          link an Objective C program.

     -nostartfiles
          Do not use the standard system startup files when link-
          ing.  The standard libraries are used normally.

     -nostdlib
          Don't use the standard  system  libraries  and  startup
          files when linking.  Only the files you specify will be
          passed to the linker.

     -static
          On systems that support dynamic linking, this  prevents
          linking  with  the shared libraries.  On other systems,
          this option has no effect.

     -shared
          Produce a shared object which can then be  linked  with
          other  objects  to form an executable.  Only a few sys-
          tems support this option.

     -symbolic
          Bind references  to  global  symbols  when  building  a
          shared  object.   Warn  about any unresolved references
          (unless overridden by the link editor option  `-Xlinker
          -z  -Xlinker  defs').   Only a few systems support this
          option.

     -Xlinker option
          Pass option as an option to the linker.   You  can  use
          this to supply system-specific linker options which GNU
          CC does not know how to recognize.

          If you want to pass an option that takes  an  argument,
          you  must use `-Xlinker' twice, once for the option and
          once for the argument.  For example, to  pass  `-assert
          definitions', you must write `-Xlinker -assert -Xlinker
          definitions'.  It does  not  work  to  write  `-Xlinker
          "-assert  definitions"', because this passes the entire
          string as a single argument,  which  is  not  what  the
          linker expects.

     -Wl,option
          Pass option as an option to the linker.  If option con-
          tains  commas, it is split into multiple options at the
          commas.

     -u symbol
          Pretend the symbol symbol is undefined, to force  link-
          ing  of library modules to define it.  You can use `-u'
          multiple times with different symbols to force  loading
          of additional library modules.

DIRECTORY OPTIONS
     These options  specify  directories  to  search  for  header
     files, for libraries and for parts of the compiler:

     -Idir
          Append  directory  dir  to  the  list  of   directories
          searched for include files.

     -I-  Any directories you specify with  `-I'  options  before
          the  `-I-'  option  are  searched  only for the case of
          `#include "file"'; they are not searched for  `#include
          <file>'.

          If additional directories are specified with  `-I'  op-
          tions  after  the `-I-', these directories are searched
          for all `#include' directives.   (Ordinarily  all  `-I'
          directories are used this way.)

          In addition, the `-I-' option inhibits the use  of  the
          current  directory  (where  the current input file came
          from) as  the  first  search  directory  for  `#include
          "file"'.   There  is  no way to override this effect of
          `-I-'.  With `-I.' you can specify searching the direc-
          tory  which  was current when the compiler was invoked.
          That is not exactly the same as what  the  preprocessor
          does by default, but it is often satisfactory.

          `-I-' does not inhibit the use of the  standard  system
          directories  for header files.  Thus, `-I-' and `-nost-
          dinc' are independent.

     -Ldir
          Add directory dir to the  list  of  directories  to  be
          searched for `-l'.

     -Bprefix
          This option specifies where to  find  the  executables,
          libraries and data files of the compiler itself.

          The compiler driver program runs one  or  more  of  the
          subprograms `cpp', `cc1' (or, for C++, `cc1plus'), `as'
          and `ld'.  It tries prefix as a prefix for each program
          it    tries    to    run,   both   with   and   without
          `machine/version/'.

          For each subprogram to  be  run,  the  compiler  driver
          first  tries  the `-B' prefix, if any.  If that name is
          not found, or if `-B' was  not  specified,  the  driver
          tries  two standard prefixes, which are `/usr/lib/gcc/'
          and `/usr/local/lib/gcc-lib/'.   If  neither  of  those
          results  in  a  file  name  that is found, the compiler
          driver searches for the unmodified program name,  using
          the  directories  specified  in your `PATH' environment
          variable.

          The run-time support file `libgcc.a' is  also  searched
          for  using  the  `-B'  prefix, if needed.  If it is not
          found there, the two standard prefixes above are tried,
          and  that  is all.  The file is left out of the link if
          it is not found by those means.  Most of the  time,  on
          most machines, `libgcc.a' is not actually necessary.

          You can get a similar result from the environment vari-
          able  GCC_EXEC_PREFIX;  if  it is defined, its value is
          used as a prefix in the same way.  If both the `-B' op-
          tion  and the GCC_EXEC_PREFIX variable are present, the
          `-B' option is used first and the environment  variable
          value second.

WARNING OPTIONS
     Warnings are diagnostic messages that  report  constructions
     which  are  not  inherently erroneous but which are risky or
     suggest there may have been an error.

     These options control the amount and kinds of warnings  pro-
     duced by GNU CC:

     -fsyntax-only
          Check the code for syntax errors, but  don't  emit  any
          output.

     -w   Inhibit all warning messages.

     -Wno-import
          Inhibit warning messages about the use of #import.

     -pedantic
          Issue all the warnings demanded by strict ANSI standard
          C; reject all programs that use forbidden extensions.

          Valid ANSI standard C programs should compile  properly
          with or without this option (though a rare few will re-
          quire `-ansi').  However, without this option,  certain
          GNU extensions and traditional C features are supported
          as well.  With this option, they are  rejected.   There
          is  no  reason  to  use  this option; it exists only to
          satisfy pedants.

          `-pedantic' does not cause warning messages for use  of
          the  alternate  keywords whose names begin and end with
          `__'.  Pedantic warnings are also disabled in  the  ex-
          pression  that  follows  __extension__.   However, only
          system header files should use these escape routes; ap-
          plication programs should avoid them.

     -pedantic-errors
          Like `-pedantic', except that errors are produced rath-
          er than warnings.

     -W   Print extra warning messages for these events:

        o A nonvolatile automatic variable might be changed by  a
          call  to  longjmp.  These warnings are possible only in
          optimizing compilation.

          The compiler sees only the calls to setjmp.  It  cannot
          know  where  longjmp  will be called; in fact, a signal
          handler could call it at any point in the code.   As  a
          result,  you  may  get  a warning even when there is in
          fact no problem  because  longjmp  cannot  in  fact  be
          called at the place which would cause a problem.

        o A function can return either with or without  a  value.
          (Falling off the end of the function body is considered
          returning without a value.)  For example, this function
          would evoke such a warning:

          foo (a)
          {
            if (a > 0)
              return a;
          }

          Spurious warnings can occur because  GNU  CC  does  not
          realize  that  certain  functions  (including abort and
          longjmp) will never return.

        o An expression-statement contains no side effects.

        o An unsigned value is compared against zero with `>'  or
          `<='.

     -Wimplicit
          Warn whenever a function or parameter is implicitly de-
          clared.

     -Wreturn-type
          Warn whenever a function is defined with a  return-type
          that  defaults  to  int.   Also  warn  about any return
          statement with no  return-value  in  a  function  whose
          return-type is not void.

     -Wunused
          Warn whenever a local variable is unused aside from its
          declaration, whenever a function is declared static but
          never defined, and  whenever  a  statement  computes  a
          result that is explicitly not used.

     -Wswitch
          Warn whenever  a  switch  statement  has  an  index  of
          enumeral  type  and lacks a case for one or more of the
          named codes of that enumeration.  (The  presence  of  a
          default label prevents this warning.)  case labels out-
          side the enumeration range also provoke  warnings  when
          this option is used.

     -Wcomment
          Warn whenever a comment-start sequence `/*' appears  in
          a comment.

     -Wtrigraphs
          Warn if any trigraphs are  encountered  (assuming  they
          are enabled).

     -Wformat
          Check calls to printf and scanf,  etc.,  to  make  sure
          that  the  arguments supplied have types appropriate to
          the format string specified.

     -Wchar-subscripts
          Warn if an array subscript has type char.   This  is  a
          common cause of error, as programmers often forget that
          this type is signed on some machines.

     -Wuninitialized
          An automatic variable is used without first being  ini-
          tialized.

          These warnings are possible only in optimizing compila-
          tion,  because  they require data flow information that
          is computed only when optimizing.  If you don't specify
          `-O', you simply won't get these warnings.

          These warnings occur only for variables that are candi-
          dates  for register allocation.  Therefore, they do not
          occur for a variable  that  is  declared  volatile,  or
          whose  address is taken, or whose size is other than 1,
          2, 4 or 8 bytes.  Also, they do not  occur  for  struc-
          tures,  unions  or arrays, even when they are in regis-
          ters.

          Note that there may be no warning about a variable that
          is  used  only  to compute a value that itself is never
          used, because such computations may be deleted by  data
          flow analysis before the warnings are printed.

          These warnings are made optional because GNU CC is  not
          smart  enough to see all the reasons why the code might
          be correct despite appearing to have an error.  Here is
          one example of how this can happen:

          {
            int x;
            switch (y)
              {
              case 1: x = 1;
                break;
              case 2: x = 4;
                break;
              case 3: x = 5;
              }
            foo (x);
          }

          If the value of y is always 1, 2 or 3, then x is always
          initialized,  but  GNU  CC  doesn't know this.  Here is
          another common case:

          {
            int save_y;
            if (change_y) save_y = y, y = new_y;
            ...
            if (change_y) y = save_y;
          }

          This has no bug because save_y is used only  if  it  is
          set.

          Some spurious warnings can be avoided if you declare as
          volatile all the functions you use that never return.

     -Wparentheses
          Warn if parentheses are omitted in certain contexts.

     -Wtemplate-debugging
          When using templates in a C++ program, warn  if  debug-
          ging is not yet fully available (C++ only).

     -Wall
          All of the above `-W' options combined.  These are  all
          the  options  which  pertain to usage that we recommend
          avoiding and that we believe is easy to avoid, even  in
          conjunction with macros.

     The remaining `-W...' options are not implied by `-Wall' be-
     cause they warn about constructions that we consider reason-
     able to use, on occasion, in clean programs.

     -Wtraditional
          Warn about certain constructs that  behave  differently
          in traditional and ANSI C.

        o Macro arguments occurring within  string  constants  in
          the macro body.  These would substitute the argument in
          traditional C, but are part of the constant in ANSI C.

        o A function declared external in one block and then used
          after the end of the block.

        o A switch statement has an operand of type long.

     -Wshadow
          Warn whenever a local variable  shadows  another  local
          variable.

     -Wid-clash-len
          Warn whenever two distinct  identifiers  match  in  the
          first len characters.  This may help you prepare a pro-
          gram that will compile with  certain  obsolete,  brain-
          damaged compilers.

     -Wpointer-arith
          Warn about anything that depends on  the  "size  of"  a
          function  type or of void.  GNU C assigns these types a
          size of 1, for convenience in calculations with void  *
          pointers and pointers to functions.

     -Wcast-qual
          Warn whenever a pointer is cast so as to remove a  type
          qualifier from the target type.  For example, warn if a
          const char * is cast to an ordinary char *.

     -Wcast-align
          Warn whenever a pointer is cast such that the  required
          alignment  of  the  target  is increased.  For example,
          warn if a char * is cast to an int * on machines  where
          integers  can  only  be  accessed  at two- or four-byte
          boundaries.

     -Wwrite-strings
          Give string constants the type  const  char[length]  so
          that copying the address of one into a non-const char *
          pointer will get a warning.  These warnings  will  help
          you  find  at  compile  time code that can try to write
          into a string constant, but only if you have been  very
          careful  about  using  const in declarations and proto-
          types.  Otherwise, it will just be a nuisance; this  is
          why we did not make `-Wall' request these warnings.

     -Wconversion
          Warn if a prototype causes a type  conversion  that  is
          different  from  what would happen to the same argument
          in the absence of a prototype.  This  includes  conver-
          sions  of  fixed  point to floating and vice versa, and
          conversions changing the width or signedness of a fixed
          point argument except when the same as the default pro-
          motion.

     -Waggregate-return
          Warn if any functions that return structures or  unions
          are defined or called.  (In languages where you can re-
          turn an array, this also elicits a warning.)

     -Wstrict-prototypes
          Warn if a  function  is  declared  or  defined  without
          specifying  the argument types.  (An old-style function
          definition is permitted without a warning  if  preceded
          by a declaration which specifies the argument types.)

     -Wmissing-prototypes
          Warn if a global function is defined without a previous
          prototype  declaration.  This warning is issued even if
          the definition itself provides a prototype.  The aim is
          to  detect global functions that fail to be declared in
          header files.

     -Wmissing-declarations
          Warn if a global function is defined without a previous
          declaration.   Do so even if the definition itself pro-
          vides a prototype.  Use this option  to  detect  global
          functions that are not declared in header files.

     -Wredundant-decls
          Warn if anything is declared more than once in the same
          scope,  even  in  cases  where  multiple declaration is
          valid and changes nothing.

     -Wnested-externs
          Warn if an extern declaration is encountered within  an
          function.

     -Wenum-clash
          Warn about  conversion  between  different  enumeration
          types (C++ only).

     -Woverloaded-virtual
          (C++ only.) In a derived class, the definitions of vir-
          tual  functions must match the type signature of a vir-
          tual function declared in the base class.  Use this op-
          tion  to request warnings when a derived class declares
          a function that may be an erroneous attempt to define a
          virtual  function:  that  is, warn when a function with
          the same name as a virtual function in the base  class,
          but with a type signature that doesn't match any virtu-
          al functions from the base class.

     -Winline
          Warn if a function can not be inlined,  and  either  it
          was  declared as inline, or else the -finline-functions
          option was given.

     -Werror
          Treat warnings as errors; abort compilation  after  any
          warning.

DEBUGGING OPTIONS
     GNU CC has various special options that are used for  debug-
     ging either your program or GCC:

     -g   Produce debugging information in the operating system's
          native  format (stabs, COFF, XCOFF, or DWARF).  GDB can
          work with this debugging information.

          On most systems that use stabs format, `-g' enables use
          of  extra  debugging information that only GDB can use;
          this extra information makes debugging work  better  in
          GDB but will probably make other debuggers crash or re-
          fuse to read the program.  If you want to  control  for
          certain  whether to generate the extra information, use
          `-gstabs+',    `-gstabs',    `-gxcoff+',     `-gxcoff',
          `-gdwarf+', or `-gdwarf' (see below).

          Unlike most other C compilers, GNU CC allows you to use
          `-g'  with `-O'.  The shortcuts taken by optimized code
          may occasionally produce surprising results: some vari-
          ables  you  declared may not exist at all; flow of con-
          trol may briefly move where you did not expect it; some
          statements  may  not  be  executed because they compute
          constant results or their values were already at  hand;
          some statements may execute in different places because
          they were moved out of loops.

          Nevertheless it proves possible to debug optimized out-
          put.  This makes it reasonable to use the optimizer for
          programs that might have bugs.

     The following options are useful when GNU  CC  is  generated
     with the capability for more than one debugging format.

     -ggdb
          Produce debugging information in the native format  (if
          that  is supported), including GDB extensions if at all
          possible.

     -gstabs
          Produce debugging information in stabs format (if  that
          is  supported),  without  GDB  extensions.  This is the
          format used by DBX on most BSD systems.

     -gstabs+
          Produce debugging information in stabs format (if  that
          is  supported), using GNU extensions understood only by
          the GNU debugger (GDB).  The use of these extensions is
          likely  to make other debuggers crash or refuse to read
          the program.

     -gcoff
          Produce debugging information in COFF format  (if  that
          is  supported).  This is the format used by SDB on most
          System V systems prior to System V Release 4.

     -gxcoff
          Produce debugging information in XCOFF format (if  that
          is  supported).  This is the format used by the DBX de-
          bugger on IBM RS/6000 systems.

     -gxcoff+
          Produce debugging information in XCOFF format (if  that
          is  supported), using GNU extensions understood only by
          the GNU debugger (GDB).  The use of these extensions is
          likely  to make other debuggers crash or refuse to read
          the program.

     -gdwarf
          Produce debugging information in DWARF format (if  that
          is  supported).  This is the format used by SDB on most
          System V Release 4 systems.

     -gdwarf+
          Produce debugging information in DWARF format (if  that
          is  supported), using GNU extensions understood only by
          the GNU debugger (GDB).  The use of these extensions is
          likely  to make other debuggers crash or refuse to read
          the program.

     -glevel
     -ggdblevel
     -gstabslevel
     -gcofflevel -gxcofflevel

     -gdwarflevel
          Request debugging information and  also  use  level  to
          specify how much information.  The default level is 2.

          Level 1 produces minimal information, enough for making
          backtraces  in parts of the program that you don't plan
          to debug.  This includes descriptions of functions  and
          external  variables,  but  no  information  about local
          variables and no line numbers.

          Level 3 includes extra information,  such  as  all  the
          macro  definitions  present  in  the program.  Some de-
          buggers support macro expansion when you use `-g3'.

     -p   Generate extra code to write profile information  suit-
          able for the analysis program prof.

     -pg  Generate extra code to write profile information  suit-
          able for the analysis program gprof.

     -a   Generate extra code to write  profile  information  for
          basic  blocks,  which  will  record the number of times
          each basic block  is  executed.   This  data  could  be
          analyzed  by  a program like tcov.  Note, however, that
          the format of the data is not what tcov expects.  Even-
          tually  GNU  gprof  should  be extended to process this
          data.

     -dletters
          Says to make  debugging  dumps  during  compilation  at
          times specified by letters.  This is used for debugging
          the compiler.  The file names for most of the dumps are
          made  by appending a word to the source file name (e.g.
          `foo.c.rtl' or `foo.c.jump').

     -dM  Dump all macro definitions, at the end  of  preprocess-
          ing, and write no output.

     -dN  Dump all macro names, at the end of preprocessing.

     -dD  Dump all macro definitions, at the end  of  preprocess-
          ing, in addition to normal output.

     -dy  Dump debugging information during parsing, to  standard
          error.

     -dr  Dump after RTL generation, to `file.rtl'.

     -dx  Just generate RTL for a function instead  of  compiling
          it.  Usually used with `r'.

     -dj  Dump after first jump optimization, to `file.jump'.

     -ds  Dump after CSE (including the  jump  optimization  that
          sometimes follows CSE), to `file.cse'.

     -dL  Dump after loop optimization, to `file.loop'.

     -dt  Dump after the second CSE pass (including the jump  op-
          timization that sometimes follows CSE), to `file.cse2'.

     -df  Dump after flow analysis, to `file.flow'.

     -dc  Dump after instruction combination, to `file.combine'.

     -dS  Dump after the first instruction  scheduling  pass,  to
          `file.sched'.

     -dl  Dump after local register allocation, to `file.lreg'.

     -dg  Dump after global register allocation, to `file.greg'.

     -dR  Dump after the second instruction scheduling  pass,  to
          `file.sched2'.

     -dJ  Dump after last jump optimization, to `file.jump2'.

     -dd  Dump after delayed branch scheduling, to `file.dbr'.

     -dk  Dump after  conversion  from  registers  to  stack,  to
          `file.stack'.

     -da  Produce all the dumps listed above.

     -dm  Print statistics on memory usage, at  the  end  of  the
          run, to standard error.

     -dp  Annotate the assembler output with a comment indicating
          which pattern and alternative was used.

     -fpretend-float
          When running a cross-compiler, pretend that the  target
          machine uses the same floating point format as the host
          machine.  This causes incorrect output  of  the  actual
          floating constants, but the actual instruction sequence
          will probably be the same as GNU  CC  would  make  when
          running on the target machine.

     -save-temps
          Store the usual  "temporary"  intermediate  files  per-
          manently;  place them in the current directory and name
          them based on the source file.  Thus, compiling `foo.c'
          with `-c -save-temps' would produce files `foo.cpp' and
          `foo.s', as well as `foo.o'.

     -print-file-name=library
          Print the  full  absolute  name  of  the  library  file
          library   that would be used when linking-and do not do
          anything else.  With this option, GNU CC does not  com-
          pile or link anything; it just prints the file name.

     -print-libgcc-file-name
          Same as `-print-file-name=libgcc.a'.

     -print-prog-name=program
          Like `-print-file-name', but  searches  for  a  program
          such as `cpp'.

OPTIMIZATION OPTIONS
     These options control various sorts of optimizations:

     -O

     -O1  Optimize.  Optimizing compilation takes  somewhat  more
          time, and a lot more memory for a large function.

          Without `-O', the compiler's goal is to reduce the cost
          of  compilation  and  to make debugging produce the ex-
          pected results.  Statements  are  independent:  if  you
          stop  the program with a breakpoint between statements,
          you can then assign a new  value  to  any  variable  or
          change  the  program  counter to any other statement in
          the function and get exactly the results you would  ex-
          pect from the source code.

          Without `-O', only variables declared register are  al-
          located in registers.  The resulting compiled code is a
          little worse than produced by PCC without `-O'.

          With `-O', the compiler tries to reduce code  size  and
          execution time.

          When you specify `-O', the two options `-fthread-jumps'
          and `-fdefer-pop' are turned on.  On machines that have
          delay slots, the `-fdelayed-branch'  option  is  turned
          on.  For those machines that can support debugging even
          without a frame pointer, the `-fomit-frame-pointer' op-
          tion  is  turned  on.  On some machines other flags may
          also be turned on.

     -O2  Optimize even more.  Nearly all supported optimizations
          that  do  not  involve  a space-speed tradeoff are per-
          formed.  Loop unrolling and function inlining  are  not
          done,  for example.  As compared to -O, this option in-
          creases both compilation time and  the  performance  of
          the generated code.

     -O3  Optimize yet more. This turns on everything  -O2  does,
          along with also turning on -finline-functions.

     -O0  Do not optimize.

          If you use multiple -O options, with or  without  level
          numbers, the last such option is the one that is effec-
          tive.

     Options of the  form  `-fflag'  specify  machine-independent
     flags.   Most  flags  have both positive and negative forms;
     the negative form of `-ffoo' would be `-fno-foo'.  The  fol-
     lowing list shows only one form-the one which is not the de-
     fault.  You can figure out the other form by either removing
     `no-' or adding it.

     -ffloat-store
          Do not store floating  point  variables  in  registers.
          This  prevents undesirable excess precision on machines
          such as the 68000 where the floating registers (of  the
          68881) keep more precision than a double is supposed to
          have.

          For most programs, the excess precision does only good,
          but  a  few  programs rely on the precise definition of
          IEEE floating point.  Use `-ffloat-store' for such pro-
          grams.

     -fmemoize-lookups

     -fsave-memoized
          Use heuristics to compile  faster  (C++  only).   These
          heuristics  are  not enabled by default, since they are
          only effective for certain input  files.   Other  input
          files compile more slowly.

          The first time the compiler must  build  a  call  to  a
          member  function  (or  reference  to a data member), it
          must (1) determine whether the class implements  member
          functions  of that name; (2) resolve which member func-
          tion to call (which involves figuring out what sorts of
          type  conversions  need  to be made); and (3) check the
          visibility of the member function to the  caller.   All
          of  this  adds up to slower compilation.  Normally, the
          second time a call is made to that member function  (or
          reference  to that data member), it must go through the
          same lengthy process again.  This means that code  like
          this

            cout << "This " << p << " has " << n << " legs.0;

          makes six passes through all three steps.  By  using  a
          software  cache,  a  "hit"  significantly  reduces this
          cost.  Unfortunately, using the cache introduces anoth-
          er  layer  of mechanisms which must be implemented, and
          so incurs its own  overhead.   `-fmemoize-lookups'  en-
          ables the software cache.

          Because access privileges (visibility) to  members  and
          member  functions  may differ from one function context
          to the next, g++ may need to flush the cache.  With the
          `-fmemoize-lookups'  flag,  the  cache is flushed after
          every function that is compiled.  The `-fsave-memoized'
          flag enables the same software cache, but when the com-
          piler determines that the context of the last  function
          compiled  would yield the same access privileges of the
          next function to compile, it preserves the cache.  This
          is most helpful when defining many member functions for
          the same class: with the exception of member  functions
          which  are  friends of other classes, each member func-
          tion has exactly the same access  privileges  as  every
          other, and the cache need not be flushed.

     -fno-default-inline
          Don't make member functions inline  by  default  merely
          because  they  are  defined inside the class scope (C++
          only).

     -fno-defer-pop
          Always pop the arguments to each function call as  soon
          as  that function returns.  For machines which must pop
          arguments after a function call, the compiler  normally
          lets  arguments  accumulate  on  the  stack for several
          function calls and pops them all at once.

     -fforce-mem
          Force memory operands to be copied into  registers  be-
          fore doing arithmetic on them.  This may produce better
          code by making all memory references  potential  common
          subexpressions.   When  they  are not common subexpres-
          sions, instruction  combination  should  eliminate  the
          separate  register-load.   I  am  interested in hearing
          about the difference this makes.

     -fforce-addr
          Force memory address constants to be copied into regis-
          ters before doing arithmetic on them.  This may produce
          better code just as `-fforce-mem' may.  I am interested
          in hearing about the difference this makes.

     -fomit-frame-pointer
          Don't keep the frame pointer in a  register  for  func-
          tions  that  don't  need one.  This avoids the instruc-
          tions to save, set up and restore  frame  pointers;  it
          also  makes  an  extra register available in many func-
          tions.  It also  makes  debugging  impossible  on  most
          machines.

          On some machines, such as the Vax, this flag has no ef-
          fect,  because  the standard calling sequence automati-
          cally handles the frame pointer and nothing is saved by
          pretending  it  doesn't exist.  The machine-description
          macro FRAME_POINTER_REQUIRED controls whether a  target
          machine supports this flag.

     -finline-functions
          Integrate all simple functions into their callers.  The
          compiler heuristically decides which functions are sim-
          ple enough to be worth integrating in this way.

          If all calls to a given function  are  integrated,  and
          the function is declared static, then GCC normally does
          not output the function as assembler code  in  its  own
          right.

     -fcaller-saves
          Enable values to be allocated in registers that will be
          clobbered by function calls, by emitting extra instruc-
          tions to save and restore  the  registers  around  such
          calls.   Such  allocation is done only when it seems to
          result in better code than would otherwise be produced.

          This option is enabled by default on certain  machines,
          usually those which have no call-preserved registers to
          use instead.

     -fkeep-inline-functions
          Even if all calls to a given function  are  integrated,
          and  the function is declared static, nevertheless out-
          put a separate run-time callable version of  the  func-
          tion.

     -fno-function-cse
          Do not put function addresses in registers;  make  each
          instruction  that calls a constant function contain the
          function's address explicitly.

          This option results in less efficient  code,  but  some
          strange  hacks  that  alter the assembler output may be
          confused by the optimizations performed when  this  op-
          tion is not used.

     -fno-peephole
          Disable any machine-specific peephole optimizations.

     -ffast-math
          This option allows GCC to violate  some  ANSI  or  IEEE
          rules/specifications in the interest of optimizing code
          for speed.  For example, it allows the compiler to  as-
          sume  arguments  to  the sqrt function are non-negative
          numbers.

          This option should never be turned on by any  `-O'  op-
          tion  since  it can result in incorrect output for pro-
          grams which depend on an exact implementation  of  IEEE
          or ANSI rules/specifications for math functions.

     The following options control specific  optimizations.   The
     `-O2'  option  turns  on  all  of these optimizations except
     `-funroll-loops' and `-funroll-all-loops'.

     The `-O' option usually turns on  the  `-fthread-jumps'  and
     `-fdelayed-branch' options, but specific machines may change
     the default optimizations.

     You can use the following  flags  in  the  rare  cases  when
     "fine-tuning" of optimizations to be performed is desired.

     -fstrength-reduce
          Perform the optimizations of  loop  strength  reduction
          and elimination of iteration variables.

     -fthread-jumps
          Perform optimizations where we check to see if  a  jump
          branches  to  a  location where another comparison sub-
          sumed by the first is found.  If so, the  first  branch
          is  redirected  to either the destination of the second
          branch or a point immediately following  it,  depending
          on whether the condition is known to be true or false.

     -funroll-loops
          Perform the optimization of loop  unrolling.   This  is
          only  done  for loops whose number of iterations can be
          determined at compile time or run time.

     -funroll-all-loops
          Perform the optimization of loop  unrolling.   This  is
          done  for  all  loops.  This usually makes programs run
          more slowly.

     -fcse-follow-jumps
          In common subexpression elimination, scan through  jump
          instructions when the target of the jump is not reached
          by any other path.  For example, when CSE encounters an
          if  statement  with an else clause, CSE will follow the
          jump when the condition tested is false.

     -fcse-skip-blocks
          This is similar to `-fcse-follow-jumps', but causes CSE
          to  follow  jumps which conditionally skip over blocks.
          When CSE encounters a simple if statement with no  else
          clause,  `-fcse-skip-blocks'  causes  CSE to follow the
          jump around the body of the if.

     -frerun-cse-after-loop
          Re-run common subexpression elimination after loop  op-
          timizations has been performed.

     -felide-constructors
          Elide  constructors  when  this  seems  plausible  (C++
          only).   With this flag, GNU C++ initializes y directly
          from the call to foo without going through a  temporary
          in the following code:

          A foo (); A y = foo ();

          Without this option, GNU C++  first  initializes  y  by
          calling  the  appropriate  constructor for type A; then
          assigns the result of foo to a temporary; and, finally,
          replaces the initial valyue of `y' with the temporary.

          The  default  behavior  (`-fno-elide-constructors')  is
          specified  by  the  draft  ANSI  C++ standard.  If your
          program's  constructors  have   side   effects,   using
          `-felide-constructors'  can  make your program act dif-
          ferently, since some constructor calls may be omitted.

     -fexpensive-optimizations
          Perform a number of minor optimizations that are  rela-
          tively expensive.

     -fdelayed-branch
          If supported for the target machine, attempt to reorder
          instructions  to  exploit  instruction  slots available
          after delayed branch instructions.

     -fschedule-insns
          If supported for the target machine, attempt to reorder
          instructions  to  eliminate execution stalls due to re-
          quired data being  unavailable.   This  helps  machines
          that  have  slow floating point or memory load instruc-
          tions by allowing other instructions to be issued until
          the result of the load or floating point instruction is
          required.

     -fschedule-insns2
          Similar to `-fschedule-insns', but  requests  an  addi-
          tional  pass  of  instruction scheduling after register
          allocation has been done.  This is especially useful on
          machines  with  a  relatively small number of registers
          and where memory load instructions take more  than  one
          cycle.

TARGET OPTIONS
     By default, GNU CC  compiles  code  for  the  same  type  of
     machine  that  you  are  using.  However, it can also be in-
     stalled as a cross-compiler, to compile for some other  type
     of  machine.   In  fact, several different configurations of
     GNU CC, for different target machines, can be installed side
     by  side.   Then  you specify which one to use with the `-b'
     option.

     In addition, older and newer versions of GNU CC can  be  in-
     stalled  side  by  side.   One of them (probably the newest)
     will be the default, but  you  may  sometimes  wish  to  use
     another.

     -b machine
          The argument machine specifies the target  machine  for
          compilation.   This  is  useful when you have installed
          GNU CC as a cross-compiler.

          The value to use for machine is the same as was  speci-
          fied  as  the machine type when configuring GNU CC as a
          cross-compiler.  For example, if a  cross-compiler  was
          configured  with  `configure i386v', meaning to compile
          for an 80386 running System V, then you  would  specify
          `-b i386v' to run that cross compiler.

          When you do not specify `-b', it normally means to com-
          pile for the same type of machine that you are using.

     -V version
          The argument version specifies which version of GNU  CC
          to  run.  This is useful when multiple versions are in-
          stalled.  For example, version might be `2.0',  meaning
          to run GNU CC version 2.0.

          The default version, when you do not specify  `-V',  is
          controlled  by  the way GNU CC is installed.  Normally,
          it will be a version that is  recommended  for  general
          use.

MACHINE DEPENDENT OPTIONS
     Each of the target machine types can have  its  own  special
     options,   starting  with  `-m',  to  choose  among  various
     hardware models  or  configurations-for  example,  68010  vs
     68020,  floating  coprocessor  or  none.  A single installed
     version of the compiler can compile for any model or  confi-
     guration, according to the options specified.

     Some configurations of the compiler also support  additional
     special options, usually for command-line compatibility with
     other compilers on the same platform.

     These are the `-m' options defined for the 68000 series:

     -m68000

     -mc68000
          Generate output for a 68000.  This is the default  when
          the compiler is configured for 68000-based systems.

     -m68020

     -mc68020
          Generate output for a  68020  (rather  than  a  68000).
          This is the default when the compiler is configured for
          68020-based systems.

     -m68881
          Generate  output  containing  68881  instructions   for
          floating  point.   This  is the default for most 68020-
          based systems unless -nfp was specified when  the  com-
          piler was configured.

     -m68030
          Generate output for a 68030.  This is the default  when
          the compiler is configured for 68030-based systems.

     -m68040
          Generate output for a 68040.  This is the default  when
          the compiler is configured for 68040-based systems.

     -m68020-40
          Generate output for a 68040, without using any  of  the
          new  instructions.   This results in code which can run
          relatively efficiently on either  a  68020/68881  or  a
          68030 or a 68040.

     -mfpa
          Generate output containing  Sun  FPA  instructions  for
          floating point.

     -msoft-float
          Generate output containing library calls  for  floating
          point.   WARNING:  the requisite libraries are not part
          of GNU CC.  Normally the facilities  of  the  machine's
          usual  C  compiler  are  used,  but  this can't be done
          directly in cross-compilation.  You must make your  own
          arrangements  to provide suitable library functions for
          cross-compilation.

     -mshort
          Consider type int to be 16 bits wide, like short int.

     -mnobitfield
          Do not use the bit-field instructions.   `-m68000'  im-
          plies `-mnobitfield'.

     -mbitfield
          Do use the bit-field instructions.   `-m68020'  implies
          `-mbitfield'.  This is the default if you use the unmo-
          dified sources.

     -mrtd
          Use a different function-calling convention,  in  which
          functions  that take a fixed number of arguments return
          with the rtd instruction, which  pops  their  arguments
          while  returning.   This  saves  one instruction in the
          caller since there is no  need  to  pop  the  arguments
          there.

          This calling convention is incompatible  with  the  one
          normally used on Unix, so you cannot use it if you need
          to call libraries compiled with the Unix compiler.

          Also, you must  provide  function  prototypes  for  all
          functions  that take variable numbers of arguments (in-
          cluding printf); otherwise incorrect code will be  gen-
          erated for calls to those functions.

          In addition, seriously incorrect code  will  result  if
          you  call a function with too many arguments.  (Normal-
          ly, extra arguments are harmlessly ignored.)

          The rtd instruction is supported by the 68010 and 68020
          processors, but not by the 68000.

     These `-m' options are defined for the Vax:

     -munix
          Do not output certain jump instructions (aobleq and  so
          on)  that  the Unix assembler for the Vax cannot handle
          across long ranges.

     -mgnu
          Do output those jump instructions,  on  the  assumption
          that you will assemble with the GNU assembler.

     -mg  Output code for g-format floating point numbers instead
          of d-format.

     These `-m' switches are supported on the SPARC:

     -mfpu

     -mhard-float
          Generate output containing floating point instructions.
          This is the default.

     -mno-fpu

     -msoft-float
          Generate output containing library calls  for  floating
          point.  Warning: there is no GNU floating-point library
          for SPARC.  Normally the facilities  of  the  machine's
          usual  C  compiler  are  used,  but this cannot be done
          directly in cross-compilation.  You must make your  own
          arrangements  to provide suitable library functions for
          cross-compilation.

          -msoft-float changes the calling convention in the out-
          put  file;  therefore, it is only useful if you compile
          all of a program with this option.

     -mno-epilogue

     -mepilogue
          With -mepilogue (the default), the compiler always  em-
          its code for function exit at the end of each function.
          Any function exit in the middle of the  function  (such
          as a return statement in C) will generate a jump to the
          exit code at the end of the function.

          With -mno-epilogue, the compiler  tries  to  emit  exit
          code inline at every function exit.

     -mno-v8

     -mv8

     -msparclite
          These three options select variations on the SPARC  ar-
          chitecture.

          By default  (unless  specifically  configured  for  the
          Fujitsu SPARClite), GCC generates code for the v7 vari-
          ant of the SPARC architecture.

          -mv8 will give you SPARC v8 code.  The only  difference
          from  v7  code  is  that the compiler emits the integer
          multiply and integer divide instructions which exist in
          SPARC v8 but not in SPARC v7.

          -msparclite will give you SPARClite  code.   This  adds
          the  integer  multiply,  integer  divide  step and scan
          (ffs) instructions which exist in SPARClite but not  in
          SPARC v7.

     -mcypress

     -msupersparc
          These two options select the processor  for  which  the
          code is optimised.

          With -mcypress (the default),  the  compiler  optimises
          code  for  the  Cypress  CY7C602  chip,  as used in the
          SparcStation/SparcSever  3xx  series.  This   is   also
          apropriate for the older SparcStation 1, 2, IPX etc.

          With -msupersparc the compiler optimises code  for  the
          SuperSparc  cpu,  as  used in the SparcStation 10, 1000
          and 2000 series. This flag also enables use of the full
          SPARC v8 instruction set.
     These `-m' options are defined for the Convex:

     -mc1 Generate output for a C1.  This is the default when the
          compiler is configured for a C1.

     -mc2 Generate output for a C2.  This is the default when the
          compiler is configured for a C2.

     -margcount
          Generate code which puts an argument count in the  word
          preceding  each argument list.  Some nonportable Convex
          and Vax programs need this word.  (Debuggers don't, ex-
          cept for functions with variable-length argument lists;
          this info is in the symbol table.)

     -mnoargcount
          Omit the argument count word.  This is the  default  if
          you use the unmodified sources.

     These `-m' options are defined for the AMD Am29000:

     -mdw Generate code that assumes the DW  bit  is  set,  i.e.,
          that byte and halfword operations are directly support-
          ed by the hardware.  This is the default.

     -mnodw
          Generate code that assumes the DW bit is not set.

     -mbw Generate code that assumes the system supports byte and
          halfword write operations.  This is the default.

     -mnbw
          Generate code that assumes the systems does not support
          byte  and  halfword  write  operations.   This  implies
          `-mnodw'.

     -msmall
          Use a small memory model that assumes that all function
          addresses  are either within a single 256 KB segment or
          at an absolute address of less than 256K.  This  allows
          the  call  instruction  to  be used instead of a const,
          consth, calli sequence.

     -mlarge
          Do not assume that the call instruction  can  be  used;
          this is the default.

     -m29050
          Generate code for the Am29050.

     -m29000
          Generate code for the Am29000.  This is the default.

     -mkernel-registers
          Generate references to registers gr64-gr95  instead  of
          gr96-gr127.   This  option  can  be used when compiling
          kernel code that wants a set of global  registers  dis-
          joint from that used by user-mode code.

          Note that when this option is used, register  names  in
          `-f' flags must use the normal, user-mode, names.

     -muser-registers
          Use the normal set  of  global  registers,  gr96-gr127.
          This is the default.

     -mstack-check
          Insert a call to __msp_check after each  stack  adjust-
          ment.  This is often used for kernel code.

     These `-m' options are defined for  Motorola  88K  architec-
     tures:

     -m88000
          Generate code that works well on both  the  m88100  and
          the m88110.

     -m88100
          Generate code that works best for the m88100, but  that
          also runs on the m88110.

     -m88110
          Generate code that works best for the m88110,  and  may
          not run on the m88100.

     -midentify-revision
          Include an ident  directive  in  the  assembler  output
          recording  the source file name, compiler name and ver-
          sion, timestamp, and compilation flags used.

     -mno-underscores
          In assembler output, emit symbol names  without  adding
          an  underscore character at the beginning of each name.
          The default is to use an underscore as prefix  on  each
          name.

     -mno-check-zero-division

     -mcheck-zero-division
          Early models of the 88K architecture had problems  with
          division  by  zero;  in particular, many of them didn't
          trap.  Use these options to avoid including (or to  in-
          clude explicitly) additional code to detect division by
          zero and signal an exception.  All  GCC  configurations
          for the 88K use `-mcheck-zero-division' by default.

     -mocs-debug-info

     -mno-ocs-debug-info
          Include  (or  omit)  additional  debugging  information
          (about registers used in each stack frame) as specified
          in the 88Open  Object  Compatibility  Standard,  "OCS".
          This  extra  information is not needed by GDB.  The de-
          fault for DG/UX, SVr4, and Delta 88 SVr3.2  is  to  in-
          clude  this  information; other 88k configurations omit
          this information by default.

     -mocs-frame-position

     -mno-ocs-frame-position
          Force (or do not require) register values to be  stored
          in  a particular place in stack frames, as specified in
          OCS.  The DG/UX, Delta88 SVr3.2, and BCS configurations
          use  `-mocs-frame-position';  other  88k configurations
          have the default `-mno-ocs-frame-position'.

     -moptimize-arg-area

     -mno-optimize-arg-area
          Control  how  to  store  function  arguments  in  stack
          frames.   `-moptimize-arg-area'  saves  space,  but may
          break       some       debuggers       (not       GDB).
          `-mno-optimize-arg-area'  conforms better to standards.
          By default GCC does not optimize the argument area.

     -mshort-data-num
          num Generate smaller data references by making them re-
          lative to r0, which allows loading a value using a sin-
          gle instruction (rather than the usual two).  You  con-
          trol  which  data references are affected by specifying
          num with this option.   For  example,  if  you  specify
          `-mshort-data-512',  then  the data references affected
          are those involving  displacements  of  less  than  512
          bytes.   `-mshort-data-num'  is  not  effective for num
          greater than 64K.

     -mserialize-volatile

     -mno-serialize-volatile
          Do, or do not, generate code  to  guarantee  sequential
          consistency of volatile memory references.

          GNU CC always guarantees consistency  by  default,  for
          the  preferred  processor  submodel.   How this is done
          depends on the submodel.

          The m88100 processor does not reorder memory references
          and  so always provides sequential consistency.  If you
          use `-m88100', GNU CC does not generate any special in-
          structions for sequential consistency.

          The order of memory references made by the m88110  pro-
          cessor  does not always match the order of the instruc-
          tions requesting those references.   In  particular,  a
          load  instruction  may execute before a preceding store
          instruction.  Such reordering violates sequential  con-
          sistency  of volatile memory references, when there are
          multiple  processors.   When  you  use   `-m88000'   or
          `-m88110',  GNU  CC generates special instructions when
          appropriate, to force execution in the proper order.

          The extra code generated to guarantee  consistency  may
          affect  the  performance  of  your application.  If you
          know that you can safely forgo this guarantee, you  may
          use the option `-mno-serialize-volatile'.

          If you use the `-m88100' option but require  sequential
          consistency  when  running on the m88110 processor, you
          should use `-mserialize-volatile'.

     -msvr4

     -msvr3
          Turn on (`-msvr4') or off  (`-msvr3')  compiler  exten-
          sions  related to System V release 4 (SVr4).  This con-
          trols the following:

        o Which variant of the assembler syntax  to  emit  (which
          you can select independently using `-mversion-03.00').

        o `-msvr4' makes the C  preprocessor  recognize  `#pragma
          weak'

        o `-msvr4' makes GCC issue additional declaration  direc-
          tives used in SVr4.

     `-msvr3' is the default for all m88K  configurations  except
     the SVr4 configuration.

     -mtrap-large-shift

     -mhandle-large-shift
          Include code to detect bit-shifts of more than 31 bits;
          respectively,  trap  such shifts or emit code to handle
          them properly.  By default GCC makes no special  provi-
          sion for large bit shifts.

     -muse-div-instruction
          Very early models of the 88K architecture didn't have a
          divide  instruction,  so GCC avoids that instruction by
          default.  Use this option to specify that it's safe  to
          use the divide instruction.

     -mversion-03.00
          In the DG/UX configuration, there are  two  flavors  of
          SVr4.   This  option  modifies -msvr4 to select whether
          the hybrid-COFF or real-ELF flavor is used.  All  other
          configurations ignore this option.

     -mwarn-passed-structs
          Warn when a function passes a struct as an argument  or
          result.   Structure-passing  conventions  have  changed
          during the evolution of the C language, and  are  often
          the  source  of  portability problems.  By default, GCC
          issues no such warning.

     These options are defined for the IBM RS6000:

     -mfp-in-toc

     -mno-fp-in-toc
          Control whether or not floating-point constants  go  in
          the  Table  of  Contents  (TOC),  a table of all global
          variable and function addresses.  By default  GCC  puts
          floating-point  constants  there; if the TOC overflows,
          `-mno-fp-in-toc' will reduce the size of the TOC, which
          may avoid the overflow.

     These `-m' options are defined for the IBM RT PC:

     -min-line-mul
          Use an in-line code sequence  for  integer  multiplies.
          This is the default.

     -mcall-lib-mul
          Call lmul$$ for integer multiples.

     -mfull-fp-blocks
          Generate full-size floating point data blocks,  includ-
          ing  the minimum amount of scratch space recommended by
          IBM.  This is the default.

     -mminimum-fp-blocks
          Do not include extra scratch space  in  floating  point
          data  blocks.  This results in smaller code, but slower
          execution, since scratch space must be allocated dynam-
          ically.

     -mfp-arg-in-fpregs
          Use a calling sequence incompatible with the  IBM  cal-
          ling  convention  in which floating point arguments are
          passed  in  floating  point   registers.    Note   that
          varargs.h  and  stdargs.h  will  not work with floating
          point operands if this option is specified.

     -mfp-arg-in-gregs
          Use the normal calling convention  for  floating  point
          arguments.  This is the default.

     -mhc-struct-return
          Return structures of more  than  one  word  in  memory,
          rather than in a register.  This provides compatibility
          with   the   MetaWare   HighC   (hc)   compiler.    Use
          `-fpcc-struct-return'  for compatibility with the Port-
          able C Compiler (pcc).

     -mnohc-struct-return
          Return some structures of more than one word in  regis-
          ters,  when convenient.  This is the default.  For com-
          patibility with the IBM-supplied compilers, use  either
          `-fpcc-struct-return' or `-mhc-struct-return'.

     These `-m' options are defined for the MIPS family  of  com-
     puters:

     -mcpu=cpu-type
          Assume the defaults for the machine type cpu-type  when
          scheduling  instructions.   The default cpu-type is de-
          fault, which picks the longest cycles times for any  of
          the  machines, in order that the code run at reasonable
          rates on all MIPS cpu's.  Other  choices  for  cpu-type
          are  r2000,  r3000,  r4000, and r6000.  While picking a
          specific cpu-type will  schedule  things  appropriately
          for  that  particular  chip, the compiler will not gen-
          erate any code that does not meet level 1 of  the  MIPS
          ISA  (instruction  set architecture) without the -mips2
          or -mips3 switches being used.

     -mips2
          Issue instructions from level 2 of the MIPS ISA (branch
          likely,  square root instructions).  The -mcpu=r4000 or
          -mcpu=r6000 switch must be  used  in  conjunction  with
          -mips2.

     -mips3
          Issue instructions from level 3 of the MIPS ISA (64 bit
          instructions).   The -mcpu=r4000 switch must be used in
          conjunction with -mips2.

     -mint64

     -mlong64

     -mlonglong128
          These options don't work at present.

     -mmips-as
          Generate  code  for  the  MIPS  assembler,  and  invoke
          mips-tfile  to  add  normal debug information.  This is
          the default for all  platforms  except  for  the  OSF/1
          reference  platform,  using the OSF/rose object format.
          If any of the -ggdb, -gstabs, or -gstabs+ switches  are
          used, the mips-tfile program will encapsulate the stabs
          within MIPS ECOFF.

     -mgas
          Generate code for the GNU assembler.  This is  the  de-
          fault  on  the  OSF/1  reference  platform,  using  the
          OSF/rose object format.

     -mrnames

     -mno-rnames
          The -mrnames switch says to output code using the  MIPS
          software  names  for  the  registers,  instead  of  the
          hardware names (ie, a0 instead of $4).  The GNU  assem-
          bler does not support the -mrnames switch, and the MIPS
          assembler will be instructed to run the MIPS C  prepro-
          cessor over the source file.  The -mno-rnames switch is
          default.

     -mgpopt

     -mno-gpopt
          The -mgpopt switch says to write all of  the  data  de-
          clarations before the instructions in the text section,
          to all the MIPS assembler to generate one  word  memory
          references  instead of using two words for short global
          or static data items.  This is on by default if optimi-
          zation is selected.

     -mstats

     -mno-stats
          For each non-inline  function  processed,  the  -mstats
          switch  causes  the  compiler  to  emit one line to the
          standard error file to print statistics about the  pro-
          gram (number of registers saved, stack size, etc.).

     -mmemcpy

     -mno-memcpy
          The -mmemcpy switch makes all block moves call the  ap-
          propriate  string function (memcpy or bcopy) instead of
          possibly generating inline code.

     -mmips-tfile

     -mno-mips-tfile
          The -mno-mips-tfile  switch  causes  the  compiler  not
          postprocess  the  object  file with the mips-tfile pro-
          gram, after the MIPS assembler has generated it to  add
          debug support.  If mips-tfile is not run, then no local
          variables will be available to the debugger.  In  addi-
          tion, stage2 and stage3 objects will have the temporary
          file names passed to the assembler embedded in the  ob-
          ject file, which means the objects will not compare the
          same.

     -msoft-float
          Generate output containing library calls  for  floating
          point.   WARNING:  the requisite libraries are not part
          of GNU CC.  Normally the facilities  of  the  machine's
          usual  C  compiler  are  used,  but  this can't be done
          directly in cross-compilation.  You must make your  own
          arrangements  to provide suitable library functions for
          cross-compilation.

     -mhard-float
          Generate output containing floating point instructions.
          This is the default if you use the unmodified sources.

     -mfp64
          Assume that the FR bit in the status word  is  on,  and
          that  there are 32 64-bit floating point registers, in-
          stead of 32 32-bit floating point registers.  You  must
          also specify the -mcpu=r4000 and -mips3 switches.

     -mfp32
          Assume that there are 32 32-bit floating  point  regis-
          ters.  This is the default.

     -mabicalls

     -mno-abicalls
          Emit (or do  not  emit)  the  .abicalls,  .cpload,  and
          .cprestore pseudo operations that some System V.4 ports
          use for position independent code.

     -mhalf-pic

     -mno-half-pic
          The -mhalf-pic switch says to put  pointers  to  extern
          references  into  the  data  section  and load them up,
          rather than put the references  in  the  text  section.
          This option does not work at present.  -Gnum Put global
          and static items less than or equal to num  bytes  into
          the  small  data  or bss sections instead of the normal
          data or bss section.  This allows the assembler to emit
          one  word  memory  reference  instructions based on the
          global pointer (gp or $28), instead of the  normal  two
          words  used.  By default, num is 8 when the MIPS assem-
          bler is used, and 0 when the  GNU  assembler  is  used.
          The  -Gnum  switch  is also passed to the assembler and
          linker.  All modules should be compiled with  the  same
          -Gnum value.

     -nocpp
          Tell the MIPS assembler to not  run  it's  preprocessor
          over user assembler files (with a `.s' suffix) when as-
          sembling them.

     These `-m' options are defined for the Intel 80386 family of
     computers: -m486

     -mno-486
          Control whether or not code is optimized for a 486  in-
          stead  of an 386.  Code generated for a 486 will run on
          a 386 and vice versa.

     -msoft-float
          Generate output containing library calls  for  floating
          point.   Warning:  the requisite libraries are not part
          of GNU CC.  Normally the facilities  of  the  machine's
          usual  C  compiler  are  used,  but  this can't be done
          directly in cross-compilation.  You must make your  own
          arrangements  to provide suitable library functions for
          cross-compilation.

          On machines where a  function  returns  floating  point
          results  in  the  80387  register  stack, some floating
          point opcodes may be emitted even if `-msoft-float'  is
          used.

     -mno-fp-ret-in-387
          Do not use the FPU registers for return values of func-
          tions.

          The  usual  calling  convention  has  functions  return
          values  of  types  float and double in an FPU register,
          even if there is no FPU.  The idea is that the  operat-
          ing system should emulate an FPU.

          The option `-mno-fp-ret-in-387' causes such  values  to
          be returned in ordinary CPU registers instead.

     These `-m' options are defined for the HPPA family  of  com-
     puters:

     -mpa-risc-1-0
          Generate code for a PA 1.0 processor.

     -mpa-risc-1-1
          Generate code for a PA 1.1 processor.

     -mkernel
          Generate code which is suitable  for  use  in  kernels.
          Specifically,  avoid  add  instructions in which one of
          the arguments is the DP register;  generate  addil  in-
          structions  instead.   This avoids a rather serious bug
          in the HP-UX linker.

     -mshared-libs
          Generate code that can be linked against  HP-UX  shared
          libraries.   This option is not fully function yet, and
          is not on by default for any PA target.  Using this op-
          tion  can  cause  incorrect code to be generated by the
          compiler.

     -mno-shared-libs
          Don't generate code that will be linked against  shared
          libraries.  This is the default for all PA targets.

     -mlong-calls
          Generate code which allows calls to  functions  greater
          than 256K away from the caller when the caller and cal-
          lee are in the same source file.  Do not turn this  op-
          tion on unless code refuses to link with "branch out of
          range errors from the linker.

     -mdisable-fpregs
          Prevent floating point registers from being used in any
          manner.   This is necessary for compiling kernels which
          perform lazy context switching of floating point regis-
          ters.   If  you  use this option and attempt to perform
          floating point operations, the compiler will abort.

     -mdisable-indexing
          Prevent the compiler from using indexing address modes.
          This avoids some rather obscure problems when compiling
          MIG generated code under MACH.

     -mtrailing-colon
          Add a colon to the end of label  definitions  (for  ELF
          assemblers).

     These `-m' options are defined for the Intel 80960 family of
     computers:

     -mcpu-type
          Assume the defaults for the machine type  cpu-type  for
          instruction and addressing-mode availability and align-
          ment.  The default cpu-type is kb;  other  choices  are
          ka, mc, ca, cf, sa, and sb.

     -mnumerics

     -msoft-float
          The -mnumerics option indicates that the processor does
          support  floating-point instructions.  The -msoft-float
          option indicates that floating-point support should not
          be assumed.

     -mleaf-procedures

     -mno-leaf-procedures
          Do (or do not) attempt to alter leaf procedures  to  be
          callable  with  the  bal  instruction  as well as call.
          This will result in more efficient  code  for  explicit
          calls  when  the  bal instruction can be substituted by
          the assembler or linker, but  less  efficient  code  in
          other  cases,  such  as calls via function pointers, or
          using a linker that doesn't support this optimization.

     -mtail-call

     -mno-tail-call
          Do (or do not) make additional attempts  (beyond  those
          of the machine-independent portions of the compiler) to
          optimize tail-recursive calls into branches.   You  may
          not  want  to  do  this  because the detection of cases
          where this is not valid is not totally  complete.   The
          default is -mno-tail-call.

     -mcomplex-addr

     -mno-complex-addr
          Assume (or do not assume) that the use of a complex ad-
          dressing  mode  is  a win on this implementation of the
          i960.  Complex addressing modes may not  be  worthwhile
          on  the  K-series,  but  they  definitely are on the C-
          series.  The default is  currently  -mcomplex-addr  for
          all processors except the CB and CC.

     -mcode-align

     -mno-code-align
          Align code to 8-byte boundaries for faster fetching (or
          don't  bother).   Currently turned on by default for C-
          series implementations only.

     -mic-compat

     -mic2.0-compat

     -mic3.0-compat
          Enable compatibility with iC960 v2.0 or v3.0.

     -masm-compat

     -mintel-asm
          Enable compatibility with the iC960 assembler.

     -mstrict-align

     -mno-strict-align
          Do not permit (do permit) unaligned accesses.

     -mold-align
          Enable structure-alignment compatibility  with  Intel's
          gcc release version 1.3 (based on gcc 1.37).  Currently
          this is buggy in that #pragma align 1 is always assumed
          as well, and cannot be turned off.

     These `-m' options are defined for the DEC Alpha implementa-
     tions:

     -mno-soft-float

     -msoft-float
          Use (do not use) the hardware  floating-point  instruc-
          tions for floating-point operations.  When -msoft-float
          is specified, functions in `libgcc1.c' will be used  to
          perform floating-point operations.  Unless they are re-
          placed by  routines  that  emulate  the  floating-point
          operations,  or  compiled in such a way as to call such
          emulations  routines,   these   routines   will   issue
          floating-point  operations.    If you are compiling for
          an Alpha without floating-point  operations,  you  must
          ensure  that  the  library  is  built so as not to call
          them.

          Note that Alpha implementations without  floating-point
          operations  are  required to have floating-point regis-
          ters.

     -mfp-reg

     -mno-fp-regs
          Generate code that uses (does not  use)  the  floating-
          point register set.  -mno-fp-regs implies -msoft-float.
          If the floating-point register set is not used,  float-
          ing  point  operands are passed in integer registers as
          if they were integers and  floating-point  results  are
          passed  in  $0  instead of $f0.  This is a non-standard
          calling sequence, so any function with a floating-point
          argument  or  return value called by code compiled with
          -mno-fp-regs must also be compiled with that option.

          A typical use of this option is building a kernel  that
          does  not use, and hence need not save and restore, any
          floating-point registers.

     These additional options are available on System V Release 4
     for compatibility with other compilers on those systems:

     -G   On SVr4 systems,  gcc  accepts  the  option  `-G'  (and
          passes it to the system linker), for compatibility with
          other compilers.  However, we suggest you use `-symbol-
          ic'  or  `-shared' as appropriate, instead of supplying
          linker options on the gcc command line.

     -Qy  Identify the versions of each tool  used  by  the  com-
          piler, in a .ident assembler directive in the output.

     -Qn  Refrain from adding .ident  directives  to  the  output
          file (this is the default).

     -YP,dirs
          Search the directories dirs, and  no  others,  for  li-
          braries specified with `-l'.  You can separate directo-
          ry entries in dirs from one another with colons.

     -Ym,dir
          Look in the directory dir to find the M4  preprocessor.
          The assembler uses this option.

CODE GENERATION OPTIONS
     These machine-independent options control the interface con-
     ventions used in code generation.

     Most of them begin with `-f'.  These options have both posi-
     tive  and negative forms; the negative form of `-ffoo' would
     be `-fno-foo'.  In the table below, only one of the forms is
     listed-the one which is not the default.  You can figure out
     the other form by either removing `no-' or adding it.

     -fnonnull-objects
          Assume that objects reached through references are  not
          null (C++ only).

          Normally, GNU C++ makes conservative assumptions  about
          objects  reached  through references.  For example, the
          compiler must check that a is not null in code like the
          following:

          obj &a = g (); a.f (2);

          Checking that references of  this  sort  have  non-null
          values requires extra code, however, and it is unneces-
          sary  for  many  programs.   You  can  use  `-fnonnull-
          objects'  to  omit the checks for null, if your program
          doesn't require checking.

     -fpcc-struct-return
          Use the same convention for returning struct and  union
          values  that  is  used  by the usual C compiler on your
          system.  This convention is less  efficient  for  small
          structures,  and  on many machines it fails to be reen-
          trant; but it has the advantage of allowing intercalla-
          bility between GCC-compiled code and PCC-compiled code.

     -freg-struct-return
          Use the convention that struct and union values are re-
          turned  in registers when possible.  This is more effi-
          cient for small structures than -fpcc-struct-return.

          If  you   specify   neither   -fpcc-struct-return   nor
          -freg-struct-return,  GNU CC defaults to whichever con-
          vention is standard for the target.   If  there  is  no
          standard     convention,    GNU    CC    defaults    to
          -fpcc-struct-return.

     -fshort-enums
          Allocate to an enum type only as many bytes as it needs
          for the declared range of possible values.  Specifical-
          ly, the enum type will be equivalent  to  the  smallest
          integer type which has enough room.

     -fshort-double
          Use the same size for double as for float .

     -fshared-data
          Requests that the data and non-const variables of  this
          compilation  be  shared  data rather than private data.
          The distinction makes sense only on  certain  operating
          systems,  where shared data is shared between processes
          running the same program, while private data exists  in
          one copy per process.

     -fno-common
          Allocate even uninitialized global variables in the bss
          section of the object file, rather than generating them
          as common blocks.  This has the effect that if the same
          variable  is declared (without extern) in two different
          compilations, you will get an error when you link them.
          The  only reason this might be useful is if you wish to
          verify that the program  will  work  on  other  systems
          which always work this way.

     -fno-ident
          Ignore the `#ident' directive.

     -fno-gnu-linker
          Do not output global initializations (such as C++  con-
          structors  and destructors) in the form used by the GNU
          linker (on systems where the GNU linker is the standard
          method  of  handling  them).   Use this option when you
          want to use a non-GNU linker, which also requires using
          the collect2 program to make sure the system linker in-
          cludes constructors and destructors.  (collect2 is  in-
          cluded  in the GNU CC distribution.)  For systems which
          must use collect2, the compiler driver gcc  is  config-
          ured to do this automatically.

     -finhibit-size-directive
          Don't output a .size assembler directive,  or  anything
          else  that would cause trouble if the function is split
          in the middle, and the two halves are placed  at  loca-
          tions  far  apart  in memory.  This option is used when
          compiling `crtstuff.c'; you should not need to  use  it
          for anything else.

     -fverbose-asm
          Put extra commentary information in the  generated  as-
          sembly  code  to make it more readable.  This option is
          generally only of use to those  who  actually  need  to
          read  the generated assembly code (perhaps while debug-
          ging the compiler itself).

     -fvolatile
          Consider all memory references through pointers  to  be
          volatile.

     -fvolatile-global
          Consider all memory references  to  extern  and  global
          data items to be volatile.

     -fpic
          If  supported  for  the   target   machines,   generate
          position-independent code, suitable for use in a shared
          library.

     -fPIC
          If supported for the  target  machine,  emit  position-
          independent code, suitable for dynamic linking, even if
          branches need large displacements.

     -ffixed-reg
          Treat the register named reg as a fixed register;  gen-
          erated code should never refer to it (except perhaps as
          a stack pointer, frame pointer or in some  other  fixed
          role).

          reg must be the name of a register.  The register names
          accepted  are  machine-specific  and are defined in the
          REGISTER_NAMES macro in the machine  description  macro
          file.

          This flag does not have a  negative  form,  because  it
          specifies a three-way choice.

     -fcall-used-reg
          Treat the register named reg as an allocatable register
          that  is  clobbered by function calls.  It may be allo-
          cated for temporaries or variables  that  do  not  live
          across  a  call.   Functions compiled this way will not
          save and restore the register reg.

          Use of this flag for a register that has a  fixed  per-
          vasive  role  in the machine's execution model, such as
          the stack pointer or frame pointer, will produce disas-
          trous results.

          This flag does not have a  negative  form,  because  it
          specifies a three-way choice.

     -fcall-saved-reg
          Treat the register named reg as an allocatable register
          saved  by functions.  It may be allocated even for tem-
          poraries or variables that live across a  call.   Func-
          tions  compiled  this way will save and restore the re-
          gister reg if they use it.

          Use of this flag for a register that has a  fixed  per-
          vasive  role  in the machine's execution model, such as
          the stack pointer or frame pointer, will produce disas-
          trous results.

          A different sort of disaster will result from  the  use
          of  this  flag  for a register in which function values
          may be returned.

          This flag does not have a  negative  form,  because  it
          specifies a three-way choice.

PRAGMAS
     Two `#pragma' directives are supported for GNU C++, to  per-
     mit using the same header file for two purposes: as a defin-
     ition of interfaces to a given object class, and as the full
     definition of the contents of that object class.

     #pragma interface
          (C++ only.) Use this directive in header files that de-
          fine  object  classes, to save space in most of the ob-
          ject files that use  those  classes.   Normally,  local
          copies  of certain information (backup copies of inline
          member functions, debugging information, and the inter-
          nal  tables  that  implement virtual functions) must be
          kept in each object file that  includes  class  defini-
          tions.   You can use this pragma to avoid such duplica-
          tion.  When a header file  containing  `#pragma  inter-
          face'  is included in a compilation, this auxiliary in-
          formation will not be generated (unless the main  input
          source file itself uses `#pragma implementation').  In-
          stead, the object files will contain references  to  be
          resolved at link time.

     #pragma implementation

     #pragma implementation "objects.h"
          (C++ only.) Use this pragma in a main input file,  when
          you  want  full output from included header files to be
          generated (and made globally  visible).   The  included
          header  file,  in turn, should use `#pragma interface'.
          Backup copies of inline member functions, debugging in-
          formation,  and  the  internal tables used to implement
          virtual functions are all generated  in  implementation
          files.

          If you use `#pragma implementation' with  no  argument,
          it applies to an include file with the same basename as
          your  source  file;  for  example,  in   `allclass.cc',
          `#pragma  implementation'  by  itself  is equivalent to
          `#pragma implementation "allclass.h"'.  Use the  string
          argument  if  you  want a single implementation file to
          include code from multiple header files.

          There is no way to split up the contents  of  a  single
          header file into multiple implementation files.

FILES
     file.c             C source file
     file.h             C header (preprocessor) file
     file.i             preprocessed C source file
     file.C             C++ source file
     file.cc            C++ source file
     file.cxx           C++ source file
     file.m             Objective-C source file
     file.s             assembly language file
     file.o             object file
     a.out              link edited output
     TMPDIR/cc*         temporary files
     LIBDIR/cpp         preprocessor
     LIBDIR/cc1         compiler for C
     LIBDIR/cc1plus     compiler for C++
     LIBDIR/collect     linker front end needed on some machines
     LIBDIR/libgcc.a    GCC subroutine library
     /lib/crt[01n].o    start-up routine
     LIBDIR/ccrt0       additional start-up routine for C++
     /lib/libc.a        standard C library, see
     intro(3)
     /usr/include       standard directory for #include files
     LIBDIR/include     standard gcc directory for #include files
     LIBDIR/g++-include additional g++ directory for #include

     LIBDIR is usually /usr/local/lib/machine/version.
     TMPDIR comes from the environment variable  TMPDIR  (default
     /usr/tmp if available, else /tmp).

SEE ALSO
     cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1).
     `gcc', `cpp', `as', `ld', and `gdb' entries in info.
     Using and Porting GNU  CC  (for  version  2.0),  Richard  M.
     Stallman; The C Preprocessor, Richard M. Stallman; Debugging
     with GDB: the GNU Source-Level Debugger, Richard M. Stallman
     and  Roland H. Pesch; Using as: the GNU Assembler, Dean Els-
     ner, Jay Fenlason & friends; ld: the GNU linker, Steve Cham-
     berlain and Roland Pesch.

BUGS
     For instructions on reporting bugs, see the GCC manual.

COPYING
     Copyright 1991, 1992, 1993 Free Software Foundation, Inc.

     Permission is granted to make and distribute verbatim copies
     of  this  manual provided the copyright notice and this per-
     mission notice are preserved on all copies.

     Permission is granted to copy and distribute  modified  ver-
     sions of this manual under the conditions for verbatim copy-
     ing, provided that the entire resulting derived work is dis-
     tributed under the terms of a permission notice identical to
     this one.

     Permission is granted to copy and distribute translations of
     this  manual  into  another language, under the above condi-
     tions for modified versions, except that this permission no-
     tice  may  be  included in translations approved by the Free
     Software Foundation instead of in the original English.

AUTHORS
     See the GNU CC Manual for the contributors to GNU CC.


grep(1)                                                               grep(1)

NAME

  grep, egrep, fgrep - Searches a file for a pattern

SYNOPSIS

  grep [-E | -F] [-c | -l | -q] [-bhinsvwxy] [-p paragraph_separator] pattern
  | -e pattern | -f pattern_file [file ... ]

  egrep [-c | -l | -q] [-bhinsvwxy] pattern | -e pattern | -f pattern_file
  [file ... ]

  fgrep [-c | -l | -q] [-bhinsvwxy] pattern | -e pattern | -f pattern_file
  [file ... ]

  The grep, egrep, and fgrep commands search the specified files (standard
  input by default) for lines containing characters that match the specified
  pattern, and then write matching lines to standard output.

FLAGS

  While most flags can be combined, some combinations result in one flag
  overriding another.  For example, if you specify -n and -l, the output
  includes filenames only (as specified by -l) and thus does not include line
  numbers (as specified by -n).

  -b  Precedes each line by the block number on which it was found.  Use this
      flag to help find disk block numbers by context.

  -c  Displays only a count of matching lines.

  -e pattern
      Specifies a pattern.  This works the same as a simple pattern, but is
      useful when the pattern begins with a - (dash).

  -E  Uses Extended Regular Expressions (EREs) to match patterns.  (Treats
      each pattern as an ERE.)

  -f pattern_file
      Specifies a file that contains patterns.

  -F  Uses fixed strings to match patterns.  (Treats each pattern as a
      literal string instead of as a regular expression.)

  -h  Suppresses reporting of filenames when multiple files are processed.

  -i  Ignores the case of letters in locating pattern; that is, uppercase and
      lowercase letters in the input are considered to be identical.  (Same
      as -y.)

  -l  Lists the name of each file with lines matching pattern.  Each filename
      is listed only once; filenames are separated by newline characters.

  -n  Precedes each line with its relative line number in the file.

  -p paragraph_separator
      Displays the entire paragraph containing matched lines.  Paragraphs are
      delimited by paragraph separators, paragraph_separator, which are pat-
      terns in the same form as the search pattern.  Lines containing the
      paragraph separators are used only as separators; they are never
      included in the output.  The default paragraph separator is a blank
      line.

  -q  Suppresses all output except error messages.  This is useful for check-
      ing status.

  -s  Supresses error messages about inaccessible files.

  -v  Displays all lines except those that match the specified pattern.  Use-
      ful for filtering unwanted lines out of a file.

  -w  The expression is searched for as a word (the pattern bracketed by
      nonalphanumeric characters or by the beginning or end of the line).
      See ex.

  -x  Displays lines that match the pattern exactly with no additional char-
      acters.

  -y  Ignores the case of letters in locating pattern; that is, uppercase and
      lowercase letters in the input are considered to be identical.  (Same
      as -i.)

DESCRIPTION

  Three versions of the grep command permit you to specify the matching pat-
  tern in varying levels of complexity:
  The grep command searches for patterns that are limited regular expressions
  as described under Regular Expressions.

  The grep command can perform the same searches as the egrep and fgrep com-
  mands, using the -E and -F flags, respectively.

  egrep
  The egrep command searches for patterns that are full regular expressions,
  except for \( and \) and with the addition of the following rules:

    o  A regular expression followed by a + (plus sign) matches one or more
       occurrences of the regular expression.

    o  A regular expression followed by a ? (question mark) matches zero or
       one occurrence of the regular expression.

    o  Two regular expressions separated by a | (vertical bar) or by a new-
       line character match either expression.

    o  A regular expression can be enclosed in ( ) (parentheses) for group-
       ing.

  The order of precedence of operators is [], then *, ?, and +, then concate-
  nation, then | and the newline character.

  The egrep command uses a deterministic algorithm that needs exponential
  space.

  fgrep
  The fgrep command searches for patterns that are fixed strings.

  Command Usage
  All versions of grep precede the matched line with the name of the file
  containing it if you specify more than one file (except when the -h flag is
  specified).

  Lines are limited to 2048 bytes; longer lines are broken into multiple
  lines of 2048 or fewer bytes. Paragraphs (under the -p flag) are currently
  limited to a length of 5000 bytes.

  Running grep on a non-text file (for example, an .o file) produces
  unpredictable results and is discouraged.

  Regular Expressions (REs)
  The following REs match a single character:

  character
      An ordinary character (one other than one of the special pattern-
      matching characters) matches itself.

  .   A . (dot) matches any single character except for the newline charac-
      ter.

  [string]
      A string enclosed in [ ] (brackets) matches any one character in that
      string.  In addition, certain pattern-matching characters have special
      meanings within brackets:

      ^   If the first character of string is a ^ (circumflex), the RE
          [^string] matches any character except the characters in string and
          the newline character.  A ^ has this special meaning only if it
          occurs first in the string.

      -   You can use a - (dash) to indicate a range of consecutive charac-
          ters.  The characters that fall within a range are determined by
          the current collating sequence, which is defined by the LC_COLLATE
          environment variable. For example, [a-d] is equivalent to [abcd] in
          the traditional ASCII collating sequence, but if you were using
          French collation rules, it would be equivalent to [abcd].
          A range can include a multicharacter collating element enclosed
          within bracket-period delimiters ([. .]). These collating symbols
          are necessary for languages that treat some strings as individual
          collating elements. For example, in Spanish, the strings ch and ll
          each are collating symbols (that is, the Spanish primary sort order
          is a, b, c, ch, d,...,k, l, ll, m,...). The bracket-period delim-
          iters in the RE syntax distinguish multicharacter collating ele-
          ments from a list of the individual characters that make up the
          element.  When using Spanish collation rules, [[.ch.]] is treated
          as an RE matching the sequence ch, while [ch] is treated as an RE
          matching c or h. In addition, [a-[.ch.]] matches a, b, c, and ch.
          A collating sequence can define equivalence classes for characters.
          An equivalence class is a set of collating elements that all sort
          to the same primary location. They are enclosed within bracket-
          equal delimiters ([= =]). An equivalence class generally is
          designed to deal with primary-secondary sorting; that is, for
          languages like French that define groups of characters as sorting
          to the same primary location, and then having a tie-breaking,
          secondary sort. For example, if e, , and  belong to the same
          equivalence class, then [[=e=]fg, [[==]fg], and [[==]fg] are each
          equivalent to [efg].
          The - (dash) character loses its special meaning if it occurs first
          ([-string]), if it immediately follows an initial circumflex
          ([^-string]), or if it appears last ([string-]) in the string.

      ]   When the ] (right bracket) is the first character in the string
          ([]string]) or when it immediately follows an initial circumflex
          ([^]string]), it is treated as a part of the string rather than as
          the string terminator.

  \special_character
      A \ (backslash) followed by a special pattern-matching character
      matches the special character itself (as a literal character).  These
      special pattern-matching characters are as follows:

      . * [ \
          Always special, except when they appear within [ ] (brackets).

      ^   Special at the beginning of an entire pattern or when it immedi-
          ately follows the left bracket of a pair of brackets ([^...]).

      $   Special at the end of an entire pattern.

  [: :]
      A character class name enclosed in bracket-colon delimiters matches any
      of the set of characters in the named class. Members of each of the
      sets are determined by the current setting of the LC_CTYPE environment
      variable. The supported classes are: alpha, upper, lower, digit, alnum,
      xdigit, space, print, punct, graph, cntrl. Here is an example of how to
      specify one of these classes:
      [[:lower:]]

      This matches any lowercase character for the current locale.

  Forming Patterns
  The following rules describe how to form patterns from REs:

    o  An RE that consists of a single, ordinary character matches that same
       character in a string.

    o  An RE followed by an * (asterisk) matches zero or more occurrences of
       the character that the RE matches.  For example, the following pat-
       tern:
       ab*cd

       matches each of the following strings:
       acd
       abcd
       abbcd
       abbbcd

       but not the following string:
       abd

       If there is any choice, the longest matching leftmost string is
       chosen.  For example, given the following string:
       122333444

       the pattern .* matches 122333444, the pattern .*3 matches 122333, and
       the pattern .*2 matches 122.

    o  An RE followed by:

       \{number\}
           Matches exactly number occurrences of the character matched by the
           RE.

       \{number,\}
           Matches at least number occurrences of the character matched by
           the RE.

       \{number1,number2\}
           Matches any number of occurrences of the character matched by the
           RE from number1 to number2, inclusive.
           The values of number1 and number2 must be integers from 0 to 255,
           inclusive.  Whenever a choice exists, this pattern matches as many
           occurrences as possible.
           Note that if number is 0 (zero), pattern matches the beginning of
           the line.

    o  You can combine REs into patterns that match strings containing the
       same sequence of characters.  For example, ABD matches the string
       AB*CD and [A-Za-z]*[0-9]* matches any string that contains any combi-
       nation of ASCII alphabetic characters (including none), followed by
       any combination of numerals (including none).

    o  The character sequence \(pattern\) matches pattern and saves it into a
       numbered holding space.  Using this sequence, up to nine patterns can
       be saved on a line.  Counting from left to right on the line, the
       first pattern saved is placed in the first holding space, the second
       pattern is placed in the second holding space, and so on.
       The character sequence \n matches the nth saved pattern, which is
       placed in the nth holding space.  (The value of n is a digit, 1-9.)
       Thus, the following pattern:
       \(A\)\(B\)C\2\1

       matches the string ABCBA.  You can nest patterns to be saved in hold-
       ing spaces.  Whether the enclosed patterns are nested or in a series,
       \n refers to the nth occurrence, counting from the left, of the delim-
       iting characters, \).

  Restricting What Patterns Match
  A pattern can be restricted to match from the beginning of a line, up to
  the end of the line, or the entire line:

    o  A ^ (circumflex) at the beginning of a pattern causes the pattern to
       match only a string that begins in the first character position on a
       line.

    o  A $ (dollar sign) at the end of a pattern causes that pattern to match
       only if the last matched character is the last character (not includ-
       ing the newline character) on a line.

    o  The construction ^pattern$ restricts the pattern to matching only an
       entire line.

EXAMPLES

   1.  To search several files for a string of characters, enter:
       grep  -F 'strcpy'  *.c

       This searches for the string strcpy in all files in the current direc-
       tory with names ending in .c.

   2.  To count the number of lines that match a pattern, enter:
       grep  -c  -F '{'  pgm.c
       grep  -c  -F '}'  pgm.c

       This displays the number of lines in pgm.c that contain left and right
       braces.
       If you do not put more than one { or } on a line in your C programs,
       and if the braces are properly balanced, then the two numbers
       displayed will be the same.  If the numbers are not the same, then you
       can display the lines that contain braces in the order that they occur
       in the file with the command:
       grep -n -E '{|}'  pgm.c
   3.  To display all lines in a file that begin with an ASCII letter, enter:
       grep  '^[a-zA-Z]'  pgm.s

       Note that because grep -F searches only for fixed strings and does not
       interpret pattern-matching characters, the following command causes
       grep to search only for the literal string ^[a-zA-Z] in pgm.s:
       grep  -F '^[a-zA-Z]'  pgm.s
   4.  To display all lines that contain ASCII letters in parentheses or
       digits in parentheses (with spaces optionally preceding and following
       the letters or digits), but not letter-digit combinations in
       parentheses, enter:
       grep -E \
       '\(  *([a-zA-Z]*|[0-9]*)  *\)'  my.txt

       This command displays lines in my.txt such as (y) or (  783902), but
       not (alpha19c).
       Note that with grep -E, \( and \) match parentheses in the text and (
       and ) are special characters that group parts of the pattern.  With
       simply grep, the reverse is true; use ( and ) to match parentheses and
       \( and \) to group characters.

   5.  To display all lines that do not match a pattern, enter:
       grep  -v  '^#'

       This displays all lines that do not begin with a # (number sign).

   6.  To display the names of files that contain a pattern, enter:
       grep  -l  -F 'rose'  *.list

       This searches the files in the current directory that end with .list
       and displays the names of those files that contain at least one line
       containing the string rose.

   7.  To display all lines that contain uppercase characters, enter:
       grep '[[:upper:]]' pgm.s
   8.  To display all lines that begin with a range of characters that
       includes a multicharacter collating symbol, enter:
       grep '^[a-[.ch.]]' pgm.s

       With your locale set to a Spanish locale, this command matches all
       lines that begin with a, b, c, or ch.

EXIT VALUES

  The exit values of the grep, egrep, and fgrep commands are as follows:

  0   A match was found.

  1   No match was found.

  2   A syntax error was found or a file was inaccessible, even if matches
      were found.
RELATED INFORMATION

  Commands:  ed(1)/red(1), ex(1), sed(1), sh(1).

  "Using Internationalization Features" in the OSF/1 User's Guide.


head(1)                                                               head(1)

NAME
  head - Displays the beginning of files

SYNOPSIS

  head [-c bytes] [-n lines] [-][lines] [file ...]

  The head command prints the first count lines of each of the specified
  files to standard output.

FLAGS

  -c bytes
      Specifies the number of bytes (not characters) to display.

  -n lines
      Specifies the number of lines to display.  The default lines is 10.

  -lines
      Specifies the number of lines to display.  The default lines is 10.
      (Obsolescent)

DESCRIPTION

  If you do not specify a file, head reads standard input.

EXAMPLES

  To display the first 5 lines of a file called test, enter:
  head -5 test
RELATED INFORMATION

  Commands:  cat(1), more(1), page(1), pg(1), tail(1).


hostname(1)                                                       hostname(1)

NAME

  hostname - Sets or displays the name of the current host system

SYNOPSIS

  hostname [new_name]

DESCRIPTION

  The hostname command sets or displays the name of the current host system.
  Only the superuser can set the hostname.

EXAMPLES

   1.  To display the name of the local host, enter:
       $ hostname
       host1
   2.  To change the name of the local host, enter:
       # hostname west
FILES

  /etc/hosts
         Defines the Interface Program name and address of the local host.

RELATED INFORMATION

  Commands: hostid(1).

  Functions:  gethostname(2), sethostname(2).


kill(1)                                                               kill(1)

NAME

  kill - Sends a signal to a running process

SYNOPSIS

  kill -l [exit_status]

  kill -s signal_name process_ID ...

  kill [-signal_name | -signal_number] process_ID ...

  The kill command sends a signal to one or more running processes, by
  default the SIGTERM signal (signal number 15).

FLAGS

  -l [exit_status]
      Lists signal names.  If you specify an exit status (a numeric value) or
      the shell special parameter $?, which expands to the exit status of the
      most recent pipeline, kill prints the name of the terminating signal.

  -s signal_name
      Specifies the signal to send, using one of the symbolic names defined
      for required signals or job control signals.  Values of signal_name are
      recognized in both uppercase or lowercase letters, and without the SIG
      prefix.  The symbolic name 0 (zero), which represents the value 0
      (zero), is also recognized.  The corresponding signal is sent instead
      of SIGTERM.

  -signal_name

  -signal_number
      Specifies the signal to send to the process.  You can specify either a
      name, stripped of the SIG prefix (such as KILL), or a number (such as
      9).  For information about signal names and numbers, see the sigac-
      tion() system call.  (Obsolescent)

DESCRIPTION

  SIGTERM normally terminates processes that do not ignore or catch the sig-
  nal.

  Specify the processes to be signaled by giving their process identification
  numbers (also known as process IDs or PIDs).  The shell reports the PID of
  each process that is running in the background (unless you start more than
  one process in a pipeline, in which case the shell reports the number of
  the last process).  You can also use the ps command to find the process ID
  of commands.

  Specify the signal to send with -s signal_name.  In particular, SIGKILL
  (specified as -s KILL) terminates all running processes, including those
  not terminated by the default SIGTERM.  Note that all numeric signal
  specifications except for 0 (zero) are obsolescent.

  Unless you are are operating with superuser authority, the process you wish
  to signal must belong to you.  When operating with superuser authority, you
  can signal any process.

  See the kill() system call for a complete discussion of kill.  (Note that
  the csh command contains a built-in subcommand named kill, but the command
  and subcommand do not necessarily work in the same way.  For information on
  the subcommand, see csh.)

  Special Process IDs
  There are several special process IDs you can specify to cause the follow-
  ing special actions:

  0   The signal is sent to all processes having a process group ID equal to
      the process group ID of the sender, except those with PIDs 0 and 1.

  -1  If the effective user ID of the sender is not 0 (root), the signal is
      sent to all processes with a process group ID equal to the effective
      user ID of the sender, except those with PIDs 0 and 1.
      If the effective user ID of the sender is 0 (root), the signal is sent
      to all processes, excluding numbers 0 and 1.

  -PID
      The signal is sent to all processes whose process group number is equal
      to the absolute value of PID.

  Note that when you specify any negative PID, you must also specify the sig-
  nal to be sent, even the default signal SIGTERM.

EXAMPLES

   1.  To terminate a given process, enter:
       kill 1095

       This terminates process 1095 by sending it the default SIGTERM signal.
       Note that process 1095 might not actually terminate if it has made
       special arrangements to ignore or catch the SIGTERM signal.

   2.  To terminate several processes that ignore the default signal, enter:
       kill -s KILL 17285 15692

       This sends SIGKILL to processes 17285 and 15692.  SIGKILL is a special
       signal that normally cannot be ignored or caught.

   3.  To terminate all of your background processes, enter:
       kill 0

       This sends the SIGTERM signal to all members of the shell process
       group.  This includes all background processes started with &.
       Although the signal is sent to the shell, it has no effect because the
       shell ignores the default signal 15.

   4.  To terminate all your processes and log yourself out, enter:
       kill -s KILL 0

       This sends SIGKILL to all members of the shell process group.  Because
       the shell cannot ignore SIGKILL, this also terminates the login shell
       and logs you out.  If you are using multiple windows, this closes the
       active window.

   5.  To terminate all processes that you own, enter:
       kill -s KILL -1

       This sends SIGKILL to all processes owned by you, even those that
       belong to other process groups.  If you are using multiple windows,
       this closes all the windows.

   6.  To send the default signal SIGTERM with a negative PID such as -1, you
       must specify the signal explicitly:
       kill -s TERM -1
   7.  To send a different signal to a process, enter:
       kill -s USR1 1103

       This sends the SIGUSR1 signal to process 1103.  The action taken on
       the SIGUSR1 signal is defined by the particular application you are
       running.  (The name of the kill command is misleading because many
       signals, including SIGUSR1, do not terminate processes.)

   8.  To list the signal names in numerical order, stripped of the SIG pre-
       fix, enter:
       kill -l

       This results in the following:
       HUP     KILL    STOP    XFSZ
       INT     BUS     TSTP    VTALRM
       QUIT    SEGV    CONT    PROF
       ILL     SYS     CHLD    WINCH
       TRAP    PIPE    TTIN    USR1
       IOT     ALRM    TTOU    USR2
       EMT     TERM    IO
       FPE     URG     XCPU

       This list may vary from system to system.

FILES

  /usr/include/signal.h
             Specifies signal names.

RELATED INFORMATION

  Commands:  csh(1), killall(8), ksh(1), ps(1), sh(1).

  Functions: kill(2), sigaction(2).


ksh(1)                                                                 ksh(1)

NAME

  ksh - Korn shell

SYNOPSIS

  ksh [-ir] [-c command_string | -s] [+ | -aefhkmnopstuvx] [+ | -o][option
       ...]
       | [+ | -A name] [argument ...] | [file] [argument ...]

  The Korn shell is an interactive command interpreter and a command program-
  ming language.

FLAGS

  -c command_string
      Causes ksh to read commands from command_string.

  -i  Causes ksh to run as an interactive shell.  The SIGTERM signal is thus
      ignored, and the SIGINT signal is caught, causing the current command
      to be terminated and a new prompt to be output.

  -r  Causes ksh to run as a restricted shell.

  -s  Causes ksh to read commands from standard input.  If you do not specify
      the -c flag or do not specify any arguments to ksh other than flags,
      ksh automatically invokes the -s flag.  The -c flag overrides the -s
      flag, however.

  The rest of the flags that can be used with ksh are described under the set
  subcommand, in the subsection Special ksh Commands.

DESCRIPTION

  The Korn shell carries out commands either interactively from a terminal
  keyboard or from a file.  The Korn shell is backward compatible with the
  Bourne shell (invoked with the sh command) and contains virtually all of
  the Bourne shell features, as well as several of the best features of the C
  shell.

  Some important features of the Korn shell are as follows:

    o  Command aliasing

    o  Filename substitution

    o  Tilde substitution

    o  Command substitution

    o  Parameter substitution

    o  Job control

    o  Inline editing

  A file from which the shell carries out commands is usually called a shell
  script, a shell procedure, or a command file.  For more information about
  writing shell scripts, see the OSF/1 User's Guide.

  A simple command is a sequence of words separated by spaces or tabs.  A
  word is a sequence of characters that contains no unquoted spaces or tabs.
  The first word in the sequence (numbered as 0), usually specifies the name
  of a command.  Any remaining words, with a few exceptions, are passed to
  that command.  A space refers to both spaces and tabs.

  The value of a simple command is its exit value if it ends normally, or
  (octal) 200 added to the signal number if it terminates due to a signal.
  For a list of status values, see the signal() system call.

  A pipeline is a sequence of one or more commands separated by a | (vertical
  bar) or, for historical compatibility, by a ^ (circumflex).  In a pipeline,
  the standard output of each command becomes the standard input of the next
  command.  Each command runs as a separate process, and the shell waits for
  the last command to end.  A filter is a command that reads its standard
  input, transforms it in some way, then writes it to its standard output.  A
  pipeline normally consists of a series of filters.  Although the processes
  in a pipeline (except the first process) can execute in parallel, they are
  synchronized to the extent that each program needs to read the output of
  its predecessor.

  The exit value of a pipeline is the exit value of the last command.

  A list is a sequence of one or more pipelines separated by ; (semicolon), &
  (ampersand), && (two ampersands), or || (two vertical bars) and optionally
  ended by a ; (semicolon), an & (ampersand), a |& (coprocess), or a newline.
  These separators and terminators have the following effects:

  ;   Causes sequential execution of the preceding pipeline; the shell waits
      for the pipeline to finish.

  &   Causes asynchronous execution of the preceding pipeline; the shell does
      not wait for the pipeline to finish.

  &&  Causes the list following it to be executed only if the preceding pipe-
      line returns a 0 (zero) exit value.

  ||  Causes the list following it to be executed only if the preceding pipe-
      line returns a nonzero exit value.
      The cd command is an exception; if it returns a nonzero exit value, no
      subsequent commands in a list are executed, regardless of the separator
      characters.

  The ; and & separators have equal precedence, as do && and ||.  The
  single-character separators have lower precedence than the double-character
  separators.  An unquoted newline character following a pipeline functions
  the same as a ; (semicolon).

  Comments
  The shell treats as a comment any word that begins with a # character and
  ignores that word and all characters following up to the next newline char-
  acter.

  Shell Flow Control Statements

  Unless otherwise stated, the value returned by a command is that of the
  last simple command executed in the command.

  for identifier [in word...] ;do list ;done
      Each time a for command is executed, identifier is set to the next word
      taken from the in word list.  If in word ...  is omitted, the for
      command executes the do list once for each positional parameter that is
      set.  (See Parameter Substitution.)  Execution ends when there are no
      more words in the list.

  select identifier [in word...] ;do list ;done
      Prints on standard error (file descriptor 2), the set of words, each
      preceded by a number.  If in word...  is omitted, then the positional
      parameters are used instead.  (See Parameter Substitution.) The PS3
      prompt is printed and a line is read from the standard input.  If this
      line consists of the number of one of the listed words, then the value
      of the parameter identifier is set to the word corresponding to this
      number.  If this line is empty, the selection list is printed again.
      Otherwise, the value of the parameter identifier is set to null.  The
      contents of the line read from standard input is saved in the REPLY
      parameter.  The list is executed for each selection until a break or
      End-of-File is encountered.

  case word in [[(] pattern [| pattern] ...) list ;;] ...  esac
      Executes the list associated with the first pattern that matches word.
      The form of the patterns is the same as that used for filename genera-
      tion.  (See Filename Generation.)

  if list ;then list [elif list ;then list] ...  [;else list] ;fi
      Executes the list following if and, if it returns a 0 (zero) exit
      status, executes the list following the first then.  Otherwise, the
      list following elif is executed and, if its value is 0 (zero), the list
      following the next then is executed.  Failing that, the else list is
      executed.  If no else list or then list is executed, then the if com-
      mand returns a 0 (zero) exit status.

  while list ;do list ;done

  until list ;do list ;done
      Executes the while list repeatedly, and if the exit status of the last
      command in the list is 0 (zero), executes the do list; otherwise the
      loop terminates.  If no commands in the do list are executed, then the
      while command returns a 0 (zero) exit status; until can be used in
      place of while to negate the loop termination test.

  (list)
      Executes list in a separate environment.  Note that if two adjacent
      open parentheses are needed for nesting, a space must be inserted to
      avoid arithmetic evaluation as described later.

  {list;}
      Executes list.  Note that unlike the metacharacters ( and ), { and }
      are reserved words and must be at the beginning of a line or after a ;
      (semicolon) in order to be recognized.

  [[expression]]
      Evaluates expression and returns a 0 (zero) exit status when expression
      is TRUE.  See Conditional Expressions for a description of expression.

  function identifier {list;}

  identifier () {list;}
      Defines a function that is referenced by identifier.  The body of the
      function is the list of commands between { and }.  (See Functions.)

  time pipeline
      Executes pipeline  and prints the elapsed time as well as the user and
      system time on standard error.

  The following reserved words are recognized only when they appear, without
  single or double quotes, as the first word of a command:
  if      for     case
  then    while   esac
  else    until   function
  elif    do      select
  fi      done    time
  { }     [[ ]]
  Command Aliasing
  The first word of each command is replaced by the text of an alias (if an
  alias for this word was defined).  The first character of an alias name can
  be any nonspecial printable character, but the rest of the characters must
  be the same as for a valid identifier.  The replacement string can contain
  any valid shell script, including the metacharacters previously listed.
  The first word of each command in the replaced text, other than any that
  are in the process of being replaced, will be tested for aliases.  If the
  last character of the alias value is a space, the word following the alias
  will also be checked for alias substitution.

  Aliases can be used to redefine special built-in commands but cannot be
  used to redefine the reserved words previously listed.  Aliases can be
  created, listed, and exported with the alias command and can be removed
  with the unalias command.  Exported aliases remain in effect for scripts
  invoked by name, but must be reinitialized for separate invocations of the
  shell.  (See Invocation.)

  Aliasing is performed when scripts are read, not while they are executed.
  Therefore, for an alias to take effect, the alias definition command has to
  be executed before the command that references the alias is read.

  Aliases are frequently used as shorthand for full pathnames.  An option to
  the aliasing facility allows the value of the alias to be automatically set
  to the full pathname of the corresponding command.  These aliases are
  called tracked aliases.

  The value of a tracked alias is defined the first time the corresponding
  command is looked up and becomes undefined each time the PATH environment
  variable is reset.  These aliases remain tracked so that the next subse-
  quent reference will redefine the value.  Several tracked aliases are com-
  piled into the shell.  The -h flag of the set command makes each referenced
  command name into a tracked alias.

  The following exported aliases are compiled into the shell, but can be
  unset or redefined:
  autoload='typeset -fu'
  false='let 0'
  functions='typeset -f'
  hash='alias -t'
  history='fc -l'
  integer='typeset -i'
  nohup='nohup '
  r='fc -e -'
  true=':'
  type='whence -v'

  Tilde Substitution
  After alias substitution is performed, each word is checked to see if it
  begins with an unquoted ~ (tilde).  If it does, then the word up to a /
  (slash) is checked to see if it matches a username in the /etc/passwd file.
  If a match is found, the tilde and the matched login name are replaced by
  the login directory of the matched user.  This is called a tilde substitu-
  tion.  If no match is found, the original text is left unchanged.  A tilde
  by itself, or in front of a /, is replaced by the value of the HOME parame-
  ter.  A tilde followed by a + (plus sign) or - (dash) is replaced by $PWD
  and $OLDPWD, respectively.

  In addition, tilde substitution is attempted when the value of a variable
  assignment parameter begins with a tilde.

  Command Substitution
  The standard output from a command enclosed in parentheses preceded by a
  dollar sign $( ) or a pair of `` (grave accents) can be used as part or all
  of a word; trailing newlines are removed.  In the second (archaic) form,
  the string between the grave accents is processed for special quoting char-
  acters before the command is executed.  (See Quoting.) The command substi-
  tution $(cat file) can be replaced by the equivalent but faster $(<file).
  Command substitution of most special commands that do not perform
  input/output redirection are carried out without creating a separate pro-
  cess.  An arithmetic expression enclosed in double parentheses preceded by
  a dollar sign ( $(( )) ) is replaced by the value of the arithmetic expres-
  sion within the double parentheses.

  Parameter Substitution
  A parameter is an identifier, one or more digits, or any of the characters
  *, @, #, ?, -, $, and !.  A named parameter (a parameter denoted by an
  identifier) has a value and 0 (zero) or more attributes.  Named parameters
  can be assigned values and attributes by using the typeset special command.
  The attributes supported by the shell are described later with the typeset
  special command.  Exported parameters pass values and attributes to the
  environment.

  The shell supports a 1-dimensional array facility.  An element of an array
  parameter is referenced by a subscript.  A subscript is denoted by an
  arithmetic expression enclosed with [ ] (brackets).  To assign values to an
  array, use set -A name value ...  The value of all subscripts must be in
  the range of 0 to 1023.  Arrays need not be declared.  Any reference to a
  named parameter with a valid subscript is legal and an array will be
  created if necessary.  Referencing an array without a subscript is
  equivalent to referencing the element 0 (zero).

  The value of a named parameter can be assigned by the following:
  name=value [ name=value ]

  If the integer attribute, -i, is set for name, the value is subject to
  arithmetic evaluation, as described later.  Positional parameters, which
  are denoted by a number, can be assigned values with the set special com-
  mand.  Parameter $0 is set from argument 0 (zero) when the shell is
  invoked.  The $ (dollar sign) character is used to introduce substitutable
  parameters.

  ${parameter}
      Reads all the characters from the ${ (dollar sign left brace) to the
      matching } (right brace) as part of the same word even if it contains
      braces or metacharacters.  The value, if any, of the parameter is sub-
      stituted.  The braces are required when parameter is followed by a
      letter, digit, or underscore that is not to be interpreted as part of
      its name or when a named parameter is subscripted.  If parameter is one
      or more digits, it is a positional parameter.  A positional parameter
      of more than one digit must be enclosed in braces.  If parameter is *
      (asterisk) or @ (at sign), all the positional parameters, starting with
      $1, are substituted (separated by a field separator character).  If an
      array identifier with subscript * or @ is used, the value for each of
      the elements is substituted (separated by a field separator character).

  ${#parameter}
      Substitutes the number of positional parameters if parameter is * or @;
      otherwise, the length of the value of the parameter is substituted.

  ${#identifier[*]}
      Substitutes the number of elements in the array identifier.

  ${parameter:-word}
      Substitutes the value of parameter if it is set and non-null; other-
      wise, substitute word.

  ${parameter:=word}
      Sets parameter to word if it is not set or is null; the value of the
      parameter is then substituted.  Positional parameters cannot be
      assigned values in this way.

  ${parameter:?word}
      Substitutes the value of parameter if it is set and is non-null; other-
      wise, print word and exit from the shell.  If word is omitted, a stan-
      dard message is printed.

  ${parameter:+word}
      Substitute word if parameter is set and is non-null; otherwise, substi-
      tute nothing.

  ${parameter#pattern} | ${parameter##pattern}
      Causes the value of this substitution to be the value of parameter with
      the matched portion deleted if the shell pattern matches the beginning
      of the value of parameter; otherwise the value of parameter is substi-
      tuted.  In the first form, the smallest matching pattern is deleted and
      in the second form, the largest matching pattern is deleted.

  ${parameter%pattern} | ${parameter%%pattern}
      Causes the value of this substitution to be the value of parameter with
      the matched part deleted if the shell pattern matches the end of the
      value of parameter; otherwise, substitute the value of parameter.  In
      the first form, the smallest matching pattern is deleted and in the
      second form, the largest matching pattern is deleted.

  If the : (colon) is omitted from the previous expressions, then the shell
  checks only whether parameter is set or not.

  In the previous expressions, word is not evaluated unless it is to be used
  as the substituted string, so that, in the following example, pwd is exe-
  cuted only if d is not set or is null:
  echo ${d:-$(pwd)}
  The following parameters are automatically set by the shell:

  # (hash mark)
     The number of positional parameters in decimal.

  - (dash)
     Flags supplied to the shell on invocation or by the set command.

  ? (question mark)
     The decimal value returned by the last executed command.

  $ (dollar sign)
     The process number of this shell.

  _ (underscore)
     Initially, the value of _ (underscore) is an absolute pathname of the
     shell or script being executed as passed in the environment.  Subse-
     quently, it is assigned the last argument of the previous command.  This
     parameter is not set for commands that are asynchronous.  This parameter
     is also used to hold the name of the matching MAIL file when checking
     for mail.

  ! (exclamation point)
     The process number of the last background command invoked.

  ERRNO
      The value of errno as set by the most recently failed system call.
      This value is system dependent and is intended for debugging purposes.

  LINENO
      The line number of the current line within the script or function being
      executed.

  OLDPWD
      The previous working directory set by the cd command.

  OPTARG
      The value of the last option argument processed by the getopts special
      command.

  OPTIND
      The index of the last option argument processed by the getopts special
      command.

  PPID
      The process number of the parent of the shell.

  PWD The present working directory set by the cd command.

  RANDOM
      Each time this parameter is referenced, a random integer, uniformly
      distributed between 0 and 32767, is generated.  The sequence of random
      numbers can be initialized by assigning a numeric value to RANDOM.

  REPLY
      This parameter is set by the select statement and by the read special
      command when no arguments are supplied.

  SECONDS
      Each time this parameter is referenced, the number of seconds since
      shell invocation is returned.  If this parameter is assigned a value,
      then the value returned upon reference will be the value that was
      assigned plus the number of seconds since the assignment.

  The following parameters are used by the shell:

  CDPATH
      The search path for the cd command.

  COLUMNS
      If this variable is set, the value is used to define the width of the
      edit window for the shell edit modes and for printing select lists.

  EDITOR
      If the value of this variable ends in emacs, gmacs, or vi and the
      VISUAL variable is not set, then the corresponding option (see set
      under Special ksh Commands) will be turned on.

  ENV If this parameter is set, then parameter substitution is performed on
      the value to generate the pathname of the script that will be executed
      when the shell is invoked.  (See Invocation.) This file is typically
      used for alias and function definitions.

  FCEDIT
      The default editor name for the fc command.

  FPATH
      The search path for function definitions.  This path is searched when a
      function with the -u attribute is referenced and when a command is not
      found.  If an executable file is found, then it is read and executed in
      the current environment.

  IFS Internal field separators, normally spaces, tabs, and newlines that are
      used to separate command words which result from command or parameter
      substitution and for separating words with the read special command.
      The first character of the IFS parameter is used to separate arguments
      for the $* substitution.  (See Quoting.)

  HISTFILE
      If this parameter is set when the shell is invoked, then the value is
      the pathname of the file that will be used to store the command his-
      tory.  (See Command Reentry.)

  HISTSIZE
      If this parameter is set when the shell is invoked, the number of pre-
      viously entered commands that are accessible by this shell will be
      greater than or equal to this number.  The default is 128.

  HOME
      The default argument (home directory) for the cd command.

  LANG
      Specifies the locale of your system, which is comprised of three parts:
      language, territory, and codeset.  The default locale is the C locale,
      which specifies the value English for language, U.S. for territory, and
      ASCII for codeset.

  LC_COLLATE
      Specifies the collating sequence to use when sorting names and when
      character ranges occur in patterns.  The default value is the collating
      sequence for American English.  If absent, the collating sequence can
      be taken from the LANG parameter.  If both LC_COLLATE and LANG are
      absent, the ANSI C collating sequence is used.

  LC_CTYPE
      Specifies the character classification information to use on your sys-
      tem.  The default value is American English.

  LC_MESSAGES
      Specifies the language in which system messages appear, and the
      language that the system expects for user input of yes and no strings.
      The default is American English.

  LC_MONETARY
      Specifies the monetary format for your system.  The default value is
      the monetary format for American English.

  LC_NUMERIC
      Specifies the numeric format for your system.  The default value is the
      numeric format for American English.

  LC_TIME
      Specifies the date and time format for your system.  The default value
      is the date and time format for American English.

  LINES
      If this variable is set, the value is used to determine the column
      length for printing select lists.  Select lists will print vertically
      until about two-thirds of LINES lines are filled.

  MAIL
      If this parameter is set to the name of a mail file and the MAILPATH
      parameter is not set, the shell informs you of the arrival of mail in
      the specified file.

  MAILCHECK
      This variable specifies how often (in seconds) the shell checks for
      changes in the modification time of any of the files specified by the
      MAILPATH or MAIL parameters.  The default value is 600 seconds.  When
      the time has elapsed, the shell checks before issuing the next prompt.

  MAILPATH
      A list of filenames separated by : (colons).  If this parameter is set,
      the shell informs you of any modifications to the specified files that
      have occurred within the last MAILCHECK seconds.  Each filename can be
      followed by a ? (question mark) and a message that will be printed.
      The message will undergo parameter substitution with the parameter, $_
      defined as the name of the file that has changed.  The default message
      is you have mail in $_.

  NLSPATH
      Specifies a list of directories to search to find message catalogs.

  PATH
      The search path for commands.  (See Execution.)  You cannot change PATH
      if executing under rsh, except in .profile.

  PS1 The value of this parameter is expanded for parameter substitution to
      define the primary prompt string which by default is the $ (dollar
      sign).  The ! (exclamation point) in the primary prompt string is
      replaced by the command number.  (See Command Reentry.)

  PS2 Secondary prompt string, by default > (right angle bracket).

  PS3 Selection prompt string used within a select loop, by default #?
      (number sign, question mark).

  PS4 The value of this parameter is expanded for parameter substitution and
      precedes each line of an execution trace.  If omitted, the execution
      trace prompt is + (plus sign).

  SHELL
      The pathname of the shell is kept in the environment.

  TMOUT
      If set to a value greater than 0 (zero), the shell terminates if a com-
      mand is not entered within the prescribed number of seconds after issu-
      ing the PS1 prompt.  (Note that the shell can be compiled with a max-
      imum bound for this value that cannot be exceeded.)

  VISUAL
      If the value of this variable ends in emacs, gmacs, or vi, the
      corresponding option (see the set command in Special ksh Commands) will
      be turned on.

  The shell gives default values to PATH, PS1, PS2, MAILCHECK, TMOUT, and
  IFS, while HOME, SHELL, ENV, and MAIL are not set by the shell (although
  HOME is set by the login command).  On some systems, MAIL and SHELL are
  also set by the login command.
  Interpretation of Spaces
  After parameter and command substitution, the results of substitutions are
  scanned for the field separator characters (those found in IFS), and split
  into distinct arguments where such characters are found.  Explicit null
  arguments (`` or '') are retained.  Implicit null arguments (those result-
  ing from parameters that have no values) are removed.

  Filename Generation
  Following substitution, each command word is scanned for the characters *
  (asterisk), ? (question mark), and [ ] (brackets), unless the -f option was
  set.  If one of these characters appears, the word is regarded as a pat-
  tern.  The word is replaced with lexicographically sorted filenames that
  match the pattern.  If no filename is found that matches the pattern, the
  word is left unchanged.  When a pattern is used for filename generation,
  the . (dot) character at the start of a filename or immediately following a
  / (slash), as well as the / character itself, must be matched explicitly.
  In other instances of pattern matching, the / and . are not treated spe-
  cially.

  *   Matches any string, including the null string.

  ?   Matches any single character.

  [...]
      Matches any one of the enclosed characters.  In an expression such as
      [a-z], the - (dash) means "through" according to the current collating
      sequence.  The collating sequence is determined by the value of the
      LC_COLLATE environment variable.  (See "Using Internationalization
      Features" in the OSF/1 User's Guide for more information on collating
      sequences.)  If the first character following the [  (left bracket) is
      a ! (exclamation point), then any character not enclosed is matched.  A
      - can be included in the character set by putting it as the first or
      last character.

  A pattern_list is a list of one or more patterns separated from each other
  with a | (vertical bar).  Composite patterns can be formed with one or more
  of the following:

  ?(pattern_list)
      Optionally matches any one of the given patterns.

  *(pattern_list)
      Matches zero or more occurrences of the given patterns.

  +(pattern_list)
      Matches one or more occurrences of the given patterns.

  @(pattern_list)
      Matches exactly one of the given patterns.

  !(pattern_list)
      Matches anything, except one of the given patterns.
  Character Classes
  You can use the following notation to match filenames within a range indi-
  cation:
  [:charclass:]

  This format instructs the system to match any single character belonging to
  charclass; the defined classes correspond to ctype() subroutines as fol-
  lows:
  alnum
  alpha
  cntrl
  digit
  graph
  lower
  print
  punct
  space
  upper
  xdigit

  Your locale might define additional character properties, such as the fol-
  lowing:
  [:vowel:]

  The preceding character class could be TRUE for a, e, i, o, u, or y.  You
  could then use [:vowel] inside a set construction to match any vowel.
  Refer to The LC_CTYPE Category section of the locale file format reference
  page for more information.

  Quoting
  The following characters have a special meaning to the shell and cause ter-
  mination of a word unless quoted:
  ; & ( ) | ^ < > <newline> <space> <tab>
  Each of the metacharacters previously listed has a special meaning to the
  shell and causes termination of a word unless quoted.  A character can be
  quoted (that is, made to stand for itself) by preceding it with a \
  (backslash).  The pair \newline is ignored. All characters enclosed between
  a pair of '' (single quotes) are quoted.  A single quote cannot appear
  within single quotes.

  Inside "" (double quotes) parameter and command substitution occurs and \
  quotes the characters \, `, ', and $.  The meaning of $* and $@ is identi-
  cal when not quoted or when used as a parameter assignment value or as a
  filename.  However, when used as a command argument, '$*' is equivalent to
  '$1d$2d. . .', where d is the first character of the IFS parameter, whereas
  '$@' is equivalent to '$1' '$2' . . .  Inside `` (grave accents) \
  (backslash) quotes the characters \, `, and $.  If the grave accents occur
  within double quotes, then \ also quotes the ' (single quote) character.

  The special meaning of reserved words or aliases can be removed by quoting
  any character of the reserved word.  The recognition of function names or
  special command names listed later cannot be altered by quoting them.

  Arithmetic Evaluation
  An ability to perform integer arithmetic is provided with the let special
  command.  Evaluations are performed using long arithmetic.  Constants are
  of the form [base#]n, where base is a decimal number between 2 and 36
  representing the arithmetic base and n is a number in that base.  If base
  is omitted, then base 10 is used.

  An arithmetic expression uses the same syntax, precedence, and associa-
  tivity of expression of the C language.  All the integral operators, other
  than ++, --, ?:, and , are supported.  Named parameters can be referenced
  by name within an arithmetic expression without using the parameter substi-
  tution syntax.  When a named parameter is referenced, its value is
  evaluated as an arithmetic expression.

  An internal integer representation of a named parameter can be specified
  with the -i option of the typeset special command.  Arithmetic evaluation
  is performed on the value of each assignment to a named parameter with the
  -i attribute.  If you do not specify an arithmetic base, the first assign-
  ment to the parameter determines the arithmetic base.  This base is used
  when parameter substitution occurs.

  Because many of the arithmetic operators require quoting, an alternative
  form of the let command is provided.  For any command that begins with a
  ((, all the characters until a matching )) are treated as a quoted expres-
  sion.  More precisely, ((...)) is equivalent to let "...".

  Note that ((...)) is a command with a return value, whereas $((...)) is the
  way to put the string representation of the value of an arithmetic expres-
  sion into the command line (that is, it is like a $ variable).

  Prompting
  When used interactively, the shell prompts with the value of PS1 before
  reading a command.  If at any time a newline is typed and further input is
  needed to complete a command, then the secondary prompt (that is, the value
  of PS2) is issued.

  Conditional Expressions
  A conditional expression is used with the [[ compound command to test
  attributes of files and to compare strings.  Word splitting and filename
  generation are not performed on the words between [[ and ]].  Each expres-
  sion can be constructed from one or more of the following unary or binary
  expressions:

  -a file
      TRUE, if file exists.

  -b file
      TRUE, if file exists and is a block-special file.

  -c file
      TRUE, if file exists and is a character-special file.

  -d file
      TRUE, if file exists and is a directory.

  -f file
      TRUE, if file exists and is an ordinary file.

  -g file
      TRUE, if file exists and has its setgid bit set.

  -G file
      TRUE, if file exists and its group matches the effective group ID of
      this process.

  -k file
      TRUE, if file exists and has its sticky bit set.

  -L file
      TRUE, if file exists and is a symbolic link.

  -n string
      TRUE, if length of string is nonzero.

  -o  option
      TRUE, if option named option is on.

  -O file
      TRUE, if file exists and is owned by the effective user ID of this pro-
      cess.

  -p file
      TRUE, if file exists and is a FIFO special file or a pipe.

  -r file
      TRUE, if file exists and is readable by current process.

  -s file
      TRUE, if file exists and has size greater than 0 (zero).

  -S file
      TRUE, if file exists and is a socket.

  -t file_des
      TRUE, if file descriptor number file_des is open and associated with a
      terminal device.

  -u file
      TRUE, if file exists and has its setuid bit set.

  -w file
      TRUE, if file exists and is writable by current process.

  -x file
      TRUE, if file exists and is executable by current process.  If file
      exists and is a directory, then the current process has permission to
      search in the directory.

  -z string
      TRUE, if length of string is 0 (zero).

  file1 -nt file2
      TRUE, if file1 exists and is newer than file2.

  file1 -ot file2
      TRUE, if file1 exists and is older than file2.

  file1 -ef file2
      TRUE, if file1 and file2 exist and refer to the same file.

  string = pattern
      TRUE, if string matches pattern.

  string != pattern
      TRUE, if string does not match pattern.

  string1 < string2
      TRUE, if string1 collates before string2.

  string1 > string2
      TRUE, if string1 collates after string2.

  expression1 -eq expression2
      TRUE, if expression1 is equal to expression2.

  expression1 -ne expression2
      TRUE, if expression1 is not equal to expression2.

  expression1 -lt expression2
      TRUE, if expression1 is less than expression2.

  expression1 -gt expression2
      TRUE, if expression1 is greater than expression2.

  expression1 -le expression2
      TRUE, if expression1 is less than or equal to expression2.

  expression1 -ge expression2
      TRUE, if expression1 is greater than or equal to expression2.

  A compound expression can be constructed from these primitives by using any
  of the following, listed in decreasing order of precedence.

  (expression)
      TRUE, if expression is TRUE.  Used to group expressions.

  ! expression
      TRUE if expression is FALSE.

  expression1 && expression2
      TRUE, if expression1 and expression2 are both TRUE.

  expression1 || expression2
      TRUE, if either expression1 or expression2 is TRUE.

  Input/Output
  Before a command is executed, you can redirect its input and output by
  using a special notation interpreted by the shell.  The following can
  appear anywhere in a simple command or can precede or follow a command and
  are not passed on to the invoked command.  Command and parameter substitu-
  tion occurs before word or digit is used, except as noted in the following
  text.  Filename generation occurs only if the pattern matches a single file
  and interpretation of spaces is not performed.

  <word
      Use file word as standard input (file descriptor 0).

  >word
      Use file word as standard output (file descriptor 1).  If the file does
      not exist, it is created.  If the file exists, and the noclobber option
      is on, this causes an error; otherwise, it is truncated to 0 (zero)
      length.

  >|word
      Sames as >, except that it overrides the noclobber option.

  >>word
      Use file word as standard output.  If the file exists, output is
      appended to it (by first seeking to the End-of-File); otherwise, the
      file is created.

  <>word
      Open file word for reading and writing as standard input.

  <<[-]word
      The shell input is read up to a line that is the same as word, or to an
      End-of-File.  No parameter substitution, command substitution, or
      filename generation is performed on word.  The resulting document,
      called a here document, becomes the standard input.  If any character
      of word is quoted, then no interpretation is placed upon the characters
      of the document; otherwise, parameter and command substitution occurs,
      \newline is ignored, and \ must be used to quote the characters \, $,
      `, and the first character of word.  If - is appended to <<, then all
      leading tabs are stripped from word and from the document.

  <&digit
      The standard input is duplicated from file descriptor digit (see
      dup()).  The standard output is duplicated using >& digit.

  <&- The standard input is closed.  The standard output is closed using >&-.

  <&p The input from the coprocess (or background process) is moved to stan-
      dard input.

  >&p The output to the coprocess is moved to standard output.

  If one of the preceding redirections is preceded by a digit, then the file
  descriptor number referred to is that specified by the digit (instead of
  the default 0 or 1).  For example:
  ...  2>&1
  means file descriptor 2 is to be opened for writing as a duplicate of file
  descriptor 1.

  The order in which redirections are specified is significant.  The shell
  evaluates each redirection in terms of the (file descriptor, file) associa-
  tion at the time of evaluation.  For example:
  ...  1>fname >&1
  first associates file descriptor 1 with file fname.  It then associates
  file descriptor 2 with the file associated with file descriptor 1 (that is,
  fname).  If the order of redirections were reversed, file descriptor 2 is
  associated with the terminal (assuming file descriptor 1 is) and then file
  descriptor 1 is associated with file fname.

  If a command is followed by & and job control is not active, the default
  standard input for the command is the empty /dev/null file.  Otherwise, the
  environment for the execution of a command contains the file descriptors of
  the invoking shell as modified by input/output specifications.

  Environment
  The environment is a list of name-value pairs that is passed to an executed
  program in the same way as a normal argument list.  The names must be iden-
  tifiers and the values are character strings.  The shell interacts with the
  environment in several ways.  On invocation, the shell scans the environ-
  ment and creates a parameter for each name found, giving it the correspond-
  ing value and marking it export.  Executed commands inherit the environ-
  ment.  If you modify the values of these parameters or create new ones,
  using the export or typeset -x commands, they become part of the environ-
  ment.  The environment seen by any executed command is thus composed of any
  name-value pairs originally inherited by the shell, whose values can be
  modified by the current shell, plus any additions that must be noted in the
  export or typeset -x commands.

  You can augment the environment for any simple command or function by pre-
  fixing it with one or more parameter assignments.  A parameter assignment
  argument is a word of the form identifier=value.

  Thus, the following two expressions are equivalent (as far as the execution
  of command is concerned):
  TERM=450 command argument ...

  (export TERM; TERM=450; command argument ...)
  If the -k flag is set, all parameter assignment arguments are placed in the
  environment, even if they occur after the command name.  The following
  first prints a=b c and then c:
  echo a=b c
  set -k
  echo a=b c
  This feature is intended for use with scripts written for early versions of
  the shell; its use in new scripts is strongly discouraged.  It is likely to
  disappear someday.

  Functions
  The function reserved word is used to define shell functions.  Shell func-
  tions are read in and stored internally.  Alias names are resolved when the
  function is read.  Functions are executed like commands with the arguments
  passed as positional parameters.  (See Execution.)

  Functions execute in the same process as the caller and share all files and
  the present working directory with the caller.  Traps caught by the caller
  are reset to their default action inside the function.  A trap condition
  that is not caught or ignored by the function causes the function to ter-
  minate and the condition to be passed on to the caller.  A trap on EXIT set
  inside a function is executed after the function completes in the environ-
  ment of the caller.  Ordinarily, variables are shared between the calling
  program and the function.  However, the special command typeset used within
  a function defines local variables whose scope includes the current func-
  tion and all functions it calls.

  The special command return is used to return from function calls.  Errors
  within functions return control to the caller.

  Function identifiers can be listed with the -f or +f option of the typeset
  special command.  The text of functions is also listed with -f.  Function
  can be undefined with the -f option of the unset special command.

  Ordinarily, functions are unset when the shell executes a shell script.
  The -xf option of the typeset command allows a function to be exported to
  scripts that are executed without a separate invocation of the shell.
  Functions that need to be defined across separate invocations of the shell
  should be specified in the ENV file with the -xf option of typeset.

  Jobs
  If the monitor option of the set command is turned on, an interactive shell
  associates a job with each pipeline.  It keeps a table of current jobs,
  printed by the jobs command, and assigns them small integer numbers.  When
  a job is started asynchronously with &, the shell prints a line that looks
  like:
  [1] 1234
  This line indicates that the job, which was started asynchronously, was job
  number 1 and had one (top-level) process, whose process ID was 1234.

  If you are running a job and want to do something else, you can enter the
  Suspend key sequence (normally <Ctrl-z>, which sends a SIGINT signal to the
  current job.  The shell then normally indicates that the job has been
  stopped, and it prints another prompt.  You can then manipulate the state
  of this job, putting it in the background with the bg command, or run some
  other commands and then eventually bring the job back into the foreground
  with the foreground command fg.  The job suspension takes effect immedi-
  ately, and corresponds to the Interrupt key sequence in that pending output
  and unread input are discarded.  A special key sequence, <Ctrl-y>, does not
  generate a SIGINT signal until a program attempts to read it.  (See the
  read() system call for more information.)  This key sequence can usefully
  be typed ahead when you have prepared some commands for a job that you wish
  to stop after it has read them.

  A job being run in the background will stop if it tries to read from the
  terminal.  Background jobs are normally allowed to produce output, but this
  can be disabled by issuing the stty tostop command.  If you set this tty
  option, then background jobs will stop when they try to produce output like
  they do when they try to read input.

  There are several ways to refer to jobs in the shell.  A job can be
  referred to by the process ID of any process of the job, or by one of the
  following:

  %job_number
      The job with the given number.

  %string
      Any job whose command line begins with string.

  %?string
      Any job whose command line contains string.

  %%  Current job.

  %+  Equivalent to %%.

  %-  Previous job.

  This shell learns immediately whenever a process changes state.  It nor-
  mally informs you whenever a job becomes blocked so that no further pro-
  gress is possible, but only just before it prints a prompt.  This is done
  so that it does not otherwise disturb your work.

  When the monitor mode is on, each background job that is completed triggers
  any trap set for CHLD.

  When you try to leave the shell while jobs are stopped or running, you are
  warned that You have stopped(running) jobs. You can use the jobs command to
  see what they are.  If you do this or immediately try to exit again, the
  shell does not warn you a second time, and the stopped jobs are terminated.

  Signals
  The SIGINT and SIGQUIT signals for an invoked command are ignored if the
  command is followed by & and job monitor option is not active.  Otherwise,
  signals have the values inherited by the shell from its parent (but see
  also the trap command).

  Execution
  Each time a command is executed, the previous substitutions are carried
  out.  If the command name matches one of the special commands listed later,
  it is executed within the current shell process.  Next, the command name is
  checked to see if it matches one of the user-defined functions.  If it
  does, the positional parameters are saved and then reset to the arguments
  of the function call.  When the function is completed or issues a return,
  the positional parameter list is restored and any trap set on EXIT within
  the function is executed.  The value of a function is the value of the last
  command executed.  A function is also executed in the current shell pro-
  cess.  If a command name is not a special command or a user-defined func-
  tion, a process is created and an attempt is made to execute the command
  via exec.

  The PATH shell parameter defines the search path for the directory contain-
  ing the command.  Alternative directory names are separated by a : (colon).
  The default path is :/usr/bin: (specifying /usr/bin, and the current direc-
  tory in that order).  The current directory can be specified by two or more
  adjacent colons, or by a colon at the beginning or end of the path list.
  If the command name contains a / (slash), then the search path is not used.
  Otherwise, each directory in the path is searched for an executable file.

  If the file has execute permission but is not a directory or an a.out file,
  it is assumed to be a file containing shell commands.  A subshell is
  spawned to read it.  All nonexported aliases, functions, and named parame-
  ters are removed in this case.  If the shell command file does not have
  read permission, or if the setuid and/or setgid bits are set on the file,
  the shell executes an agent whose job it is to set up the permissions and
  execute the shell with the shell command file passed down as an open file.
  A command in parentheses is executed in a subshell without removing nonex-
  ported quantities.

  Command Reentry
  The text of the last HISTSIZE (default 128) commands entered from a termi-
  nal device is saved in a history file.  The $HOME/.sh_history file is used
  if the HISTFILE variable is not set or is not writable.  A shell can access
  the commands of all interactive shells that use the same named HISTFILE.
  The fc special command is used to list or edit a portion of this file.  The
  portion of the file to be edited or listed can be selected by number or by
  giving the first character or characters of the command.  A single command
  or range of commands can be specified.  If you do not specify an editor
  program as an argument to fc, then the value of the FCEDIT parameter is
  used.  If FCEDIT is not defined, then /usr/bin/ed is used.  The edited com-
  mands are printed and reexecuted upon leaving the editor.  The editor name
  - (dash) is used to skip the editing phase and to reexecute the command.
  In this case, a substitution parameter of the form old=new can be used to
  modify the command before execution.  For example, if r is aliased to 'fc
  -e -', then typing `r bad=good c' reexecutes the most recent command, which
  starts with the letter c, replacing the first occurrence of the string bad
  with the string good.

  Inline Editing Options
  Normally, each command line entered from a terminal device is simply typed
  followed by a newline (<Return> or linefeed).  If the emacs, gmacs, or vi
  option is active, you can edit the command line.  To be in any of these
  edit modes, set the corresponding option.  An editing option is automati-
  cally selected each time the VISUAL or EDITOR variable is assigned a value
  ending in either of these option names.

  The editing features require that the terminal accept <Return> as
  carriage-return without linefeed and that a space must overwrite the
  current character on the screen.  ADM terminal users should set the space-
  advance switch to Space.  Hewlett-Packard series 2621 terminal users should
  set the straps to bcGHxZ etX.

  The editing modes create the impression that the user is looking through a
  window at the current line.  The window width is the value of COLUMNS if it
  is defined, otherwise it is 80 bytes.  If the line is longer than the win-
  dow width minus 2, a mark is displayed at the end of the window to notify
  the user.  As the cursor moves and reaches the window boundaries, the
  window will be centered about the cursor.  The mark is a > (right angle
  bracket) if the line extends on the right side of the window, a < (left
  angle bracket) if the line extends on the left side of the window, and an *
  (asterisk) if the line extends on both sides of the window.
  The search commands in each edit mode provide access to the history file.
  Only strings are matched, not patterns, although if the leading character
  in the string is a ^ (circumflex), the match is restricted to begin at the
  first character in the line.

  The emacs Editing Mode
  This mode is entered by enabling either the emacs or gmacs option.  The
  only difference between these two modes is the way they handle <Ctrl-t>.
  To edit, the user moves the cursor to the point needing correction and then
  inserts or deletes characters or words as needed.  All the editing commands
  are control characters or escape sequences.  The notation for control char-
  acters is ^ (circumflex) followed by the character.  For example, ^F is the
  notation for <Ctrl-f>.  This is entered by pressing f while holding down
  <Ctrl>.  <Shift> is not depressed.  (The notation ^? indicates <Delete>.)

  The notation for escape sequences is M- followed by a character.  For exam-
  ple, M-f (pronounced Meta f) is entered by pressing <Esc> (ASCII 033) fol-
  lowed by f.  (M-F would be the notation for <Esc> followed by <Shift> (cap-
  ital) F.)

  All edit commands operate from any place on the line (not just at the
  beginning).  Do not press <Return> or linefeed after edit commands except
  when noted.

  <Ctrl-f>
      Moves the cursor forward (right) one character.

  <Esc-f>
      Moves the cursor forward one word.  (The emacs editor's definition of a
      word is a string of characters, consisting of only letters, digits, and
      underscores, and delimited with spaces or tabs.)

  <Ctrl-b>
      Moves the cursor backward (left) one character.

  <Esc-b>
      Moves the cursor backward one word.

  <Ctrl-a>
      Moves the cursor to the start of the line.

  <Ctrl-e>
      Moves the cursor to the end of the line.

  <Ctrl-]> character
      Moves the cursor forward on the current line to the character indicated
      by the character argument.

  <Esc-Ctrl-]> character
      Moves the cursor backward on the current line to the character indi-
      cated by the character argument.

  <Ctrl-x Ctrl-x>
      Interchanges the cursor and mark.

  Erase
      Deletes the previous character.  (User-defined Erase character as
      defined by the stty command, often <Ctrl-h> or #.)

  <Ctrl-d>
      Deletes the current character.

  <Esc-d>
      Deletes the current word.

  <Esc-Backspace>
      Deletes the previous word.

  <Esc-h>
      Deletes the previous word.

  <Esc-Delete>
      Deletes the previous word (if your Interrupt character is <Delete>,
      this command does not work).

  <Ctrl-t>
      Transposes the current character with next character in emacs mode.
      Transposes two previous characters in gmacs mode.

  <Ctrl-c>
      Capitalizes the current character.

  <Esc-c>
      Capitalizes the current word.

  <Esc-l>
      Changes the current word to lowercase.

  <Ctrl-k>
      Deletes from the cursor to the end of the line.  If preceded by a
      numerical parameter whose value is less than the current cursor posi-
      tion, deletes from given position up to the cursor.  If preceded by a
      numerical parameter whose value is greater than the current cursor
      position, deletes from the cursor up to given cursor position.

  <Ctrl-w>
      Deletes from the cursor to the mark.

  <Esc-p>
      Pushes the region from the cursor to the mark on the stack.

  Kill
      Kills the entire current line.  If two Kill characters are entered in
      succession, all Kill characters from then on cause a linefeed (useful
      when using paper terminals).  (User-defined Kill character as defined
      by the stty command, often <Ctrl-g> or @.)

  <Ctrl-y>
      Restores the last item removed from the line.  (Yanks the item back to
      the line.)

  <Ctrl-l>
      Performs a linefeed and prints the current line.

  <Ctrl-@>
      (Null character.)  Sets the mark.

  <Esc space>
      Sets the mark.

  <Ctrl-j>
      Executes the current line (newline).

  <Ctrl-m>
      Executes the current line (enter).

  EOF The End-of-File character is processed as an End-of-File only if the
      current line is null.

  <Ctrl-p>
      Fetches the previous command.  Each time <Ctrl-p> is entered, the pre-
      vious command back in time is accessed.  Moves back one line when not
      on the first line of a multiline command.

  <Esc-<>
      Fetches the least recent (oldest) history line.

  <Esc->>
      Fetches the most recent (youngest) history line.

  <Ctrl-n>
      Fetches the next command line.  Each time <Ctrl-n> is entered, the next
      command line forward in time is accessed.

  <Ctrl-r> string
      Reverses the search history for a previous command line containing
      string.  If an argument of 0 (zero) is given, the search is forward.
      string is terminated by an <Return> or newline character.  If string is
      preceded by a ^ (circumflex), the matched line must begin with string.
      If string is omitted, then the next command line containing the most
      recent string is accessed.  In this case, an argument of 0 (zero) rev-
      erses the direction of the search.

  <Ctrl-o>
      Executes the current line and fetches the next line relative to current
      line from the history file.  (Operate)

  <Esc> digits
      Defines the numeric parameter (escape).  The digits are taken as an
      argument to the next command.  The commands that accept a parameter are
      <Ctrl-f>, <Ctrl-b>, <Erase>, <Ctrl-c>, <Ctrl-d>, <Ctrl-k>, <Ctrl-r>,
      <Ctrl-p>, <Ctrl-n>, <Ctrl-]>, <Esc-.>, <Esc-Ctrl-]>, <Esc-_>, <Esc-b>,
      <Esc-c>, <Esc-d>, <Esc-f>, <Esc-h>, <Esc-l> and <Esc-Ctrl-h>.

  <Esc> letter
      Your alias list is searched for an alias by the name _letter and if an
      alias of this name is defined, its value is inserted on the input
      queue.  letter must not be one of the preceding metafunctions. (Soft-
      key)

  <Esc-]> letter
      Your alias list is searched for an alias by the name _letter and if an
      alias of this name is defined, its value is inserted on the input queue
      (Soft-key).  This can be used to program functions keys on many sys-
      tems.

  <Esc-.>
      The last word of the previous command is inserted on the line.  If pre-
      ceded by a numeric parameter, the value of this parameter determines
      which word to insert, rather than the last word.

  <Esc-_>
      Same as the <Esc-.> combination.

  <Esc-*>
      Attempts filename generation on the current word.  An * (asterisk) is
      appended if the word does not match any file or contain any special
      pattern characters.

  <Esc-Esc>
      Filename completion.  Replaces the current word with the longest common
      prefix of all filenames matching the current word with an asterisk
      appended.  If the match is unique, a / (slash) is appended if the file
      is a directory, and a space is appended if the file is not a directory.

  <Esc-=>
      Lists the files matching current word pattern if an * (asterisk) were
      appended.

  <Ctrl-u>
      Multiplies the argument of the next command by 4.

  \   Escapes the next character.  Editing characters, the user's Erase,
      Kill, and Interrupt (normally by using <Delete>) characters can be
      entered in a command line or in a search string if preceded by a \
      (backslash).  The backslash removes the next character's editing
      features (if any).

  <Ctrl-v>
      Displays the version of the shell.

  <Esc-#>
      Inserts a # (number sign) at the beginning of the line and executes it.
      This causes a comment to be inserted in the history file.

  The vi Editing Mode
  There are two typing modes.  Initially, when you enter a command you are in
  the input mode.  To edit, the user enters control mode by typing <Esc>
  (ASCII 033) and moves the cursor to the place needing correction and then
  inserts or deletes characters or words as needed.  Most control commands
  accept an optional repeat count prior to the command.  When in vi mode on
  most systems, canonical processing is initially enabled and the command are
  echoed again if the speed is 1200 baud or greater, if it contains any con-
  trol characters, or if less than 1 second has elapsed since the prompt was
  printed.  The Escape character terminates canonical processing for the
  remainder of the command and the user can then modify the command line.

  This scheme has the advantages of canonical processing with the type-ahead
  echoing of raw mode.  If the option viraw is also set, the terminal always
  has canonical processing disabled.  This mode is implicit for systems that
  do not support two alternate End-of-Line delimiters, and can be helpful for
  certain terminals.

  Input Edit Commands
  By default the editor is in input mode.

  Erase
      (User-defined Erase character as defined by the stty command, often
      <Ctrl-h> or #.) Deletes the previous character.

  <Ctrl-w>
      Deletes the previous space-separated word.

  <Ctrl-d>
      Terminates the shell.

  <Ctrl-v>
      Escapes the next character.  Editing characters and the user's Erase or
      Kill characters can be entered in a command line or in a search string
      if preceded by a <Ctrl-v>.  <Ctrl-v> removes the next character's edit-
      ing features (if any).

  \   Escapes the next Erase or Kill character.

  Motion Edit Commands

  These commands move the cursor:

  [count]l
      Cursor forward (right) one character.

  [count]w
      Cursor forward one word.  A word is a string of characters delimited by
      spaces or tabs.

  [count]W
      Cursor to the beginning of the next word that follows a space.

  [count]e
      Cursor to the end of the word.

  [count]E
      Cursor to end of the current space-delimited word.

  [count]h
      Cursor backward (left) one character.

  [count]b
      Cursor backward one word.

  [count]B
      Cursor to the preceding space-delimited word.

  [count]|
      Cursor to the column count.

  [count]fc
      Finds the next character c in the current line.

  [count]Fc
      Finds the previous character c in the current line.

  [count]tc
      Equivalent to f followed by h.

  [count]Tc
      Equivalent to F followed by l.

  [count];
      Repeats count times, the last single character find command: f, F, t,
      or T.

  [count],
      Reverses the last single character find command count times.

  0   Cursor to the start of the line.

  ^   Cursor to the first nonspace character in the line.

  $   Cursor to the end of the line.

  Search Edit Commands
  These commands access your command history.

  [count]k
      Fetches the previous command.  Each time k is entered, the previous
      command back in time is accessed.

  [count]-
      Equivalent to k.

  [count]j
      Fetches the next command.  Each time j is entered, the next command
      forward in time is accessed.

  [count]+
      Equivalent to j.

  [count]G
      Fetches the command number count.  The default is the least recent his-
      tory command.

  /string
      Searches backward through history for a previous command containing the
      specified string.  string is terminated by <Return> or a newline char-
      acter.  If the specified string is preceded by a ^ (circumflex), the
      matched line must begin with string.  If string is null, the previous
      string is used.

  ?string
      Same as / (slash) except that the search is in the forward direction.

  n   Searches for next match of the last pattern to the / or ? commands.

  N   Searches for next match of the last pattern to the / or ? commands, but
      in reverse direction.  Searches the command history for the string
      entered by the previous / command.

  Text Modification Edit Commands
  These commands modify the line.

  a   Enters input mode and enters text after the current character.

  A   Appends text to the end of the line.  Equivalent to $a.

  [count]cmotion
  c[count]motion
      Deletes the current character through the character to which motion
      would move the cursor, and enters input mode.  If motion is c, the
      entire line is deleted and input mode is entered.

  C   Deletes the current character through the end of line, and enters input
      mode.  Equivalent to c$.

  S   Equivalent to cc.

  D   Deletes the current character through the end of line.  Equivalent to
      d$.

  [count]dmotion

  d[count]motion
      Deletes the current character through the character to which motion
      would move.  If motion is d, the entire line is deleted.

  i   Enters input mode and inserts text before the current character.

  I   Inserts text before the beginning of the line.  Equivalent to 0i.

  [count]P
      Places the previous text modification before the cursor.

  [count]p
      Places the previous text modification after the cursor.

  R   Enters input mode and replaces characters on the screen with the char-
      acters you type, overlay fashion.

  [count]rc
      Replaces the count characters, starting at the current cursor position
      with c and advancing the cursor.

  [count]x
      Deletes the current character.

  [count]X
      Deletes the preceding character.

  [count].
      Repeats the previous text modification command.

  [count]~
      Inverts the case of the count characters, starting at the current cur-
      sor position and advancing the cursor.

  [count]_
      Causes the count word of the previous command to be appended and input
      mode entered.  The last word is used if count is omitted.

  *   Causes an * (asterisk) to be appended to the current word and filename
      generation to be attempted.  If no match is found, it rings the bell.
      Otherwise, the word is replaced by the matching pattern and input mode
      is entered.

  \   Filename completion.  Replaces the current word with the longest common
      prefix of all filenames matching the current word with an * (asterisk)
      appended.  If the match is unique, a / (slash) is appended if the file
      is a directory; a space is appended if the file is not a directory.

  Miscellaneous vi Commands
  [count]ymotion

  y[count]motion
      Yanks the current character through the character to which motion would
      move the cursor and puts the characters into the delete buffer.  The
      text and cursor are unchanged.

  Y   Yanks from current position to the end of line.  Equivalent to y$.

  u   Undoes the last text-modifying command.

  U   Undoes all the text-modifying commands performed on the line.

  [count]v
      Returns the command fc -e ${VISUAL:-${EDITOR:-vi}} count in the input
      buffer.  If count is omitted, the current line is used.

  <Ctrl-l>
      Performs a linefeed and prints the current line.  Effective only in
      control mode.

  <Ctrl-j>
      Executes the current line, regardless of mode (newline).

  <Ctrl-m>
      Executes the current line, regardless of mode (enter).

  #   Sends the line after inserting a # (number sign) in front of the line.
      Useful for causing the current line to be inserted in the history
      without being executed.

  =   Lists the filenames that match the current word if an * (asterisk) is
      appended to it.

  @letter
      Searches the alias list for an alias by the name _letter .  If an alias
      of this name is defined, its value is inserted in the input queue for
      processing.

  Special ksh Commands
  The following simple commands are executed in the shell process.
  Input/output redirection is permitted.  Unless otherwise indicated, the
  output is written on file descriptor 1 and the exit status, when there is
  no syntax error, is 0 (zero).

  Commands that are indicated as command1 or command2 are treated specially
  in the following ways:

    o  Parameter assignment lists that precede the command remain in effect
       when the command completes.

    o  I/O redirections are processed after parameter assignments.

    o  Errors cause a script that contains the commands so marked to abort.

    o  Words, following a command specified as command2 that are in the for-
       mat of a parameter assignment, are expanded with the same rules as a
       parameter assignment.  This means that ~ (tilde) substitution is per-
       formed after the = (equal sign).  Word splitting and filename genera-
       tion are not performed.

  :[argument ...]1
      The command only expands arguments.

  .file [argument ...]1
      Reads the complete file and executes the commands.  The commands are
      executed in the current shell environment.  The search path specified
      by PATH is used to find the directory containing file.  If any argu-
      ments are specified, they become the positional parameters.  Otherwise,
      the positional parameters are unchanged.  The exit status is the exit
      status of the last command executed.

  alias [-tx] [name[=value ...]]2
      The alias command with no arguments prints the list of aliases in the
      form name=value on standard output.  An alias is defined for each name
      whose value is given.  A trailing space in value causes the next word
      to be checked for alias substitution.  The -t flag is used to set and
      list tracked aliases.  The value of a tracked alias is the full path-
      name corresponding to the given name.  The value becomes undefined when
      the value of PATH is reset but the aliases remained tracked.  Without
      the -t flag, for each name in the argument list for which no value is
      given, the name and value of the alias is printed.  The -x flag is used
      to set or print exported aliases.  An exported alias is defined for
      scripts invoked by name.  The exit status is nonzero if a name is given
      without a value, and no alias was defined.

  bg [job ...]
      Puts each specified job into the background.  The current job is put
      into the background if job is not specified.  (See Jobs for a descrip-
      tion of the format of job.)

  break [n]1
      Exits from the enclosing for, while, until, or select loop, if any.  If
      n is specified, breaks n levels.

  continue [n]1
      Resumes the next iteration of the enclosing for, while, until, or
      select loop.  If n is specified, resumes at the nth enclosing loop.

  cd [argument]

  cd old new
      This command can be in either of two forms.  In the first form, it
      changes the current directory to argument.  If argument is a - (dash),
      the directory is changed to the previous directory.  The HOME shell
      parameter is the default argument.  The PWD parameter is set to the
      current directory.  The CDPATH shell parameter defines the search path
      for the directory containing argument.  Alternative directory names are
      separated by a : (colon).  The default path is a null string, specify-
      ing the current directory.  Note that the current directory is speci-
      fied by a null pathname, which can appear immediately after the =
      (equal sign) or between the colon delimiters anywhere else in the path
      list.
      If argument begins with a / (slash), the search path is not used.  Oth-
      erwise, each directory in the path is searched for argument.  The
      second form of cd substitutes the string new for the string old in the
      current directory name PWD and tries to change to this new directory.
      The cd command cannot be executed by rsh.

  echo [argument ...]
      Writes arguments to standard output.  See echo for a discussion of its
      usage and arguments.

  eval [argument ...]1
      The arguments are read as input to the shell and the resulting commands
      are executed.

  exec [argument ...]1
      If argument is given, the command specified by the arguments is exe-
      cuted in place of this shell without creating a new process.
      Input/output arguments can appear and affect the current process.  If
      no arguments are given, the effect of this command is to modify file
      descriptors as prescribed by the input/output redirection list.  In
      this case, any file descriptor numbers greater than 2 that are opened
      with this mechanism are closed when invoking another program.

  exit [n]1
      Causes the shell to exit with the exit status specified by n.  If n is
      omitted, the exit status is that of the last command executed.  An
      End-of-File also causes the shell to exit, except for a shell which has
      the ignoreeof option (see set) turned on.

  export [name[=value ...]]2
      The given names are marked for automatic export to the environment of
      subsequently executed commands.

  fc [-e editor] [-nlr] [first [last]]

  fc -e - [old=new] [command]
      In the first form, a range of commands from first to last is selected
      from the last HISTSIZE commands that were entered at the terminal.  The
      arguments first and last can be specified as a number or as a string.
      A string is used to locate the most recent command, starting with the
      given string.  A negative number is used as an offset to the current
      command number.  If the -l flag is selected, the commands are listed on
      standard output.  Otherwise, the editor program editor is invoked on a
      file containing these keyboard commands.
      If editor is not supplied, the value of the parameter FCEDIT (default
      /usr/bin/ed) is used as the editor.  When editing is complete, the
      edited commands are executed.  If last is not specified, then it will
      be set to first.  If first is not specified, the default is the previ-
      ous command for editing and -16 for listing.  The -r flag reverses the
      order of the commands and the -n flag suppresses command numbers when
      listing.  In the second form, the command is reexecuted after the sub-
      stitution old=new is performed.

  fg [job ...]
      Each job specified is brought to the foreground.  Otherwise, the
      current job is brought into the foreground.  (See Jobs for a descrip-
      tion of the format of job.)

  getopts optstring name [argument ...]
      Checks argument for legal options.  If argument is omitted, the posi-
      tional parameters are used.  An option argument begins with a + (plus
      sign) or a - (dash).  An option not beginning with + or - or the argu-
      ment -- ends the options.  optstring contains the letters that getopts
      recognizes.  If a letter is followed by a : (colon), that option is
      expected to have an argument.  The options can be separated from the
      argument by spaces.  getopts places the next option letter it finds
      inside variable name each time it is invoked with a + prepended when
      argument begins with a +.  The index of the next argument is stored in
      OPTIND.
      The option argument, if any, gets stored in OPTARG.  A leading : in
      optstring causes getopts to store the letter of an invalid option in
      OPTARG, and to set name to a ? (question mark) for an unknown option
      and to : when a required option is missing.  Otherwise, getopts prints
      an error message.  The exit status is nonzero when there are no more
      options.

  inlib library_name
      Installs the specified shared library into the shell's private table of
      installed libraries.  This makes the library available for resolution
      of unresolved symbols in commands subsequently executed from this
      shell.

  jobs [-lnp] [job ...]
      Lists information about each given job; or all active jobs if job is
      omitted.  The -l flag lists process IDs in addition to the normal
      information.  The -n flag only displays jobs that have stopped or
      exited since last notified.  The -p flag causes only the process group
      to be listed.  (See Jobs for a description of the format of job.)

  kill [-signal] job ...

  kill -l
      Sends either the TERM signal or the specified signal to the specified
      jobs or processes.  Signals are either given by number or by names (as
      given in /usr/include/signal.h, stripped of the prefix SIG).  If the
      signal being sent is TERM (terminate) or HUP (hangup), the job or pro-
      cess is sent a CONT (continue) signal if it is stopped.  The argument
      job can be the process ID of a process that is not a member of one of
      the active jobs.  (See Jobs for a description of the format of job.) In
      the second form, kill -l, the signal numbers and names are listed.

  let argument ...
      Each argument is a separate arithmetic expression to be evaluated.
      (See Arithmetic Evaluation for a description of arithmetic expression
      evaluation.)  The exit status is 0 (zero) if the value of the last
      expression is nonzero, and 1 otherwise.

  newgrp [-] [group]
      Changes the primary group identification of the current shell process
      to group.  If you specify a - (dash), newgrp changes the login environ-
      ment to the login environment of the new group.  If you do not specify
      a group, newgrp changes the group identification to that specified for
      the current user in the /etc/passwd file.  newgrp recognizes group
      names only; it does not recognize group ID numbers.
      Only a user with superuser authority can change the primary group of
      the shell to one to which that user does not belong.
      Any active user-generated shell is terminated when the newgrp command
      is used.

  print [-Rnprsu[n]] [argument ...]
      The shell output mechanism.  With no flags or with flag - or --, the
      arguments are printed on standard output as described by echo.  In raw
      mode, -R or -r, the escape conventions of echo are ignored.  The -R
      option prints all subsequent arguments and options other than -n.
      The -p option causes the arguments to be written onto the pipe of the
      process spawned with |& instead of standard output.  The -s option
      causes the arguments to be written onto the history file instead of
      standard output.  The -u flag can be used to specify a 1-digit file
      descriptor unit number n on which the output will be placed.  The
      default is 1.  If the -n flag is used, no newline is added to the out-
      put.

  pwd Equivalent to print -r - $PWD.

  read [-prsu[n]] [name?prompt] [name ...]
      The shell input mechanism.  One line is read and is broken up into
      fields using the characters in IFS as separators.  In raw mode, a \
      (backslash) at the end of a line does not signify line continuation.
      The first field is assigned to the first name, the second field to the
      second name, and so on, with leftover fields assigned to the last name.
      The -p flag causes the input line to be taken from the input pipe of a
      process spawned by the shell using |&.  If the -s flag is present, the
      input will be saved as a command in the history file.  The -u flag can
      be used to specify a 1-digit file descriptor unit to read from.  The
      file descriptor can be opened with the exec special command.  The
      default value of n is 0 (zero).  If name is omitted, REPLY is used as
      the default name.  The exit status is 0 (zero) unless an End-of-File is
      encountered.  An End-of-File with the -p flag causes cleanup for this
      process so that another can be spawned.  If the first argument contains
      a ? (question mark), the remainder of this word is used as a prompt on
      standard error when the shell is interactive.  The exit status is 0
      (zero) unless an End-of-File is encountered.

  readonly [name[=value ...]]2
      The given names are marked read-only.  These names cannot be changed by
      subsequent assignment.

  return [n]1
      Causes a shell function to return to the invoking script with the
      return status specified by n.  If n is omitted, the return status is
      that of the last command executed.  If return is invoked while not in a
      function or a . (dot) script, it is the same as an exit.

  rmlib library_name
      Removes the specified shared library from the shell's private table of
      installed libraries.  This library is no longer available for resolu-
      tion of unresolved symbols in commands executed from this shell.

  set [+ | -aefhkmnopstuvx] [+ | -o option ...] [+ | -A name] [argument ...]
      Preceding a flag with + sets the parameter, and preceding the flag with
      - unsets the parameters.  The flags for the set command have the fol-
      lowing meanings:

      A name
          Array assignment.  Unset the variable name and assign values
          sequentially from the list argument.  If +A is used, the variable
          name is not unset first.

      a   All subsequent parameters that are defined are automatically
          exported.

      e   If a command has a nonzero exit status, executes the ERR trap, if
          set, and exits.  This mode is disabled while reading profiles.

      f   Disables filename generation.

      h   Each command becomes a tracked alias when first encountered.

      k   All parameter assignment arguments are placed in the environment
          for a command, not just those that precede the command name.

      m   Background jobs will run in a separate process group and a line
          will print upon completion.  The exit status of background jobs is
          reported in a completion message.  On systems with job control,
          this flag is turned on automatically for interactive shells.

      n   Reads commands and checks them for syntax errors, but does not exe-
          cute them.  Ignored for interactive shells.

      o   The argument can be one of the following option names:

          allexport
              Same as a.

          errexit
              Same as e.

          bgnice
              Runs all background jobs at a lower priority.  This is the
              default mode.

          emacs
              Invokes an emacs style inline editor for command entry.

          gmacs
              Invokes a gmacs-style inline editor for command entry.

          ignoreeof
              The shell does not exit on End-of-File.  The exit command must
              be used.

          keyword
              Same as k.

          markdirs
              All directory names resulting from filename generation have a
              trailing / (slash) appended.

          monitor
              Same as m.

          noclobber
              Prevents redirection > from truncating existing files.
              Requires >| to truncate a file when turned on.

          noexec
              Same as n.

          noglob
              Same as f.

          nolog
              Does not save function definitions in history file.

          nounset
              Same as u.

          privileged
              Same as p.

          verbose
              Same as v.

          trackall
              Same as h.

          vi  Invokes, in insert mode, a vi-style inline editor until you
              press Escape (ASCII 033).  This changes to move mode.  A return
              sends the line.

          viraw
              Each character is processed as it is entered in vi mode.

          xtrace
              Same as x.
              If no option name is supplied, then the current option settings
              are printed.

      p   Disables processing of the $HOME/.profile file and uses the
          /etc/suid_profile file instead of the ENV file.  This mode is on
          whenever the effective user ID or group ID is not equal to the real
          user ID or group ID.  Turning this off causes the effective user ID
          and group ID to be set to the real user ID and group ID.

      s   Sorts the positional parameters.

      t   Exits after reading and executing one command.

      u   Treats unset parameters as an error when substituting.

      v   Prints shell input lines as they are read.

      x   Prints commands and their arguments as they are executed.

      -   Unsets x and v flags and stops examining arguments for flags.

      --  Does not change any of the flags; useful in setting $1 to a value
          beginning with -.  If no arguments follow this flag, the positional
          parameters are unset.
          These flags can also be used upon invocation of the shell.  The
          current set of flags can be found in $-.  Unless -A is specified,
          the remaining arguments are positional parameters and are assigned,
          in order, to $1 $2 ....  If no arguments are given, the names and
          values of all named parameters are printed on the standard output.
          If the only argument is +, the names of all named parameters are
          printed.

  shift [n]1
      The positional parameters from $n+1 ...  are renamed $1 ...  , default
      n is 1.  The argument n can be any arithmetic expression that evaluates
      to a nonnegative number less than or equal to $#.

  times1
      Prints the accumulated user and system times for the shell and for
      processes run from the shell.

  trap [argument] [signal ...]1
      The argument variable specifies a command to be read and executed when
      the shell receives the specified signals.  (Note that argument is
      scanned once when the trap is set and once when the trap is taken.)
      Each signal can be given as a number or as the name of the signal.
      Trap commands are executed in order of signal number.  Any attempt to
      set a trap on a signal that was ignored on entry to the current shell
      is ineffective.
      If argument is omitted or is -, all traps signal are reset to their
      original values.  If argument is the null string, this signal is
      ignored by the shell and by the commands it invokes.  If signal is ERR,
      argument is executed whenever a command has a nonzero exit status.  If
      signal is DEBUG, argument is executed after each command.  If signal is
      0 or EXIT and the trap statement is executed inside the body of a func-
      tion, the command argument is executed after the function completes.
      If signal is 0 (zero) or EXIT for a trap set outside any function, the
      command argument is executed on exit from the shell.  The trap command
      with no arguments prints a list of commands associated with each signal
      number.

  typeset [+ | -HLRZfilrtux[n]] [name[=value ...]]2
      Sets attributes and values for shell parameters.  When invoked inside a
      function, a new instance of the parameter name is created.  The parame-
      ter value and type are restored when the function completes.  The fol-
      lowing list of attributes can be specified:

      -f  The names refer to function names rather than parameter names.  No
          assignments can be made and the only other valid flags are -t, -u,
          and -x.  The -t flag turns on execution tracing for this function.
          The -u flag causes this function to be marked undefined.  The FPATH
          variable is searched to find the function definition when the func-
          tion is referenced.  The -x flags allows the function definition to
          remain in effect across shell procedures invoked by name.

      -H  Provides OSF/1 system-to-hostname file mapping on machines that
          restrict the set of characters in filenames.

      -i  Parameter is an integer.  This makes arithmetic faster.  If n is
          nonzero, it defines the output arithmetic base; otherwise, the
          first assignment determines the output base.

      -l  All uppercase characters are converted to lowercase.  The uppercase
          -u flag is turned off.

      -L  Left justifies and removes leading spaces from value.  If n is
          nonzero, it defines the width of the field; otherwise, it is deter-
          mined by the width of the value of first assignment.  When the
          parameter is assigned, it is filled on the right with spaces or
          truncated, if necessary, to fit into the field.  Leading zeros are
          removed if the -Z flag is also set.  The -R flag is turned off.

      -r  The given names are marked read-only and these names cannot be
          changed by subsequent assignment.

      -R  Right justifies and fills with leading spaces.  If n is nonzero, it
          defines the width of the field; otherwise, it is determined by the
          width of the value of first assignment.  The field is left-filled
          with spaces or truncated from the end if the parameter is reas-
          signed.  The L flag is turned off.

      -t  Tags the named parameters.  Tags are user definable and have no
          special meaning to the shell.

      -u  All lowercase characters are converted to uppercase characters.
          The lowercase -l flag is turned off.

      -x  The given names are marked for export.

      -Z  Right justifies and fills with leading zeros if the first nonspace
          character is a digit and the -L flag was not set.  If n is nonzero,
          it defines the width of the field; otherwise, it is determined by
          the width of the value of first assignment.
      Using + (plus sign) rather than - (dash) causes these flags to be
      turned off.  If no name arguments are given but flags are specified, a
      list of names (and optionally the values) of the parameters that have
      these flags set is printed.  (Using + rather than - keeps the values
      from being printed.)  If no names and flags are given, the names and
      attributes of all parameters are printed.

  ulimit [-HSacdfmnpstvw] [limit]
      Sets or displays a resource limit.  Available resources limits follow.
      Many systems do not contain one or more of these limits.  The limit for
      a specified resource is set when limit is specified.  The value of
      limit can be a number in the unit specified with each resource, or the
      value unlimited.
      The H and S flags specify whether the hard limit or the soft limit for
      the given resource is set.  A hard limit cannot be increased once it is
      set.  A soft limit can be increased up to the value of the hard limit.
      If neither H nor S is specified, the limit applies to both.  The
      current resource limit is printed when limit is omitted.  In this case,
      the soft limit is printed unless H is specified.  When more than one
      resource is specifed, the limit name and unit are printed before the
      value.

      -a  Lists all of the current resource limits.

      -c  The number of 512-byte blocks on the size of core dumps.

      -d  The number of Kilobytes on the size of the data area.

      -f  The number of 512-byte blocks on files written by child processes
          (files of any size can be read).

      -m  The number of Kilobytes on the size of physical memory.

      -n  The number of file descriptors.

      -p  The number of 512-byte blocks for pipe buffering.

      -s  The number of Kilobytes on the size of the stack area.

      -t  The number of seconds to be used by each process.

      -v  The number of Kilobytes for virtual memory.

      -w  The number of Kilobytes for the swap area.
          If no option is given, -f is assumed.

  umask [mask]
      The user file-creation mask is set to mask  (See umask.)  mask can
      either be an octal number or a symbolic value, as described in chmod.
      If a symbolic value is given, the new umask value is the complement of
      the result of applying mask to the complement of the previous umask
      value.  If mask is omitted, the current value of the mask is printed.

  unalias name ...
      The parameters given by the list of names are removed from the alias
      list.

  unset [-f] name ...
      The parameters given by the list of names are unassigned, that is,
      their values and attributes are erased.  Read-only variables cannot be
      unset.  If the -f flag is set, the names refer to function names.
      Unsetting ERRNO, LINENO, MAILCHECK, OPTARG, OPTIND, RANDOM, SECONDS,
      TMOUT, and _ removes their special meaning even if they are subse-
      quently assigned.

  {wait [job]
      Waits for the specified job and reports its termination status.  If job
      is not given, all currently active child processes are waited for.  The
      exit status from this command is that of the process waited for.  (See
      Jobs for a description of the format of job.)

  whence [-pv] name ...
      For each name, indicates how it would be interpreted if used as a com-
      mand name.  The -v flag produces a more verbose report.  The -p flag
      does a path search for name even if name is an alias, a function, or a
      reserved word.

  Invocation
  If the shell is invoked by exec, and the first character of argument zero
  ($0) is - (dash), the shell is assumed to be a login shell and commands are
  read from /etc/profile and then from either .profile in the current direc-
  tory or $HOME/.profile, if either file exists.  Next, commands are read
  from the file named by performing parameter substitution on the value of
  the ENV environment variable, if the file exists.  If the -s flag is not
  present and argument is present, a path search is performed on the first
  argument to determine the name of the script to execute.  The script argu-
  ment must have read permission and any setuid and getgid settings are
  ignored.  Commands are then read, as described in the following text.

  See the FLAGS section for a complete description of flags that can be
  interpreted by the shell when it is invoked.

FILES

  /etc/profile
             System profile.

  $HOME/.profile
             User profile.

  /etc/passwd
             Contains user information.

NOTES

   1.  If a command is executed, and a command with the same name is
       installed in a directory in the search path before the directory where
       the original command was found, the shell will execute the original
       command.  Use the hash command to correct this situation.

   2.  When the shell encounters the >> characters, it does not open the file
       in append mode; instead, the shell opens the file for writing and
       seeks to the end.

   3.  Failure (nonzero exit status) of a special command preceding a || sym-
       bol prevents the list following || from executing.

   4.  If a command that is a tracked alias is executed, and then a command
       with the same name is installed in a directory in the search path
       before the directory where the original command was found, the shell
       continues to exec the original command.  Use the -t flag of the alias
       command to correct this situation.

   5.  Using the fc built-in command within a compound command causes the
       whole command to disappear from the history file.

   6.  The built-in .file command reads the whole file before any commands
       are executed.  Therefore, the alias and unalias commands in the file
       do not apply to any functions defined in the file.

   7.  Traps are not processed while a job is waiting for a foreground pro-
       cess.  Thus, a trap on CHLD is not executed until the foreground job
       terminates.

EXIT VALUES

  Errors detected by the shell, such as syntax errors, cause the shell to
  return a nonzero exit status.  Otherwise, the shell returns the exit status
  of the last command executed.  (See also the exit command, described previ-
  ously.)  If the shell is being used noninteractively, execution of the
  shell file is abandoned.  Run-time errors detected by the shell are
  reported by printing the command or function name and the error condition.
  If the line number that the error occurred on is greater than 1, the line
  number is also printed in [ ] (brackets) after the command or function
  name.

RELATED INFORMATION

  Commands:  cat(1), cd(1), chmod(1), csh(1), echo(1), env(1)/printenv(1),
  sh(1), stty(1), test(1), umask(1), vi(1)/vedit(1)/view(1).

  Functions:  exec(2), fcntl(2), fork(2), ioctl(2), ldr_install(2),
  ldr_remove(2), lseek(2), pipe(2), rand(3), sigaction(2), umask(2),
  ulimit(3), wait(2).

  Files:  osf_rose(4), null(7).

  The environ variable.

  The OSF/1 User's Guide, which discusses the OSF/1 shells and some useful
  shell functions.

  "Using Internationalization Features" in the OSF/1 User's Guide.


lint(1)                                                               lint(1)

NAME

  lint - Checks C programs for potential problems

SYNOPSIS

  lint [-abchnpuvx] [-Dname[=definition]] [-Idirectory] [-lkey] [-o library]
       [-MA]
       [-Ndnumber] [-Nlnumber] [-Nnnumber] [-Ntnumber] [-Uname]
       [-w class...] [file...]

  The lint command checks C language source code for coding and syntax errors
  and for inefficient or nonportable code.

FLAGS

  -a  Suppresses messages about assignments of long values to variables that
      are not long.

  -b  Suppresses messages about unreachable break statements.

  -c  Causes the lint program to produce a .ln file for every .c file on the
      command line. These .ln files are the product of the first pass of the
      lint program only and are not checked for interfunction compatibility.

  -h  Does not try to detect bugs, improper style, or reduce waste.

  -lkey
      Includes the additional library llib-lkey.ln.  You can include a ver-
      sion of the math library llib-lm.ln by specifying -lm on the command
      line.  Use this flag to include local libraries when checking files
      that are part of a project having a large number of files. This flag
      does not prevent lint from using the llib-lc.ln library. The library
      must be in the /usr/ccs/lib/lint directory.

  -MA Enforces ANSI C Standard rules. The default mode is extended C mode.
      ANSI mode prepends (adds at the beginning) the standard ANSI library
      function prototypes in place of the default extended mode C library.
      ANSI mode enforces a stricter interfile object reference/definition
      linkage checking.

  -n  Suppresses the check for compatibility with either the standard or the
      portable lint libraries. This applies for both ANSI and extended mode
      libraries.

  -Ndnumber
      Changes the dimension table size to number.  The default value of
      number is 2000.

  -Nlnumber
      Changes the number of type nodes to number.  The default value of
      number is 8000.

  -Nnnumber
      Increases the size of the symbol table to number. The default size is
      1500.

  -Ntnumber
      Changes the number of tree nodes to number.  The default value of
      number is 1000.

  -o library
      Causes the lint program to create a library with the name llib-
      llibrary.ln. The -c flag nullifies any use of the -o flag. The library
      produced is the input that is given to the second pass of the lint pro-
      gram. The -o flag causes this file to be saved in the named lint
      library. To produce a llib-llibrary.ln without extraneous messages, use
      the -x flag. The -v flag is useful if the source files for the lint
      library are just external interfaces (for example, the way the file
      llib-lc is written). These flag settings are also available through the
      use of lint comment lines.

  -p  Checks for portability to other C dialects.

  -u  Suppresses messages about functions and external variables that are
      either used and not defined or defined and not used. Use this flag to
      run the lint command on a subset of files of a larger program.

  -v  Suppresses messages about function arguments that are not used.

  -w class [class...]
      Controls the reporting of warning classes. All warning classes are
      active by default, but may be individually activated by including the
      appropriate option as part of the class argument. The individual
      options are as follows:

      a   Non-ANSI features

      c   Comparisons with unsigned values

      d   Declaration consistency

      h   Heuristic complaints

      k   Suppresses the following messages:

            o
            static function %s is not defined or used

            o
            argument %s is unused in function %s

            o
            %s set but not used in function %s

            o
            %s redefinition hides earlier one

            o
            partially elided initialization

            o
            function prototype not in scope

            o
            %s may be used before set
          Note that other flags may also suppress these messages.

      l   Assignment of long values to variables that are not long

      n   Null-effect code

      o   Unknown order of evaluation

      p   Various portability concerns

      r   Return statement consistency

      u   Proper usage of variables and functions

      A   Deactivate all warnings

      C   Constants occurring in conditionals

      D   External declarations are never used

      O   Obsolescent features

      P   Suppresses the messages function prototype not in scope and old
          style argument declaration

      R   Detection of unreachable code

      S   Storage capacity checks

  -x  Suppresses messages about variables that have external declarations but
      are never used.

  In addition, the lint command recognizes the following flags of the cpp
  macro preprocessor:

  -Idirectory
      Adds directory to the list of directories in which the lint program
      searches for the #include files.

  -Dname[=definition]
      Defines the name, as if by #define. The default definition is 1.

  -Uname
      Removes any initial definition of name, where name is a reserved symbol
      that is predefined by the particular preprocessor.

DESCRIPTION

  You can use lint to do the following:

    o  Identify source code and library incompatibility.

    o  Enforce type checking rules more often, and in some cases, more
       strictly than the compiler.

    o  Identify potential problems with variables.

    o  Identify potential problems with functions.

    o  Identify problems with flow control.

    o  Identify legal constructions that may produce errors or be ineffi-
       cient.

    o  Identify unused variable and function declarations.

    o  Identify possibly nonportable code.
  The interfile usage of functions is checked to find functions that return
  values in some instances and not in others, functions called with varying
  numbers or types of arguments, and functions whose values are not used or
  whose values are used but not returned.
  The lint command interprets filename extensions as follows:

    o  Filenames ending in .c are C Language source files

    o  Filenames ending in .ln are nontext files that lint produces when
       either the -c or the -o flag is used.  The lint command warns you
       about files with other suffixes and ignores them.

  The lint command takes all the .c and .ln files and the libraries specified
  by -l flags and processes them in the order that they appear on the command
  line. By default, it adds the standard lint library (llib-lc.ln) to the end
  of the list of files. However, when you select the -p flag, the lint com-
  mand uses the portable library llib-port.ln.  By default, the second pass
  of lint checks this list of files for mutual compatibility; however, if you
  specify the -c flag, the .ln and lib-lx files are ignored.

  The -c and -o flags allow for incremental use of the lint program on a set
  of C Language source files.  Generally, use the lint command once for each
  source file with the -c flag. Each of these runs produces a .ln file that
  corresponds to the .c file and writes all messages concerning that source
  file.

  After you have run all source files separately through the lint program,
  run it once more, without the -c flag, listing all the .ln files with the
  needed -l arguments. This writes all interfile inconsistencies. This pro-
  cedure works well with the make command, allowing it to run the lint com-
  mand on only those source files modified since the last time that set of
  source files was checked.

  The following comments in a C source program change the way that lint
  operates when checking the source program:

  /*NOTREACHED*/
      Suppresses comments about unreachable code.

  /*VARARGSn*/
      Suppresses checking the following old style function declaration for
      varying numbers of arguments, but does check the data type of the first
      n arguments. If you do not include a value for n, lint checks no argu-
      ments (n=0). ANSI function prototypes should use the ellipsis to indi-
      cate unspecified arguments rather than this comment mechanism.

  /*ARGSUSED*/
      Suppresses warnings about function arguments not used within the func-
      tion definition.

  /*LINTLIBRARY*/
      If you place this comment at the beginning of a file, lint does not
      identify unused functions, and function arguments in the file. This is
      used when running the lint command on libraries.

  /*NOTUSED*/
      Suppresses warnings about unused external symbols, functions and func-
      tion arguments in the file beginning at its point of occurrence.  This
      is a superset of the /*LINTLIBRARY*/ comment directive, but applies
      also to external symbols. It is useful for suppressing warnings about
      unused function prototypes and other external object declarations.

  /*NOTDEFINED*/
      Suppresses warnings about used but undefined external symbols and
      functions in the file beginning at its point of occurrence.

  /*LINTSTDLIB*/
      Permits a standard prototype checking library to be formed from header
      files by making function prototypes declarations appear as function
      definitions. This directive implicitly activates both /*NOTUSED*/ and
      /*LINTLIBRARY*/ to reduce warning noise levels.

  The lint command produces its warning messages in a consistent format with
  cc; namely, warnings give filename and line number. As each file goes
  through the first pass, warnings for each file and each line number are
  reported.

  If you have not specified the -c flag, the lint program collects informa-
  tion gathered from all input files and checks it for consistency. At this
  point, if it is not clear whether a message stems from a given source file
  or from one of its included files, the lint command displays the source
  filename followed by a ? (question mark).

  If your ANSI programs include many standard header files, consider setting
  the -wD option to reduce the quantity of warnings about prototypes not
  used, and the -n option to disable checking against the ANSI standard
  library. For non-ANSI programs, it is advisable to specify the -wk option
  to reduce the amount of warnings concerning the absence of function proto-
  types.

EXAMPLES

   1.  To check a C program for errors, enter:
       lint program.c
   2.  To suppress some of the messages, enter:
       lint -v -x program.c

       This checks program.c, but does not display error messages about
       unused function arguments (-v) or unused externals (-x).

   3.  To check the program against an additional lint library, enter:
       lint -lsubs program.c

       This checks program.c against both the standard lint library
       (/usr/ccs/lib/lint/llib-lc.ln) and /usr/ccs/lib/lint/llib-lsubs.ln.

   4.  To check against the portable library and an additional library,
       enter:
       lint -lsubs -p program.c

       This checks program.c against both the portable lint library
       (/usr/ccs/lib/lint/llib-port.ln) and /usr/ccs/lib/lint/llib-lsubs.ln.

   5.  To check against a nonstandard library only, enter:
       lint -lsubs -n program.c

       This checks program.c against only /usr/ccs/lib/lint/llib-lsubs.ln.

FILES

  /usr/ccs/lib/lint/llib-lansi.c
             Declarations for Standard ANSI functions (source).

  /usr/ccs/lib/lint/llib-lansi.ln
             Declarations for Standard ANSI functions (binary format).

  /usr/ccs/lib/lint/llib-lc.c
             Declarations for standard functions (source).

  /usr/ccs/lib/lint/llib-lc.ln
             Declarations for standard functions (binary format).

  /usr/ccs/lib/lint/llib-lm.c
             Declarations for standard math functions (source).

  /usr/ccs/lib/lint/llib-lm.ln
             Declarations for standard math functions (binary format).

  /usr/ccs/lib/lint/llib-port.c
             Declarations for portable functions (source).

  /usr/ccs/lib/lint/llib-port.ln
             Declarations for portable functions (binary format).

  /usr/ccs/lib/lint/llib-lcrses.c
             Declarations for curses definition (source).

  /usr/ccs/lib/lint/llib-lcrses.ln
             Declarations for the curses library (binary format).

  /var/tmp/*lint*
             Temporary files.

RELATED INFORMATION

  Commands: make(1).


lp(1)                                                                   lp(1)

NAME

  lp, cancel - Sends or cancels a printing request

SYNOPSIS

  lp [-cmsw] [-dprinter] [-nnumber] [-ttitle] [file ...]

  cancel [request_ID ...] [printer ...]

  The lp command sends the specified files and associated information (col-
  lectively called a request) to a line printer for printing.  The cancel
  command cancels printing requests.

FLAGS

  Flags for the lp command can appear in any order and can be mixed with
  filenames.

  -c  Makes copies of the files to be printed immediately when lp is invoked.
      Normally, files are not copied, but are linked whenever possible.  If
      the -c flag is not given, be careful not to remove any of the files
      before the request is finished printing.  Note also that in the absence
      of the -c flag any changes made to the named files after the request is
      made, but before it is printed, are reflected in the printed output.

  -dprinter
      Selects printer as the device to do the printing (also known as the
      printing destination).  Under certain conditions (printer unavailabil-
      ity, file space limitations, and so on), requests for specific destina-
      tions cannot be accepted.  By default, printer is taken from the LPDEST
      environment variable if it is set.  Otherwise, the PRINTER environment
      variable or a default destination, if one exists, for the system is
      used.  Destination names vary between systems.  (See the lpq and lpstat
      commands.)

  -m  Sends mail (see the mailx command) after the files are printed.  By
      default, no mail is sent upon normal completion of the print request.

  -nnumber
      Prints number copies (default of 1).

  -s  Suppresses messages from lp, such as request id is ...

  -ttitle
      Prints title on the banner page of the output.

  -w  Functions like -m (for compatibility reasons).

DESCRIPTION

  The lp command associates a unique ID with each request and prints it on
  the standard output.  If you do not specify a file, or specify a - (dash)
  in place of a file, lp accepts standard input at this point in the list of
  files.

  The cancel command cancels printer requests made by the lp or lpr commands
  (see lpr).  You can specify either request_ID, to cancel the request with
  that request ID, or printer, to cancel all requests made by you with that
  printer as the destination.  (If you are operating with superuser author-
  ity, all requests to that printer are cancelled, including those of other
  users.) A specified request is cancelled even if it is currently printing,
  and the printer is freed to print the next available request.

  You can also use the request ID to find the status of the request (see the
  lpq and lpstat commands).

FILES

  /etc/printcap
             Printer description file.

  /var/spool/*
             Spool directories.

  /var/spool/*/cf*
             Daemon control files.

  /var/spool/*/df*
             Data files specified in cf files.

  /var/spool/*/tf*
             Temporary copies of cf files.

  /var/spool/*/minfree
             Minimum free space to leave.

  /dev/lp*   Line printer devices.

  /dev/printer
             Socket for local requests.

RELATED INFORMATION

  Commands:  lpc(8), lpd(8), lpq(1), lpr(1), lprm(1), lpstat(1),
  mailx(1)/Mail(1).


lpq(1)                                                                 lpq(1)

NAME

  lpq - Spool queue examination program

SYNOPSIS

  lpq [+][number] [-l] [-Pprinter] [request_ID ...] [user ...]

  The lpq command examines the spooling area used by lpd for printing files
  on the line printer, and reports the status of the specified requests or
  all requests associated with a user.

FLAGS

  -l  Displays information about each of the files comprising the printer
      request.

  -Pprinter
      Specifying printer displays requests queued for that printer only.

  +[number]
      Displays the spool queue until it empties.  Sleeps number seconds
      between scans of the queue if number is specified.

DESCRIPTION

  The lpq command invoked without any arguments reports on any requests
  currently in the queue.  The -P flag may be used to specify a particular
  printer; otherwise, the default line printer is used (or the value of the
  PRINTER environment variable).

  Specifying one or more request_IDs displays only the specified requests.
  Specifying one or more users displays print requests from those users only.

  If you specify the + argument, lpq displays the spool queue until it emp-
  ties.  Supplying a number immediately after the + argument indicates that
  lpq should sleep number seconds in between scans of the queue.  All other
  arguments supplied are interpreted as user or request_ID arguments to
  filter out only those requests of interest.

  For each request submitted (that is, each request invoked by lp or lpr) lpq
  reports the user's name, current rank in the queue, the names of files
  comprising the request, the request ID (a number that you can use to iden-
  tify the request to other commands, such as lprm) and the total size in
  bytes.

  The -l flag causes information about each of the files comprising the
  request to be printed; without it, only as much information as will fit on
  one line is displayed.  Job ordering depends on the algorithm used to scan
  the spooling directory and is supposed to be FIFO (First In First Out).
  Filenames comprising a request may be unavailable (when lp or lpr is used
  as a sink in a pipeline) in which case the file is indicated as follows:
  standard input
EXAMPLES

  To display a request in the print queue, enter:
  lpq -Pprinter1
  This command displays a list similar to the following:
  Mon March 2 15:15:15 1990: printer1 is ready and printing

  Rank    Pri     Owner   Job     Files                   Total Size
  active   0      rcb     888     massachusetts           1024 bytes
  1st      0      jmp     110     berkshire               2048 bytes
  (Output may be formatted differently on your system.)

FILES

  /usr/share/lib/termcap
             Manipulates the screen for repeated display.

  /etc/printcap
             Printer description file.

  /var/spool/*
             Spool directories.

  /var/spool/*/cf*
             Daemon control files.

  /var/spool/*/df*
             Data files specified in cf files.

  /var/spool/*/tf*
             Temporary copies of cf files.

  /var/spool/*/lock
             Lock file used to obtain the process ID of the current daemon
             and the request ID of the currently active request.

NOTES

  Due to the dynamic nature of the information in the spooling directory, lpq
  may report unreliably.  Output formatting is sensitive to the line length
  of the terminal; this can result in widely spaced columns.

DIAGNOSTICS

  Appropriate diagnostic messages appear under several conditions:

    o  If there is no daemon active, but there are files in the spooling
       directory, the message Warning: no daemon present is displayed.

    o  If the network is unreachable, the message connection to device is
       down is displayed.

    o  If the printcap file is unavailable, the message lpq: device cannot
       open printer description file is displayed.

    o  If the spooling directory is unavailable, the message lpq: device can-
       not chdir to spooling directory is displayed.

  An appropriate message is displayed if the lock file is malformed.

RELATED INFORMATION

  Commands: lp(1)/cancel(1), lpc(8), lpd(8), lpr(1), lprm(1), lpstat(1).


lpr(1)                                                                 lpr(1)

NAME

  lpr - Sends files to spooling daemon for printing

SYNOPSIS

  lpr [-hjmrs] [filetype_flag] [-C class] [-i] [number] [-J name] [-Pprinter]
       [-T title] [-#number] [-1 font, -2 font, -3 font, -4 font] [-wnumber]
       file ...  | -

  The lpr command uses a spooling daemon to print the named files when facil-
  ities become available.

FLAGS

  Several of the following flags, indicated by filetype_flag in SYNOPSIS, are
  used to notify the line printer spooler that the files are not standard
  text files (-c, -d, -f, -g, -l, -n, -p, -t, -v).  These flags, therefore,
  are mutually exclusive.  The spooling daemon uses the appropriate filters
  to print the data when you specify one of these flags.

  -c  Assumes that the files contain data produced by the cifplot filter.

  -C class
      Specifies a print class as the request classification on the burst
      page.

  -d  Assumes that files contain data from tex (DVI format from Stanford
      University).

  -f  Interprets the first character of each line as a standard FORTRAN car-
      riage control character.

  -g  Assumes that files contain standard plot data as produced by plot rou-
      tines.

  -h  Suppresses the printing of the burst page.

  -i [number]
      Indents the output number spaces.  If number is not given, prints 8
      spaces.

  -j  Causes the request ID of the printer request to be displayed on stan-
      dard output after it is entered in the queue.

  -J name
      Specifies the request name to appear on the burst page.  Normally, the
      lpr command uses the name of the first file.

  -l  Prints control characters and suppresses page breaks.

  -m  Sends mail (see the mailx command) upon completion of spooling.

  -n  Assumes that files contain data from ditroff (device independent
      troff).

  -p  Formats the files using pr as a filter.

  -Pprinter
      Specifies printer as the output device (also known as the destination).
      Without it, the default printer or the value of the PRINTER environment
      variable is used.

  -r  Removes the file on completion of spooling or on completion of printing
      (with -s).

  -s  Uses symbolic links.  Usually files are copied to the spool directory.
      The -s flag uses symlink() to link data files, rather than trying to
      copy them, so large files can be printed.  This means the files should
      not be modified or removed until they are printed.

  -t  Assumes that files contain data from troff (cat phototypesetter com-
      mands) binary data.

  -T title
      Specifies the title to be used by the pr command in place of the
      filename.  Use with the -p flag.

  -v  Assumes that the files contain a raster image for devices like the Ben-
      son Varian.

  -wnumber
      Defines the page width for pr.

  -#number
      Produces number copies of the output.

  -1 font, -2 font, -3 font, -4 font
      Mounts the specified font on font position 1, 2, 3, or 4.

DESCRIPTION

  The filename - (dash) stands for standard input and can be used in conjunc-
  tion with the named files.  If no files are specified, lpr reads from stan-
  dard input.

  The -P flag selects the specified printer as the output device.  Normally,
  the default printer or the value of the PRINTER environment variable is
  used.

  To check the status of printer requests made with the lpr or lp commands
  (see lp), use the lpq or lpstat commands.  To cancel printer requests, use
  the lprm or cancel commands.

EXAMPLES

   1.  To print three copies of the files new.index.c, print.index.c, and
       more.c, enter:
       lpr -#3 new.index.c print.index.c more.c
   2.  To print three copies of the concatenation of the three files
       new.index.c, print.index.c, and more.c, enter:
       cat new.index.c print.index.c more.c |lpr -#3
   3.  To print Operations on the burst page before the file new.index.c,
       enter:
       lpr -C Operations new.index.c

       This causes the system name (the name returned by hostname) to be
       replaced on the burst page by Operations, and the file new.index.c to
       be printed.
FILES

  /etc/passwd
             Contains user information.

  /etc/printcap
             Printer description file.

  /usr/sbin/lpd
             Line printer daemon.

  /var/spool/*
             Spool directories.

  /var/spool/*/cf*
             Daemon control files.

  /var/spool/*/df*
             Data files specified in cf files.

  /var/spool/*/tf*
             Temporary copies of cf files.

NOTES

   1.  If you try to spool too large a file, the file will be truncated.  lpr
       will object to printing binary files.  If a user other than the root
       user prints a file and spooling is disabled, lpr will print a message
       saying so and will not put requests in the queue.  If a connection to
       lpd on the local machine cannot be made, lpr will say that the daemon
       cannot be started.

   2.  Fonts for troff and text reside on the host with the printer.  It is
       not currently possible to use local font libraries.

RELATED INFORMATION

  Commands: lp(1)/cancel(1), lpc(8), lpd(8), lpq(1), lprm(1), lpstat(1),
  mailx(1)/Mail(1), pr(1).

  Functions:  symlink(2).


lprm(1)                                                               lprm(1)

NAME

  lprm - Removes requests from the line printer spooling queue

SYNOPSIS

  lprm [-Pprinter] [-] [request_ID ...] [user ...]

  The lprm command removes one or more requests from a printer's spool queue.

FLAGS

  -   Removes all requests that a user owns.  If specified by a user with
      superuser authority, the spool queue is emptied entirely.

  -Pprinter
      Specifies the queue associated with a specific printer; otherwise, the
      default printer or the value of the PRINTER variable in the environment
      is used.

DESCRIPTION

  Because the spooling directory is protected from users, using lprm is nor-
  mally the way a user can remove a request.

  The lprm command without any arguments deletes the currently active request
  if it is owned by the user who invoked lprm.

  The - flag removes all requests from the user issuing the command.  If a
  user who has superuser authority uses this flag, the spool queue is emptied
  entirely.  The owner is determined by the user's username and hostname on
  the machine where the lpr command was invoked.

  You can remove an individual request from a queue by specifying its request
  ID.  (You can obtain the request ID by using the lpq or lpstat commands.)
  Specifying one or more users removes any requests queued belonging to those
  users. This works only for a user with superuser authority.

  The lprm command is silent if there are no requests in the queue that match
  the request list.

  The lprm command kills an active daemon, if necessary, before removing any
  spooling files.  If a daemon is killed, a new one is automatically res-
  tarted upon completion of file removals.

EXAMPLES

   1.  To remove a request from the default queue by specifying the request
       ID, enter:
       lprm 13
   2.  To remove a request from a specific queue, enter:
       lprm -Plp0 13
   3.  To remove from a specific queue a request from user guest, enter:
       lprm -Plp0 guest
FILES

  /etc/printcap
             Printer description file.

  /var/spool/*
             Spool directories.

  /var/spool/*/cf*
             Daemon control files.

  /var/spool/*/df*
             Data files specified in cf files.

  /var/spool/*/tf*
             Temporary copies of cf files.

  /var/spool/*/lock
             Lock file used to obtain the process ID of the current daemon
             and the request ID of the currently active request.

NOTES

  Because race conditions are possible in the update of the lock file, the
  currently active request may be incorrectly identified.

DIAGNOSTICS

  Permission denied
                The user tried to remove files that belong to another user.

RELATED INFORMATION

  Commands: lp(1)/cancel(1), lpc(8), lpd(8), lpq(1), lpr(1), lpstat(1).


lpstat(1)                                                           lpstat(1)

NAME

  lpstat - Displays line printer status information

SYNOPSIS

  lpstat [-a][list] [-d | -r | -s | -t] [-o][list] [-p][list] [-u][list] [-
  v][list]

  The lpstat command displays information about the current status of the
  line printer.

FLAGS

  -a[list]
      Specifies the display of acceptance status (with respect to the lp  and
      lpr commands) of destinations for requests.  list is a list of inter-
      mixed printer names and request IDs.

  -d  Specifies the display of the system default destination for the lp and
      lpr commands.

  -o[list]
      Specifies the display of the status of printer requests. list is a list
      of intermixed printer names and request IDs.

  -p[list]
      Specifies the display of the status of printers.  list is a list of
      printer names.

  -r  Specifies the display of the status of the line printer daemon.

  -s  Specifies the display of a status summary, including the status of the
      line printer scheduler, the system default destination, and a list of
      printers and their associated devices.

  -t  Specifies the display of all status information.

  -u[list]
      Specifies the display of the status of all printer requests. list is a
      list of usernames.

  -v[list]
      Specifies the display of the names of printers and the pathnames of the
      devices associated with them. list is a list of printer names.

DESCRIPTION

  If no flags are given, then lpstat displays the status of all requests made
  by the lp and lpr commands. Any arguments that are not flags are assumed to
  be request IDs (as returned by the lp or lpr commands).  The lpstat command
  displays the status of such requests.

  Flags can appear in any order and can be repeated and intermixed with other
  flags.  Some flags can be followed by an optional list that is either a
  list of items separated from one another by a , (comma), or a list of items
  enclosed in " " (double quotes) and separated from one another by a comma
  or one or more spaces.  For example:
  -u"user1, user2, user3"
  Specifying just the flag with no arguments causes all information pertain-
  ing to that flag to be displayed.

  If the LPDEST environment variable is set to a valid printer name, this
  becomes the default destination; otherwise, PRINTER is tried and, as a last
  resort, a system-specific printer.

FILES

  /etc/printcap
             Printer description file.

  /var/spool/*
             Spool directories.

  /var/spool/*/minfree
             Minimum free space to leave.

  /dev/lp*   Line printer devices.

  /dev/printer
             Socket for local requests.

  /var/spool/*/cf*
             Daemon control files.

  /var/spool/*/df*
             Data files specified in cf files.

  /var/spool/*/tf*
             Temporary copies of cf files.

  /var/spool/*/lock
             Lock file used to obtain the process ID of the current daemon
             and the request ID of the currently active request.

NOTES

  Output produced by the lpstat command is very similar to output from lpq
  and lpc, rather than output from earlier versions of lpstat.

RELATED INFORMATION

  Commands: lp(1)/cancel(1), lpc(8), lpd(8), lpq(1), lpr(1), lprm(1).


LS(1)                           Paragon OSF/1                           LS(1)

NAME
  LS - Lists and generates statistics for files.

SYNTAX
  ls [ -aAbcCdfFgilLmnopqrRstux1 ] [ file ... | directory ...]

ARGUMENTS

  The arguments are the same as described in the OSF/1 ls manual page, except
  that the -l switch also displays node number information for device special
  files, as described here:

  -l        Displays the mode, number of links, owner, group, size, time of
            last modification for each file, and pathname. If the file is a
            special file, the size field contains the device's node number
            and the major and minor device numbers. If the file is a symbolic
            link, the pathname of the linked-to file is also printed preceded
            by ->. The attributes of the symbolic link are displayed. The -n
            flag overrides the -l flag.

DESCRIPTION

  The standard OSF/1 ls command is unchanged except for the semantics of the
  -l switch, as described above.

  For a detailed description of the OSF/1 ls command, refer to the OSF/1
  ls(1) manual page.

EXAMPLES

  The following example displays information about the special file rz0a in
  the /dev/io directories including the device's node number and the major
  and minor device numbers.

    # ls -l /dev/io*/rz0a

    brw-r--r-- 1 root system  3: 3, 0 Jun 05 09:08 io0/rz0a
    brw------- 1 root system  7: 3, 0 Jun 08 07:29 io1/rz0a
    brw------- 1 root system 11: 3, 0 Jun 08 07:29 io2/rz0a
    brw------- 1 root system 15: 3, 0 Jun 08 07:29 io3/rz0a

LIMITATIONS AND WORKAROUNDS

  For information about limitations and workarounds, see the release notes
  files in /usr/share/release_notes.

SEE ALSO

  OSF/1 Programmer's Reference: chmod(1), find(1), ln(1), stty(1), ioctl(2)
NAME

  ls - Lists and generates statistics for files

SYNOPSIS

  ls [-aAbcCdfFgilLmnopqrRstux1] [file ... | directory ...]

  The ls command writes to standard output the contents of each specified
  directory or the name of each specified file, along with any other
  information you ask for with flags.  If you do not specify a file or a
  directory, ls displays the contents of the current directory.

FLAGS

  -a  Lists all entries in the directory, including the entries that begin
      with a . (dot).  Entries that begin with a . (dot) are not displayed
      unless 1) they are explicitly referenced, or 2) the -a flag is
      specified.

  -A  Lists all entries, except . (dot) and ..  (dot dot).

  -b  Displays nonprintable characters in octal notation.

  -c  Uses the time of last modification (file created, mode changed, and so
      on) for sorting (when used with -t) or for displaying (when used with
      -l).  This flag has no effect when not used with either -t or -l or
      both.

  -C  Sorts output vertically in a multicolumn format.  This is the default
      when output is to a terminal.

  -d  Displays only the information for the directory that is named, rather
      than for its contents.  This is useful with the -l flag to get the
      status of a directory.

  -f  Lists the name in each slot for each named directory.  This flag turns
      off -l, -t, -s, and -r, and turns on -a; this flag uses the order in
      which entries appear in the directory.

  -F  Puts a / (slash) after each filename if the file is a directory, an *
      (asterisk) after each filename if the file can be executed, an = (equal
      sign) after each filename if the file is a socket, an @ (at sign) for a
      symbolic link, and a | (vertical bar) for a FIFO.

  -g  Displays the same information as -l, except for the owner.

  -i  Displays the i-number in the first column of the report for each file.

  -l  Displays the mode, number of links, owner, group, size, time of last
      modification for each file, and pathname.  If the file is a special
      file, the size field instead contains the major and minor device
      numbers.  If the file is a symbolic link, the pathname of the linked-to
      file is also printed preceded by ->.  The attributes of the symbolic
      link are displayed.  The -n flag overrides the -l flag.

  -L  Lists the file or directory the link references rather than the link
      itself, if the argument is a symbolic link.

  -m  Uses stream output format (a comma-separated series).

  -n  Displays the same information as -l, except that it displays the user
      and the group IDs instead of the usernames and group names.

  -o  Displays the same information as with -l, except for the group.  The -n
      flag overrides the -o flag.

  -p  Puts a slash after each filename if that file is a directory.

  -q  Displays nonprintable characters in filenames as a ? (question mark)
      character, if output is to a terminal (default).

  -r  Reverses the order of the sort, giving reverse collation or the oldest
      first, as appropriate.

  -R  Lists all subdirectories recursively.

  -s  Gives space used in 512-byte units (including indirect blocks) for each
      entry.

  -t  Sorts by time of last modification (latest first) instead of by name.

  -u  Uses the time of the last access instead of time of the last
      modification for sorting (when used with -t) or for displaying (when
      used with -l).  This flag has no effect when not used with either -t or
      -l or both.

  -x  Sorts output horizontally in a multicolumn format.

  -1  Forces one entry per line output format; this is the default when
      output is not directed to a terminal.

DESCRIPTION

  By default, ls displays all information in collated order by filename.  The
  collating sequence is determined by the LC_COLLATE environment variable
  (see the ctab command).

  There are three main ways to format the output:

    o  List entries in multiple columns by specifying either the -C or -x
       flags.  -C is the default format, when output is to a terminal.

    o  List one entry per line.

    o  List entries in a comma-separated series by specifying the -m flag.

  The ls command uses ioctl() to determine the number of byte positions in
  the output line.  If ls cannot get this information, it uses a default
  value of 80.  Note that columns may not be smaller than 20 bytes or larger
  than 400 bytes.

  Modes
  The mode displayed with the -l flag is interpreted by the first character,
  as follows:

  b   Block special file

  c   Character special file

  d   Directory

  l   Symbolic link

  p   First-In-First-Out (FIFO) special file

  s   Local socket

  -   Ordinary file

  Permissions
  The next nine characters are divided into three sets of three characters
  each.  The first three characters show the owner's permission.  The next
  set of three characters show the permission of the other users in the
  group.  The last set of three characters show the permission of everyone
  else.  The three characters in each set show read, write and execute
  permission of the file.  Execute permission of a directory lets you search
  a directory for a specified file.

  Permissions are indicated as follows:

  r   Read

  w   Write

  x   Execute or search (directories)

  -   No access

  The group-execute permission character is s if the file has set-group-ID
  mode.  The user-execute permission character is s if the file has set-
  user-ID mode.  The last character of the mode (normally x or -) is t if the
  01000 (octal) bit of the mode is set; see the chmod command for the meaning
  of this mode.  The indications of set-ID and the 01000 bit of the mode are
  capitalized (S and T, respectively) if the corresponding execute permission
  is not set.

  When the sizes of the files in a directory are listed, the ls command
  displays a total count in 512-byte units, including indirect blocks.

  The LC_TIME environment variable controls the format of the date and time.

EXAMPLES

   1.  To list all files in the current directory, enter:
       ls  -a

       This lists all files, including . (dot), .. (dot dot), and other files
       with names beginning with a dot.

   2.  To display detailed information, enter:
       ls  -l  chap1  .profile

       This displays a long listing with detailed information about the files
       chap1 and .profile.

   3.  To display detailed information about a directory, enter:
       ls  -d  -l  .  manual  manual/chap1

       This displays a long listing for the directories . and manual, and for
       the file manual/chap1.  Without the -d flag, this command lists the
       files in . and manual instead of providing detailed information about
       the directories themselves.

   4.  To list the files in the current directory in order of modification
       time, enter:
       ls  -l  -t

       This displays a long listing of the files that were modified most
       recently, followed by the older files.
FILES

  /etc/passwd
             Contains user information.

  /etc/group Contains group information.

RELATED INFORMATION

  Commands:  chmod(1), find(1), ln(1), stty(1).

  Functions:  ioctl(2).

  "Using Internationalization Features" in the OSF/1 User's Guide.


make(1)                                                               make(1)

NAME

  make - Maintains program dependencies

SYNOPSIS

  make [-einpqrst] [-f makefile] ...  [-k|-S] [operands ...]

FLAGS

  -e  Specifies that environmental variables override macro assignments
      within makefiles.

  -f makefile
      Specifies a makefile to read instead of the default makefile or
      Makefile.  If makefile is - (dash), standard input is read.  Multiple
      makefiles may be specified, and are read in the order specified.

  -i  Ignores nonzero exit of shell commands in the makefile.  Equivalent to
      specifying - (dash) before each command line in the makefile.

  -k  Continues processing after errors are encountered, but only on those
      targets that do not depend on the target whose creation caused the
      error.

  -n  Displays the commands that would have been executed, but does not actu-
      ally execute them.  If the lines have + (plus sign) prefixes, the com-
      mands will be executed.

  -p  Displays all the macro definitions and target descriptions.

  -q  Does not execute any commands, but returns exit value 0 (zero) if the
      specified targets are up-to-date and 1, otherwise.  If the lines have +
      (plus sign) prefixes, the commands will be executed.

  -r  Does not use the built-in rules specified in the system makefile.

  -S  Terminates make process if errors are encountered during updates.  This
      is the default behavior and is the opposite of the -k option.

  -s  Does not echo any commands as they are executed.  Equivalent to speci-
      fying @ before each command line in the makefile.

  -t  Creates a target or updates its modification time to make it appear
      up-to-date, instead of rebuilding a target as specified in the
      makefile.   The target command lines are typically not executed, unless
      the target command lines have + (plus sign) prefixes, in which case
      they are executed.

  operand
      Specifies a target name of the form target or sets the value of vari-
      able to value with the form variable=value (macro definitions).

DESCRIPTION

  The make program is designed to simplify the maintenance of other programs.
  Its input is a list of specifications as to the files upon which programs
  and other files depend.  If the makefile file exists, it is read for this
  list of specifications.  If it does not exist, the Makefile file is read.

  There are four different types of lines in a makefile: file dependency
  specifications, shell commands, variable assignments, and comments.

  In general, lines may be continued from one line to the next by ending them
  with a \ (backslash).  The trailing newline character and initial white
  space on the following line are compressed into a single space.

  File Dependency Specifications
  Dependency lines consist of one or more targets, an operator, and zero or
  more sources (prerequisites).  This creates a relationship where the tar-
  gets depend on the sources and are usually created from them.  The exact
  relationship between the target and the source is determined by the opera-
  tor that separates them.  The operators are as follows:

  :   A target is considered out-of-date if its modification time is less
      than those of any of its sources.  Sources for a target accumulate over
      dependency lines when this operator is used.  The target is removed if
      make is interrupted.

  ::  If no sources are specified, the target is always re-created.  Other-
      wise, a target is considered out-of-date if any of its sources were
      modified more recently than the target.  Sources for a target do not
      accumulate over dependency lines when this operator is used.  The tar-
      get will not be removed if make is interrupted.

  File dependency specifications have two types of rules, inference and tar-
  get, as follows:

  inference rules
                 Have one target with no / (slash) and a minimum of one .
                 (period).  These rules specify how a target is to be made
                 up-to-date.

  target rules   Can have more than one target.  These rules specify how to
                 build the target.

  Makefile Execution
  The make command executes the commands in the makefile line by line.  As
  make executes each command, it writes the command to standard output
  (unless otherwise directed, for example the -s option).  A makefile must
  have a tab in front of the commands on each line.

  When a command is executed through make, it uses make's execution environ-
  ment.  This includes any macros from the command line to make, and any
  environment variables specified in the MAKEFLAGS variable (refer to Section
  Variables).  make's environment variables overwrite any variables of the
  same name in the existing environment.

  Target Rules
  Target rules have the following format:
  target [target...] :
  [prerequisite...] [;command]
  <Tab>command
  ...
  Multiple targets and prerequisites are separated by spaces (note that the
  list of prerequisites can be empty).  The commands that follow the semi-
  colon or <Tab> update the target.  A new target entry is started when a new
  line does not begin with a <Tab> or # (number sign).  The following section
  lists the special sources, or prerequisites, and targets for a makefile.

  Special Targets
  Special targets may not be included with other targets; that is, they must
  be the only target specified.  These control the operation of the make com-
  mand.

  .DEFAULT
      This is used as the rule for any target (that was used only as a
      source) that make cannot figure out any other way to create.  Only the
      shell script is used.  The < (left angle bracket) variable of a target
      that inherits .DEFAULT's commands is set to the target's own name.

  .IGNORE
      Marks each of the sources with the .IGNORE attribute.  If no sources
      are specified, this is the equivalent of specifying the -i flag.

  .POSIX
      This keyword currently has no effect on make behavior, since it is the
      only behavior supported.  However, you should use this as the first
      non-command line of a makefile if you want to avoid possible conflicts
      with future enhancements.

  .PRECIOUS
      Applies the .PRECIOUS attribute to any specified sources.  If no
      sources are specified, the .PRECIOUS attribute is applied to every tar-
      get in the file.  Normally, when make is interrupted (for example, with
      SIGHUP, SIGTERM, SIGINT, or SIGQUIT), it removes any partially made
      targets.  .PRECIOUS prevents the target from being removed.

  .SILENT
      Applies the .SILENT attribute to any specified sources.  If no sources
      are specified, the .SILENT attribute is applied to every command in the
      file.

  .SUFFIXES
      Each source specifies a suffix to make.  If no sources are specified,
      any previous specified suffices are deleted.  These suffices are used
      by inference rules.  To change the order of suffices, you need to
      specify an empty .SUFFIXES entry, then a new list of .SUFFIXES entries.

  Inference Rules
  The make command has a default set of inference rules, which you can sup-
  plement, or overwrite, with additional inference rule definitions in the
  makefile.  Inference rules consist of target suffices and commands.  From
  the suffices, make infers the prerequisites, and from both the suffices and
  their prerequisites, make command can infer how to make a target up-to-
  date.  Inference rules have the following format:
  rule:
  <Tab>command
  ...
  where rule has one of the following forms:

  .s1  A single-suffix inference rule.  This describes how to build a target
       that is appended with one of the single suffices.

  .s1.s2
       A double-suffix inference rule.  This describes how to build a target
       that is appended with .s2 with a prerequisite that is appended with
       .s1.
  s1 and s2 are suffices defined as prerequisites of the special target,
  .SUFFIXES.  The inference rules use the suffices in the order in which they
  are specified in .SUFFIXES.   A new inference rule is started when a new
  line does not begin with a <Tab> or # (number sign).

  If rule is empty, for example:
  rule: ;
  execution has no effect, and make will recognize that the suffix exists,
  but take no actions when targets are out-of-date.

  Libraries
  A target or prerequisite may also be a member of an archive library, and is
  treated as such if there are parentheses in the name.  For example,
  library(name) indicates that name is a member of the archive library
  library.  To update a member of a library from a particular file, you can
  use the format .s1.a, where a file with the .s1 suffix is used to update a
  member of the archive library.  The .a refers to an archive library.

  Using Macros
  In makefiles, macro definitions are defined in the format:
  variable=value
  Macros can appear throughout the makefile, as follows:

    o  If a macro appears in a target line, then it is evaluated when the
       target line is read.

    o  If a macro appears in a command line, then it is evaluated when the
       command is executed.

    o  If a macro appears in a macro definition line, it is evaluated when
       the new macro itself appears in a rule or command.

  If a macro has no definition, it evaluates to NULL.  A new macro definition
  overwrites an existing macro of the same name.  Macros assignments can come
  from the following, in the listed order:

   1.  Default inference rules

   2.  Contents of the environment

   3.  Makefiles or makefiles

   4.  Command lines
  Note, however, that the -e option causes environment variables to override
  those defined in the makefile.

  The SHELL macro is special.  It is automatically set to the pathname of the
  shell command (sh, csh, or ksh).  However, if it is redefined in the
  makefile, or on the command line, then this default setting is overridden.
  Note that this macro does not affect, and is not affected by, the SHELL
  environment variable.

  Shell Commands
  Each target may have associated with it a series of shell commands, nor-
  mally used to create the target.  Each of the commands in this script must
  be preceded by a tab.  While any target may appear on a dependency line,
  only one of these dependencies may be followed by a creation script, unless
  the :: operator is used.

  If the first or first two characters of the command line are @ and/or -
  and/or +, the command is treated specially, as follows:

  @         Causes the command not to be echoed before it is executed.

  -         Causes any nonzero exit status of the command line to be ignored.

  +         Causes a command line to be executed, even though the options -n,
            -q, or -t are specified.

  Variable Assignments
  Variables in make are much like variables in the shell, and, by tradition,
  consist of all uppercase letters.  The = operator assigns values to vari-
  ables.  Any previous variable is then overridden.

  Any white space before the assigned value is removed; if the value is being
  appended, a single space is inserted between the previous contents of the
  variable and the appended value.

  Variables are expanded by surrounding the variable name with either {}
  (braces) or () (parentheses) and preceding it with a $ (dollar sign).  If
  the variable name contains only a single letter, the surrounding braces or
  parentheses are not required.  This shorter form is not recommended.

  Variable substitution occurs at two distinct times, depending on where the
  variable is being used.  Variables in dependency lines are expanded as the
  line is read.  Variables in shell commands are expanded when the shell com-
  mand is executed.

  The four different classes of variables (in order of increasing precedence)
  are

  Environment variables
      Variables defined as part of make's environment.

  Global variables
      Variables defined in the makefile or in included makefiles.

  Command line variables
      Variables defined as part of the command line.

  Local variables
      Variables that are defined specific to a certain target.  The local
      variables are as follows:

      $<        Represents either the full name of a source that made a tar-
                get out-of-date (inference rule), or the full name of a tar-
                get (.DEFAULT rule).

      $*        Represents the filename section of a source that made a tar-
                get out-of-date (in an inference rule).  The suffix has been
                deleted from the filename.

      $@        Represents the full target name (entire library).

      $?        Represents the list of sources causing a target to be out-
                of-date (inference and target rule).

      $%        Represents a library member in a target rule if the target is
                a member of the archive library.
  You can also use these local variables appended with D or F, where

  D         Indicates that the local variable applies to the directory part
            of the name.  This is the pathname prefix without a trailing \*O
            (slash).  For current directories, D is a . (period)

  F         Indicates that the local variable applies to the filename part of
            the name

  The $? local variable can represent a list of sources.  When used with D or
  F, the local variable can represent a list of directory and filename parts,
  respectively.

  In addition, make sets or knows about the following variables:

  $   A single dollar sign ($); that is, $$ expands to a single dollar sign.

  make also knows about the following environment variables:

            Determines the locale to use for the locale categories when both
            LC_ALL and the corresponding environment variable (beginning with
            LC_) do not specify a locale.

            Determines the locale to be used to override any values for
            locale categories specified by the setting of LANG or any other
            LC_ environment variable.

            Determines the locale for the interpretation of sequences of
            bytes of text data as characters; for example, single- versus
            multi-byte characters in arguments.

            Determines the language in which messages should be written.

  MAKEFLAGS The environment variable MAKEFLAGS may contain anything that may
            be specified on make's command line.  Anything specified on
            make's command line is appended to the MAKEFLAGS variable, which
            is then entered into the environment for all programs that make
            executes.  Note that the operation of the -f and -p options in
            the MAKEFLAGS variable are undefined.  Command line options will
            have precedence over the -f and -p options in this variable.

  Comments
  Comments begin with a # (number sign), anywhere but in a shell command
  line, and continue to the end of the line.

  Environment
  The make command uses the MAKEFLAGS environment variable, if it exists.

EXIT STATUS

  The make command exits with 0 (zero) on success, and greater than 1 if an
  error occurred.  In addition, if the -q option was specified, make exits
  with 1 if the target was not up-to-date.

FILES

  /usr/share/mk/posix
             Default POSIX rules for the make utility.

  Makefile   List of dependencies.

  makefile   List of dependencies.

RELATED INFORMATION

  "Using make" in the OSF/1 Applications Programmer's Guide.


man(1)                                                                 man(1)

NAME

  man - Displays reference pages

SYNOPSIS

  man [-ctw] [-] [-M pathname] [section] title ...

  man [-M pathname] -f | -k keyword ...

  The man command displays reference pages for the command, system call, sub-
  routine, or file you specify with the title argument.

FLAGS

  -c      Does not pipe output through more.

  -f keyword ...
          Describes the function of a command, call, function, or special
          filename (same as the whatis command).

  -k keyword ...
          Locates reference pages by keyword (same as the apropos command).

  -M pathname
          Specifies an alternative search path.  pathname is a colon-
          separated list of directories in which man expects to find the
          standard subdirectories.

  -t      Uses troff instead of nroff to format the reference page.

  -w      Displays the pathname of the reference page source instead of
          displaying the reference page itself.

  -       Does not pipe output through more.  (Same as -c.)

DESCRIPTION

  The man program provides online access to the system's reference pages.  If
  a section argument is specified, man looks in that reference section for
  the given titles.  section is either a section number (1-8) or one of the
  letters CLFlnop.  If you specify C or 1, man searches in the sections
  Cnlpo1.  By default, man searches the sections CLFnlpo12345678, giving
  preference to commands over library subroutines. man displays the first
  reference page it finds, if any.

  The following section specifiers have a pre-defined meaning:

  C   Command

  l   Local

  o   Old

  n   New

  The other section specifiers correspond to a section identified by that
  letter or number.

  Normally man looks for the requested reference page in the directories
  specified by the MANPATH environment variable.  You can supply an alterna-
  tive search path with the -M flag.  If the MANPATH variable is not set and
  the -M flag is not specified, man checks in the default locations
  /usr/share/man and /usr/local/man for reference information.

  If the standard output is a tty, and the -c flag is not provided, man uses
  more, or the pager provided by the PAGER environment variable, to display
  the reference page.

FILES

  /usr/share/man
             Default reference page directory.

  /usr/share/man/man?
             Directories containing source for reference pages.

  /usr/share/man/cat?
             Directories containing standard preformatted reference pages.

  /usr/local/man/cat?/*
             Preformatted reference pages.

  /usr/share/man/whatis
             The whatis keyword database.

RELATED INFORMATION

  Commands:  apropos(1), catman(1), more(1), page(1), whatis(1), whereis(1).


mkdir(1)                                                             mkdir(1)

NAME

  mkdir - Makes a directory

SYNOPSIS

  mkdir [-m mode] [-p] directory ...

  The mkdir command creates new directories with read, write, and execute
  permissions based upon the permissions established by the umask setting.

FLAGS

  -m mode
      Sets the file permissions to mode, a symbolic mode string as defined
      for chmod, after creating the specified directory.

  -p  Creates intermediate directories as necessary; otherwise, the full
      pathname prefix to directory must already exist.  Note that mkdir
      requires write permission in the parent directory for users other than
      root.
      Each component of directory that does not name an existing directory is
      created with mode 777, modified by the current file mode creation mask
      (umask).  The equivalent of chmod u+wx is performed on each component
      to ensure that mkdir can create lower directories regardless of the
      setting of umask.  Each component of directory that names an existing
      directory is ignored without error, except for the last component.  If
      an intermediate pathname component exists, but permissions are set to
      prevent writing or searching, mkdir fails and returns an error message.
      The mode argument does not apply to any intermediate directories
      created when the -p flag is specified.

DESCRIPTION

  The mkdir command also creates the standard entries . (dot), for the direc-
  tory itself, and .. (dot dot), for its parent.

EXAMPLES

   1.  To create a new directory called test, enter:
       mkdir test
   2.  To set file permissions for new directory test in absolute mode,
       enter:
       mkdir -m 444 test
   3.  To set file permissions for new directory test in symbolic mode,
       enter:
       mkdir -m+rw test
NOTES

  To make a new directory, you must have write permission in the parent
  directory.
RELATED INFORMATION

  Commands:  chmod(1), rm(1), sh(1).

  Functions:  mkdir(2).


more(1)                                                               more(1)

NAME

  more, page - Displays a file one screenful at a time

SYNOPSIS

  more [-cdflpsuvzw] [-number] [+line_number | +g | +/pattern] file ...

  page [-cdflpsuvzw] [-number] [+line_number | +g | +/pattern] file ...

  The more command invokes a filter that allows examination of continuous
  text, one screenful at a time, on a soft-copy terminal.  The page command
  is equivalent to more, but erases the screen before displaying each screen-
  ful.

FLAGS

  -c  Starts each screenful at the top of the screen and erases existing out-
      put on each line before displaying a new line.  This avoids scrolling
      the screen, making it easier to read while more is writing.  It is also
      faster than scrolling on many terminals.  This flag is ignored if the
      terminal does not have the ability to clear to the end of a line.

  -d  Prompts you to continue, quit, or obtain help after each screenful of
      text.

  -f  Counts logical lines rather than screen lines; that is, long lines are
      not folded.  This flag is recommended if nroff output is piped through
      ul, or if more reads any text that contains escape sequences.  Escape
      sequences contain characters that would ordinarily occupy screen posi-
      tions, but which do not print when they are sent to the terminal as
      part of an escape sequences.  Thus more may think that lines are longer
      than they actually are, and fold lines erroneously.

  -l  Does not treat <Ctrl-l> specially.  If this flag is not specified, more
      pauses after any line that contains <Ctrl-l>, as if at the end of a
      screenful.  Also, if a file begins with a <Ctrl-l>, the screen is
      cleared before the file is printed.

  -p  Sets no scroll mode, causing more to clear the screen before displaying
      each screenful.  This is equivalent to invoking the program as page.

  -s  Squeezes multiple empty lines from the output, producing only one empty
      line.  Especially helpful when viewing nroff output, this flag maxim-
      izes the amount of useful information present on the screen.

  -u  Suppresses processing of underlined text for terminal display.  Nor-
      mally, more handles underlining in a manner appropriate to the particu-
      lar terminal: if the terminal can perform underlining or has a
      highlight mode, more outputs appropriate escape sequences to enable
      underlining or highlight mode for underlined information in the source
      file.

  -w  Keeps the current file open, even when it is at end-of-file.  This
      gives you an opportunity to page or scroll backward through the file.
      Normally, when more reads an end-of-file, it goes on to display the
      next file specified on the command line, or exits if there is no next
      file.  When more is used to read from a file that is growing, or from a
      pipe, the -w flag allows you to ``poll'' periodically in order to
      display any new text that has been appended to the file or pipe.

  -v  Does not display nonprinting characters graphically.  Without this
      flag, all non-ASCII and control characters (except <Tab>, <Backspace>,
      and <Return>) are displayed visibly in the form ^X for <Ctrl-x>, or M-x
      for non-ASCII character x.

  -z  Same as if the -v flag is not given, but in addition, <Backspace> is
      displayed as ^H, <Return> as ^M, and <Tab> as ^I.

  +line_number
      Starts up at line_number.

  +g  Starts up at the last screenful in the file.  Instead of exiting (or
      going on to the next file) after showing the last line of the file,
      more displays the -More--(EOF) prompt, as if the -w flag were in
      effect.  This gives you an opportunity to scroll or page backward
      through the file.

  +/pattern
      Starts up at the line before the line containing the regular expression
      pattern.

  -number
      Sets the number of lines in the display window to number.  The default
      is two lines less than the number of lines displayed by the terminal;
      on a screen that displays 24 lines, the default is 22.

DESCRIPTION

  The more command normally pauses after each screenful, printing --More-- at
  the bottom of the screen.  You can then enter a carriage-return to display
  one more line, or press <Space> to display another screenful.  Other possi-
  bilities are described under SUBCOMMANDS.

  The more command looks in the terminfo database to determine terminal
  characteristics, and to determine the default window size.  On a terminal
  capable of displaying 24 lines, the default window size for both more and
  page is 23 lines.

  The more command looks in the MORE environment variable to preset any
  desired flags; for example, assume that you prefer to view files using the
  -c and -w flags.  The csh command setenv MORE cw, or the ksh or sh command
  sequence MORE='cw' ; export MORE would cause all invocations of more,
  including invocations by programs such as man and mesg, to use this mode.
  Normally, you place the command sequence that sets up the MORE environment
  variable in the .kshrc, .cshrc, or .profile file.

  If more is reading from a file, rather than a pipe, then a percentage is
  displayed along with the -More-- prompt.  This gives the fraction of the
  file (in characters, not lines) that was displayed so far.

  If the standard output is not a terminal, then more processes like cat,
  except that a header is printed before each file (if there is more than one
  file).

SUBCOMMANDS

  The more command provides the following subcommands that you can type when
  more pauses.  These commands are designed to be similar to the commands
  supported by the vi editor.  (i is an optional integer argument, defaulting
  to 1.)  Regular expressions (as referred to here) are described under grep.

  i<Return>

  ij

  i<Ctrl-e>
      All three forms display i more lines.

  i<Space>
      Displays i more lines, or another screenful if i is not specified.

  i<Ctrl-d>
      Scrolls one-half screen forward (displays the next k/2 lines, where k
      is the number of lines displayed by the <Space> command).  If i is
      specified, then the scroll size is set to i.

  d   Same as <Ctrl-d>.

  i<Ctrl-u>
      Scrolls one-half screen backward.  If i is specified, then the scroll
      size is set to i.  Note that if your line kill character is <Ctrl-u>,
      then you must use the u command to scroll backward.

  iu  Same as <Ctrl-u>.

  ik

  i<Ctrl-y>
      Both forms scroll back i lines.

  iz  Displays i more lines and sets the new window (screenful) size to i.

  ig  Goes to line i and displays a screenful, making line i the top line on
      the screen.  If i is not specified, then more displays the last screen-
      ful in the file.  Instead of exiting (or going on to the next file)
      after showing the last line of the file, more displays the -More--(EOF)
      prompt, as if the -w flag were in effect.  This gives you an opportun-
      ity to scroll or page backward through the file.

  is  Skips i lines and prints a screenful.

  if  Skips i screenfuls and prints a screenful.

  ib  Skips back i screenfuls and prints a screenful.

  i<Ctrl-b>
      Same as b.

  q, Q
      Exits from more.

  =   Displays the current line number.

  v   Starts up the vi editor at the current line.

  h   Displays a description of all the more subcommands.

  i/expression
      Searches for the ith occurrence of the regular expression expression.
      If there are less than i occurrences of expression, and the input is a
      file rather than a pipe, then the position in the file remains
      unchanged.  Otherwise, a screenful is displayed, starting with the line
      matching expression.  You can use Erase and Kill characters to edit the
      regular expression, which must be terminated by pressing <Return> (with
      no trailing / character).  Erasing back past the first column cancels
      the search command.  If expression is null, more uses the last regular
      expression entered.

  i?expression
      Same as /, but searches backward in the file.

  in  Searches for the ith occurrence of the last regular expression entered.

  iN  Searches for the ith occurrence of the last regular expression entered,
      but reverses the direction of that search.

  ' (single quote)
      Returns to the point from which the last search started.  If no search
      was performed in the current file, returns to the beginning of the
      file.

  !command or :!command
      Invokes a shell with command.  The % (percent sign) and ! (exclamation
      point) characters in command are replaced with the current filename and
      the previous shell command, respectively.  If there is no current
      filename, % is not expanded.  The sequences \% and \! are replaced by %
      and !, respectively.

  i:n Skips to the ith next file specified in the command line.

  i:p Skips to the ith previous file given in the command line.  If this com-
      mand is given during display of a file, more returns to the beginning
      of the file.  If more is not reading from a file, the bell is rung and
      nothing else happens.

  :f  Displays the current filename and line number.

  :v  Displays the version number of the more command.

  :q, :Q
      Exits from more (same as q or Q).

  .   Repeats the previous command.

  <Ctrl-l>
      Redraws the screen.

  The commands take effect immediately; it is not necessary to type a
  carriage-return.  Up to the time when the command character itself is
  given, you can enter the line Kill character to cancel the numerical argu-
  ment being formed.  In addition, you can enter the Erase character to
  redisplay the -More--(xx%) message.

  At any time when output is being sent to the terminal, you can press q.
  The more command stops sending output, and displays the usual -More--
  prompt.  You can then enter one of the preceding commands in the normal
  manner.  Some output is lost when this is done, due to the fact that any
  characters waiting in the terminal's output queue are flushed when the QUIT
  signal occurs.

  The terminal is set to noecho mode by this program so that the output can
  be continuous.  Thus, subcommands you enter do not show on your terminal,
  except for the / (slash), ? (question mark), and ! (exclamation point) com-
  mands.

EXAMPLES

  The following is a sample use of more in previewing nroff output:
  nroff -ms +2 doc.n | more -s
FILES

  /usr/share/lib/terminfo/?/*
                Terminal information database.

RELATED INFORMATION

  Commands:  cat(1), csh(1), grep(1)/egrep(1)/fgrep(1), ksh(1), man(1),
  pg(1), script(1), sh(1).

  Files:  terminfo(4).


mv(1)                                                                   mv(1)

NAME

  mv - Moves files and directories

SYNOPSIS

  mv [-i | f] [--] file1 file2

  mv [-i | f] [--] file1 ...  directory

  mv [-i | f] [--] directory1 ...  destination_directory

  The mv command moves files from one directory to another or renames files
  and directories.

FLAGS

  -f  Overrides the -i flag and any mode restrictions.  (If both -f and -i
      are specified; for example, because an alias includes one of them,
      whichever appears last overrides the other.)

  -i  Prompts you with the name of the file followed by a question mark when-
      ever a move is to supercede an existing file.  If the answer begins
      with y, or the locale's equivalent of a y, the move continues.  Any
      other reply prevents the move from occurring.  (If both -f and -i are
      specified; for example, because an alias includes one of them, which-
      ever appears last overrides the other.)

  --  Interprets all following arguments to mv as filenames.  This allows
      filenames to start with a - (dash).

DESCRIPTION

  If you move a file to a new directory, mv retains the original filename.
  When you move a file, all other links to the file remain intact.

  In the second form, one or more files are moved to directory with their
  original filenames.  In the third form, one or more directories are moved
  to the destination directory with their original names.

  Note that mv does not move a file onto itself.

  When you use mv to rename a file, the target file can be either a new
  filename or a new directory pathname.  If moving the file would overwrite
  an existing file that does not have write permission set and if standard
  input is a tty, mv displays the permission code of the file to be overwrit-
  ten and reads one line from standard input.  If the line begins with y, or
  the locale's equivalent of a y, the move takes place and the file is
  overwritten.  If not, mv does nothing with the file.

  When you use mv to move a directory into an existing directory, the direc-
  tory and its contents are added under the existing directory.

  The LC_MESSAGES variable determines the locale's equivalent of y or n (for
  yes/no queries).
EXAMPLES

   1.  To rename a file, enter:
       mv  file1  file2

       This renames file1 to file2.a.  If a file named file2 already exists,
       its old contents are replaced with those of file1.

   2.  To move a directory, enter:
       mv  dir1  dir2

       This moves dir1 to dir2.  It moves all files and directories under
       dir1 to the directory named dir2, if the second directory exists.
       Otherwise, the directory dir1 gets renamed dir2.

   3.  To move a file to another directory and give it a new name, enter:
       mv  file1  dir1/file2

       This moves file1 to dir1/file2.  The name file1 is removed from the
       current directory, and the same file appears as file2 in the directory
       dir1.

   4.  To move a file to another directory, keeping the same name, enter:
       mv  file1  dir1

       This moves file1 to dir1/file1.

   5.  To move several files into another directory, enter:
       mv  file1  dir1/file2  /u/dir2

       This moves file1 to /u/dir2/file1 and dir1/file2 to /u/dir2/file2.

   6.  To use mv with pattern-matching characters, enter:
       mv  dir1/*  .

       This moves all files in the directory dir1 into the current directory
       (.), giving them the same names they had in dir1.  This also empties
       dir1.  Note that you must type a space between the * (asterisk) and
       the . (dot).

NOTES

  If the source is on a different file system than the destination, mv must
  copy the source to the destination's file system and then delete the
  source.  In this case, the user ID becomes that of the current user, but
  the mode and times are not changed.  The effect is equivalent to the fol-
  lowing command syntax:
  rm -f destination && cp -pR source destination && rm -rf source

CAUTIONS

  The mv command may overwrite existing files unless the -i flag is specified
  to prompt you first.

RELATED INFORMATION

  Commands:  cp(1), ln(1), rm(1).

  Functions: rename(2).


PEXEC(0)                              0                              PEXEC(0)

NAME
  PEXEC - Execute a compute partition program within a SAFE partition.

SYNTAX
  pexec a.out [ -sz size | -sz hXw | -nd nodespec ] [  -ss | [ [ -rq time ]
  [ -epl priority ] ] ]

ARGUMENTS

  a.out     Specifies the compute partition program you wish to execute.

  -sz size  Specifies the size of the partition you wish to use to run the
            program. The size argument must be an integer between 0 and the
            number of nodes in the compute partition. The default is all the
            usable nodes of the compute partition.

  -sz hXw   Uses a contiguous rectangular partition that is h nodes high and
            w nodes wide. (You can use an uppercase or lowercase letter X
            between the integers h and w.) The default is all the usable
            nodes of the compute partition.

  -nd nodespec                                               Uses a partition
            that consists of exactly the specified nodes, where nodespec is
            one of the following:

              x           The node whose node number is x.

              x..y        The range of nodes from numbers x to y.

              hXw:n       The rectangular group of nodes that is h nodes high
                          and w nodes wide and whose upper left corner is
                          node number n. (You can use an uppercase or
                          lowercase letter X between the integers h and w.)

              nspec[,nspec]...                               The specified
                          list of nodes, where each nspec is a node specifier
                          of the form x, x..y, or hXw:n. Do not put any
                          spaces in this list.

            The numbers you use with -nd are node numbers within the compute
            partition, which always range from 0 to one less than the size of
            the partition. The default is all the usable nodes of the compute
            partition.

  -ss       Uses a partition that uses standard scheduling. This switch
            cannot be used with the -rq or -epl switches. If you don't use
            the -ss, -rq, or -epl switch, the new partition uses the same
            scheduling technique, rollin quantum, and effective priority
            limit as the compute partition.

  -rq time  Uses a partition that uses gang scheduling with a rollin quantum
            of time, where time is one of the following:

              n           n milliseconds (if n is not a multiple of 100, it
                          is silently rounded up to the next multiple of
                          100).

              ns          n seconds.

              nm          n minutes.

              nh          n hours.

              0           ``Infinite'' time: once rolled in, an application
                          runs until it exits.

            The rollin quantum cannot be more than 24 hours.

            The -rq argument can be used with or without -epl. If you use -rq
            without -epl, the new partition has the same effective priority
            limit as its parent partition.

            If you don't use the -ss, -rq, or -epl switch, the new partition
            uses the same scheduling technique, rollin quantum, and effective
            priority limit as the compute partition.

  -epl priority                                              Uses a partition
            that uses gang scheduling with an effective priority limit of
            priority, where priority is an integer from 0 to 10 inclusive (0
            is low priority, 10 is high priority).

            The -epl argument can be used with or without -rq. If you use
            -epl without -rq, the created partition has the same rollin
            quantum as the compute partition.

            If you don't use the -ss, -rq, or -epl switch, the created
            partition uses the same scheduling technique, rollin quantum, and
            effective priority limit as the compute partition.

DESCRIPTION

  Use the pexec command to execute a compute partition program in a SAFE
  partition. pexec creates a partition of the requested size and shape,
  executes your program within this partition, and removes the partition. The
  created partition will not overlap with any other existing partitions. The
  command will fail if a non-overlapping partition of the requensted size and
  shape cannot be created.

  If you wish to pass arguments to your compute node program, you must
  enclose the program name and the arguments in double-quotes.

EXAMPLES

  To execute a program called a.out in a 4-processor partition, you can use
  the following command:

    pexec a.out -sz 4

  The following passes a command-line argument to a.out.:

    pexec "a.out -mbf 1000000" -sz 4

ERRORS

pexec: Partition not available

  No non-overlapping partition with the requested characteristics is
  available.

SEE ALSO

  mkpart, chpart, lspart, pspart, rmpart, showpart, application

  OSF/1 Programmer's Reference: chmod(1), ls(1)


pg(1)                                                                   pg(1)

NAME

  pg - Formats files for a tty display

SYNOPSIS

  pg [-cefns] [-p string] [+line_number | +/pattern/] [-number] [file ...]

  The pg command reads the specified file or files (or standard input by
  default) and writes them to standard output one screen at a time.  At the
  end of each screen you can display the next screen or enter various subcom-
  mands, including those that let you back up to review something that has
  already passed.

FLAGS

  -c  Moves the cursor to the home position and clears the screen before each
      page.  This flag is ignored if clear_screen is not defined for your tty
      type in the terminfo file.

  -e  Does not pause at the end of each file.  However, pg still pauses at
      the beginning of each file.

  -f  Does not split lines.  Normally, pg splits (wraps) lines longer than
      the screen width.

  -n  Stops processing when a pg command letter is entered.  Normally, com-
      mands must end with a newline character.

  -p string
      Uses string as the prompt.  If the string contains %d, %d is replaced
      by the current page number in the prompt.  The default prompt is :
      (colon).  If string contains spaces, you must quote it.  In addition,
      if string contains either the < or > characters, you must quote it;
      otherwise, these characters are treated as shell redirection commands.

  -s  Highlights all messages and prompts.

  +line_number
      Starts at line_number.

  -number
      Specifies the number of lines in the window.

  +/pattern/
      Starts at the first line that contains pattern.

DESCRIPTION

  If you specify file as a - (dash) or run pg without arguments, pg reads
  standard input.  To determine tty attributes, pg looks up the tty type
  specified by the TERM environment variable in the terminfo database.  The
  default type is dumb.

  At any time during the operation of pg, you can enter the Quit (usually
  <Ctrl-\> ) or Interrupt (usually <Ctrl-c>) key sequences.  If pg is sending
  output, it interrupts output and and displays the prompt, and you can then
  enter one of the subcommands in the normal manner.  If the prompt is
  already displayed, the Quit and Interrupt sequences terminate pg.  (Note
  that on a high-speed display it may be difficult to enter a Quit or Inter-
  rupt between prompts, because the interval between them is so short.)

  Note that some output is lost when when you use the Quit or Interrupt
  sequences during output because any characters waiting in the output queue
  are purged when the QUIT or INTERRUPT signal is received.  When you use pg
  in a pipe, an Interrupt is likely to end the other commands in the pipe.

  If standard output is not a tty, pg acts like the cat command, writing the
  input to standard output without any formatting or special treatment,
  except that a header is displayed before each file.

  If tty tabs are not set for every eight positions, unpredictable results
  can occur.

SUBCOMMANDS

  When pg pauses and displays its prompt, you can enter a subcommand.  Some
  of these subcommands change the display to a particular place in the file,
  some search for specific patterns in the text, and others change the
  environment in which pg works.

  Location Subcommands
  The following commands display a selected place in the file:

  number
      Displays page number number.

  +number
      Displays the page number pages after the current page.

  -number
      Displays the page number pages before the current page.

  l   Scrolls the display one line forward.

  numberl
      Displays a screen with the specified line number at the top.

  +numberl
      Scrolls the display number lines forward.

  -numberl
      Scrolls the display number lines backward.

  d   Scrolls half a screen forward.  Pressing <Ctrl-d> (and <Return> if you
      have not specified -n) has the same effect.

  -d  Scrolls half a screen backward.  Pressing - and then <Ctrl-d> (and
      <Return> if you have not specified -n) has the same effect.

  +numberf
      Skips number screens forward.

  -numberf
      Skips number screens backward.

  <Ctrl-l>
      Displays the current page again.  A single . (dot) also does this.

  $   Displays the last page in the file.  Do not use this when the input is
      from a pipeline.
  Search Subcommands
  The following commands search for patterns in the text.  You can use the
  regular expressions described in grep.  They must always end with a newline
  character, even if the -n flag is used.  In an expression such as [a-z],
  the dash means through according to the current collating sequence.  See
  "Using Internationalization Features" in the OSF/1 User's Guide for more
  information on collating sequences.  The collating sequence is determined
  by the value of the LC_COLLATE environment variable.

  [number]/pattern/
      Searches for the number'th occurrence of pattern.  The search begins
      immediately after the current page and continues to the end of the
      current file, without wrapping around.  The default for number is 1.

  number?pattern?
      or

  number^pattern^
      Searches backward for the number'th occurrence of pattern.  The search
      begins immediately before the current page and continues to the begin-
      ning of the current file, without wraparound.  The ^ (circumflex) is
      useful for the Adds 100 terminal, which cannot handle a ? (question
      mark).  The default for number is 1.

  After searching, pg normally displays the line found at the top of the
  screen.  You can change this by adding m or b to the search command to
  leave the line found in the middle or at the bottom of the window with all
  succeeding subcommands.  Use the suffix t to return to displaying the line
  with the pattern to the top of the screen.

  Environment Subcommands
  You can change the pg environment with the following subcommands:

  [number]n
      Begins examining the number'th next file in the command line.  The
      default number is 1.

  [number]p
      Begins examining the number'th previous file on the command line.  The
      default number is 1.

  [number]w
      Sets the window size to number.  If number is not present, displays
      another window of text.

  [number]lz
      Same as w.

  s file
      Saves the input in file.  Only the current file being examined is
      saved.  This command must always end with a newline character, even if
      you specify the -n flag.

  h   Displays an abbreviated summary of available subcommands.

  q or Q
      Quits pg.

  !command
      Sends the specified command to the shell named in the SHELL environment
      variable.  If this is not available, the default shell is used.  This
      command must always end with a newline character, even if the -n flag
      is used.

EXAMPLES

  To look at the contents of file file1 one page at a time, enter:
  pg file1
FILES

  /usr/share/lib/terminfo/?/*
                Terminal capability database.

  /tmp/pg*      Temporary file used when input is from a pipe.

RELATED INFORMATION

  Commands:  cat(1), grep(1)/egrep(1)/fgrep(1), more(1)/page(1).

  Files:  terminfo(4).

  "Using Internationalization Features" in the OSF/1 User's Guide.


PMAKE(1)                        Paragon OSF/1                        PMAKE(1)

NAME
  PMAKE - Parallel make utility that maintains up-to-date versions of target
  files and performs shell commands.

SYNTAX
  pmake [-bcdeFikmnNpqrsStuUvw] [ -C dir ] [ -f file ] [ -I dir ] [ -j [ jobs
  ] ]
   [ -l [ load ] ] [ -o file ] [ -P [ partition ] ] [ -W file ] [
  macro_definition ... ]
   [ target ... ]

ARGUMENTS

  -b        Has no effect; exists so older-version make dependency files
            continue to work.

  -c        Does not try to find a corresponding Revision Control System
            (RCS) or Source Code Control System (SCCS) file and check it out
            if the file does not exist.

  -C dir    Changes to directory dir before reading the description files or
            doing anything else. If multiple -C switches are specified, each
            is interpreted relative to the previous one: -C/  -Cetc is
            equivalent to -C  /etc. This is typically used with recursive
            invocations of pmake.

  -d        Prints debugging information in addition to normal processing.
            The debugging information includes information about the files
            considered for processing, the comparison of file-times, the
            files that need processing, and the implicit rules being
            considered and actually applied.

  -e        Does not reassign environment variables within the description
            file.

  -f file   Reads file for a description of how to build the target file. If
            you do not specify the -f switch, pmake looks in the current
            directory for a description file named makefile or Makefile. If a
            - (dash) follows the -f switch, pmake reads standard input. You
            can specify more than one description file by entering the -f
            switch with the file argument more than once.

  -F        Causes a fatal error if a description file is not present.

  -i        Ignores error codes returned by commands and continues to execute
            until finished. This is similar to the pseudotarget command
            .IGNORE:, which can be specified in the description file. The
            pmake command normally stops if a command returns a nonzero exit
            code.

  -I dir    Specifies a directory dir to search for description files to be
            included. You can specify the -I switch multiple times in a
            command line to specify multiple directories to search. The
            directories are searched in the order specified.

  -j [jobs] Specifies the maximum number of jobs that can run simultaneously.
            The default is the partition size, or 1 if the pmake command is
            running in the service partition. If there is more than one -j
            switch, the last one is effective. If the -j switch is given
            without an argument, the pmake command does not limit the number
            of jobs that can run simultaneously.

  -k        Stops processing the current target if an error occurs, but
            continues with other branches that do not depend on the target
            that failed.

  -l [load] Specifies that no new jobs should be started if there are other
            jobs running and the load average is at least the value of load
            (a floating-point number). Specifying the switch with no argument
            removes a previous load limit.

  -m        Searches for machine-specific subdirectories automatically. On a
            Paragon system, if a PARAGON subdirectory exists in the current
            directory, the -m switch adds the PARAGON subdirectory to the
            directory list specified by the VPATH special variable. See the
            ``Special Variables'' section for more information.

  -n        Echoes commands that would be executed, but does not execute
            them.

  -N        Disables all configuration file (Makeconf) processing.

  -o file   Does not process file even if it is older than its dependencies,
            and does not process anything because of changes in file.
            Essentially, the file is treated as very old and its rules are
            ignored.

  -p        Echoes all the environment variables, macro definitions, and
            target descriptions before executing any commands. This also
            prints the version information given by the -v switch. To print
            the database without trying to remake any files, use the
            following:

                % pmake -p -f /dev/null

  -P [partition]                                             Runs the pmake
            command as a parallel application in the partition specified by
            the partition argument. The name you specify for the partition
            argument must be .compute or the name of a subpartition in the
            .compute partition. If you specify the -P switch without an
            argument, the default partition is the value of the NX_DFLT_PART
            environment variable or the .compute partition if the
            NX_DFLT_PART variable is not set. If you do not specify the -P
            switch, the .service partition is the default partition.

  -q        Does not execute the commands in the description file. Returns a
            status code of zero if the object files are up-to-date;
            otherwise, returns a nonzero value.

  -r        Eliminates the built-in implicit rules and clears out the default
            list of suffixes for suffix rules.

  -s        Does not echo the commands being executed. This is similar to the
            pseudotarget command .SILENT:, which would be specified in the
            description file.

  -S        Stops processing the current target if an error occurs and does
            not continue to any other branch. This is the default. This
            cancels the effect of the -k switch. This is not necessary except
            in a recursive pmake where -k might be inherited from the
            top-level pmake via MAKEFLAGS or if you set -k in MAKEFLAGS in
            your environment.

  -t        Touches the targets; marks the files up-to-date without running
            commands to update them, or creates the target if it does not
            exist.

  -u        Does not unlink files that were automatically checked out from
            SCCS or RCS.

  -U        Has no effect; exists so older-version make dependency files
            continue to work.

  -v        Prints the version of the pmake command, a copyright, a list of
            authors, and a notice that there is no warranty. After this
            information is printed, processing continues normally. To get
            this information without doing anything else, use the following:

                % pmake -v -f /dev/null

  -w        Prints a message containing the working directory before and
            after other processing in the directory. This may be useful for
            tracking down errors from complicated nests of recursive pmake
            commands.

  -W file   Pretends that the target file has just been modified. When used
            with the -n switch, this shows you what would happen if you were
            to modify that file. Without -n, it is almost the same as running
            a touch command on the given file before running the pmake
            command, except that the modification time is changed only in the
            imagination of the pmake command.

  macro_definition
            Specifies a macro to use with the definition file. Use the same
            macro syntax as required for the definition file. Enclose strings
            in quotes. Spaces and tabs are ignored. See the ``Macros''
            section for more information on using macros.

  target    Name of the target to build or update. Target names are typically
            executable files, but this is not always the case. If target is
            not specified, pmake uses the first target in the definition
            file.

DESCRIPTION

  The pmake command updates a target based on whether the target's
  dependencies have been modified relative to the last modification of the
  target. Targets are typically executable files, but this is not always the
  case. Typically you use pmake to recompile large programs, but you can use
  it for any applications where a target must be updated whenever files the
  target depends on change. The pmake command executes commands in a
  description file, also called a makefile, to build or update the target.

  The pmake command is an extension of GNU make, which was written by Richard
  Stallman and Roland McGrath. It has been renamed pmake to emphasize its
  ability to execute several commands in parallel, and to distinguish it from
  the standard sequential make utility. This manual page provides a summary
  of the base GNU make features as well as the pmake extensions. For more
  detailed information about GNU make features, refer to The GNU Make Manual.
  This manual is available through the Intel Supercomputer Systems Division
  Customer Service Response Center (support@ssd.intel.com).

  For switches that have arguments, spaces between switches and argument are
  optional. For example, when using the -I switch, the directory name may
  come directly after the switch (-Idir) or a space may be inserted (-I dir).

DESCRIPTION FILES

  When a description file exists for a program, invoking pmake executes all
  the commands needed to build the program. The pmake command uses a
  definition file and the last-modification time of the target and the files
  that a target depends on to decide which targets need updating.

  Description files contain a sequence of entries that define target names
  and dependencies and describe the rules for updating the targets. A typical
  entry includes a dependency line and a series of commands, and takes the
  following form:

  target1 [target2 ...] :[:][dependency1 ...] [; command]
              [command] [; command ...]

  The dependency line begins with one or more target names separated by
  spaces. A single or double colon separates the target(s) from a list of
  zero or more dependencies for the target(s). If no dependencies are given,
  the target files are always updated if they do not exist. Otherwise, a
  target is updated only if a dependency has changed since the target was
  last updated. A single command may also appear on the dependency line,
  separated from the dependencies by a semicolon. Alternatively, commands may
  appear on subsequent lines provided that each command line begins with a
  tab character. When a target requires updating, the specified commands are
  executed.

DEPENDENCY LINES

  Dependency lines may take several forms:

  target... : [dependency] ...
            Single-colon rules. Words following the colon are added to the
            dependency list for the target(s). If a target is named in more
            than one single-colon rule, the dependencies for all of its
            entries are concatenated to form that target's complete
            dependency list. In that case, only one of the single colon rules
            may include commands for remaking the target.

  target... :: [dependency] ...
            Double-colon rules. When used in place of a single colon (:), the
            double colon (::) allows a target to be checked and updated with
            respect to alternate dependency lists. Each double colon rule is
            considered independently when deciding whether and how to update
            a particular target.

  target... : target-pattern : dep-pattern...
            Static-pattern rules. The target-pattern and dep-pattern values
            specify how to compute the dependencies for each target. Each
            target is matched against the target-pattern to extract a part of
            the target name, called the stem. The stem is then substituted
            into each of the dep-pattern values to make the dependency names,
            for example, the following dependency line specifies that foo.c
            and foo.h are dependencies of foo.o:

                                    $(OBJECTS): %.o : %.c %.h

  .s1.s2 :  Double-suffix rules. The rule tells how to make a file foo.s2
            from the file foo.s1 where foo is an arbitrary stem and s1 and s2
            are suffixes.

  .s1 :     Single-suffix rules. The rule tells how to make a file foo from
            the file foo.s1 where foo is an arbitrary stem and s1 is a
            suffix.
  target-pattern : dependency-pattern...
            Pattern rules. The target and dependency patterns each contain
            the wild card character, % (percent). The % in the target-pattern
            is matched against a stem of a target name. That stem is
            substituted for the % in the dependency-pattern. This creates the
            dependency for the target, for example, %.o : %.c with the stem
            foo creates the target foo.o from the dependency foo.c.

PARALLEL EXECUTION

  The pmake command updates multiple target files in parallel. Parallel
  execution may occur either in the service partition or the compute
  partition. In the service partition, pmake relies on process migration and
  load balancing to ensure parallel execution. In the compute partition,
  pmake places commands on the available nodes within a partition and
  executes as a parallel application.

  You can request parallel execution using either the -j or -P switch, or
  using both switches together. The -P switch specifies the partition in
  which pmake runs jobs. If you specify the -P switch without an argument,
  the default partition is the value of the NX_DFLT_PART environment variable
  or the .compute partition if the NX_DFLT_PART variable is not set. If you
  do not specify the -P switch, the .service partition is the default
  partition.

  The -j switch specifies the maximum number of jobs that can run in
  parallel. If the -j switch is not used, the maximum number of jobs defaults
  to the number of nodes in the partition, or one job if the pmake command is
  running in the service partition. If you use the -j switch followed by the
  optional jobs argument, the pmake command runs up to the number of jobs you
  specify in parallel. The number of jobs the pmake command can run in
  parallel is not limited to the number of nodes in the partition, because
  multiple jobs can run on a node. If you specify the -j switch without the
  jobs argument, the maximum number of jobs the pmake command can run in
  parallel is unlimited.

  The -l switch also affects parallel execution of the pmake command. This
  switch specifies that no new jobs should be started if there are other jobs
  running and the load average is at least the value of the load
  argument.This switch can limit parallel execution when the system load
  level is above the specified load level. The -l switch does not itself
  cause parallel execution. It affects parallel execution when you use it
  with the -j or the -P switches, only.

  The pmake command relies on the dependencies defined in the description
  file to determine which files can be updated in parallel. For example, if
  the file foo is a dependency of the file bar, the pmake command ensures
  that the foo and bar files are not simultaneously updated. For this reason,
  it is important that the description file dependencies be complete when
  using the -j and -P switches.

  When using the -j or -P switch, pmake becomes a parallel application. If
  you use the -j or -P switch after this on a recursive invocation of pmake,
  it is ignored since pmake is already executing as a parallel application.
  Therefore, when invoking pmake, choose the best recursion level at which to
  use the -j or -P switch.

  For example, if pmake is invoked with ``-j2 -P.compute'' switches on the
  following description file, the two targets big and little will be updated
  simultaneously.

  all: big little

  big:
        cd bigdir; $(MAKE)
  little:
        cd littledir; $(MAKE)

  If, in the above example, the little target is quickly updated, while the
  big target involves lots of compiles and takes several hours to build, the
  benefits of parallelism will be lost.

  A better approach in this case is to invoke the top-level pmake without the
  -j or-P switches and use the switches at the second level instead. The
  better approach is shown below.

  all: big little

  big:
        cd bigdir; $(MAKE) -j8 -P.compute

  little:
        cd littledir; $(MAKE) -j2 -P.compute

COMMANDS

  The commands to remake a target may be prefaced by one or more of the
  following special characters. The special characters are not passed to the
  shell but have the following effect within pmake:

  -         pmake ignores any non-zero error code returned by the command.

  +         pmake executes the command even if the -n, -q or -t switches are
            specified.

  @         pmake does not print the command before executing it.

INCLUDED DESCRIPTION FILES

  Description files may be included within other description files by using
  the include directive as shown below. When pmake encounters an include
  directive within a description file, it temporarily stops processing the
  first description file, processes the included description file, and then
  resumes processing the original description file.

  include filename
            A file named filename is included and processed. An error occurs
            if the file is not found.

  -include filename
            A file named filename is included and processed. No error occurs
            if the file is not found.

  Relative pathnames for the filename argument are interpreted as relative to
  the location of the file that includes them.

CONFIGURATION FILE SUPPORT

  When you invoke pmake, it searches for the configuration file Makeconf. It
  searches the build tree starting from the current directory and continuing
  up to the root directory. It includes the first Makeconf file it finds and
  processes this file prior to processing any description file. Not having a
  Makeconf file does not produce an error. This file contains rules that
  override the default rules pmake uses.

  The pmake command allows a software project to be organized into separate
  source and object directory trees. The source tree contains files that are
  read but not modified by pmake. The object tree contains the target files
  that pmake creates or updates. The trees are assumed to have the same
  structure so that each source directory has a counterpart with the same
  name within the object tree. If the Makeconf file contains a definition for
  the variable OBJECTDIR, it is interpreted as the root of the object
  directory tree. OBJECTDIR may be defined either as an absolute path or as a
  path relative to the location of the Makeconf file.

  Before running any commands, pmake computes the relative path from the
  location of the Makeconf file to the current directory and appends that
  path to the root of the object directory tree to determine the current
  object directory. The pmake command then changes directories to the object
  directory, creating subdirectories as needed, and modifies the 123 to
  search for source files in the original directory. For example, assume a
  Makeconf file in /usr/foo defines OBJECTDIR as /usr/obj. If you invoke
  pmake from /usr/foo/bar, the object directory is /usr/obj/bar and
  /usr/foo/bar will be added to the VPATH.

  The Makeconf file may include a definition for the variable SOURCEDIR. The
  SOURCEDIR variable is interpreted as a colon-separated list of alternate
  source directory trees. As with OBJECTDIR, SOURCEDIR may include both
  absolute pathnames and pathnames relative to the location of the Makeconf
  file.

  If SOURCEDIR is defined, pmake computes the additional source directories
  to be searched in much the same manner as it computes the current object
  directory. The relative path from the location of the Makeconf file to the
  current directory is computed and then appended to each of the
  colon-separated path names in the SOURCEDIR variable. The resulting
  pathnames are then added to the VPATH and searched after the current
  directory.

MACROS

  Macros may be used to simplify and improve the portability of description
  files. Macros may be defined either on the command line or from within the
  description file. Macro definitions can have the following general forms:

  MACRO = value
            Recursively expanding macro definition. The macro value is
            installed verbatim; if it contains references to other macros,
            those references are expanded when the macro is evaluated.

  MACRO := value
            Simply expanding macro definition. The value is evaluated once,
            when the macro is installed; imbedded macro references are
            evaluated at that time.

  override MACRO = value
            Override directive. Causes macro definition within a description
            file to override definition from the command line.

  Macro references take the form $(macro-name) or ${macro-name} and may
  appear anywhere within the description file. Again, several special forms
  are supported.

  $(...$(MACRO)...)
            Nested macro references.

  $(MACRO:suffix1=suffix2)
            Suffix replacement references. The value of suffix1 is replaced
            by suffix2 in the expansion of MACRO. The suffix1 must occur at
            the end of a word.

  $(MACRO:pattern1=pattern2)
            Pattern replacement references.The pattern1 and pattern2 values
            each contain the wild card character, %. Occurrences of pattern1
            in the expansion of MACRO are replaced by pattern2 with the %
            character matching any stem.
  $(MACRO/reg-expression/replacement)
            Pattern replacement references. The replacement string is
            substituted for the reg-expression within the macro expansion.
            The valid forms of regular expressions are described in
            regexp(3). Semicolons may be used in place of the slashes that
            separate the MACRO, reg-expression, and replacement strings.

  $(MACRO:X)                                                 C-shell style
            modifiers. X may be t (tail), h (head), r (root) or e
            (extension).

  $(MACRO?value1:value2)
            Conditional expressions. Evaluates to value1 if MACRO is defined
            and value2 otherwise.

SPECIAL MACROS

  The following internal macros are automatically set as each target is
  processed:

  $@        The name of the current target.

  $*        The base name of the current target.

  $<        The name of the current dependency file.

  $?        The list of dependencies that are newer than the target.

  $%        The name of the library member being processed.

  $^        The list of all dependencies.

  $$@       The current target (valid only on the dependency line).

SPECIAL VARIABLES

  Some variables have special meaning for the pmake command. Some of these
  variables are set automatically by the pmake command or they can be set as
  environment variables. The following special variables are supported:

  cputype   The CPU type of the target system in lower-case (for example,
            i860). This variable is set automatically by the pmake command.

  CPUTYPE   The CPU type of the target system in upper-case (for example,
            I860). This variable is set automatically by the pmake command.

  MAKE      The command line with which pmake was invoked, excluding
            switches. This variable is set automatically by the pmake
            command.

  MAKEFILES                                                  A list of
            description files to be read before any others. This variable may
            be set in the environment.

  MAKEFLAGS                                                  A list of the
            switches specified on the command line. This variable is set
            automatically by the pmake command.

  MAKELEVEL                                                  The current
            level of make recursion. This variable is set automatically by
            the pmake command.

  OBJECTDIR                                                  The root of the
            object tree where pmake will build its targets.
  SHELL     The shell to use for command execution. The default is /bin/sh.
            This variable may be set in the environment or in a description
            file.

  SOURCEDIR The roots of the source tree where pmake will search for sources.

  SUFFIXES  The list of default, known suffixes from built-in suffix rules.
            This variable is set automatically by the pmake command.

  target_machine                                             The machine
            architecture of the target system in lower-case (for example,
            paragon). This variable is set automatically by the pmake
            command.

  TARGET_MACHINE                                             The machine
            architecture of the target system in upper-case (for example,
            PARAGON). This variable is set automatically by the pmake
            command.

  VPATH     A colon-separated list of directories to search for dependency
            files. This variable may be set in the environment or in a
            description file.

PSEUDOTARGET NAMES

  The pmake command assigns special meanings to the following pseudotargets:

  .DEFAULT  If it appears in the description file, the rule for this target
            is used to process a target when there is no other entry for it.

  .EXIT     If defined in the description file, pmake processes this target
            and its dependencies after all other targets are built.

  .EXPORT   Variables listed as dependencies of this target are expanded and
            exported to the environment in which pmake runs it's commands.
            Unlike GNU make, pmake does not normally export variables defined
            within a definition file.

  .IGNORE   Ignore errors. When this target appears in the description file,
            pmake ignores non-zero error codes returned from commands.

  .INIT     If defined in the description file, this target and its
            dependencies are built before any other targets are processed.

  .PHONY    The dependencies of this target are considered to be ``phony''
            targets. When it is time to consider such a target, pmake will
            run its commands unconditionally regardless of whether a file
            with that name exists or what its last modification time is.

  .PRECIOUS                                                  List of files
            not to delete. pmake does not remove any of the files listed as
            dependencies for this target when interrupted. pmake normally
            removes the current target when it receives an interrupt.

  .SILENT   Run silently. When this target appears in the description file,
            pmake does not echo commands before executing them.

  .SUFFIXES                                                  The dependencies
            of this target are the suffixes that pmake will search for when
            applying suffix rules.

CONDITIONAL EXECUTION

  The pmake utility provides conditional execution directives that control
  what parts of the description file pmake sees. The general format of a
  conditional directive is the following:

  conditional-directive
  text-if-true
  endif
  Another format is the following:

  conditional-directive
  text-if-true
  else
  text-if-false
  endif

  There are four different conditional directives. They are:

  ifeq (arg1, arg2)
            The conditional evaluates to true if arg1 is equal to arg2.

  ifneq (arg1, arg2)
            The conditional evaluates to true if arg1 is not equal to arg2.

  ifdef variable-name
                      The conditional evaluates to true if variable-name is
            defined.

  ifndef variable-name
            The conditional evaluates to true if variable-name is not
            defined.

ARCHIVE SUPPORT

  Archive library members may be referenced within a description file using
  the following form:

  lib(member)

FUNCTIONS

  Functions provide support for text processing within a description file.
  The pmake utility provides approximately 20 functions including functions
  to do pattern replacement, filtering, sorting and filename component
  selection. The general form of a function call is: $(function arguments) or
  ${function arguments}.

  For a description of the available functions and their arguments, refer to
  The GNU Make Manual.

LIMITATIONS AND WORKAROUNDS

  For information about limitations and workarounds, see the release notes
  files in /usr/share/release_notes.

SEE ALSO

   The GNU Make Manual, available through the Intel Supercomputer Systems
  Division Customer Service Response Center (support@ssd.intel.com).

COPYRIGHT

  Copyright .if n .ul 0 1988-1994 Intel Corporation

  The pmake utility is an extension of GNU make and is distributed under the
  terms of the GNU General Public License. Intel will provide a complete copy
  of the pmake source code upon request. For more information, contact
  Intel's SSD Customer Service Response Center.


env(1)                                                                 env(1)

NAME

  env, printenv - Displays or sets the current environment, or displays the
  values of environment variables

SYNOPSIS

  env [-i] [-] [name=value ...] [command] [argument ...]

  printenv [name]

FLAGS

  -i  Invokes command with the environment specified by the arguments; env
      ignores the inherited environment.

  -   Invokes command with the environment specified by the arguments; env
      ignores the inherited environment. (Obsolescent)

DESCRIPTION

  The env command lets you get and change your current environment, and then
  run the specified command with the changed environment.  Changes in the
  form name=value are added to the current environment before the command is
  run.  If the -i flag is used, the current environment is ignored and the
  command runs with only the changed environment.  Changes are only in effect
  while the specified command is running.

  If command is not specified, env displays your current environment, one
  name=value pair per line.

  The printenv command displays the values of the variables in the environ-
  ment.  If name is specified, only its value is printed.  If name is not
  specified, printenv displays the current environment, one name=value per
  line.

EXAMPLES

   1.  To add a shell variable to the environment for the duration of one
       command (sh only), enter:
       TZ=MST7MDT date
       env TZ=MST7MDT date

       Each of these commands displays the current date and time in Mountain
       Standard Time.  The two commands shown are equivalent.  When date is
       finished, the previous value of TZ takes effect again.

   2.  To replace the environment with another one, enter:
       env - PATH=$PATH IDIR=/u/jim/include LIBDIR=/u/jim/lib make

       This runs make in an environment that consists only of these defini-
       tions for PATH, IDIR, and LIBDIR.  You must redefine PATH so that the
       shell can find the make command.
       When make is finished, the previous environment takes effect again.

   3.  To find the current setting of the TERM environment variable, enter:
       printenv TERM

       The command returns the value for the TERM environment variable.

EXIT VALUES

  The env command exists with the following values:

  0   The env command completed successfully.

  127 An error occurred for the env command or command could not be invoked.

  If name is specified and it is not defined in the environment, printenv
  returns exit status 1; otherwise, printenv returns status 0 (zero).

RELATED INFORMATION

  Commands:  csh(1), ksh(1), sh(1).

  Functions:  exec(2).

  "Using Internationalization Features" in the OSF/1 User's Guide.


ps(1)                                                                   ps(1)

NAME

  ps - Displays current process status

SYNOPSIS

  ps [-adejflm] [-oO specifier][=header],...  [-g glist] [-p plist] [-s
       slist] [-t tlist]
       [-u ulist]

  BSD Compatible Syntax
  ps [aAeghkjlLmsSTuvwx] [oO specifier][=header],...  [t tty]
       [process_number]

  The ps command displays the current process status.

FLAGS

  The following flags can be used with ps:

  -a  Prints information to standard output about all processes, except the
      process group leaders and processes not associated with a terminal.

  -d  Prints information to standard output about all processes, except the
      process group leaders.

  -e  Prints information to standard output about all processes, except ker-
      nel processes.

  -f  Generates a full listing.

  -g glist
      Prints only information about processes that are in the process groups
      listed in glist.  The glist is a list of process-group identifiers
      enclosed in " " (double quotes) and separated from one another by a
      comma or one or more spaces (or tabs), or both.  Because of the way the
      shell treats spaces and tabs, you need to quote space-separated lists.

  -j  Produces job control information, with fields specified for user, pid,
      ppid, pgid, sess, jobc, state, tname, cputime and comm.

  -l  Generates a long listing.

  -m  Prints all threads in a task, if the task has more than one.

  -o specifier[=header],...
      Specifies a list of format specifiers to describe the output format.

  -O specifier[=header],...
      Same as o, except it displays the fields specified by pid, state,
      tname, cputime, and comm in addition to the specifiers supplied on the
      command line.

  -p plist
      Displays only information about processes with the process numbers
      specified in plist.  The plist argument is either a list of process ID
      numbers or a list of process ID numbers enclosed in " " (double quotes)
      and separated from one another by a comma or one or more spaces (or
      tabs), or both.  Because of the way the shell treats spaces and tabs,
      you need to quote space-separated lists.

  -s slist
      Displays information about processes belonging to the sessions speci-
      fied in slist.  The slist argument is either a list of session ID
      numbers or a list of session ID numbers enclosed in " " (double quotes)
      and separated from one another by a comma or one or more spaces (or
      tabs), or both.  Because of the way the shell treats spaces and tabs,
      you need to quote space-separated lists.

  -t tlist
      Displays only information about processes associated with the terminals
      listed in tlist.  The tlist argument is either a list of terminal iden-
      tifiers or a list of terminal identifiers enclosed in " " (double
      quotes) and separated from one another by a comma or one or more
      spaces, or both.  Because of the way the shell treats spaces and tabs,
      you need to quote space-separated lists.

  -u ulist
      Displays only information about processes with the user ID numbers or
      login names specified in ulist.  The ulist argument is either a list of
      user IDs or a list of user IDs enclosed in " " (double quotes) and
      separated from one another by a comma or one or more spaces, or both.
      Because of the way the shell treats spaces and tabs, you need to quote
      space-separated lists.
      In the listing, ps displays the numerical user ID unless the -f flag is
      used; then it displays the login name.

  The following BSD compatible flags can be used with ps (note that these
  flags are not prefixed with a - (dash) character):

  a   Asks for information regarding processes associated with terminals
      (ordinarily only one's own processes are displayed).

  A   Increases the argument space.

  e   Asks for the environment to be printed, as well as the arguments to the
      command.

  g   Asks for all processes.  Without this flag, ps only prints interesting
      processes.  Processes are deemed to be uninteresting if they are pro-
      cess group leaders.  This normally eliminates top-level command inter-
      preters and processes waiting for users to log in on free terminals.

  h   Repeats the header after each screenful of information.

  j   Produces job control information, with fields specified by user, ppid,
      pgid, sess, and jobc.

  l   Asks for a detailed list, with fields specified by ppid, cp, pri, nice,
      vsize, rssize and wchan.

  L   Lists all available format specifiers.

  m   Prints all threads in a task, if the task has more than one.

  o specifier[=header],...
      Specifies a list of format specifiers to describe the output format.

  O specifier[=header],...
      Same as o, except it displays the fields specified by pid, state,
      tname, cputime, and comm in addition to the specifiers supplied on the
      command line.

  s   Gives signal states of the processes, with fields specified by uid,
      cursig, sig, sigmask, sigignore, and sigcatch.

  S   Prints usage summaries (total usage of a command, as opposed to current
      usage).

  ttty
      Lists only processes for the specified tty.

  T   Lists all processes on your tty.

  u   Produces a user oriented output. This includes fields specified by
      user, pcpu, pmem, vsize, rssize, and start.

  v   Produces a version of the output containing virtual memory statistics.
      This includes fields specified by cputime, sl, pagein, vsize, rssize,
      pcpu, and pmem.

  w   Uses a wide output format (132 columns (bytes) rather than 80); if this
      flag is doubled (ww), uses an arbitrarily wide output.  This informa-
      tion determines how much of long commands to print.

  x   Asks even about processes with no terminal.

  process_number
      Restricts output to the specified process.  This argument must be
      entered last on the command line.

DESCRIPTION

  While ps is a fairly accurate snapshot of the system, ps cannot begin and
  finish a snapshot as fast as some processes change state.  At times there
  may be minor discrepancies.

  Output formats for each process include the process ID (pid), control ter-
  minal of the process (tname), CPU time used by the process (cputime) (this
  includes both user and system time), the state of the process (state), and
  an indication of the command that is running (comm).

  The state is given by a sequence of letters, for example, RWN.  The first
  letter indicates the status of the process:

  R   Runnable process.

  U   Uninterruptible sleeping process.

  S   Process sleeping for less than about 20 seconds.

  I   Idle (sleeping longer than about 20 seconds) process.

  T   Stopped process.

  H   Halted process.

  Additional characters after these, if any, indicate additional state infor-
  mation:

  W   Process is swapped out (shows a blank space if the process is loaded
      (in-core)).

  >   Process has specified a soft limit on memory requirements and is
      exceeding that limit; such a process is (necessarily) not swapped.

  An additional letter may indicate whether a process is running with altered
  CPU scheduling priority (nice):

  N   Process priority is reduced.

  <   Process priority has been artificially raised.

  +   Process is a process group leader with a controlling tty.

  Format Specifiers
  The following list contains all format specifiers that can be used with ps:
         Specifier   Header    Meaning
         comm        COMMAND

                               Command arguments (and environment
                               with BSD e flag)
         ucomm       COMMAND   Command name for accounting
         logname     LOGNAME   User's login name
         flag        F         Process flags
         status      STATUS    Process status
         uid         UID       Process user ID (effective UID)
         ruid        RUID      Process user ID (real UID)
         svuid       SVUID     Saved process group ID
         rgid        RGID      Process group (real GID)
         svgid       SVGID     Saved process group ID
         pid         PID       Process ID
         ppid        PPID      Parent process ID
         cp          CP

                               Short-term CPU utilization factor
                               (used in scheduling)
         wchan       WCHAN

                               Address of event on which a process is
                               waiting (an address in the system).  A
                               symbol is chosen that classifies the
                               address, if available, from the sys-
                               tem; otherwise, it is printed numeri-
                               cally.
         nwchan      WCHAN

                               In this case, the initial part of the
                               address is trimmed off and is printed
                               hexadecimally, for example, 0x80004000
                               prints as 4000.
         cursig      CURSIG    Current signal
         sig         PENDING   Signals pending to this process
         sigmask     BLOCKED   Current signal mask
         sigignore   IGNORED   Signals being ignored
         sigcatch    CAUGHT    Signals being caught
         user        USER      Username
         ruser       RUSER     User ID
         pgid        PGID      Process group ID
         jobc        JOBC

                               Current count of processes qualifying
                               PGID for job control
         sess        SESS      Session ID
         tdev        TDEV      Major/minor device for controlling tty
         tname       TT        Controlling tty device name
         longtname   TT        Long controlling tty device name
         tpgid       TPGID

                               Foreground process group associated
                               with tty
         tsession    TSESS     Session associated with tty
         state       STAT      Symbolic process status
         pri         PRI

                               Process priority (nonpositive when in
                               noninterruptible wait)
             Specifier   Header    Meaning
             usrpri      UPR       Base scheduling priority
             nice        NI

                                   Process scheduling increment
                                   (see the setpriority() call).
             vsize       VSZ       Process virtual address size

             rssize      RSS

                                   Real memory (resident set) size
                                   of the process (in 1024 byte
                                   units)
             u_procp     UPROCP    Address of process in user area
             umask       UMASK     Process umask
             acflag      ACFLG     Process accounting flag
             start       STARTED

                                   Start time of process.  If
                                   start time was more than 24
                                   hours ago, gives the date.
             lstart      STARTED   Start time and date of process
             cputime     TIME      Current CPU time used
             usertime    USER      Time spent in user space
             systime     SYSTEM    Time spent in system
             pcpu        %CPU

                                   Percent CPU usage.  This is a
                                   decaying average of up to a
                                   minute of previous (real) time.
                                   Since the time base over which
                                   this is computed varies (since
                                   processes may be very young),
                                   it is possible for the sum of
                                   all %CPU fields to exceed 100%.
             pmem        %MEM      Percent real memory usage
             sl          SL        Sleep time
             pagein      PAGEIN

                                   Number of disk I/Os resulting
                                   from references by the process
                                   to pages not loaded in core.
             minflt      MINFLT    Page reclaims
             majflt      MAJFLT    Page faults
             nswap       NSWAP     Swaps
             inblock     INBLK     Block input operations
             oublock     OUBLK     Block output operations
             msgsnd      MSGSND    Messages sent
             msgrcv      MSGRCV    Messages received
             nsignals    NSIGS     Signals received
             nvcsw       VCSW      Voluntary context switches
             nivcsw      IVCSW     Involuntary context switches
             scount      SCNT      Suspend count

  Compound format specifiers are made up of groups of individual format
  specifiers, as follows:
          Specifier                        Meaning
          RUSAGE

                                           minflt, majflt, nswap,
                                           inblock, oublock, msgsnd,
                                           msgrcv, nsigs, nvcsw,
                                           nivcsw
          THREAD

                                           user, pcpu, pri, scnt,
                                           wchan, usertime, systime
          DFMT (default printing format)

                                           pid, tname, state, cpu-
                                           time, comm
          LFMT (BSD l format)

                                           uid, pid, ppid, cp, pri,
                                           nice, vsz, rss, wchan,
                                           state, tname, cputime,
                                           comm
          JFMT (j format)

                                           user, pid, ppid, pgid,
                                           sess, jobc, state, tname,
                                           cputime, comm
          SFMT (BSD s format)

                                           uid, pid, cursig, sig,
                                           sigmask, sigignore,
                                           sigcatch, stat, tname,
                                           comm
          VFMT (BSD v format)

                                           pid, tt, state, cputime,
                                           sl, pagein, vsz, rss,
                                           pcpu, pmem, comm
          UFMT (BSD u format)

                                           uname, pid, pcpu, pmem,
                                           vsz, rss, tt, state,
                                           start, cputime, comm
          F5FMT (f format)

                                           uname, pid, ppid, pcpu,
                                           start, tt, cputime, comm
          L5FMT (l format)

                                           flag, state, uid, pid,
                                           ppid, pcpu, pri, nice,
                                           rss, wchan, tt, cputime,
                                           ucomm
          FL5FMT (lf format)

                                           flag, state, uid, pid,
                                           ppid, pcpu, pri, nice,
                                           rss, wchan, start, cpu-
                                           time, comm
          process_flags

                                           Flags associated with pro-
                                           cess as in <sys/proc.h>

  The flags associated with process as in <sys/proc.h> (see process_flags in
  the preceding table) are as follows:
          Symbolic Constant   Flag Value (Hex)   Meaning
          SLOAD               0x00000001

                                                 In core
          SSYS                0x00000002

                                                 Swapper or pager
                                                 process
          STRC                0x00000010

                                                 Process is being
                                                 traced
          SWTED               0x00000020

                                                 Another tracing
                                                 flag
          SOMASK              0x00000200

                                                 Restore old mask
                                                 after taking signal
          SWEXIT              0x00000400

                                                 Working on exiting
          SPHYSIO             0x00000800

                                                 Doing physical I/O
          SPAGV               0x00008000

                                                 Init data space on
                                                 demand, from vnode
          SSEQL               0x00010000

                                                 User warned of
                                                 sequential vm
                                                 behavior
          SUANOM              0x00020000

                                                 User warned of ran-
                                                 dom vm behavior
          STIMO               0x00040000

                                                 Timing out during
                                                 sleep
          SOUSIG              0x00100000

                                                 Using old signal
                                                 mechansim
          SOWEUPC             0x00200000

                                                 Owe process an
                                                 addupc() call
          SCTTY               0x00800000

                                                 Has a controlling
                                                 terminal
          SXONLY              0x02000000

                                                 Process image
                                                 read-protected
          SNOCLDSTOP          0x40000000

                                                 No SIGCHLD when
                                                 children stop
          SEXEC               0x80000000

                                                 Process called exec

  <defunct>
      A process that has exited but whose parent process has not waited for
      it is marked <defunct>.

  <exiting>
      A process that is blocked trying to exit is marked <exiting>.

  The ps program examines memory to get the filename and arguments given when
  the process was created.  The method is inherently somewhat unreliable
  because a process can destroy this information, so the names cannot be
  counted on too much.

EXAMPLES

   1.  To list all your processes, enter:
       ps
   2.  To list all processes except kernel processes, enter:
       ps  -e

       The BSD equivalent looks like this:
       ps ax
   3.  To list processes owned by specific users, enter:
       ps  -f  -l  -ujim,jane,su
   4.  To list processes associated with a specific tty, enter:
       ps  -t console

       The BSD equivalent looks like this:
       ps tco
   5.  To display only the pid, user, and comm information for all processes,
       enter:
       ps -o pid,user,comm -e
   6.  To display the parent process ID under the header PARENT, as well as
       the default headers (fields specified by pid, state, tname, cputime,
       comm), enter:
       ps -O ppid=PARENT
FILES

  /dev   Searched to find tty names.

NOTES

  The following BSD compatible flags are not supported.  (You can reconstruct
  the output of these flags by using the appropriate format specifiers, how-
  ever.)

  c   Displays the command name, as stored internally in the system for pur-
      poses of accounting, rather than the command arguments, which are kept
      in the process's address space.

  n   Displays numeric output.  In a long listing, the wchan field is printed
      numerically rather than symbolically.  In a user listing, the user
      field is replaced by a uid field.

RELATED INFORMATION

  Commands: kill(1), w(1).


PSPART(1)                       Paragon OSF/1                       PSPART(1)

NAME
  PSPART - Shows status of the applications in a partition.

SYNTAX
  pspart [-r] [partition]

ARGUMENTS

  -r        Recursively displays status information for the specified
            partition and all its subpartitions.

  partition Absolute or relative pathname of a partition. If the partition
            argument is not specified, the value of the NX_DFLT_PART
            environment variable is used. If NX_DFLT_PART is not defined, the
            compute partition is used. You must have read permission on the
            specified partition to use this command.

DESCRIPTION

  The pspart command shows the following status information about all of the
  applications running in a partition and subpartitions:

  PGID      Process group ID of an application running in the specified
            partition. The process group ID of an application is always the
            same as the process ID of the application's controlling process.

  USER      Name of the user who invoked the application.

  SIZE      Number of nodes allocated to the application from the partition.

  PRI       Application's priority.

  STARTED   Starting time of the application's process. If the application
            was started more than 24 hours before the current time, the date
            it was started is displayed instead.

  TIME ACTIVE
            Amount of time the application has been active (rolled in) in the
            current rollin quantum. The time active is shown both in the
            following format:

                [[hours:]minutes:]seconds.milliseconds percent

            The percent is the percentage of the partition's rollin quantum.
            If the application is not active in the current rollin quantum, a
            dash (-) is shown for the time and percentage. If the partition
            uses space sharing, the time shown is the total amount of time
            the application has been running and the percentage is always
            100%.

  TOTAL TIME                                                 Total time the
            application has been rolled in since it was started. The time
            format is the following:

                [[hours:]minutes:]seconds.milliseconds.

            If the partition uses space sharing, the TOTAL TIME is always the
            same as TIME ACTIVE.

  COMMAND   Command line used to start the application.

  The following information is displayed for active partitions:

  OWNER     Owner of the active partition.

  GROUP     Group the active partition belongs to.

  SIZE      Size of the subpartition. All the nodes in the subpartition
            containing an active application are considered active, even if
            not all the nodes in the subpartition are actually in use by
            applications.

  PRI       The current priority of the subpartition. This is the highest
            priority of all applications in the subpartition or the
            subpartition's effective priority limit, whichever is lowest.

  STARTED   Time or date when the oldest application in the subpartition was
            started.

  TIME ACTIVE
            Amount of time the subpartition has been active (rolled in) in
            the current rollin quantum.

  TOTAL TIME                                                 Total time the
            subpartition has been rolled in since it was started.

  NAME      Subpartition name.

EXAMPLES

  The following example shows the status of the applications in the partition
  mypart. The parent partition is the compute partition:
% pspart mypart
     PGID  USER      SIZE PRI START      TIME ACTIVE   TOTAL TIME COMMAND
    12345  pat        256   5 11:42:20      45.00  75%    0:04:41 mag -sz 256
    23456  chris       67   4   Jan 21          -    -    0:12.30 boggle
    34567  smith      192  10 02:21:51    0:01:00 100%    2:12:03 myfft
Active Partitions
    OWNER  GROUP     SIZE PRI START      TIME ACTIVE   TOTAL TIME NAME
smith      eng         64   6 09:16:30          -    -    1:18.10 subpart

  The pspart command shows that the partition mypart has two active
  applications (mag and myfft), one inactive application (boggle), and one
  active subpartition (subpart).

  This following example uses the -r switch to display status information
  about the applications, active partitions, and the subpartitions in the
  partition mypart.

% pspart -r mypart
mypart:
     PGID  USER      SIZE PRI START      TIME ACTIVE   TOTAL TIME COMMAND
    12345  pat        256   5 11:42:20      45.00  75%    0:04:41 mag -sz 256
    23456  chris       67   4   Jan 21          -    -    0:12.30 boggle
    34567  smith      192  10 02:21:51    0:01:00 100%    2:12:03 myfft
Active Partitions

    OWNER  GROUP     SIZE PRI START      TIME ACTIVE   TOTAL TIME NAME
smith      eng         64   6 09:16:30          -    -    1:18.10 subpart
mypart.subpart:
     PGID  USER      SIZE PRI START      TIME ACTIVE   TOTAL TIME COMMAND
    45678  smith       56   7 09:16:30          -    -    1:18.10 span

  The pspart command shows that the partition mypart has two active
  applications (mag and myfft), one inactive application (boggle), and one
  active subpartition (subpart). The subpartition subpart has the application
  span in it. The application is not active.

ERRORS

pspart: Partition not found

  You specified a partition that does not exist.

pspart: Partition permission denied

  You do not have read permission for that partition.

FILES

  /usr/bin/pspart                                            Specifies the
            command path.

LIMITATIONS AND WORKAROUNDS

  For information about limitations and workarounds, see the release notes
  files in /usr/share/release_notes.

SEE ALSO

  calls: nx_pspart()

  commands: chpart, lspart, mkpart, rmpart, showpart

  OSF/1 Command Reference: ps(1)


pwd(1)                                                                 pwd(1)

NAME

  pwd - Displays the pathname of the current (working) directory

SYNOPSIS

  pwd

DESCRIPTION

  The pwd command writes to standard output the full pathname of your current
  directory, from the root directory.  All directories are separated by a /
  (slash).  The root directory is represented by the first /, and the last
  directory named is your current directory.

RELATED INFORMATION

  Commands:  cd(1), csh(1), ksh(1), sh(1).

  Functions:  stat(2).


QSTAT(1)                        Paragon OSF/1                        QSTAT(1)

NAME
  QSTAT - Displays the status of NQS requests and queues.

SYNOPSIS
  qstat [ -a ] [ -v ] [ -b ] [ -d ] [ -f ] [ -h hostname ] [ -l ] [ -n ]  [
  -p ]
  [ -s state ] [ -t n_days  ] [ -u user-name ]  [ -U ] [ -T user-target-name
  ]
  [ queue-name ... ] [ queue-name@host-name ... ]

DESCRIPTION OF PARAMETERS

  -a        Displays the status of all requests in an abbreviated format.

  -v        Displays output in 132-column format.

  -b        Displays batch queues.

  -d        Displays device queues.

  -f        Shows queues in a full format. The -l flag displays in the same
            format.

  -h host-name                                               Displays
            requests for queues on the host-name host.

  -l        Displays all requests. If a user is specified (with the -u flag)
            provides detailed information about jobs queued by that user. By
            default, detailed information is displayed about jobs queued by
            the currently logged in user. This is the default display mode.

  -n        The queue header and trailer are not displayed.

  -p        Displays pipe queues.

  -s state  Displays only those requests with the specified state.
            Allowable states are:

              r           Running

              h           Holding

              q           Queued

              t           Exiting

  -t n_days Displays the tennis court schedule for a dedicated request up to
            7 days in advance. The n_day is an integer from 0 to 6, where 0
            is the current day. If a 0 is specified, the available time slot
            will be listed. If an integer n from 1 to 6 is specified, the
            available time slots for the days which is n days in advance of
            the current day will be listed.

  -T* user-target-name
            Displays requests by the user-target-name.

  -u user-name                                               Shows only those
            requests belonging to user-name.

  -U        Displays all queued devices.

  queue-name ...                                             The name of a
            queue for which the status is being requested. The local host is
            assumed if it is not indicated with the @host-name specifier.

  queue-name@host-name ...
            The name of a queue for which the status is being requested. The
            host-name host is indicated.

  *  This flag is not supported on the Paragon OSF/1 system, but can be used
  when submitting NQS jobs from the Paragon OSF/1 system to other systems
  that do support the flag.

DISCUSSION

  If no objects are specified, then the current state of each NQS request on
  the local host is displayed. Otherwise, information is displayed for the
  specified object only. Each entry displays information about a given
  request. Ordinarily, qstat shows only those requests belonging to the
  invoker.

  If information about the queues is requested with the -b, -d, or -p flags,
  but no queues are specified, then the current state of each NQS queue on
  the local host is displayed. Otherwise, information is displayed for the
  specified queues only. Queues may be specified either as queue-name or
  queue-name@host-name. In the absence of a host-name specifier, the local
  host is assumed. You must have an account on the host specified in order
  for qstat to work. Also, root use of qstat is limited to the local machine.

  For each selected queue, qstat displays information about the queue itself.
  The flags can be used to display particular types of information.

  When a queue is being examined, the queue name, host machine, priority,
  number of requests in a given state, resource limits, and access are
  displayed.

QUEUE STATE

  The general state of a queue is defined by two principal properties of the
  queue.

  The first property determines whether or not requests can be submitted to
  the queue. If they can, then the queue is said to be enabled. Otherwise the
  queue is said to be disabled.

  The second principal property of a queue determines if requests which are
  ready to run, but are not now presently running, will be allowed to run
  upon the completion of any currently running requests, and whether any
  requests are presently running in the queue.

  If queued requests not already running are blocked from running, and no
  requests are presently executing in the queue, then the queue is said to be
  stopped. If the same situation exists with the difference that at least one
  request is running, then the queue is said to be stopping, where the
  requests presently executing will be allowed to complete execution, but no
  new requests will be spawned.

  One of the words AVAILABLE, STOPPED, DISABLED, UNAVAIL, or NQS DOWN will
  appear in the queue status field to indicate the respective queue states
  of:

  AVAILABLE   Enabled and started.

  STOPPED     Enabled and stopped.

  DISABLED    Disabled and started.

  UNAVAIL     Disabled and stopped.

  Requests can only be submitted to the queue if the queue is enabled, and
  the local NQS daemon is present.

  If the NQS daemon for the local host upon which the queue resides is not
  running, the status displays NQS DOWN.

CAVEATS

  The -s flag currently gives incorrect results.

SEE ALSO

  qcmplx, qdel, qdev, qlimit, qmgr, qpr, qsub


QSUB(1)                         Paragon OSF/1                         QSUB(1)

NAME
  QSUB - Submit an NQS batch request.

SYNOPSIS
  qsub [ flags ] [ script-file ]

DESCRIPTION OF PARAMETERS

  flags     The qsub command's flags. What follows is a terse definition of
            the flags implemented by the qsub command (see the ``Long
            Description'' discussion on page 5-65 for the complete definition
            and syntax used for each of these flags).
              -c        establish per-request account
              -e        direct stderr output to stated destination
              -eo       direct stderr output to the stdout destination
              -ke       keep stderr output on the execution machine
              -ko       keep stdout output on the execution machine
              -lc*      establish per-process corefile size limit
              -ld*      establish per-process data-segment size limits
              -lf *     establish per-process permanent-file size limits
              -lF*      establish per-request permanent-file space limits
              -lm*      establish per-process memory size limits
              -lM*      establish per-request memory space limits
              -ln       establish per-process nice execution value limit
              -lP       establish per-request number of nodes
              -ls*      establish per-process stack-segment size limits
              -lt*      establish per-process CPU time limits
              -lT       establish per-request CPU time limits
              -lv*      establish per-process temporary-file size limits
              -lV*      establish per-request temporary-file space limits
              -lw*      establish per-process working set limit
              -mb       send mail when the request begins execution
              -me       send mail when the request ends execution
              -mu       send mail for the request to the stated user
              -nr       declare that batch request is not restartable
              -o        direct stdout output to the stated destination
              -q        queue request in the stated queue
              -r        assign stated request name to the request
              -re       remotely access the stderr output file
              -ro       remotely access the stdout output file
              -s        specify shell to interpret the batch request script
              -x        export all environment variables with request
              -z        submit the request silently

  script-file                                                An optional
            batch file that contains embedded default flags that set default
            characteristics for the batch request.

  *  This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.
DISCUSSION

  The qsub command submits a batch request to the Network Queueing System
  (NQS).
  If no script file is specified, then the set of commands to be executed as
  a batch request is taken directly from the standard input file (stdin). In
  all cases however, the script file is spooled, so that later changes will
  not affect previously queued batch requests.

  All of the flags that can be specified on the command line can also be
  specified within the first comment block inside the batch request script
  file as embedded default flags. Such flags appearing in the batch request
  script file set default characteristics for the batch request. If the same
  flag is specified on the command line, then the command line flag (and any
  associated value) takes precedence over the embedded flag. See the ``Long
  Description'' discussion on page 5-65 for more information on embedded
  default flags.

LONG DESCRIPTION

  As described above, it is possible to specify default flags within the
  batch request script file that configure the default behavior of the batch
  request. The algorithm used to scan for such embedded default flags within
  an NQS batch request script file is as follows:

  1.  Read the first line of the script file.

  2.  If the current line contains only whitespace characters, or the first
      non-whitespace character of the line is : (colon), then go to step 7.

  3.  If the first non-whitespace character of the current line is not a #
      (pound) character, then go to step 8.

  4.  If the second non-whitespace character in the current line is not the @
      (at) character, or the character immediately following the second
      non-whitespace character in the current line is not a $ (dollar sign)
      character, or if the second non-whitespace character is not a Q
      character followed immediately by the string ``SUB'', then go to step
      7.

  5.  If no - is present as the character immediately following the ``@$''
      sequence or the ``QSUB'' sequence, then go to step 8.

  6.  Process the embedded flag, stopping the parsing process upon reaching
      the end of the line, or upon reaching the first unquoted # character.

  7.  Read the next script file line. Go to step 2.

  8.  End. No more embedded flags will be recognized.

  Here is an example of the use of embedded flags within the script file.

    #
    #  Batch request script example:
    #
    #  @$-a "11:30pm EDT" -lt "21:10, 20:00"
    #         # Run request after 11:30 EDT by default,
    #         # and set a maximum per-process CPU time
    #         # limit of 21 minutes and ten seconds.
    #         # Send a warning signal when any process
    #         # of the running batch request consumes
    #         # more than 20 minutes of CPU time.
    #  QSUB-lT 1:45:00
    #         # Set a maximum per-request CPU time limit
    #         # of one hour, and 45 minutes.  (The
    #         # implementation of CPU time limits is
    #         # completely dependent upon the NQS
    #         # implementation at the execution
    #         # machine.)
    #  QSUB-mb -me
    #         # Send mail at beginning and end of
    #         # request execution.
    #  @$-q batch1 # Queue request to queue: batch1 by
    #         # default.
    #  @$     # No more embedded flags.
    #
    make all

  The following paragraphs give the detailed descriptions of the flags
  supported by the qsub command.

-A FLAG

  -a date-time                                               Currently
            unused. Do not run the batch request before the specified date
            and/or time. If a date-time specification has two or more tokens
            separated by whitespace characters, then the date-time
            specification must be placed within double quotes as in: -a
            "July, 4, 2026 12:31-EDT", or otherwise escaped such that qsub
            and the shell will interpret the entire date-time specification
            as a single character string. This restriction also applies when
            an embedded default -a flag with accompanying date-time
            specification appears within the batch request script file.

            The syntax accepted for the date-time parameter is relatively
            flexible. Unspecified date and time values default to an
            appropriate value (e.g. if no date is specified, then the current
            month, day, and year are assumed).

            A date may be specified as a month and day (current year
            assumed), or the year can also be explicitly specified. It is
            also possible to specify the date as a weekday name (e.g. Tues),
            or as one of the strings: today, or tomorrow. Weekday names and
            month names can be abbreviated by any three character (or longer)
            prefix of the actual name. An optional period can follow an
            abbreviated month or day name.

            Time of day specifications can be given using a twenty-four hour
            clock, or am and pm specifications may be used alternatively. In
            the absence of a meridian specification, a twenty-four hour clock
            is assumed.

            It should be noted that the time of day specification is
            interpreted using the precise meridian definitions whereby
            ``12am'' refers to the twenty-four hour clock time of 0:00:00,
            ``12m'' refers to noon, and ``12-pm'' refers to 24:00:00.
            Alternatively, the phrases midnight and noon are accepted as time
            of day specifications, where midnight refers to the time of
            24:00:00.

            A time zone may also appear at any point in the date-time
            specification. Thus, it is legal to say: April 1, 1987 13:01-PDT.
            In the absence of a timezone specification, the local timezone is
            assumed, with daylight savings time being inferred when
            appropriate, based on the date specified.

            All alphabetic comparisons are performed in a case insensitive
            fashion, such that both WeD and weD refer to Wednesday.
            Some valid date-time examples are:

                01-Jan-1986 12am, PDT
                Tuesday, 23:00:00
                11pm tues.
                tomorrow 23-MST

            The -a switch is also used to make a reservation for a dedicated
            job if the queue to which the batch request is to be submitted is
            designated "dedicated." A queue is designated "dedicated" if the
            queue priority is greater than or equal to the tsched_pri value
            defined in the /usr/spool/nqs/conf/sched_param file. In addition,
            the starting time specified by the -a switch and the time limit
            (specified with the -1T switch) must be specified in 30 minute
            increments for dedicated job reservation because dedicated times
            are allocated at 30 minute intervals.

-C FLAG

  -c account                                                 An integer
            accounting ID or a character string representing the accounting
            group name may be specified for account. If this option is not
            specified, the account ID in the ACCOUNT environment variable is
            used. If the ACCOUNT environment variable is not set, the current
            account ID associated with the user submitting the job is used.
            Accounting IDs and group names are defined in the /etc/nxaccount
            file.

            This flag is unique to the Paragon system, and as such, is not
            supported by other NQS implementations. For this reason, if a
            batch job is submitted from a remote system (including another
            Paragon system), this flag has no effect. In these cases, the
            account ID should be specified through the ACCOUNT environment
            variable and then exported with the -x option.

-E FLAG

  -e  [machine:][[/]path/] stderr-filename
            Direct output generated by the batch request which is sent to the
            stderr file to the named [machine:][[/]path/] stderr-filename.
            The brackets [ ] enclose optional portions of the stderr
            destination machine, path, and stderr-filename.

            If no explicit machine destination is specified, then the
            destination machine defaults to the machine that originated the
            batch request, or to the machine that will eventually run the
            request, depending on the respective absence, or presence of the
            -ke flag.

            If no machine destination is specified, and the path/filename
            does not begin with a /, then the current working directory is
            prepended to create a fully qualified path name, provided that
            the -ke (keep stderr) flag is also absent. In all other cases,
            any partial path/filename is interpreted relative to the user's
            home directory on the stderr destination machine.

            This flag cannot be specified when the -eo flag option is also
            present.

            If the -eo and -e [machine:][[/]path/] stderr-filename flag
            options are not present, then all stderr output for the batch
            request is sent to the file whose name consists of the first
            seven characters of the request-name followed by the characters
            .e, followed by the request sequence number portion of the
            request-id discussed below. In the absence of the -ke flag, this
            default stderr output file is placed on the machine that
            originated the batch request in the current working directory, as
            defined when the batch request was first submitted. Otherwise,
            the file will be placed in the user's home directory on the
            execution machine.
-EO FLAG

  -eo       Direct all output that would normally be sent to the stderr file
            to the stdout file for the batch request. This flag cannot be
            specified when the -e [machine:][[/]path/] stderr-filename flag
            option is also present.

-KE FLAG

  -ke       In the absence of an explicit machine destination for the stderr
            file produced by a batch request, the machine destination chosen
            for the stderr output file is the machine that originated the
            batch request. In some cases however, this behavior may be
            undesirable, and so the -ke flag can be specified which instructs
            NQS to leave any stderr output file produced by the request on
            the machine that actually executed the batch request.

            This flag is meaningless if the -eo flag is specified, and cannot
            be specified if an explicit machine destination is given for the
            stderr parameter of the -e flag.

-KO FLAG

  -ko       In the absence of an explicit machine destination for the stdout
            file produced by a batch request, the machine destination chosen
            for the stdout output file is the machine that originated the
            batch request. In some cases however, this behavior may be
            undesirable, and so the -ko flag can be specified which instructs
            NQS to leave any stdout output file produced by the request on
            the machine that actually executed the batch request.

            This flag cannot be specified if an explicit machine destination
            is given for the stdout parameter of the -o flag.

-LC FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lc per-process corefile size limit
            Set a per-process maximum corefile size limit for all processes
            that constitute the running batch request. If any process
            comprising the running request attempts to exit creating a core
            file whose size would exceed the maximum per-process corefile
            size limit for the request, then the core file image of the
            aborting process will be reduced to the necessary size by an
            algorithm dependent upon the underlying operating system.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of a per-process corefile size
            limit.

-LD FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -ld per-process data-segment size limit [, warn-limit]
            Set a per-process maximum and an optional warning data-segment
            size limit for all processes that constitute the running batch
            request. If any process comprising the running request exceeds
            the maximum per-process data-segment size-limit for the request,
            then that process may be terminated by a signal chosen by the
            underlying operating system. For OSF/1, memory allocation calls
            will fail and no signal will be sent

            The ability to specify an optional warning limit exists for those
            operating systems that support per-process data-segment warning
            size limits. When a warning limit is exceeded, a signal as
            determined by the underlying operating system is delivered to the
            offending process (OSF/1 does not support a warning limit).

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -ld flag
            with its associated limit value(s) appears within the batch
            request script file.

            Not all NQS implementations support per-process data-segment size
            limits. If a batch request specifies this limit, and the machine
            upon which the batch request is eventually run does not support
            the enforcement of this limit, then the limit is simply ignored.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of a per-process data-segment
            size limit.

-LF FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

  -lf  per-process permanent-file size limit [, warn-limit]
            Set a per-process maximum and an optional warning permanent-file
            size limit for all processes that constitute the running batch
            request. If any process comprising the running request attempts
            to write to a permanent file such that the file size would
            increase beyond the maximum per-process permanent-file size limit
            for the request, then that process is terminated by a signal
            chosen by the underlying operating system. For OSF/1, this is
            SIGXFSZ.

            The ability to specify an optional warning limit exists for those
            operating systems that support per-process warning permanent-file
            size limits. When a warning limit is exceeded, a signal, as
            determined by the underlying operating system, is delivered to
            the offending process. For OSF/1, this is SIGXFSZ.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -lf flag
            with its associated limit value(s) appears within the batch
            request script file.
            Not all NQS implementations support per-process permanent-file
            size limits. If a batch request specifies this limit, and the
            machine upon which the batch request is eventually run does not
            support the enforcement of this limit, then the limit is simply
            ignored.

            For all NQS implementations that do not support a distinction
            between permanent, and temporary files at the kernel level (such
            as OSF/1), this limit is interpreted as a per-process file size
            limit, with the word permanent removed from the definition.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of a per-process permanent-file
            size limit.

-LF FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lF  per-request permanent-file space limit [, warn-limit]
            Set a per-request maximum and an optional warning cumulative
            permanent-file space limit for all processes that constitute the
            running batch request. If any process comprising the running
            request attempts to write to a permanent file such that the file
            space consumed by all permanent files opened for writing by all
            of the processes in the batch request, would increase beyond the
            maximum per-request permanent-file space limit for the request,
            then all of the processes in the request will be terminated by a
            signal chosen by the underlying operating system implementation.

            The ability to specify an optional warning limit exists for those
            operating systems that support per-request warning permanent-file
            space limits. When such a warning limit is exceeded, a signal is
            delivered to one or more of the processes comprising the running
            request, depending upon the underlying operating system
            implementation.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -lF flag
            with its associated limit value(s) appears within the batch
            request script file.

            Not all NQS implementations support per-request permanent-file
            space limits. If a batch request specifies this limit, and the
            machine upon which the batch request is eventually run does not
            support the enforcement of this limit, then the limit is simply
            ignored.

            For all OSF/1 implementations that do not support a distinction
            between permanent, and temporary files at the kernel level, this
            limit is interpreted as a per-request file space limit, with the
            word permanent removed from the definition.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-request permanent-file
            space limit.
-LM FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lm  per-process memory size limit [, warn-limit]
            Set a per-process maximum and an optional warning memory size
            limit for all processes that constitute the running batch
            request. If any process comprising the running request exceeds
            the maximum per-process memory size limit for the request, then
            that process is terminated by a signal chosen by the underlying
            operating system.

            The ability to specify an optional warning limit exists for those
            operating systems that support per-process warning memory size
            limits. When a warning limit is exceeded, a signal, as determined
            by the operating system, is delivered to the offending process.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -lm flag
            with its associated limit value(s) appears within the batch
            request script file.

            Not all NQS implementations support per-process memory size
            limits. If a batch request specifies this limit, and the machine
            upon which the batch request is eventually run does not support
            the enforcement of this limit, then the limit is simply ignored.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-process memory size
            limit.

-LM FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lM  per-request memory space limit [, warn-limit]
            Set a per-request maximum and an optional warning cumulative
            memory space limit for all processes that constitute the running
            batch request. If the sum of all memory consumed by all of the
            processes comprising the running request exceeds the maximum
            per-request memory space limit for the request, then all of the
            processes in the request will be terminated by a signal chosen by
            the underlying OSF/1 implementation.

            The ability to specify an optional warning limit exists for those
            OSF/1 operating systems that support per-request warning memory
            size limits. When such a warning limit is exceeded, a signal is
            delivered to one or more of the processes comprising the running
            request, depending upon the underlying OSF/1 implementation.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -lM flag
            with its associated limit value(s) appears within the batch
            request script file.

            Not all OSF/1 implementations support per-request memory space
            limits. If a batch request specifies this limit, and the machine
            upon which the batch request is eventually run does not support
            the enforcement of this limit, then the limit is simply ignored.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-request memory space
            limit.

-LN FLAG

  -ln  per-request nice value limit
            Set a per-process nice value for all processes comprising the
            running batch request.

            Most NQS implementations support the use of an integer called the
            nice value, which determines the execution-time priority of a
            process relative to all other processes in the system. By letting
            the user set a limit on the nice value for all processes
            comprising the running request, a user can cause a request to
            consume less (or more) of the CPU resource presented by the
            execution machine.

            This is particularly useful when a user wishes to execute a CPU
            intensive batch request on a machine running interactive
            processes. By setting a low execution-time priority, a user can
            make a long running batch request give way to more interactive
            processes during the daytime, while the coming of the nighttime
            hours with typically smaller process loads will allow such a
            request to gain more and more of the CPU resource. In this way,
            long running batch requests can be polite to their more
            transient, interactive neighbor processes.

            In general, increasingly negative nice values cause the relative
            execution priority of a process to increase, while increasingly
            positive nice values causes the relative priority to decrease.
            Thus, a nice value limit specification of: -ln -10 is greedier
            than a nice value limit specification of: -ln 0.

            Since varying operating systems often support a different finite
            range of nice values, NQS allows the specification of nice values
            that can eventually turn out to be outside the limits for the NQS
            implementation running at the execution machine. In such cases,
            NQS will simply bind the specified nice value limit to within the
            necessary range as appropriate.

            Any nice value specified by the use of this flag must be
            acceptable to the batch queue in which the request is ultimately
            placed (see the ``Limits'' discussion on page 5-92 for more
            information).

-LP FLAG

  -lP node-number

            Set a per-request limit on the number of nodes used. This option
            is used to set a node limit for each parallel application within
            an NQS job that is less than or equal to the limit associated
            with a batch queue. In the absence of this flag, parallel
            applications of an NQS job will run in the number of nodes
            specified as an attribute of the NQS batch queue.
            This flag is unique to the Paragon OSF/1system, and as such, is
            not supported by other NQS implementations. For this reason, if a
            batch job is submitted from a remote system (including another
            Paragon system), this flag has no effect. In these cases, a node
            limit can be specified through the NCPUS environment variable and
            then exported with the -x option.
-LS FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -ls  per-process stack-segment size limit [, warn-limit]
            Set a per-process maximum and an optional warning stack-segment
            size limit for all processes that constitute the running batch
            request. If any process comprising the running request exceeds
            the maximum per-process stack-segment size limit for the request,
            then that process is terminated by a signal chosen by the
            underlying OSF/1 implementation.

            The ability to specify an optional warning limit exists for those
            OSF/1 operating systems that support per-process warning
            stack-segment size limits. When a warning limit is exceeded, a
            signal as determined by the underlying OSF/1 implementation is
            delivered to the offending process.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -ls flag
            with its associated limit value(s) appears within the batch
            request script file.

            Not all OSF/1 implementations support per-process stack-segment
            size limits. If a batch request specifies this limit, and the
            machine upon which the batch request is eventually run does not
            support the enforcement of this limit, then the limit is simply
            ignored.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-process stack-segment
            size limit.

-LT FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lt per-process CPU time limit [, warn-limit]
            Set a per-process maximum and an optional warning CPU time limit
            for all processes that constitute the running batch request. If
            any process comprising the running request exceeds the maximum
            per-process CPU time limit for the request, then that process is
            terminated by a signal chosen by the underlying operating system.
            For OSF/1, this is SIGXCPU.

            The ability to specify an optional warning limit exists for those
            OSF/1 operating systems that support per-process CPU warning time
            limits. When a warning limit is exceeded, a signal, as determined
            by the underlying operating system is delivered to the offending
            process. For OSF/1, this is SIGXCPU.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -lt flag
            with its associated limit value(s) appears within the batch
            request script file.

            Not all NQS implementations support per-process CPU time limits.
            If a batch request specifies this limit, and the machine upon
            which the batch request is eventually run does not support the
            enforcement of this limit, then the limit is simply ignored.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-process CPU time limit.

-LT FLAG

  -lT per-request CPU time limit [, warn-limit]
            Sets a per-request maximum time limit and an optional warning
            limit for a batch request. If the per-request maximum time limit
            is exceed, all of the processes in the request are terminated by
            a SIGKILL signal. If the optional warning limit is specified, the
            user is notified before the processes are terminated.

            If the maximum limit (and optional warning limit) is comprised of
            two or more tokens separated by whitespace characters, they must
            be enclosed within double quotes, or otherwise escaped such that
            qsub and the shell will interpret the entire specification as a
            single character string token. This caveat also applies when an
            embedded default -lT flag with its associated limit value(s)
            appears within the batch request script file.

            Not all OSF/1 implementations support per-request CPU time
            limits. If a batch request specifies this limit, and the machine
            upon which the batch request is eventually run does not support
            the enforcement of this limit, then the limit is simply ignored.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-request CPU time limit.

-LV FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lv  per-process temporary file size limit [, warn-limit]
            Set a per-process maximum and an optional warning temporary
            (volatile) file size limit for all processes that constitute the
            running batch request. If any process comprising the running
            request attempts to write to a temporary file such that the file
            size would increase beyond the maximum per-process temporary-file
            size limit for the request, then that process is terminated by a
            signal chosen by the underlying operating system.

            The ability to specify an optional warning limit exists for those
            operating systems that support per-process warning temporary-file
            size limits. When a warning limit is exceeded, a signal as
            determined by the underlying operating system implementation is
            delivered to the offending process.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -lv flag
            with its associated limit value(s) appears within the batch
            request script file.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-process temporary-file
            size limit.

-LV FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lV  per-request temporary file space limit [, warn-limit]
            Set a per-request maximum and an optional warning cumulative
            temporary (volatile) file space limit for all processes that
            constitute the running batch request. If any process comprising
            the running request attempts to write to a temporary file such
            that the file space consumed by all temporary files opened for
            writing by all of the processes in the batch request would
            increase beyond the maximum per-request temporary-file space
            limit for the request, then all of the processes in the request
            will be terminated by a signal chosen by the underlying operating
            system implementation.

            The ability to specify an optional warning limit exists for those
            operating systems that support per-request warning temporary-file
            space limits. When such a warning limit is exceeded, a signal is
            delivered to one or more of the processes comprising the running
            request, depending upon the underlying operating system
            implementation.

            If a maximum limit (and optional warning limit) specification is
            comprised of two or more tokens separated by whitespace
            characters, then the specification must be enclosed within double
            quotes, or otherwise escaped such that qsub and the shell will
            interpret the entire specification as a single character string
            token. This caveat also applies when an embedded default -lV flag
            with its associated limit value(s) appears within the batch
            request script file.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of temporary-file space limit.

-LW FLAG

  (This flag is not supported on the Paragon system, but can be used when
  submitting NQS jobs from the Paragon system to other systems that do
  support the flag.)

            -lw  per-process working set size limit
            Set a per-process maximum working set size limit for all
            processes that constitute the running batch request.

            Not all operating systems support per-process working set size
            limits, and such a limit only makes sense in the context of a
            paged virtual memory machine. If a batch request specifies this
            limit, and the machine upon which the batch request is eventually
            run does not support the enforcement of this limit, then the
            limit is simply ignored.

            See the ``Limits'' discussion on page 5-92 for more information
            on the implementation of batch request limits, and for a
            description of the precise syntax of per-process working set size
            limit.

-MB FLAG

  -mb       Send mail to the user on the originating machine when the request
            begins execution. If the -mu flag is also present, then mail is
            sent to the user specified for the -mu flag instead of to the
            invoking user.

-ME FLAG

  -me       Send mail to the user on the originating machine when the request
            has ended execution. If the -mu flag is also present, then mail
            is sent to the user specified for the -mu flag instead of to the
            invoking user.

-MU FLAG

  -mu  user-name                                             Specify that any
            mail concerning the request should be delivered to the user
            user-name. User-name may be formatted either as user (containing
            no @ characters), or as user@machine. In the absence of this
            flag, any mail concerning the request will be sent to the invoker
            on the originating machine.

-NR FLAG

  -nr       Declare that the request is non-restartable. If this flag is
            specified, then the request will not be restarted by NQS upon
            system boot if the request was running at the time of an NQS
            shutdown or system crash.

            By default, NQS assumes that all requests are restartable, with
            the caveat that it is the responsibility of the user to ensure
            that the request will execute correctly if restarted, by the use
            of appropriate programming techniques.

            Requests that are not running are always preserved across host
            crashes and NQS shutdowns for later requeueing, with or without
            this flag.

            When NQS is shutdown via an operator command to the qmgr NQS
            control program, a SIGTERM signal is sent to all processes
            comprising all running NQS requests on the local host, and all
            queued NQS requests are barred from beginning execution. After a
            finite number of seconds have elapsed (typically 60, but this
            value can be overridden by the operator), all remaining processes
            comprising all remaining running NQS requests are killed by the
            signal: SIGKILL.

            For an NQS request to be properly restarted after an NQS
            shutdown, the -nr flag must not be specified, and the spawned
            batch request shell must ignore SIGTERM signals (which is done by
            default). The spawned batch request shell must also not exit
            before the final SIGKILL arrives. Since the batch request shell
            is simply spawning commands and programs, waiting for their
            completion, this implies that the commands and programs being
            executed by the batch request shell must also be immune to
            SIGTERM signals, saving state as appropriate before being killed
            by the final SIGKILL signal.

            See the ``Caveats'' discussion on page 5-95 for more discussion
            concerning the restartability of NQS batch requests.
-O FLAG

  -o  [machine:][[/]path/] stdout-filename
            Direct output generated by the batch request which is sent to the
            stdout file to the named [machine:][[/]path/] stdout-filename.

            The brackets ``['' and ``]'' enclose optional portions of the
            stdout destination machine, path, and stdout-filename.

            If no explicit machine destination is specified, then the
            destination machine defaults to the machine that originated the
            batch request, or to the machine that will eventually run the
            request, depending on the respective absence, or presence of the
            -ko flag.

            If no machine destination is specified, and the path/filename
            does not begin with a /, then the current working directory is
            prepended to create a fully qualified path name, provided that
            the -ko (keep stdout) flag is also absent. In all other cases,
            any partial path/filename is interpreted relative to the user's
            home directory on the stdout destination machine.

            If no -o   [machine:][[/]path/] stdout-filename flag is
            specified, then all stdout output for the batch request is sent
            to the file whose name consists of the first seven characters of
            the request-name followed by the characters .o, followed by the
            request sequence number portion of the request-id discussed
            below. In the absence of the -ko flag, this default stdout output
            file will be placed on the machine that originated the batch
            request in the current working directory, as defined when the
            batch request was first submitted. Otherwise, the file will be
            placed in the user's home directory on the execution machine.

-Q FLAG

  -q  queue-name                                             Specify the
            queue to which the batch request is to be submitted. If no -q
            queue-name specification is given, then the user's environment
            variable set is searched for the variable QSUB_QUEUE. If this
            environment variable is found, then the character string value
            for QSUB_QUEUE is presumed to name the queue to which the request
            should be submitted. If the QSUB_QUEUE environment variable is
            not found, then the request will be submitted to the default
            batch request queue, if defined by the local system
            administrator. Otherwise, the request cannot be queued, and an
            error message is displayed to this effect.

-R FLAG

  -r  request-name                                           Assign the
            specified request-name to the request. In the absence of an
            explicit -r  request-name specification, the request-name
            defaults to the name of the script file (leading path name
            removed) given on the command line. If no script file was given,
            then the default request-name assigned to the request is stdin.

            In all cases, if the request name is found to begin with a digit,
            then the character R is prepended to prevent a request-name from
            beginning with a digit. All request names are truncated to a
            maximum length of 15 characters.

-RE FLAG

  -re       By default, all output generated by a batch request sent to the
            stderr file is temporarily written to a file residing in a
            protected directory on the machine that executes the request.
            When the batch request completes execution, this file is then
            spooled to its final destination, possibly on a remote machine.

            This default spooling of the stderr output file is done to reduce
            the network traffic costs incurred by the submitter (owner) of a
            batch request which is to return its stderr output to a remote
            machine upon completion. In some cases, this behavior is not
            desired. If it is necessary to override this behavior, then the
            -re flag can be specified which says that stderr output produced
            by the request is to be immediately written to the final
            destination file, as output is generated, no matter what the
            networking cost.

-RO FLAG

  -ro       By default, all output generated by a batch request sent to the
            stdout file is temporarily spooled into a file residing in a
            protected directory on the machine that executes the request.
            When the batch request completes execution, this file is then
            spooled to its final destination, possibly on a remote machine.

            This default spooling of the stdout output file is done to reduce
            the network traffic costs incurred by the submitter (owner) of a
            batch request which is to return its stdout output to a remote
            machine upon completion. In some cases, this behavior is not
            desired. If it is necessary to override this behavior, then the
            -ro flag can be specified which says that stdout output produced
            by the request is to be immediately written to the final
            destination file, as output is generated, no matter what the
            networking cost.

-S FLAG

  -s  shell-name                                             Specify the
            absolute path name of the shell which will be used to interpret
            the batch request script. This flag unconditionally overrides any
            shell strategy configured on the execution machine for selecting
            which shell to spawn in order to interpret the batch request
            script.

            In the absence of this flag, the NQS system at the execution
            machine will use one of three distinct shell choice strategies
            for the execution of the batch request. Any one of the three
            strategies can be configured by a system administrator for each
            NQS machine.

            The three shell strategies are called fixed, free, and login.
            These shell strategies respectively cause the configured fixed
            shell to be exec'd to interpret all batch requests, cause the
            user's login shell as defined in the password file to be exec'd
            which in turn chooses and spawns the appropriate shell for
            interpreting the batch request script, or cause only the user's
            login shell to be exec'd to interpret the script.

            A shell strategy of fixed means that the same shell (as
            configured by the System Administrator), will be used to execute
            all batch requests.

            A shell strategy of free will run the batch request script
            exactly as would an interactive invocation of the script, and is
            the default NQS shell strategy.

            The strategies of fixed and login exist for host systems that are
            short on available free processes. In these two strategies, a
            single shell is exec'd, and that same shell is the shell that
            executes all of the commands in the batch request script.

            The shell strategy configured for a particular NQS system can be
            determined by the qlimit command.

-X FLAG

  -x        Export all environment variables. When a batch request is
            submitted, the current values of the environment variables: HOME,
            SHELL, PATH, LOGNAME (not all systems), USER (not all systems),
            MAIL, and TZ are saved for later recreation when the batch
            request is spawned, as the respective environment variables:
            QSUB_HOME, QSUB_SHELL, QSUB_PATH, QSUB_LOGNAME, QSUB_USER,
            QSUB_MAIL, and QSUB_TZ. Unless the -x flag is specified, no other
            environment variables will be exported from the originating host
            for the batch request. If the -x flag option is specified, then
            all remaining environment variables whose names do not conflict
            with the automatically exported variables, are also exported with
            the request. These additional environment variables will be
            recreated under the same name when the batch request is spawned.

-Z FLAG

  -z        Submit the batch request silently. If the request is submitted
            successfully, then no messages are displayed indicating this
            fact. Error messages will, however, always be displayed.

  If the batch request is successfully submitted and the -z flag has not been
  specified, the request-id of the request is displayed to the user. A
  request-id is always of the form: seqno.hostname where seqno refers to the
  sequence number assigned to the request by NQS, and hostname refers to the
  name of originating local machine. This identifier is used throughout NQS
  to uniquely identify the request, no matter where it is in the network.

BATCH REQUEST SEQUENCE

  The following events take place in the following order when an NQS batch
  request is spawned:

  1.  The process that will become the head of the process group for all
      processes comprising the batch request is created by NQS.

  2.  Resource limits are enforced.

  3.  The real and effective group-id of the process is set to the group-id
      as defined in the local password file for the request owner.

  4.  The real and effective user-id of the process is set to the real
      user-id of the batch request owner.

  5.  The user file creation mask is set to the value that the user had on
      the originating machine when the batch request was first submitted.

  6.  If the user explicitly specified a shell by use of the -s flag
      (discussed above), then that user-specified shell is chosen as the
      shell that will be used to execute the batch request script. Otherwise,
      a shell is chosen based upon the shell strategy as configured for the
      local NQS system (see the earlier discussion of the -s flag for a
      description of the possible shell strategies that can be configured for
      an NQS system).

  7.  The environment variables of HOME, SHELL, PATH, LOGNAME (not all
      systems), USER (not all systems), and MAIL are set from the user's
      password file entry, as though the user had logged directly into the
      execution machine.

  8.  The environment variable ENVIRONMENT is set to BATCH. This allows shell
      scripts and the user's .profile, .cshrc, or .kshrc and .login files to
      test for batch request execution when appropriate, and not set terminal
      characteristics since a batch request is not connected to an input
      terminal. For example, you could put something similar to the following
      example in your .cshrc file:

    if ($ENVIRONMENT) then
     if (``$ENVIRONMENT'' != ``BATCH'') then
     setenv NX_DFLT_PART foobar
     endif
    endif

  9.  The environment variables of QSUB_WORKDIR, QSUB_HOST, QSUB_REQNAME, and
      QSUB_REQID are added to the environment. These environment variables
      equate to the obvious respective strings of the working directory at
      the time that the request was submitted, the name of the originating
      host, the name of the request, and the request request-id.

  10. All of the remaining environment variables saved for recreation when
      the batch request is spawned are added at this point to the
      environment. When a batch request is initially submitted, the current
      values of the environment variables: HOME, SHELL, PATH, LOGNAME (not
      all systems), USER (not all systems), MAIL, and TZ are saved for later
      recreation when the batch request is spawned. When recreated however,
      these variables are added to the environment under the respective
      names: QSUB_HOME, QSUB_SHELL, QSUB_PATH, QSUB_LOGNAME, QSUB_USER,
      QSUB_MAIL, and QSUB_TZ, to avoid the obvious conflict with the local
      version of these environment variables. Additionally, all environment
      variables exported from the originating host by the -x option are added
      to the environment at this time.

  11. The current working directory is then set to the user's home directory
      on the execution machine, and the chosen shell is exec'd to execute the
      batch request script with the environment as constructed in the steps
      outlined above.

  In all cases, the chosen shell is exec'd as though it were the login shell.
  If the Bourne shell is chosen to execute the script, then the .profile file
  is read. If the C shell is chosen, then the .cshrc and .login scripts are
  read. If the K shell is chosen, then both the .profile and .kshrc files are
  read.

  If the user did not specify a specific shell for the batch request, then
  NQS chooses which shell should be used to execute the shell script, based
  on the shell strategy as configured by the system administrator (see the
  earlier discussion of the -s flag).

  In such a case, a free shell strategy instructs NQS to execute the login
  shell for the user (as configured in the password file). The login shell is
  in turn instructed to examine the shell script file, and fork another shell
  of the appropriate type to interpret the shell script, behaving exactly as
  an interactive invocation of the script.

  Otherwise no additional shell is spawned, and the chosen fixed or login
  shell sequentially executes the commands contained in the shell script file
  until completion of the batch request.
QUEUE TYPES

  NQS supports both batch queues and pipe queues. A batch queue holds
  requests for scheduled or delayed processing. A pipe queue is a queue that
  can pass queued requests on to batch queues or other pipe queues.

  Pipe queues are used to send NQS requests to other pipe queues or to batch
  queues. In general, pipe queues act as the mechanism that NQS uses to
  transport batch requests to queues on other remote machines. Pipe queues
  can also transport requests to queues on the same machine.

  When a pipe queue is defined, it is given a destination set which defines
  the set of possible destination queues for requests entered in that pipe
  queue. In this manner, it is possible for a batch request to pass through
  many pipe queues on its way to its ultimate destination, which must
  eventually be a batch queue.

  Each pipe queue has an associated server. For each request handled by a
  pipe queue, the associated server is spawned which must select a queue
  destination for the request being handled, based on the characteristics of
  the request, and upon the characteristics of each queue in the destination
  set defined for the pipe queue.

  Since a different server can be configured for each pipe queue, and batch
  queues can be endowed with the pipeonly attribute that will only admit
  requests queued via another pipe queue, it is possible for respective NQS
  installations to use pipe queues as a request class mechanism, placing
  requests that ask for different resource allocations in different queues,
  each of which can have different associated limits and priorities.

  If a pipe queue server cannot handle a request, the request is deleted and
  the user is notified by mail (see mail(1)).

QUEUE ACCESS

  NQS supports queue access restrictions. For each queue, access may be
  either unrestricted or restricted. If access is unrestricted, any request
  may enter the queue. If access is restricted, a request can only enter the
  queue if the requester or the requester's login group has been given access
  to that queue. Requests submitted by root are an exception; they are always
  queued, even if root has not explicitly been given access.

  Use qstat to determine who has access to a particular queue.

LIMITS

  NQS supports many batch request resource limit types that can be applied to
  an NQS batch queue. The existence of configurable resource limits allows an
  NQS user to set resource limits within which his or her request must
  execute. In many instances, smaller limit values can result in a more
  favorable scheduling policy for a batch request.

  For finite CPU time limits, the acceptable syntax is as follows:

    [[hours :] minutes : ] seconds [.milliseconds]

  Whites pace can appear anywhere between the principal tokens, with the
  exception that no white space can appear around the decimal point.

  Example time limit-values are:

    1234 : 58 : 21.29 - 1234 hrs 58 mins 21.290 secs
    12345             - 12345 seconds
    121.1             - 121.100 seconds
    59:01             - 59 minutes and 1 second

  For all other finite limits (with the exclusion of the nice-value), the
  acceptable syntax is:

    .fraction [units]
        or

    integer [.fraction] [units]

  where the integer and fraction tokens represent strings of up to eight
  decimal digits, denoting the obvious values. In both cases, the units of
  allocation may also be specified as one of the case insensitive strings:

              b         bytes
              w         words
              kb        kilobytes (210 bytes)
              kw        kilowords (210 words)
              mb        megabytes (220 bytes)
              mw        megawords (220 words)
              gb        gigabytes (230 bytes)
              gw        gigawords (230 words)

  In the absence of any units specification, the units of ``bytes'' are
  assumed.

  For all limit types with the exception of the nice-value, it is possible to
  state that no limit should be applied. This is done by specifying a limit
  of unlimited, or any initial substring thereof. Whenever an infinite
  limit-value is specified for a particular resource type, then the batch
  request operates as though no explicit limits have been placed upon the
  corresponding resource, other than by the limitations of the physical
  hardware involved.

  The complications caused by batch request resource limits first show up
  when queueing a batch request in a batch queue. This operation is described
  in the following paragraphs.

  If a batch request specifies a limit that cannot be enforced by the
  underlying operating system executing the job, then the limit is simply
  ignored, and the batch request will operate as though there were no limit
  (other than the obvious physical maximums), placed upon that resource type.

  For each remaining finite limit that can be supported by the underlying
  operating system that is not a CPU time limit, or nice value, the
  limit-value is internally converted to the units of bytes or words,
  whichever is more appropriate for the underlying machine architecture.

  As an example, a per-process memory size limit value of 321 megabytes would
  be interpreted as 321 x 220 bytes, provided that the underlying machine
  architecture was capable of directly addressing single bytes. Thus the
  original limit coefficient of 321 would become 321 x 220. On a machine that
  was only capable of addressing words, the appropriate conversion of 321 x
  220 bytes / #of-bytes-per-word would be performed.

  If the result of such a conversion would cause overflow when the
  coefficient was represented as a signed-long integer on the supporting
  hardware, then the coefficient is replaced with the coefficient of: of 2N-1
  where N is equal to the number of bits of precision in a signed long
  integer. For typical 32-bit machines, this default extreme limit would
  therefore be 231-1 bytes. For word addressable machines in the
  supercomputer class supporting 64-bit long integers, the default extreme
  limit would be 263-1 words.

  Lastly, some operating systems reserve coefficients of the form: 2N-1 as
  synonymous with infinity, meaning no limit is to be applied. For such
  implementations, NQS further decrements the default extreme limit so as to
  not imply infinity.

  The identical internal conversion process as described in the preceding
  paragraphs is also performed for all finite limit-values configured for a
  particular batch queue using the qmgr program.
  After all of the applicable limit-values have been converted as described
  above, each such resulting limit-value is then compared against the
  corresponding limit-value as configured for the destination batch queue.
  If, for every type of limit, the batch queue limit-value is greater than or
  equal to the corresponding batch request limit-value, then the request can
  be successfully queued, provided that no other anomalous conditions occur.
  For request infinity limit-values, the corresponding queue limit-value must
  also be configured as infinity.

  These resource limit checks are performed irrespective of the batch request
  arrival mechanism, either by a direct use of the qsub command, or by the
  indirect placement of a batch request into a batch queue via a pipe queue.
  It is impossible for a batch request to be queued in an NQS batch queue if
  any of these resource limit checks fail.

  Finally, if a request fails to specify a limit-value for a resource limit
  type that is supported on the execution machine, then the corresponding
  limit-value configured for the destination queue becomes the limit-value
  for the unspecified request limit.

  Upon the successful queueing of a request in a batch queue, the set of
  limits under which the request will execute is frozen, and will not be
  modified by subsequent qmgr commands that alter the limits of the
  containing batch queue.

CAVEATS

  When an NQS batch request is spawned, a new process-group is established
  such that all processes of the request exist in the same process-group. If
  the qdel command is used to send a signal to an NQS batch request, the
  signal is sent to all processes of the request in the created
  process-group. However, should one or more processes of the request choose
  to successfully execute a setpgrp (2) system call, then such processes will
  not receive any signals sent by the qdel command. This can lead to rogue
  requests whose constituent processes must be killed by other means such as
  the kill(1) command. However, NQS takes advantage of any operating systems
  that provide a mechanism of locking a process, and all of its subsequent
  children in a particular process-group. For such operating systems, this
  problem does not occur.

  It is extremely wise for all processes of an NQS request to catch any
  SIGTERM signals. By default, the receipt of a SIGTERM signal causes the
  receiving process to die. NQS sends a SIGTERM signal to all processes in
  the established process-group for a batch request as a notification that
  the request should be prepared to be killed, either because of an abort
  queue subcommand issued by an operator using the qmgr program, or because
  it is necessary to shutdown NQS and all running requests as part of a
  general shutdown procedure of the local host.

  It must be understood that the spawned shell ignores SIGTERM signals. If
  the current immediate child of the shell does not ignore or catch SIGTERM
  signals, then it will be killed by the receipt of such, and the shell will
  go on to execute the next command from the script (if there is one). In any
  case, the shell will not be killed by the SIGTERM signal, though the
  executing command will have been killed.

  After receiving a SIGTERM signal delivered from NQS, a process of a batch
  request typically has sixty seconds to get its house in order before
  receiving a SIGKILL signal (though the sixty second duration can be changed
  by the operator).

  All batch requests terminated because of an operator NQS shutdown request
  that did not specify the -nr flag are considered restartable by NQS, and
  are requeued (provided that the batch request shell process is still
  present at the time of the SIGKILL signal broadcast as discussed above), so
  that when NQS is rebooted, such batch requests will be respawned to
  continue execution. It is however, up to the user to make the request
  restartable by the appropriate programming techniques. NQS simply spawns
  the request again as though it were being spawned for the first time.

  Upon completion of a batch request, a mail message can be sent to the
  submitter (see the discussion of the -me flag above). In many instances,
  the completion code of the spawned Bourne, K-shell,  or C-shell are
  displayed. This is merely the value returned by the shell through the exit
  (2) system call.

SEE ALSO

  mail,  qdel, qdev, qlimit, qmgr, qpr, qstat, kill, setpgrp(), signal()


rm(1)                                                                   rm(1)

NAME

  rm - Removes (unlinks) files or directories

SYNOPSIS

  rm [-efirR] [-] file ...

  The rm command removes the entries for the specified files from a direc-
  tory.

FLAGS

  -e  Displays a message after deleting each file.

  -f  Does not prompt before removing a file that does not have write permis-
      sion set, and does not display an error message if a specified file
      does not exist.

  -i  Prompts you before deleting each file (interactive).  When you use both
      -i and -r, rm also asks if you want to examine directories.

  -r  Permits recursive removal of directories and their contents.

  -R  Permits recursive removal of directories and their contents (same as -
      r.)

  -   Indicates that all arguments following it are to be treated as
      filenames.  This allows the specification of filenames starting with a
      - (dash).

DESCRIPTION

  If an entry is the last link to a file, it is destroyed.  To remove a file,
  you must have write permission for its parent directory, but need neither
  read nor write permission for the file itself.  If the sticky bit on the
  directory is set, you must be the owner of the file or superuser.

  If a file has no write permission and standard input is a tty, rm displays
  the file permission code and reads a line from standard input.  If that
  line begins with y, or the locale's equivalent of a y, rm deletes the file.
  If the response is anything else, the rm command does nothing to that file
  and continues with the next specified file.

  The LC_MESSAGES variable determines the locale's equivalent of y or n (for
  yes/no queries).

EXAMPLES

   1.  To delete a file, enter:
       rm  myfile

       If there is another link to this file, then the file remains under
       that name, but myfile is removed.  If myfile is the only link, the
       file itself is deleted.

   2.  To delete a file silently, enter:
       rm  -f  core

       This removes core without asking any questions or displaying any error
       messages.  This is normally used in shell procedures.  It prevents
       confusing messages from being displayed when deleting files that may
       or may not exist.

   3.  To delete files interactively, enter:
       rm  -i  mydir/*

       After each filename is displayed, enter the to affirmative response;
       press <Return> (or anything other than the affirmative response) to
       retain the file.

   4.  To delete a directory tree interactively, enter:
       rm  -ir  manual

       This recursively removes the contents of all subdirectories of manual,
       then removes manual itself, asking if you want to remove each file and
       directory.

RELATED INFORMATION

  Commands:  ln(1), rmdir(1).

  Functions:  rmdir(2), unlink(2).


rmdir(1)                                                             rmdir(1)

NAME

  rmdir - Removes a directory

SYNOPSIS

  rmdir [-p] directory ...

FLAGS

  -p  Removes all directories in a pathname.

DESCRIPTION

  The rmdir command removes a directory from the system.  The directory must
  be empty before you can remove it, and you must have write permission in
  its parent directory.  Use the ls -al command to see if a directory is
  empty.

EXAMPLES

  To empty and remove a directory, enter:
  rm mydir/* mydir/.*
  rmdir mydir
  This removes the contents of mydir, then removes the empty directory. The
  rm command displays an error message about trying to remove the directories
  . (dot) and .. (dot dot), and then rmdir removes them.

  Note that rm mydir/* mydir/.* first removes files with names that do not
  begin with a . (dot), then those with names that do begin with a . (dot).
  You may not realize that the directory contains filenames that begin with a
  . (dot) because the ls command does not normally list them unless you use
  the -a flag to see the files whose names begin with a . (dot).

RELATED INFORMATION

  Commands:  ls(1), rm(1).

  Functions: rmdir(2), unlink(2).


sed(1)                                                                 sed(1)

NAME

  sed - Provides a stream line editor

SYNOPSIS

  sed [-n] [-e escript...] [script] [-f source_file] [file ...]

  The sed command modifies lines from the specified file or from standard
  input according to edit commands and writes them to standard output.

FLAGS

  -e escript
      Uses the string script as an editing script.  If you are using just one
      -e flag and no -f flag, you can omit the -e flag and include the single
      script on the command line as an argument to sed.

  -f source_file
      Uses source_file as the source of the edit script.  The source_file is
      a set of editing commands to be applied to file.

  -n  Suppresses all information normally written to standard output.

DESCRIPTION

  The sed command includes many features for selecting lines to be modified
  and making changes only to the selected lines.

  The sed command uses two work spaces for holding the line being modified:
  the pattern space, where the selected line is held, and the hold space,
  where a line can be stored temporarily.

  An edit script consists of individual subcommands, each one on a separate
  line.  The general form of sed subcommands is as follows:
  [address_range] function [modifier ...]

  The sed command processes each input file by reading an input line into a
  pattern space, sequentially applying all sed subcommands in sequence whose
  addresses select that line, and writing the pattern space to standard out-
  put.  It then clears the pattern space and repeats this process for each
  line in the input file.  Some of the subcommands use a hold space to save
  all or part of the pattern space for subsequent retrieval.

  When a command includes an address, either a line number or a search pat-
  tern, only the addressed line or lines are affected by the command.  Other-
  wise, the command is applied to all lines.

  The sed Addresses
  An address is either a decimal line number, a $, which addresses the last
  line of input, or a context address.  A context address is a regular
  expression as described for grep, except that you can select the character
  delimiter for patterns.  The general form of the expression is as follows:
  \?pattern\?

  The ? represents a character delimiter you select.  This delimiter cannot
  be a multibyte character.

  The default form for the pattern is as follows:
  /pattern/
    o  The sequence \n matches a newline character in the pattern space,
       except the terminating new line.

    o  A . (dot) matches any character except a terminating newline charac-
       ter.  That is, unlike grep, which cannot match a newline character in
       the middle of a line, sed can match a newline character in the pattern
       space.

  Certain commands allow you to specify one line or a range of lines to which
  the command applies.  These commands are called addressed commands.  The
  following rules apply to addressed commands:

    o  A command line with no address selects every line.

    o  A command line with one address, expressed in context form, selects
       each line that matches the address.

    o  A command line with two addresses separated by a , (comma) or ; (semi-
       colon) selects the entire range from the first line that matches the
       first address through the next line that matches the second.  (If the
       second address is a number less than or equal to the line number first
       selected, only one line is selected.)  Thereafter, the process is
       repeated, looking again for the first address.

SUBCOMMANDS

  Backslashes in text are treated like backslashes in the replacement string
  of an s command and can be used to protect initial spaces and tabs against
  the stripping that is done on every script line.

  The text argument accompanying the a\, c\, and i\ commands can continue
  onto more than one line, provided all lines but the last end with a \
  (backslash) to quote the newline character.

  The read_file and write_file arguments must end the command line and must
  be preceded by exactly one space.  Each write_file is created before pro-
  cessing begins.

  The sed command can process up to 99 commands in a file.

  In the following list of subcommands, the maximum number of permissible
  addresses for each subcommand is indicated in parentheses.  The sed script
  subcommands are as follows:

  (1) a\

  text
      Places text on the output before reading the next input line.

  (2)b[label]
      Branches to the : command bearing the label.  If label is empty, it
      branches to the end of the script.

  (2)c\

  text
      Deletes the pattern space.  With a 0 or 1 address or at the end of a
      2-address range, places text on the output.  Then it starts the next
      cycle.

  (2)d
      Deletes the pattern space.  Then it starts the next cycle.

  (2)D
      Deletes the initial segment of the pattern space through the first new-
      line character.  Then it starts the next cycle.

  (2)g
      Replaces the contents of the pattern space with the contents of the
      hold space.

  (2)G
      Appends the contents of the hold space to the pattern space.

  (2)h
      Replaces the contents of the hold space with the contents of the pat-
      tern space.

  (2)H
      Appends the contents of the pattern space to the hold space.

  (1)i\

  text
      Writes text to standard output before reading the next line into the
      pattern space.

  (2)l
      Writes the pattern space to standard output, showing nondisplayable
      characters as hexadecimal values.  Long lines are folded.

  (2)n
      Writes the pattern space to standard output.  It replaces the pattern
      space with the next line of input.

  (2)N
      Appends the next line of input to the pattern space with an embedded
      newline character.  (The current line number changes.)  You can use
      this to search for patterns that are split onto two lines.

  (2)p
      Writes the pattern space to standard output.

  (2)P
      Writes the initial segment of the pattern space through the first new-
      line character to standard output.

  (1)q
      Branches to the end of the script.  It does not start a new cycle.

  (1)r read_file
      Reads the contents of read_file.  It places contents on the output
      before reading the next input line.

  (2)s/pattern/replacement/flags
      Substitutes the replacement string for the first occurrence of the pat-
      tern in the pattern space.  Any character that is displayed after the s
      command can substitute for the / (slash) separator.
      You can add zero or more of the following flags:

      n   Where n is 1 to 512, substitutes replacement for the nth occurrence
          of pattern on each addressed line, rather than for the first
          occurrence.

      g   Substitutes replacement for all nonoverlapping instances of pattern
          on each addressed line, rather than for just the first one (or for
          the one specified by n).

      p   Writes the pattern space to standard output if a replacement was
          made.

      w write_file
          Writes the pattern space to write_file if a replacement was made.
          Appends the pattern space to write_file.  If write_file was not
          already created by a previous write by this sed script, sed creates
          it.  Each write_file is created before processing begins.

  (2)t[label]
      Branches to :label in the script file if any substitutions were made
      since the most recent reading of an input line execution of a t subcom-
      mand.  If you do not specify label, control transfers to the end of the
      script.

  (2)w write_file
      Appends the pattern space to write_file.

  (2)x
      Exchanges the contents of the pattern space and the hold space.

  (2)y/pattern1/pattern2/
      Replaces all occurrences of characters in pattern1 with the correspond-
      ing characters from pattern2. pattern1 and pattern2 must contain the
      same number of characters.

  (2)!sed_command
      Applies the specified sed subcommand only to lines not selected by the
      address or addresses.

  (0):label
      This script entry simply marks a branch point to be referenced by the b
      and t commands.  This label can be any sequence of eight or fewer
      bytes.

  (1)=
      Writes the current line number to standard output as a line.

  (2){subcommand ...

  }   Groups subcommands enclosed in { } (braces).

  (0) Ignores an empty command.

  (0)#
      If a # (number sign) appears as the first character on the first line
      of a script file, that entire line is treated as a comment, with one
      exception.  If the character after the # is an n, the default output is
      suppressed.  The rest of the line after the #n is ignored.  A script
      must contain at least one noncomment line.

EXAMPLES

   1.  To perform a global change, enter:
       sed  "s/happy/enchanted/g"  chap1  >chap1.new

       This replaces each occurrence of happy found in the file chap1 with
       enchanted, and puts the edited version in a separate file named
       chap1.new.  The g at the end of the s subcommand tells sed to make as
       many substitutions as possible on each line.  Without the g, sed
       replaces only the first happy on a line.
       The sed stream editor operates as a filter.  It reads text from stan-
       dard input or from the files named on the command line (chap1 in this
       example), modifies this text, and writes it to standard output.
       Unlike most editors, it does not replace the original file.  This
       makes sed a powerful command when used in pipelines.

   2.  To use sed as a filter in a pipeline (sh only), enter:
       pr  chap2 | sed  "s/Page  *[0-9]*$/(&)/" | print

       This encloses the page numbers in parentheses before printing chap2.
       The pr command puts a heading and page number at the top of each page,
       then sed puts the page numbers in parentheses, and the print command
       prints the edited listing.
       The sed pattern /Page *[0-9]*$/ matches page numbers that appear at
       the end of a line.  The s subcommand changes this to (&), where the &
       stands for the pattern that was matched (for example, Page  5).

   3.  To display selected lines of a file, enter:
       sed  -n  "/food/p" chap3

       This displays each line in chap3 that contains the word food.  Nor-
       mally, sed copies every line to standard output after it is edited.
       The -n flag stops sed from doing this.  You then use subcommands like
       p to write specific parts of the text.  Without the -n, this example
       displays all the lines in chap3, and it shows each line containing
       food twice.

   4.  To perform complex editing, enter:
       sed  -f  script.sed  chap4  >chap4.new

       It is always a good idea to create a sed script file when you want to
       do anything complex.  You can then test and modify your script before
       using it.  You can also reuse your script to edit other files.  Create
       the script file with an interactive text editor.

   5.  A sample sed script follows:
       :join
       /\\$/{N
       s/\\\n//
       b join
       }

       This sed script joins each line that ends with a \ (backslash) to the
       line that follows it.  First, the pattern /\\$/ selects a line that
       ends with a \ for the group of commands enclosed in { }.  The N sub-
       command then appends the next line, embedding a newline character.
       The s/\\\n// deletes the \ (backslash) and embedded newline character.
       Finally, b join branches back to the label :join to check for a \
       (backslash) at the end of the newly joined line.  Without the branch,
       sed writes the joined line and reads the next one before checking for
       a second \ character.
       The N subcommand causes sed to stop immediately if there are no more
       lines of input (that is, if N reads the End-of-File character).  It
       does not copy the pattern space to standard output before stopping.
       This means that if the last line of the input ends with a \
       (backslash) character, then it is not copied to the output.

RELATED INFORMATION

  Commands:  awk(1), grep(1)/egrep(1)/fgrep(1), vi(1)/vedit(1)/view(1).


sh(1)                                                                   sh(1)

NAME

  sh - The Bourne shell, an interactive command interpreter and command pro-
  gramming language

SYNOPSIS

  sh [-ir] [+ | -aefhkntuvx] [file] [argument ...] [-ccommand_string | -s]

  Rsh [-ir] [+ | -aefhkntuvx] [file] [argument ...] [-ccommand_string | -s]

  The shell carries out commands either interactively from a keyboard or from
  a file.

FLAGS

  The following flags are interpreted by the shell only when you call it.
  Note that unless you specify either the -c or -s flag, the shell assumes
  that the next argument is a command file (shell procedure).  It passes any-
  thing else on the command line to that command file (see Positional Parame-
  ters).

  -c command_string
      Runs commands read from command_string.  The shell does not read addi-
      tional commands from standard input when you specify this flag.

  -i  Makes the shell interactive, even if input and output are not from a
      tty.  In this case, the shell ignores the SIGTERM signal (so that kill
      0 does not stop an interactive shell) and traps a SIGINT (so that you
      can interrupt wait).  In all cases, the shell ignores the SIGQUIT sig-
      nal.  (See the sigaction() system call and kill for more information
      about signals.)

  -r  Creates a restricted shell (the same as running Rsh).

  -s  Reads commands from standard input.  Any remaining arguments specified
      are passed as positional parameters to the new shell.  Shell output is
      written to standard error, except for the output of built-in commands
      (see Built-In Commands).

  The remaining flags and arguments are discussed in the description of the
  built-in set command (see Built-In Commands).

DESCRIPTION

  The Bourne shell is a command programming language that executes commands
  read from a terminal or a file.  Rsh is a restricted version of the stan-
  dard command interpreter sh; Rsh is used to set up login names and execu-
  tion environments whose capabilities are more controlled than those of the
  standard shell.  This allows you to create user environments that have a
  limited set of privileges and capabilities.  (See Restricted Shell for more
  information.)

  A file from which the shell carries out commands is usually called a shell
  script, a shell procedure, or a command file.  For more information about
  writing shell scripts, see the OSF/1 User's Guide.

  A simple command is a sequence of words separated by spaces or tabs.  A
  word is a sequence of characters that contains no unquoted spaces or tabs.
  The first word in the sequence (numbered as 0), usually specifies the name
  of a command.  Any remaining words, with a few exceptions, are passed to
  that command.  A space refers to both spaces and tabs.

  The value of a simple command is its exit value if it ends normally, or
  (octal) 200 added to the signal number if it terminates due to a signal.
  For a list of status values, see the signal() system call.

  A pipeline is a sequence of one or more commands separated by a | (vertical
  bar) or, for historical compatibility, by a ^ (circumflex).  In a pipeline,
  the standard output of each command becomes the standard input of the next
  command.  Each command runs as a separate process, and the shell waits for
  the last command to end.  A filter is a command that reads its standard
  input, transforms it in some way, then writes it to its standard output.  A
  pipeline normally consists of a series of filters.  Although the processes
  in a pipeline (except the first process) can execute in parallel, they are
  synchronized to the extent that each program needs to read the output of
  its predecessor.

  The exit value of a pipeline is the exit value of the last command.

  A list is a sequence of one or more pipelines separated by ; (semicolon), &
  (ampersand), && (two ampersands), or || (two vertical bars) and optionally
  ended by a ; (semicolon), an & (ampersand), a |& (coprocess), or a newline.
  These separators and terminators have the following effects:

  ;   Causes sequential execution of the preceding pipeline; the shell waits
      for the pipeline to finish.

  &   Causes asynchronous execution of the preceding pipeline; the shell does
      not wait for the pipeline to finish.

  &&  Causes the list following it to be executed only if the preceding pipe-
      line returns a 0 (zero) exit value.

  ||  Causes the list following it to be executed only if the preceding pipe-
      line returns a nonzero exit value.
      The cd command is an exception; if it returns a nonzero exit value, no
      subsequent commands in a list are executed, regardless of the separator
      characters.

  The ; and & separators have equal precedence, as do && and ||.  The
  single-character separators have lower precedence than the double-character
  separators.  An unquoted newline character following a pipeline functions
  the same as a ; (semicolon).

  The shell treats as a comment any word that begins with a # character and
  ignores that word and all characters following up to the next newline char-
  acter.

  Shell Flow Control Statements
  Unless otherwise stated, the value returned by a statement is that of the
  last simple command executed in the statement.

  for identifier [in word ...] do list done
      For each word, sets identifier to word and executes the commands in
      list.  If you omit in word ..., then the for command executes list for
      each positional parameter that is set.  Execution ends when there are
      no more words in the list.

  case word in pattern [|pattern] ...)list;;] ... esac
      Executes the commands in the list associated with the first pattern
      that matches word.  Uses the same character-matching notation in pat-
      terns that you use for filename substitution (see Filename
      Substitution), except that you do not need to match explicitly a /
      (slash), a leading . (dot), or a . (dot) immediately following a /
      (slash).

  if list then list [elif list then list] ... [else list] fi
      Executes the list following the if keyword.  If it returns a 0 (zero)
      exit value, executes the list following the first then.  Otherwise,
      executes the list following elif (if there is an elif), and if its exit
      value is 0 (zero), executes the next then.  Failing that, executes the
      list following the else.  If no else list or then list is executed, the
      if command returns a 0 (zero) exit value.

  while list do list done
      Executes the list following the while.  If the exit value of the last
      command in the list is 0 (zero), executes the list following do.  Con-
      tinues looping through the lists until the exit value of the last com-
      mand in the while list is nonzero.  If no commands in the do list are
      executed, the while command returns a 0 (zero) exit value.

  until list do list done
      Executes the list following the until.  If the exit value of the last
      command in the list is nonzero, executes the list following do.  Con-
      tinues looping through the lists until the exit value of the last com-
      mand in the until list is 0 (zero).  If no commands in the do list are
      executed, the until command returns a 0 (zero) exit value.

  (list)
      Executes the commands in list in a subshell.

  { list; }
      Executes the commands in list in the current shell process; does not
      spawn a subshell.

  name () {  list;  }
      Defines a function that is referenced by name.  The body of the func-
      tion is the list of commands between the braces.

  The following reserved words are recognized only when they appear without
  quotes as the first word of a command.
  if      esac
  then    case
  else    for
  elif    while
  fi      until
  do      done
  {  }

  Command Execution
  Each time the shell executes a command, it carries out the substitutions
  discussed in the following text.  If the command name matches one of the
  built-in commands discussed in Built-In Commands, it executes it in the
  shell process.  If the command name does not match a built-in command but
  matches the name of a defined function, it executes the function in the
  shell process.  The shell sets the positional parameters to the parameters
  of the function.

  If the command name matches neither a built-in command nor the name of a
  defined function and the command names an executable file that is a
  compiled (binary) program, the shell (as parent) spawns a new (child) pro-
  cess that immediately runs the program.  If the file is marked executable
  but is not a compiled program, the shell assumes that it is a shell script.
  In this case, the shell spawns another instance of itself (a subshell), to
  read the file and execute the commands included in it (note how this
  differs from the execution of functions).  The shell also executes a
  command enclosed in parentheses in a subshell.  From the perspective of an
  end user, a compiled program is run in exactly the same way as a shell
  script.

  The shell normally searches for commands in two places in the file system.
  The shell first looks for the command in the current directory; if it does
  not find the command there, it looks in the /usr/bin directory.  This
  search order is in effect if the PATH environment variable is not set (or
  is set to :/usr/bin, as is the case by default on many systems).

  You can also give a specific pathname when you invoke a command, for exam-
  ple /usr/bin/sort, in which case the shell does not search any directories
  other than the one you specify in the pathname.  If the command name con-
  tains a / (slash), the shell does not use the search path (note that the
  restricted shell will not execute such commands).  You can give a full
  pathname that begins with the root directory (as in /usr/bin/sort), or a
  pathname relative to the current directory, for example bin/myfile.  In
  this last case, the shell looks in the current directory for a directory
  named bin and in that directory for myfile.

  You can change the particular sequence of directories searched by resetting
  the PATH variable (see Variables Used by the Shell).

  The shell remembers the location in the search path of each executed com-
  mand (to avoid unnecessary exec commands later).  If the command was found
  in a relative directory (one whose name does not begin with /), the shell
  must redetermine its location whenever the current directory changes.  The
  shell forgets all remembered locations whenever you change the PATH vari-
  able or execute the hash -r command (see Built-In Commands).

  Signals
  The shell ignores SIGINT and SIGQUIT signals for an invoked command if the
  command is terminated with a  & (that is, if it is running in the back-
  ground).  Otherwise, signals have the values inherited by the shell from
  its parent, with the exception of signal 11 (see also the built-in trap
  command in Built-In Commands).

  Initialization Files
  When you log in, the shell is called to read your commands.  Before it does
  that, however, it checks to see if a file named /etc/profile exists on the
  system, and if it does, it reads commands from it (this file sets variables
  needed by all users).  After this, the shell looks for a file named .pro-
  file in your login directory.  If it finds one, it executes commands from
  it.  Finally, the shell is ready to read commands from your standard input.

  Filename Substitution
  Command arguments are very often filenames.  You can automatically produce
  a list of filenames as arguments on a command line by specifying a pattern
  that the shell matches against the filenames in a directory.

  Most characters in such a pattern match themselves, but you can also use
  some special pattern-matching characters in your pattern.  These special
  characters are as follows:

  .   Matches any single character, except a newline character.

  *   Matches any string, including the null string.

  ?   Matches any one character.

  [ ...]
      Matches any one of the characters enclosed in brackets.

  [! ...]
      Matches any character other than those that follow the exclamation
      point within brackets.

  Inside brackets, a pair of characters separated by a - (dash) specifies a
  set of all characters lexically within the inclusive range of that pair
  according to the current collating sequence.  The LANG and LC_COLLATE
  environment variables control the collating sequence.  See "Using Interna-
  tionalization Features" in the OSF/1 User's Guide for more information on
  collating sequences.

  The current collating sequence groups characters into equivalence classes
  for the purpose of defining the endpoints of a range of characters.  For
  example, if the collating sequence defines the lexical order to be AaBbCc
  ... and groups uppercase and lowercase characters into equivalence classes,
  then all the following have the same effect:  [a-c], [A-C], [a-C], and [A-
  c].

  Pattern matching has some restrictions.  If the first character of a
  filename is a . (dot), it can be matched only by a pattern that begins with
  a dot.  For example, * (asterisk) matches the filenames myfile and your-
  file, but not the filenames .myfile and .yourfile.  To match these files,
  use a pattern such as the following:
  .*file
  If a pattern does not match any filenames, then the pattern itself is
  returned as the result of the attempted match.

  File and directory names should not contain the characters *, ?, [, or ],
  because this requires quoting those names in order to refer to the files
  and directories.

  Shell Variables and Command-Line Substitutions
  The shell has several mechanisms for creating variables (assigning a string
  value to a name).  Certain variables, positional parameters and keyword
  parameters, are normally set only on a command line.  Other variables are
  simply names to which you or the shell can assign string values.

  Positional Parameters
  When you run a shell script, the shell implicitly creates positional param-
  eters that reference each word on the command line by its position on the
  command line.  The word in position 0 (the procedure name), is called $0,
  the next word (the first parameter) is called $1, and so on up to $9.  To
  refer to command-line parameters numbered higher than 9, use the built-in
  shift command (see Built-In Commands).

  You can also assign values to these positional parameters explicitly by
  using the built-in set command (see Built-In Commands).

  When an argument for a position is not specified, its positional parameter
  is set to null.

  Positional parameters are global and can be passed to nested shell scripts.

  User-Defined Variables

  The shell also recognizes alphanumeric variables to which string values can
  be assigned.  You assign a string value to a name, as follows:
  name=string

  A name is a sequence of letters, digits, and underscores that begins with
  an underscore or a letter.  To use the value that you have assigned to a
  variable, add a $ (dollar sign) to the beginning of its name.  Thus, $name
  yields the value string.  Note that no spaces surround the = (equal sign)
  in an assignment statement.  (Positional parameters cannot appear in an
  assignment statement; they can only be set as described earlier.) You can
  put more than one assignment on a command line, but remember: the shell
  performs the assignments from right to left.

  If you surround string with quotes, either " " (double) or ' ' (single),
  the shell does not treat spaces, tabs, semicolons, and newline characters
  within it as word delimiters but embeds them literally in the string.

  If you surround string with double quotes, the shell still recognizes vari-
  able names in the string and performs variable substitution; that is, it
  replaces references to positional parameters and other variable names that
  are prefaced by $ with their corresponding values, if any.  The shell also
  performs command substitution (see Command Substitution) within strings
  that are surrounded by double quotes.

  If you surround string with single quotes, the shell does no variable or
  command substitution within the string.  The following sequence illustrates
  this difference:

  You enter:
  stars=*****
  asterisks1="Add $stars"
  asterisks2='Add $stars'
  echo $asterisks1

  The system displays:
  Add *****

  You enter:
  echo $asterisks2

  The system displays:
  Add $stars

  The shell does not reinterpret spaces in assignments after variable substi-
  tution (see Interpretation of Spaces).  Thus, the following assignments
  result in $first and $second having the same value:
  first='a string with embedded spaces'
  second=$first
  When you reference a variable, you can enclose the variable name (or the
  digit designating a positional parameter) in { } (braces) to delimit the
  variable name from any following string.  In particular, if the character
  immediately following the name is a letter, digit, or underscore and the
  variable is not a positional parameter, then the braces are required:

  You enter:
  a='This is a'
  echo "${a}n example"

  The system displays:
  This is an example

  You enter:
  echo "$a test"

  The system displays:
  This is a test

  See Conditional Substitution for a different use of braces in variable sub-
  stitutions.

  A Command's Environment
  All the variables (with their associated values) that are known to a com-
  mand at the beginning of its execution constitute its environment.  This
  environment includes variables that a command inherits from its parent pro-
  cess and variables specified as keyword parameters on the command line that
  calls the command.

  The shell passes to its child processes the variables that were named as
  arguments to the built-in export command.  export places the named vari-
  ables in the environments of both the shell and all its future child
  processes.

  Keyword parameters are variable-value pairs that appear in the form of
  assignments, normally before the procedure name on a command line (but see
  also the -k flag, discussed under the set command in Built-In Commands).
  Such variables are placed in the environment of the procedure being called.

  For example, given the following simple procedure that echoes the values of
  two variables (saved in a command file named key_command):
  # cat key_command
  echo $a $b
  #
  the following command lines produce the output shown:

  You enter:
  a=key1 b=key2 key_command
  The system displays:
  key1 key2
  You enter:
  a=tom b=john key_command
  The system displays:
  tom john
  A procedure's keyword parameters are not included in the parameter count
  stored in $#.

  A procedure can access the values of any variables in its environment; how-
  ever, if it changes any of these values, these changes are not reflected in
  the shell environment.  They are local to the procedure in question.  To
  place these changes in the environment that the procedure passes to its
  child processes, you must export these values within that procedure.
  To obtain a list of variables that were made exportable from the current
  shell, enter:
  export

  (You will also get a list of variables that were made read only.) To get a
  list of name-value pairs in the current environment, enter:
  env
  Conditional Substitution
  Normally, the shell replaces $variable with the string value assigned to
  variable, if there is one.  However, there is a special notation that
  allows conditional substitution, depending on whether the variable is set
  and is not null.  By definition, a variable is set if it was assigned a
  value.  The value of a variable can be the null string, which you can
  assign to a variable in any one of the following ways:
  A=
  bcd=""
  Efg=''
  set '' ""
  The first three of these examples assign the null string to each of the
  corresponding variable names.  The last example sets the first and second
  positional parameters to the null string and unsets all other positional
  parameters.

  The following is a list of the available expressions you can use to perform
  conditional substitution:

  ${ variable-string }
      If the variable is set, substitute the value of variable in place of
      this expression.  Otherwise, replace this expression with the value of
      string.

  ${ variable:-string }
      If the variable is set and is not null, substitute the value of vari-
      able in place of this expression.  Otherwise, replace this expression
      with the value of string.

  ${ variable=string }
      If the variable is set, substitute the value of variable in place of
      this expression.  Otherwise, set variable to string and then substitute
      the value of the variable in place of this expression.  You cannot
      assign values to positional parameters in this fashion.

  ${ variable:=string }
      If the variable is set and is not null, substitute the value of vari-
      able in place of this expression.  Otherwise, set variable to string
      and then substitute the value of the variable in place of this expres-
      sion.  You cannot assign values to positional parameters in this
      fashion.

  ${ variable?string }
      If the variable is set, substitute the value of variable in place of
      this expression.  Otherwise, display a message of the form:
      variable:       string
      and exit from the current shell, unless the shell is the login shell.
      If you do not specify string, the shell displays the following message:
      variable:       parameter null or not set

  ${ variable:?string }
      If the variable is set and not null, substitute the value of variable
      in place of this expression.  Otherwise, display a message of the form:
      variable:       string
      and exit from the current shell, unless the shell is the login shell.
      If you do not specify string, the shell displays the following message:
      variable:       parameter null or not set

  ${ variable+string }
      If the variable is set, substitute the value of string in place of this
      expression.  Otherwise, substitute the null string.

  ${ variable:+string }
      If the variable is set and not null, substitute the value of string in
      place of this expression.  Otherwise, substitute the null string.

  In conditional substitution, the shell does not evaluate string until it
  uses it as a substituted string, so that, in the following example, the
  shell executes the pwd command only if d is not set or is null:
  echo ${ d:-`pwd` }
  Variables Used by the Shell
  The shell uses the following variables.  The shell sets some of them, and
  you can set or reset all of them.

  CDPATH
      The search path for the cd (change directory) command.

  HOME
      The name of your login directory, the directory that becomes the
      current directory upon completion of a login.  The login program ini-
      tializes this variable.  The cd command uses the value of $HOME as its
      default value.  If you use this variable in your shell scripts rather
      than using the full pathname, your procedures run even if your login
      directory is changed or if another user runs them.

  LANG
      Specifies the locale of your system, which is comprised of three parts:
      language, territory, and codeset.  The default locale is the C locale,
      which specifies the value English for language, U.S. for territory, and
      ASCII for codeset.

  LC_COLLATE
      Specifies the collating sequence to use when sorting names and when
      character ranges occur in patterns.  The default value is the collating
      sequence for American English.  If absent, the collating sequence may
      be taken from the LANG variable.  If both LC_COLLATE and LANG are
      absent, the ANSI C collating sequence is used.

  LC_CTYPE
      Specifies the character classification information to use on your sys-
      tem.  The default value is American English.

  LC_MESSAGES
      Specifies the language in which system messages appear, and the
      language that the system expects for user input of yes and no strings.
      The default is American English.

  LC_MONETARY
      Specifies the monetary format for your system.  The default value is
      the monetary format for American English.

  LC_NUMERIC
      Specifies the numeric format for your system.  The default value is the
      numeric format for American English.

  LC_TIME
      Specifies the date and time format for your system.  The default value
      is the date and time format for American English.

  LOGNAME
      Your login name, marked readonly in the /etc/profile file.

  MAIL
      The pathname of the file used by the mail system to detect the arrival
      of new mail.  If MAIL is set, the shell periodically checks the modifi-
      cation time of this file and displays the value of $MAILMSG, if this
      time changes and the length of the file is greater than 0 (zero).
      Set MAIL in your .profile file.  The value normally assigned to it by
      users of the mail or mailx commands is /var/spool/mail/$LOGNAME.

  MAILCHECK
      The number of seconds that the shell lets elapse before checking again
      for the arrival of mail in the files specified by the MAILPATH or MAIL
      variables.  The default value is 600 seconds (10 minutes).  If you set
      MAILCHECK to 0 (zero), the shell checks before each prompt.

  MAILPATH
      A list of filenames separated from one another by a : (colon).  If you
      set this variable, the shell informs you of the arrival of mail in any
      of the files specified in the list.  You can follow each filename by a
      % (percent sign) and a message to be displayed when mail arrives.  Oth-
      erwise, the shell uses the value of MAILMSG or, by default, the message
      you have mail.
      When MAILPATH is set, these files are checked instead of the file set
      by MAIL.  To check the files set by MAILPATH and the file set by MAIL,
      specify the MAIL file in your list of MAILPATH files.

  MAILMSG
      The mail notification message.  If you explicitly set MAILMSG to a null
      string (MAILMSG=""), no message is displayed.

  NLSPATH
      Specifies a list of directories to search to find message catalogs.

  PATH
      An ordered list of directory pathnames separated by colons.  The shell
      searches these directories in the specified order when it looks for
      commands.  A null string anywhere in the list represents the current
      directory.
      PATH is normally initialized in the /etc/profile file, usually to
      :/usr/bin (by definition, a null string is assumed in front of the
      leading colon).  You can reset this variable to suit your own needs.
      Thus, if you wish to search your current directory last rather than
      first, you would enter:
      PATH=/usr/bin:

      If you have a personal directory of commands (say, $HOME/bin) that you
      want searched before the standard system directories, set your PATH as
      follows:
      PATH=$HOME/bin:/usr/bin:

      The best place to set your PATH to something other than the default
      value is in your .profile file (see The .profile File).  You cannot
      reset PATH if you are executing commands under the restricted shell
      (Rsh).

  PS1 The string to be used as the primary system prompt.  An interactive
      shell displays this prompt string when it expects input.  The default
      value of PS1 is $ followed by a space.

  PS2 The value of the secondary prompt string.  If the shell expects more
      input when it encounters a newline character in its input, it prompts
      with the value of PS2.  The default value of PS2 is > followed by a
      space.

  IFS The characters that are internal field separators (the characters that
      the shell uses during interpretation of spaces, see Interpretation of
      Spaces).  The shell initially sets IFS to include the space, tab, and
      newline characters.

  SHACCT
      The name of a file that you own.  If this variable is set, the shell
      writes an accounting record in the file for each shell script executed.
      You can use accounting programs such as acctcom and acctcms to analyze
      the data collected.

  SHELL
      A pathname whose simple part (the part after the last /) contains an r
      if you want the shell to become restricted when invoked.  This should
      be set and exported by the $HOME/.profile file of each restricted
      login.

  TIMEOUT
      A number of minutes.  After the shell displays its prompt, you have
      TIMEOUT minutes to enter a command.  If you fail to do so, the shell
      exits; in the login shell, such an exit is a logout.  Setting TIMEOUT
      to 0 (zero) inhibits automatic logout.

  Predefined Special Variables
  Several variables have special meanings; the following are set only by the
  shell:

  $#  The number of positional parameters passed to the shell, not counting
      the name of the shell script itself.  The $# variable thus yields the
      number of the highest-numbered positional parameter that is set.  One
      of the primary uses of this variable is to check for the presence of
      the required number of arguments.

  $?  The exit value of the last command executed.  Its value is a decimal
      string.  Most commands return 0 (zero) to indicate successful comple-
      tion.  The shell itself returns the current value of $? as its exit
      value.

  $$  The process number of the current process.  Because process numbers are
      unique among all existing processes, this string of up to five digits
      is often used to generate unique names for temporary files.  The fol-
      lowing example illustrates the recommended practice of creating tem-
      porary files in a directory used only for that purpose:
      temp=$HOME/temp/$$
      ls >$temp
              .
              .
              .
      rm $temp
  $!  The process number of the last process run in the background (using the
      & terminator).  Again, this is a string of up to five digits.

  $-  A string consisting of the names of the execution flags (see Built-In
      Commands) currently set in the shell.
  Command Substitution
  To capture the output of any command as an argument to another command,
  place that command line within ` ` (grave accents).  This concept is known
  as command substitution.  The shell first executes the command or commands
  enclosed within the grave accents, and then replaces the whole expression,
  grave accents and all, with their output.  This feature is often used in
  assignment statements:
  today=`date`
  This statement assigns the string representing the current date to the
  today variable.  The following assignment saves, in the files variable, the
  number of files in the current directory:
  files=`ls | wc -l`
  You perform command substitution on any command that writes to standard
  output by enclosing that command in grave accents.  You can nest command
  substitutions by preceding each of the inside sets of grave accents with a
  \ (backslash):
  logmsg=`echo Your login directory is \`pwd\``
  You can also give values to shell variables indirectly by using the built-
  in read command.  The read command takes a line from standard input (usu-
  ally your keyboard), and assigns consecutive words on that line to any
  variables named:
  read first middle last
  Thus, read will accept the following input line
  Jane C. Chen
  and it will have the same effect as if you had entered
  first=Jane init=C. last=Chen
  The read command assigns any excess words to the last variable.

  Quoting Mechanisms
  The following characters have a special meaning to the shell and cause ter-
  mination of a word unless quoted:
  ; & ( ) | ^ < > <newline> <space> <tab>

  Using ' ' (single) and " " (double) quotes to surround a string or a \
  (backslash) before a single character enables the character to stand for
  itself, instead of conveying special meaning to the shell.

  Within single quotes, all characters (except the single quote character
  itself), are taken literally, with any special meaning removed.  Thus,
  entering:
  stuff='echo $? $*; ls * | wc'
  results only in the literal string echo $? $*; ls * | wc being assigned to
  the stuff variable; the echo, ls, and wc commands are not executed, nor are
  the variables $? and $* and the special character * expanded by the shell.

  To verify this you could export the variable stuff with the command export
  stuff, and then use the command printenv stuff to view it.  Note that this
  is different from the simple command echo $stuff.

  Within double quotes, the special meaning of certain characters ($, `, and
  ") does persist, while all other characters are taken literally.  Thus,
  within double quotes, command and variable substitution takes place.  In
  addition, the quotes do not affect the commands within a command substitu-
  tion that is part of the quoted string, so characters there retain their
  special meanings.

  Consider the following sequence:

  You enter:
  ls *

  System displays:
  file1
  file2
  file3

  You enter:
  message="This directory contains `ls * ` "
  echo $message

  System displays:
  This directory contains file1 file2 file3

  This shows that the * special character inside the command substitution was
  expanded.

  To hide the special meaning of $, `, and " within double quotes, precede
  these characters with a \ (backslash).  Outside of double quotes, preceding
  a character with \ (backslash) is equivalent to placing it within single
  quotes.  Hence, a \ (backslash) immediately preceding the newline character
  (that is, a \ (backslash) at the end of the line) hides the newline charac-
  ter and allows you to continue the command line on the next physical line.

  Redirection of Input and Output
  In general, most commands do not know or care whether their input or output
  is associated with the keyboard, the display screen, or a file.  Thus, a
  command can be used conveniently either at the keyboard or in a pipeline.

  Standard Input and Standard Output
  When a command begins running, it usually expects that three files are
  already open: standard input, standard output, and standard error (some-
  times called error output or standard error output).  A number called a
  file descriptor is associated with each of these files as follows:

  File descriptor 0
      Standard input

  File descriptor 1
      Standard output

  File descriptor 2
      Standard error

  A child process normally inherits these files from its parent; all three
  files are initially assigned to the tty.  Conventionally, commands read
  from standard input (0), write to standard output (1), and write error mes-
  sages to standard error (2).  The shell permits them to be redirected else-
  where before control is passed to a command.  Any argument to the shell in
  the form <file or >file opens the specified file as the standard input or
  output, respectively.

  In the case of output, this process destroys the previous contents of file,
  if it already exists and write permission is available.  An argument in the
  form >>file directs the standard output to the end of file, thus allowing
  you to add data to it without destroying its existing contents.  If file
  does not exist, the shell creates it.

  Such redirection arguments are subject only to variable and command substi-
  tution; neither interpretation of spaces nor pattern matching of filenames
  occurs after these substitutions.  Thus, entering:
  echo 'this is a test' > *.ggg
  produces a 1-line file named *.ggg, and entering:
  cat < ?
  produces an error message, unless you have a file named ? (a bad choice for
  a filename).

  Diagnostic and Other Output
  Diagnostic output from commands is normally directed to the file associated
  with file descriptor 2.  You can redirect this error output to a file by
  immediately preceding either output redirection symbol (> or >>) with a 2
  (the number of the file descriptor).  Note that there must be no spaces
  between the file descriptor and the redirection symbol; otherwise, the
  shell interprets the number as a separate argument to the command.

  You can also use this method to redirect the output associated with any of
  the first 10 file descriptors (numbered 0 to 9) so that, for instance, if a
  command writes to file descriptor 9 (although this is not a recommended
  programming habit), you can capture that output in a file named savedata as
  follows:
  command 9> savedata
  If a command writes to more than one output, you can independently redirect
  each one.  Suppose that a command directs its standard output to file
  descriptor 1, directs its error output to file descriptor 2, and builds a
  data file on file descriptor 9.  The following command line redirects each
  of these outputs to a different file:
  command > standard 2> error 9> data
  Inline Input (Here) Documents
  When the shell sees a command line of the following form, where eof_string
  is any string that contains no pattern-matching characters, the shell takes
  the subsequent lines as the standard input of command until it reads a line
  consisting of only eof_string (possibly preceded by one or more tab charac-
  ters):
  command << eof_string

  The lines between the first eof_string and the second are frequently
  referred to as a here document.  If a - (dash) immediately follows the <<,
  the shell strips leading tab characters from each line of the input docu-
  ment before it passes the line to the command.

  The shell creates a temporary file containing the input document and per-
  forms variable and command substitution on its contents before passing it
  to the command.  It performs pattern matching on filenames that are a part
  of command lines in command substitutions.  If you want to prohibit all
  substitutions, quote any character of eof_string:
  command << \eof_string

  The here document is especially useful for a small amount of input data
  that is more conveniently placed in the shell script rather than kept in a
  separate file (such as editor scripts).  For instance, you could enter:
  cat <<- xyz
  This message will be shown on the
  display with leading tabs removed.
  xyz
  This feature is most useful in shell scripts.  Note that inline input docu-
  ments cannot appear within grave accents (command substitution).

  I/O Redirection with File Descriptors
  As discussed previously, a command occasionally directs output to some file
  associated with a file descriptor other than 1 or 2.  The shell also pro-
  vides a mechanism for creating an output file associated with a particular
  file descriptor.  For example, if you enter the following, where digit1 and
  digit2 are valid file descriptors, you can direct the output that would
  normally be associated with file descriptor digit1 to the file associated
  with digit2:
  digit1>&digit2

  The default value for digit1 and digit2 is 1 (standard output).  If, at
  execution time, no file is associated with digit2, then the redirection is
  void.  The most common use of this mechanism is to direct standard error
  output to the same file as standard output, as follows:
  command 2>&1
  If you want to redirect both standard output and standard error output to
  the same file, enter:
  command > file 2>&1
  The order here is significant.  First, the shell associates file descriptor
  1 with file; then it associates file descriptor 2 with the file that is
  currently associated with file descriptor 1.  If you reverse the order of
  the redirections, standard error output goes to the display and standard
  output goes to file because at the time of the error output redirection,
  file descriptor 1 was still associated with the display.

  You can also use this mechanism to redirect standard input.  You could
  enter:
  digit1<&digit2

  where digit1 refers to standard input and digit2 refers to standard output,
  to cause both file descriptors to be associated with the same input file.
  For commands that run sequentially, the default value of digit1 and digit2
  is 0 (standard input).  For commands that run asynchronously (commands ter-
  minated by &), the default value of digit1 and digit2 is /dev/null.  Such
  input redirection is useful for commands that use two or more input
  sources.

  Summary of Redirection Options
  The following can appear anywhere in a simple command or can precede or
  follow a command, but they are not passed to the command:

  <file
      Use file as standard input.

  >file
      Use file as standard output.  Create the file if it does not exist;
      otherwise, truncate it to 0 (zero) length.

  >>file
      Use file as standard output.  Create the file if it does not exist;
      otherwise, append the output to the end of the file.

  <<[-]eof_string
      Read as standard input all lines from eof_string up to a line contain-
      ing only eof_string or up to an End-of-File character.  If any charac-
      ter in eof_string is quoted, the shell does not expand or interpret any
      characters in the input lines; otherwise, it performs variable and com-
      mand substitution and ignores a quoted newline character (\newline).
      Use a \ (backslash) to quote characters within eof_string or within the
      input lines.
      If you add a - (dash) to <<, then all leading tabs are stripped from
      eof_string and from the input lines.

  < &digit
      Associate standard input with file descriptor digit.

  > &digit
      Associate standard output with file descriptor digit.

  < &-
      Close standard input.

  > &-
      Close standard output.

  The restricted shell does not allow the redirection of output.

  Interpretation of Spaces
  After the shell performs variable and command substitution, it scans the
  results for internal field separators (those defined in the IFS shell vari-
  able, see Variables Used by the Shell).  It splits the line into distinct
  words at each place it finds one of these characters.  It retains explicit
  null arguments (""  '') and discards implicit null arguments (those result-
  ing from parameters that have no values).

  Built-In Commands
  :   Does nothing.  This null command returns a 0 (zero) exit value.

  . file
      Reads and executes commands from file and returns.  Does not spawn a
      subshell.  The search path specified by PATH is used to find the direc-
      tory containing file.

  break [n]
      Exits from the enclosing for, while, or until loop, if any.  If n is
      specified, then breaks n levels.

  continue [n]
      Resumes the next iteration of the enclosing for, while, or until loop.
      If n is specified, resumes at the nth enclosing loop.

  cd [directory]
      Changes the current directory to directory.  If no directory is speci-
      fied, the value of the HOME shell variable is used.  The CDPATH shell
      variable defines the search path for directory.  Alternative directory
      names appear in a list, separated from one another by a : (colon).  A
      null pathname specifies the current directory, which is the default
      path.  This null pathname can appear immediately after the = (equal
      sign) in the assignment or between the colon delimiters anywhere else
      in the path list.  If directory begins with a / (slash), the shell does
      not use the search path.  Otherwise, the shell searches each directory
      in the path.  The cd command cannot be executed by the restricted
      shell.

  echo [argument ...]
      Writes arguments to standard output.

  eval [argument ...]
      Reads arguments as input to the shell and executes the resulting com-
      mands.  eval is most often used in command substitution.  For example,
      the following command sets up the shell's TERM and TERMCAP variables
      according to the type of terminal the user is logged in on:
      eval `tset -s vt100`
  exec [argument ...]
      Executes the command specified by argument in place of this shell
      without creating a new process.  Input and output arguments can appear
      and, if no other arguments appear, cause the shell input or output to
      be modified (not a good idea with your login shell).  If this command
      is given from your login shell, you will be logged out after the speci-
      fied command has been executed.

  exit [n]
      Causes a shell to exit with the exit value specified by n.  If you omit
      n, the exit value is that of the last command executed.  (Pressing the
      End-of-File key sequence also causes a shell to exit.)  The value of n
      can be from 0 to 255, inclusive.

  export [name ...]
      Marks the specified names for automatic export to the environments of
      subsequently executed commands.  If you do not specify a name, the
      export command displays a list of all the names that are exported in
      this shell.  You cannot export function names.

  hash [-r] [name ...]
      For each name, finds and remembers the location in the search path of
      the command specified by name.  The -r flag causes the shell to forget
      all locations.  If you do not specify the flag or any names, the shell
      displays information about the remembered commands.  In this informa-
      tion, hits is the number of times a command has been run by the shell
      process.  cost is a measure of the work required to locate a command in
      the search path.  There are certain situations that require that the
      stored location of a command be recalculated (for example, the location
      of a relative pathname when the current directory changes).  Commands
      for which that might be done are indicated by an * (asterisk) next to
      the hits information.  cost is incremented when the recalculation is
      done.

  inlib library_name
      Installs the specified shared library into the shell's private table of
      installed libraries.  This makes the library available for resolution
      of unresolved symbols in commands subsequently executed from this
      shell.

  newgrp [-] [group]
      Changes the primary group identification of the current shell process
      to group.  If you specify -, newgrp changes the login environment to
      the login environment of the new group.  If you do not specify a group,
      newgrp changes the group identification to that specified for the
      current user in the /etc/passwd file.  newgrp recognizes group names
      only; it does not recognize group ID numbers.
      Only a user with superuser authority can change the primary group of
      the shell to one to which that user does not belong.
      Any active user-generated shell is terminated when the newgrp command
      is used.

  pwd Displays the current directory.  See pwd for a discussion of command
      options.

  read [name...]
      Reads one line from standard input.  Assigns the first word in the line
      to the first name, the second word to the second name, and so on, with
      leftover words assigned to the last name.  This command returns a 0
      (zero) unless it encounters an end of file.

  readonly [name...]
      Marks the specified names as read only.  The values of these names can-
      not be reset.  If you do not specify any names, the readonly command
      displays a list of all readonly names.

  return [n]
      Causes a function to exit with a return value of n.  If you do not
      specify n, the function returns the status of the last command executed
      in that function.  This command is valid only when executed within a
      shell function.

  rmlib library_name
      Removes the specified shared library from the shell's private table of
      installed libraries.  This library is no longer available for resolu-
      tion of unresolved symbols in commands executed from this shell.

  set [+ | -flag ...] [argument ...]
      Sets one or more of the following flags:

      -a  Marks for export all variables that are modified or changed.

      -e  Exits immediately if a command exits with a nonzero exit value.

      -f  Disables filename substitution.

      -h  Locates and remembers the commands called within functions as the
          functions are defined.  (Normally these commands are located when
          the function is executed; see the built-in hash command.)

      -k  Places all keyword parameters in the environment for a command, not
          just those that precede the command name.

      -n  Reads commands, but does not execute them.

      -t  Exits after reading and executing one command.

      -u  Treats an unset variable as an error when performing variable sub-
          stitution.

      -v  Displays shell input lines as they are read.

      -x  Displays commands and their arguments as they are executed.

      --  Does not change any of the flags.  This is useful in setting the $1
          positional parameter to a string beginning with a - (dash).
      Using a + (plus sign) rather than a - (dash) unsets flags.  You can
      also specify these flags on the shell command line.  The $- special
      variable contains the current set of flags.
      Any arguments to set are positional parameters and are assigned, in
      order, to $1, $2, and so on.  If you do not specify flags or arguments,
      set displays all names.

  shift [n]
      Shifts command-line arguments to the left; that is, reassigns the value
      of the positional parameters by discarding the current of value of $1
      and assigning the value of $2 to $1, of $3 to $2, and so on.  If there
      are more than nine command line arguments, the tenth is assigned to $9
      and any that remain are still unassigned (until after another shift).
      If there are nine or fewer arguments, a shift unsets the highest-
      numbered positional parameter.
      $0 is never shifted.  The command shift n is a shorthand notation for n
      consecutive shifts.  The default value of n is 1.

  test expression | [ expression ]
      Evaluates conditional expressions.  See test for a discussion of com-
      mand options.

  times
      Displays the accumulated user and system times for processes run from
      the shell.

  trap [command] [n] ...
      Runs the command specified by command when the shell receives n
      signal(s).  (Note that the shell scans command once when the trap is
      set and once when the trap is taken).  The trap commands are executed
      in order of signal number.  Any attempt to set a trap on a signal that
      was ignored on entry to the current shell is ineffective.
      If you do not specify a command, then all traps n are reset to their
      current values.  If command is a null string, this signal is ignored by
      the shell and by the commands it invokes.  If n is 0 (zero), the com-
      mand is executed on exit from the shell.  If neither a command or a
      signal (n) is specified, trap displays a list of commands associated
      with each signal number.

  type [name ...]
      For each name specified, indicates how the shell interprets it as a
      command name.

  ulimit [-b [m]] [-f] [n] [-s [m]]
      Sets or queries size limits.  The -b flag sets the break value to m.
      This limits the size of data segment to m pages.  If you specify -b
      with no m, ulimit displays the current break value.  The -f flag
      imposes a size limit of n blocks on files written by the child
      processes (files of any size can be read).  Without n, ulimit displays
      the current limit; this is the default action of ulimit.
      Any user can decrease this limit, but only a user operating with
      superuser authority can increase the limit.  The -s flag imposes a size
      limit of m pages on the stack.  If you specify -s with no m, ulimit
      displays the current stack size limit.

  umask [nnn]
      Sets your file-creation mask to the octal value nnn (see the umask()
      system call).  If you omit nnn, umask displays the current value of the
      mask.

  unset [name ...]
      For each name, removes the corresponding variable, built-in command, or
      function.  The PATH, PS1, PS2, MAILCHECK, and IFS variables cannot be
      unset.

  wait [n]
      Waits for the child process whose process number is n to end and
      reports its termination status.  If you do not specify n, then the
      shell waits for all currently active child processes and the return
      value is 0 (zero).

  Character Classes
  You can use the following notation to match filenames within a range indi-
  cation:
  [:charclass:]

  This format instructs the system to match any single character belonging to
  charclass; the defined classes correspond to ctype() subroutines as fol-
  lows:
  alnum
  alpha
  cntrl
  digit
  graph
  lower
  print
  punct
  space
  upper
  xdigit

  Your locale might define additional character properties, such as the fol-
  lowing:
  [:vowel:]

  The preceding character class could be TRUE for a, e, i, o, u, or y.  You
  could then use [:vowel] inside a set construction to match any vowel.
  Refer to The LC_CTYPE Category section of the locale file format reference
  page for more information.

  Running the Shell
  The sh command can be run either as a login shell or as a subshell under
  the login shell.  Only the login command can call sh as a login shell.  It
  does this by using a special form of the sh command name:  -sh.  When
  called with an initial - (dash), the shell first reads and runs commands
  found in the system .profile file and your $HOME/.profile, if one exists.
  It then accepts commands as described in the following discussion of flags.

  Once logged in and working under a login shell, you can call sh with the
  command name sh.  This command runs a subshell, a second shell running as a
  child of the login shell.

  Restricted Shell
  The restricted shell, Rsh, is used to set up login names and execution
  environments whose capabilities are more controlled than those of the stan-
  dard shell.  The actions of Rsh are identical to those of sh, except that
  the following are not allowed:

    o  Changing directory (with the cd command).

    o  Setting the value of PATH or SHELL.

    o  Specifying pathnames or command names containing /.

    o  Redirecting output (with > and >>).

  A restricted shell can be invoked in one of the following ways:  (1) Rsh is
  the filename part of the last entry in the /etc/passwd file; (2) the
  environment variable SHELL exists and Rsh is the filename part of its
  value; (3) the shell is invoked and Rsh is the filename part of argument 0
  (zero); (4) the shell is invoked with the -r flag.

  When a command to be run is determined to be a shell script, Rsh invokes sh
  to run the command.  Thus, it is possible to provide the end user with
  shell scripts that have access to the full power of the standard shell,
  while imposing a limited menu of commands; this scheme assumes that the end
  user does not have write and execute permissions in the same directory.

  The preceding restrictions are enforced after the .profile file is inter-
  preted.  Therefore, the writer of the .profile has complete control over
  user actions by performing set-up actions and leaving the user in an
  appropriate directory (probably not the login directory).  An administrator
  can set up a directory of commands in /usr/rbin that the Rsh command can
  invoke.

  When called with the name -rsh or -Rsh, Rsh reads the user's .profile from
  $HOME/.profile.  It acts as the standard sh while doing this, except that
  an Interrupt causes an immediate exit instead of a return to command level.

  The system administrator should be aware that use of Rsh does not imply
  that the system is secure.  A secure system implements a system-wide frame-
  work to protect the system against unauthorized activity.  Rsh is not
  designed to implement this type of system security.

FILES

  $HOME/.profile
             User profile.

  /etc/passwd
             Contains user information.

EXIT VALUES
  For information about exit values, see the following sections: The Shell
  Commands, Predefined Special Variables, Built-In Commands, and FLAGS.

NOTES

   1.  If a command is executed, and a command with the same name is
       installed in a directory in the search path before the directory where
       the original command was found, the shell will execute the original
       command.  Use the hash command to correct this situation.

   2.  When the shell encounters the >> characters, it does not open the file
       in append mode; instead, the shell opens the file for writing and
       seeks to the end.

   3.  Failure (nonzero exit status) of a special command preceding a || sym-
       bol prevents the list following || from executing.

RELATED INFORMATION

  Commands:  acctcms(8), acctcom(8), cd(1), csh(1), echo(1),
  env(1)/printenv(1), ksh(1), login(1), mail(1)/binmail(1), mailx(1)/Mail(1),
  pwd(1), test(1).

  Functions:  fcntl(2), exec(2), fork(2), ldr_install(2), ldr_remove(2),
  pipe(2), sigaction(2), stat(2), ulimit(3), umask(2).

  Files:  osf_rose(4), null(7).

  "Using Internationalization Features" in the OSF/1 User's Guide.


SHOWPART(1)                     Paragon OSF/1                     SHOWPART(1)

NAME
  SHOWPART - Displays a partition's characteristics.

SYNTAX
  showpart [-f] [partition]

ARGUMENTS

  -f        Displays the nodes in a partition that are free. An ``F''
            character indicates which nodes are free.

  partition Absolute or relative pathname of a partition. If you do not
            specify a partition argument, the command uses the value
            specified in the NX_DFLT_PART environment variable. If the
            NX_DFLT_PART environment variable is not set, the default is the
            compute partition. You must have read permission on the specified
            partition.

DESCRIPTION

  The showpart command displays information about a specified partition. The
  columns at the top of the showpart output provide the following
  information:

  USER        The owner of the partition.

  GROUP       The group of the partition.

  ACCESS      The access permissions, expressed as an octal number. For
              example, 777 represents the permissions rwxrwxrwx.

  SIZE        The number of nodes in the partition.

  FREE        The number of free nodes in the partition. A node is free if no
              application is running on that node and no subpartition in
              which any applications are running includes that node. (Note
              that all the nodes of a subpartition are considered busy if an
              application is running anywhere in the subpartition, or in any
              of its sub-subpartitions. This occurs because partitions are
              scheduled recursively.)

  RQ          The rollin quantum or scheduling type of the partition, as
              follows:

              -           The partition uses standard scheduling.

              SPS         The partition uses space sharing.

              time        The partition uses gang scheduling with a rollin
                          quantum of time. The time is expressed as a number
                          followed by an optional letter: no letter for
                          milliseconds, s for seconds, m for minutes, or h
                          for hours.

  EPL         The effective priority limit of the partition. A dash (-)
              indicates a standard-scheduled partition.

  The command displays a rectangle that represents the root partition. The
  numbers to the left of the rectangle show the root-partition node numbers
  for the nodes in the first column of each row of the root partition.
  Special characters shows the specified partition's size, shape, and
  position in the root partition. The following characters indicate
  information about the partition:

  o Asterisk (*) represents a node that is allocated to the partition.

  o Dash (-) represents empty slots.

  o ``X'' represents a bad or unusable node allocated to the partition.

  o ``F'' represents a node that is free in the partition. This character is
    displayed only if the -f switch is specified.

  o Dot (.) represents a node that is not in the partition.

                                     NOTE

       Creating or removing a subpartition that is in the service partition
       may not take effect until after a reboot, and you may not be able to
       use the showpart command to display the changes to the service
       partition until after the reboot.

EXAMPLES

  To show the characteristics of the partition called mypart, whose parent
  partition is the compute partition, you can use the following command:

    % showpart mypart

    USER     GROUP     ACCESS  SIZE         FREE  RQ   EPL
    smith    eng          777     9            0  1h     5

         +---------+
        0| . . . . |
        4| . * * * |
        8| . * * * |
       12| . * * * |
         +---------+

  The mypart partition belongs to the user smith in group eng. It has
  permissions 777 (rwxrwxrwx), a size of 9 nodes, no free nodes, a rollin
  quantum of 1 hour, and an effective priority limit of 5. The rectangle at
  the bottom of the showpart output shows that the root partition is 4 nodes
  high by 4 nodes wide. The mypart subpartition is within the root partition
  and consists of nodes 5-7, 9-11, and 13-15 of the root partition.

  The following command has the same output as the first example, but uses an
  absolute partition pathname:

    % showpart .compute.mypart

  To show the characteristics and the free nodes of the partition called
  part1, whose parent partition is the compute partition, you can use the
  following command:

    % showpart -f part1

    USER     GROUP     ACCESS  SIZE         FREE  RQ   EPL

    smith    eng          777    15            6 SPS     5

         +---------+
        0| . . . . |
        4| . * * * |

        8| . * * * |
       12| . * * * |
       16| . F F F |
       20| . F F F |
         +---------+

  The root partition is 6 nodes high by 4 nodes wide. The part1 partition has
  a size of 15 nodes, 6 free nodes, and a rollin quantum set to space-sharing
  (SPS). The F characters show the location of the 6 free nodes.

ERRORS

showpart: Partition not found

  You specified a partition that does not exist.

showpart: Partition permission denied

  You do not have read permission for the specified partition.

FILES

  /usr/bin/showpart
            Specifies the command path.

LIMITATIONS AND WORKAROUNDS

  For information about limitations and workarounds, see the release notes
  files in /usr/share/release_notes.

SEE ALSO

  chpart, lspart, mkpart, pspart, rmpart


sort(1)                                                               sort(1)

NAME

  sort - Sorts or merges files

SYNOPSIS

  sort [-m] [-o output_file] [-Abdfinru] [-k keydef] [-tcharacter] [-T direc-
       tory] [-ykilobytes]
       [-zrecord_size] ...  file ...

  sort -c [-u] [-Abdfinr] [-k keydef] [-tcharacter] [-T directory] [-
       ykilobytes]
       [-zrecord_size] ...  file ...

  sort [-Abcdfimnru] [-o output_file] [-tcharacter] [-T directory] [-
       ykilobytes]
       [-zrecord_size] [+fskip][.cskip] [-fskip][.cskip] [-bdfinr] ...  file
       ...

  The sort command sorts lines in its input files and writes the result to
  standard output.

FLAGS

  -A  Sorts on a byte-by-byte basis using each character's encoded value.  On
      some systems, extended characters will be considered negative values,
      and so sort before ASCII characters.

  -b  Ignores leading spaces and tabs when determining the starting and end-
      ing positions of a restricted sort key.  If the -b flag is specified
      before the first -k flag, the -b flag is applied to all -k flags on the
      command line; otherwise, the -b flag can be independently attached to
      each -k field_start or field_end argument.

  -c  Checks that the input is sorted according to the ordering rules speci-
      fied in the flags and the collating sequence of the current locale.
      Displays nothing unless the file is not sorted.

  -d  Specifies that only spaces and alphanumeric characters (according to
      the current setting of LC_TYPE) are significant in comparisons.

  -f  Treats all lowercase characters as their uppercase equivalents (accord-
      ing to the current setting of LC_TYPE) for the purposes of comparison.

  -i  Sorts only by printable characters (according to the current setting of
      LC_TYPE).

  -k keydef
      Specifies one or more restricted sort key field definitions.  The for-
      mat of a key field definition is as follows:
      field_start[type][,field_end[type]]
      where the field_start and field_end arguments define a key field that
      is restricted to a portion of the line, and type is a modifier
      specified by b, d, f, i, n, or r.  The b modifier behaves like the -b
      flag, but applies only to the field_start or field_end argument to
      which it is attached.  The other modifiers behave like their
      corresponding flags, but apply only to the key field to which they are
      attached; these modifiers have this effect if specified with
      field_start, field_end or both.  Modifiers attached to a field_start or
      field_end argument override any specifications made by the flags.
      The field_start portion of the keydef argument takes the following
      form:
      field_number[.first_character]
      Fields and characters within fields are numbered starting with 1.  The
      field_number and first_character pieces, interpreted as positive
      decimal integers, specify the character to be used as part of a sort
      key.  If first_character is not specified, the default is the first
      character of the field.
      The field_end portion of the keydef argument takes the following form:
      field_number[.last_character]
      The field_number is the same as that described for field_start.  The
      last_character argument, interpreted as a nonnegative decimal integer,
      specifies the last character to be used as part of the sort key.  If
      last_character evaluates to 0 (zero) or is not specified, the default
      is the last character of the field specified by field_number.
      If -k is not specified, the default sort key is the entire line.
      When there are multiple key fields, later keys are compared only after
      all earlier keys compare as equal.  Except when the -u flag is speci-
      fied, lines that otherwise compare as equal are ordered as though none
      of the flags -d, -f, -i, -n, or -k were present (but with -r still in
      effect, if it was specified) and with all bytes in the lines signifi-
      cant to the comparison.

  -m  Merges only (assumes sorted input).

  -n  Sorts any initial numeric strings (consisting of optional spaces,
      optional dashes, and zero or more digits with optional radix character
      and thousands separator, as defined by the current locale) by arith-
      metic value.  An empty digit string is treated as zero; leading zeros
      and signs on zeros do not affect ordering.

  -o output_file
      Directs output to output_file instead of standard output.  output_file
      can be the same as one of the input files.

  -r  Reverses the order of the specified sort.

  -tcharacter
      Sets the field separator character to character.  Each occurrence of
      character is significant (for example, two consecutive occurrences of
      character delimit an empty field).  To specify the tab character as the
      field separator, you must enclose it in ' ' (single quotes).
      The default field separator is one or more spaces.

  -T directory
      Places all the temporary files that are created in directory.

  -u  Suppresses all but one in each set of equal lines.  Ignored characters
      such as leading tabs and spaces, and characters outside of sort keys
      are not considered in this type of comparison.
      If used with the -c flag, -u checks that there are no lines with dupli-
      cate keys, in addition to checking that the input file is sorted.

  -ykilobytes
      Starts the sort command using kilobytes of main storage and adds
      storage as needed.  (If kilobytes is less than the minimum storage size
      or greater than the maximum, the mimimum or maximum is used instead.)
      If the -y flag is omitted, the sort command starts with the default
      storage size; -y0 starts with minimum storage, and -y (with no value)
      starts with the maximum storage.  The amount of storage used by the
      sort command has a significant impact on performance.  Sorting a small
      file in a large amount of storage is wasteful.

  -zrecord_size
      Prevents abnormal termination if lines being sorted are longer than the
      default buffer size can handle.  When the -c or -m flags are specified,
      the sorting phase is omitted and a system default size buffer is used.
      If sorted lines are longer than this size, sort terminates abnormally.
      The -z option specifies that the longest line be recorded in the sort
      phase so that adequate buffers can be allocated in the merge phase.
      record_size must be a value in bytes equal to or greater than the
      number of bytes in the longest line to be merged.

  +fskip.cskip
      Specifies the start position of a key field.  (Obsolescent)
      The fskip variable specifies the number of fields to skip from the
      beginning of the input line, and the cskip variable specifies the
      number of additional characters to skip to the right beyond that point.
      For both the starting point (+fskip.cskip) and the ending point (-
      fskip.cskip) of a sort key, fskip is measured from the beginning of the
      input line, and cskip is measured from the last field skipped.  If you
      omit .cskip, .0 (zero) is assumed.  If you omit fskip, 0 (zero) is
      assumed.  If you omit the ending field specifier (-fskip.cskip), the
      end of the line is the end of the sort key.
      You can supply more than one sort key by repeating +fskip.cskip and
      -fskip.cskip.  In cases where you specify more than one sort key, keys
      specified further to the right on the command line are compared only
      after all earlier keys are sorted.  For example, if the first key is to
      be sorted in numerical order and the second according to the collating
      sequence, all strings that start with the number 1 are sorted according
      to the collating order before the strings that start with the number 2.
      Lines that are identical in all keys are sorted with all characters
      significant.  You can also specify different flags for different sort
      keys in multiple sort keys.

  -fskip.cskip
      Specifies the end position of a key field.  (Obsolescent)

DESCRIPTION

  The sort command treats all of its input files as one file when it performs
  the sort.  A - (dash) in place of a filename specifies standard input.  If
  you do not specify a filename, it sorts standard input.

  The sort command can handle a variety of collation rules typically used in
  Western European languages, including primary/secondary sorting, one-to-two
  character mapping, N-to-one character mapping, and ignore-character map-
  ping.  To summarize briefly:

  Primary/Secondary Sorting

  In this system, a group of characters all sort to the same primary loca-
  tion.  If there is a tie, a secondary sort is applied.  For example, in
  French, the plain and accented a's all sort to the same primary location.
  If two strings collate to the same primary location, the secondary sort
  goes into effect.  These words are in correct French order:

  abord
  pre
  aprs
  pret
  azur

  One-to-Two Character Mappings

  This system requires that certain single characters be treated as if they
  were two characters.  For example, in German, the  (scharfes-S) is collated
  as if it were ss.

  N-to-One Character Mappings

  Some languages treat a string of characters as if it were one single col-
  lating element.  For example, in Spanish, the ch and ll sequences are
  treated as their own elements within the alphabet.  (ch comes between c and
  d in the alphabet, and ll comes between l and m.)

  Ignore-Character Mappings

  In some cases, certain characters may be ignored in collation.  For exam-
  ple, if - were defined as an ignore-character, the strings re-locate and
  relocate would sort to the same place.

  The results that you get from sort depend on the collating sequence as
  defined by the current setting of the LC_COLLATE environment variable.  The
  configuration files for collation and character classification information
  are /usr/lib/nls/loc/locale.

  A field is one or more characters bounded by the beginning of a line and
  the current field separator, or one or more characters bounded by a field
  separator on either side.  The space character is the default field separa-
  tor.

  Lines longer than 1024 bytes are truncated by sort.  The maximum number of
  fields on a line is 10.

EXAMPLES

   1.  To perform a simple sort, enter:
       sort  fruits

       This displays the contents of fruits sorted in ascending lexicographic
       order.  This means that the characters in each column are compared one
       by one, including spaces, digits, and special characters.
       For instance, if fruits contains the text:
       banana
       orange
       Persimmon
       apple
       %%banana
       apple
       ORANGE

       then sort fruits displays:
       %%banana
       ORANGE
       Persimmon
       apple
       apple
       banana
       orange

       This order follows from the fact that in the ASCII collating sequence,
       symbols (such as %) precede uppercase letters, and all uppercase
       letters precede the lowercase letters.  If you are using a different
       collating order, your results may be different.

   2.  To group lines that contain uppercase and special characters with
       similar lowercase lines, and remove duplicate lines, enter:
       sort  -d  -f  -u  fruits

       The -u flag tells sort to remove duplicate lines, making each line of
       the file unique.  This displays:
       apple
       %%banana
       orange
       Persimmon

       Note that not only was the duplicate apple removed, but banana and
       ORANGE were removed as well.  The -d flag told sort to ignore symbols,
       so %%banana and banana were considered to be duplicate lines and
       banana was removed.  The -f flag told sort not to differentiate
       between uppercase and lowercase, so ORANGE and orange were considered
       to be duplicate lines and ORANGE was removed.
       When the -u flag is used with input that contains nonidentical lines
       that are considered by sort (due to other flags) to be duplicates,
       there is no way to predict which lines sort will keep and which it
       will remove.

   3.  To sort as in Example 2, but remove duplicates unless capitalized or
       punctuated differently, enter:
       sort -u -k 1df -k 1  fruits

       Flags appearing between sort key specifiers apply only to the specif-
       ier preceding them.  There are two sorts specified in this command
       line.  -k 1df specifies the first sort, of the same type done with -d
       -f in Example 3.  Then -k 1 performs another comparison to distinguish
       lines that are not actually identical.  This prevents -u, which
       applies to both sorts because it precedes the first sort key specif-
       ier, from removing lines that are not exactly identical to other
       lines.
       Given the fruits file shown in Example 1, the added -k 1 distinguishes
       %%banana from banana and ORANGE from orange.  However, the two
       instances of apple are exactly identical, so one of them is deleted.
       apple
       %%banana
       banana
       ORANGE
       orange
       Persimmon
   4.  To specify a new field separator, enter:
       sort  -t: -k 2  vegetables

       This sorts vegetables, comparing the text that follows the first colon
       on each line.  -t: tells sort that colons separate fields.  -k 2 tells
       sort to ignore the first field and to compare from the start of the
       second field to the end of the line.  If vegetables contains:
       yams:104
       turnips:8
       potatoes:15
       carrots:104
       green beans:32
       radishes:5
       lettuce:15

       then sort -t: -k 2 vegetables displays:
       carrots:104
       yams:104
       lettuce:15
       potatoes:15
       green beans:32
       radishes:5
       turnips:8

       Note that the numbers are not in ascending order.  This is because a
       lexicographic sort compares each character from left to right.  In
       other words, 3 comes before 5 so 32 comes before 5.

   5.  To sort on more than one field, enter:
       sort  -t: -k 2n  -k 1r  vegetables

       This performs a numeric sort on the second field (-k 2n) and then,
       within that ordering, sorts the first field in reverse collating order
       (-k 1r).  The output looks like this:
       radishes:5
       turnips:8
       potatoes:15
       lettuce:15
       green beans:32
       yams:104
       carrots:104

       The lines are sorted in numeric order; when two lines have the same
       number, they appear in reverse collating order.

   6.  To replace the original file with the sorted text, enter:
       sort  -o  vegetables  vegetables

       The -o vegetables flag stores the sorted output into the file veget-
       ables.

   7.  To collate using Spanish rules, set the LC_COLLATE (or LANG) environ-
       ment variable to a Spanish locale, and then use sort in the regular
       way, enter:
       sort sp.words

       If an input file named sp.words contains the following Spanish words:
       dama
       loro
       chapa
       canto
       mover
       chocolate
       curioso
       llanura

       The sorted file looks like this:
       canto
       curioso
       chapa
       chocolate
       dama
       loro
       llanura
       mover

       If you sort the file using ASCII collation rules, the output looks
       like this:
       canto
       chapa
       chocolate
       curioso
       dama
       llanura
       loro
       mover
FILES

  /usr/lib/nls/loc/locale
             Configuration files.
RELATED INFORMATION

  Commands:  comm(1), join(1), uniq(1).

  Files:  locale(4).

  "Using Internationalization Features" in the OSF/1 User's Guide.


split(1)                                                             split(1)

NAME

  split - Splits a file into pieces

SYNOPSIS

  split [-number] file | - [prefix]

  The split command reads file and writes it in number-line pieces (default
  1000 lines) to a set of output files.

FLAGS

  -number
      Specifies the number of lines in each output file.  The default is 1000
      lines per output file.

DESCRIPTION

  The name of the first output file is prefixaa, the second is prefixab, and
  so on lexicographically, through prefixzz (a maximum of 676 files).  The
  value of prefix cannot be longer than the value of NAME_MAX from limits.h
  minus two.  If you do not specify an output name, x is assumed.

  If you do not specify an input file, or if you specify - (dash) in place of
  file, split reads standard input.

EXAMPLES

   1.  To split a file into 1000-line segments, enter:
       split  book

       This splits book into 1000-line segments named xaa, xab, xac, and so
       forth.

   2.  To split a file into 50-line segments and specify the filename prefix,
       enter:
       split  -50  book  sect

       This splits book into 50-line segments named sectaa, sectab, sectac,
       and so forth.

RELATED INFORMATION

  Commands:  bfs(1), csplit(1).


tail(1)                                                               tail(1)

NAME

  tail - Writes a file to standard output, beginning at a specified point

SYNOPSIS

  tail [-f | -r] [-c number | -n number] [file]

  tail [+number | -number][unit] [-f | -r] [file]

  The tail command writes the named file (standard input by default) to stan-
  dard output, beginning at a point you specify.

FLAGS

  -c number
      Displays last number bytes of the file.

  -f  Does not end after it copies the last line of the input file if the
      input file is not read from a pipe, but enters an endless loop in which
      it sleeps for a second and then attempts to read and copy further
      records from the input file.  Thus, it can be used to monitor the
      growth of a file being written by another process.  Has no effect if
      specified with -r.

  -n number
      Displays last number lines of the file.

  -r  Causes tail to print lines from the end of the file in reverse order.
      The default for -r is to print the entire file this way.  Overrides -f.

  -[number]l

  -[number]b

  -[number]k

  -[number]c

  -[number]m
      Begins reading number lines (l), 512-byte blocks (b), 1-kilobyte blocks
      (k), characters (c and m) from the end of the input.  m counts a multi-
      byte character as a single character, while c counts characters byte-
      by-byte but does not break multibyte characters.  (Obsolescent)
      An l for lines is the default unit.  The default number is 10 for all
      units.

  +[number]l

  +[number]b

  +[number]k

  +[number]c

  +[number]m
      Begins reading number lines (l), 512-byte blocks (b), 1-kilobyte blocks
      (k), or characters (c and m) from the beginning of the input.  m counts
      a multibyte character as a single character, while c counts characters
      byte-by-byte but does not break multibyte characters.  (Obsolescent)
      An l for lines is the default unit.  The default number is 10 for all
      units.

DESCRIPTION

  If you do not specify -f, -r, -number, or +number, tail begins reading 10
  lines before the end of the file.  - (end of input) is the default starting
  point, l (lines) is the default unit, and 10 is the default number.

  By specifying +, you can direct tail to read from the beginning of the
  file.  By specifying a number or a unit, or both, you can change the point
  at which tail begins reading.

  The unit argument can specify lines, blocks, or characters.  The tail com-
  mand can begin reading number (10 by default) units from either the end or
  the beginning of the file.

  The block size is either 512 bytes or 1 kilobyte.

EXAMPLES

   1.  To display the last 10 lines of a file named notes, enter:
       tail  notes
   2.  To specify how far from the end to start, enter:
       tail  -20  notes

       This displays the last 20 lines of notes.

   3.  To specify how far from the beginning to start, enter:
       tail  +200c  notes  |  more

       This displays notes a page at a time, starting with the 200th charac-
       ter from the beginning.

   4.  To follow the growth of a file named accounts, enter:
       tail  -1  -f  accounts

       This displays the last line of accounts.  Once every second, tail
       displays any lines that have been added to the file.  This continues
       until stopped by pressing the Interrupt key sequence.

RELATED INFORMATION

  Commands:  cat(1), head(1), more(1)/page(1), pg(1).


vi(1)                                                                   vi(1)

NAME

  vi, vedit, view - Edits files with a full screen display

SYNOPSIS

  vi [-lRsv] -r[file] [-t tag] [-wnumber] [+subcommand] [-] [file ...]

  view [-lv] [-t tag] [-wnumber] [+subcommand] [-] [file ...]

  vedit

  The vi command is a display editor that is based on an underlying line edi-
  tor (ex).

FLAGS

  -l  Indents appropriately for LISP code, and accepts the (, ), {, }, [, and
      ] characters (parentheses, braces, and brackets) as text rather than
      interpreting them as vi subcommands.  The LISP modifier is active in
      open or visual modes.

  -r[file]
      Recovers file after an editor or system crash.  If you do not specify a
      file, vi displays a list of all saved files.

  -R  Sets the readonly option to protect the file against overwriting.

  -s  Invokes vi in open mode.  (Silent mode.)

  -t tag
      Edits the file containing the tag and positions the editor at its
      definition.  To use this flag, you must first create a database of
      function names and their locations using the ctags command.

  -v  Invokes the visual editor.  When the -v flag is specified, an enlarged
      set of subcommands is available, including screen editing and cursor
      movement features.

  -wnumber
      Sets the default window size to number.  This is useful when you use
      the editor over a low-speed line.

  -   Suppresses all interactive user feedback.  If you use this flag, file
      input/output errors do not generate an error message.

  +[subcommand]
      Performs the ex subcommand before editing begins.  If you do not
      specify subcommand, the cursor is placed on the first line of the file.
DESCRIPTION

  The ex editor subcommands can be used within the vi editor, because vi is
  based on ex.  The view command is a read-only version of vi; the readonly
  option is set to protect files during browsing.  The vedit command is a
  version of vi intended for beginners.  In it, the report option is set to
  1, the showmode option is set, and the novice option (making vedit a line
  editor, rather than a screen editor) is set.  (For more information on
  these options, see Setting Options.)

  The file argument specifies the files to be edited.  If you supply more
  than one file on the command line, vi edits each file in the order speci-
  fied.

  When you use vi, changes you make to a file are reflected on your display.
  The position of the cursor on the display indicates its position within the
  file.  The subcommands affect the file at the cursor position.

  Limitations of the vi Editor
  The maximum limits of the vi editor are as follows:

    o  2048 bytes per line.

    o  256 bytes per global command list.

    o  128 bytes in the previous inserted and deleted text.

    o  128 bytes in a shell escape command.

    o  128 bytes in a string-valued option.

    o  30 bytes in a tag name.

    o  128 map macros with 2048 bytes total.

  Editing Modes
  The vi editor has the following operational modes:

  Command mode
      When you start the vi editor, it is in Command mode.  Any subcommand
      can be entered from this mode, except commands that can only be used in
      the Text Input mode (those subcommands that make corrections during
      text insertion).  When subcommands and the other modes end, vi returns
      to Command mode.  Pressing <Esc> cancels a partial subcommand.

  Text Input mode
      Entered by the a, A, i, I, o, O, cx (where x represents the scope of
      the subcommand), C, s, S, and R subcommands.  After entering one of
      these commands, you can enter text into the editing buffer at the
      current cursor position.  To return to Command mode, press <Esc> for
      normal exit or press the Interrupt key sequence to end abruptly.

  Last Line mode
      Some subcommands (those with the prefix : (colon), / (slash), ? (ques-
      tion mark), or !!) read input on a line displayed at the bottom of the
      screen.  When you enter the initial character, vi places the cursor at
      the bottom of the screen, where you enter the remaining characters of
      the command.  Press <Return> to perform the subcommand and enter the
      Interrupt key sequence to cancel it.
      When !! is used, the cursor moves only after the two exclamation points
      are entered.  When : is used, special meaning is given to the following
      characters if used as counts before a command:

      %   All lines, regardless of cursor position.

      $   Last line.

      .   Current line.

  Setting Options
  The vi editor allows you to customize options so that you can use the edi-
  tor for a specific task.  Use the set command to set or change an option.
  To view the current setting of options, enter :set all while in vi Command
  mode.

  Some options are set to a string or a number value; other options are sim-
  ply turned on or off.  To change an option that is set to a value, enter a
  command in the form :set option=value.  To toggle an option that can be set
  to on or off, enter a line of the form :set option to set it to on or :set
  nooption to set it to off.

  Options can be abbreviated in a set command.  The following table lists
  some of vi's options, along with abbreviations and descriptions:
                          Table 0-0.  The vi Options
   Option                 Abbreviation   Description

  [no]autoindent         ai

                                        Indents automatically in Text mode
                                        to the indentation on the previous
                                        line by using the spacing between
                                        tab stops specified by the
                                        shiftwidth option.  The default is
                                        noai.  To back the cursor up to the
                                        previous tab stop, type <Ctrl-d>.
                                        This option is not in effect for
                                        global commands.

  [no]autoprint          ap

                                        Prints the current line after any
                                        command that changes the editing
                                        buffer. The default is ap.  This
                                        option applies only to the last
                                        command in a sequence of commands
                                        on a single line, and is not in
                                        effect for global commands.

  [no]autowrite          aw

                                        Writes the editing buffer to the
                                        file automatically before the :n,
                                        :ta, <Ctrl-a>, and ! subcommands if
                                        the editing buffer was changed
                                        since the last write command.  The
                                        default is noaw.

  [no]beautifying text   bf

                                        Prevents user from entering control
                                        characters (except for tab, new-
                                        line, and formfeed) in the editing
                                        buffer during text entry.  The
                                        default is nobf.  This option does
                                        apply to command input.

  directory              dir=

                                        Displays the directory that con-
                                        tains the editing buffer.  The
                                        default is dir=/tmp.

  [no]edcompatible       ed

                                        Retains global (g) and confirm (c)
                                        subcommand suffixes during multiple
                                        substitutions and causes the read
                                        (r) suffix to work like the r sub-
                                        command.  The default is noed.

  [no]flash              fl

                                        Uses visual flash rather than audi-
                                        ble bell.  The default is fl.

  hardtabs               ht=

                                        Tells vi the distance between the
                                        hardware tab stops on your display.
                                        The default is ht=8.

  [no]ignorecase         ic

                                        Ignores the distinction between
                                        uppercase and lowercase while
                                        searching for regular expressions.
                                        The default is noic.

  [no]lisp               lisp

                                        Enters vi in LISP mode.  In this
                                        mode, vi appropriately indents for
                                        LISP code and the (, ), {, }, [[,
                                        and ]].  The default is nolisp.

  [no]list               list

                                        Displays text with tabs and the end
                                        of lines marked.  Tabs are
                                        displayed as ^I and the end of
                                        lines as $.  The default is nolist.

  [no]magic              magic

                                        Treats the characters ., [, and *
                                        as special characters in scans.  In
                                        Off mode, only the (, ), and $
                                        characters retain special meanings;
                                        however, special meaning of other
                                        characters can still be invoked by
                                        preceding the character with a \
                                        (backslash).  The default is magic.

  [no]modeline           modeline

                                        Runs an editor command line if
                                        found in the first five and the
                                        last five lines of the file.  An
                                        editor command line may be anywhere
                                        in a line.  To be recognized as a
                                        command line, it must contain a
                                        space or a tab followed by the
                                        string ex: or vi:.  The command
                                        line is ended by a second :
                                        (colon).  The editor tries to
                                        interpret any data between the
                                        first and second : as editor com-
                                        mands.  The default is nomodeline.

  [no]number             nu

                                        Displays lines prefixed with their
                                        line numbers.  The default is nonu.

  [no]optimize           opt

                                        Speeds up the operation of termi-
                                        nals that do not have cursor
                                        addressing.  The default is noopt.

  paragraphs             para=

                                        Defines macro names that start
                                        paragraphs.  The default is
                                        para=IPLPPPQPP LIpplpipnpbp.  Sin-
                                        gle letter nroff macros, such as .P
                                        must include the space as a quoted
                                        character if respecifying a para-
                                        graph.

  [no]redraw             re

                                        Simulates a smart display on a dumb
                                        display.  The default is nore.
  [no]remap              remap

                                        Enables following of map keys.  For
                                        example, if remap is set, map u k
                                        map r u causes r to map to k.  If
                                        noremap is set, r maps to u.  The
                                        default is remap.

  report                 report=

                                        Sets the number of repetitions of a
                                        command before a message is
                                        displayed.  For subcommands that
                                        can produce a number of messages,
                                        such as global subcommands, the
                                        messages are displayed when the
                                        command is completed.  The default
                                        is report=5.

  scroll                 scr=

                                        Sets the number of lines to be
                                        scrolled when you scroll the screen
                                        up or down.  The default scroll is
                                        one-half the size of the screen.

  sections               sect=

                                        Defines macro names that start sec-
                                        tions.  The default is sect=NHSHH
                                        HUuhsh+c.  Single letter nroff mac-
                                        ros, such as .P must include the
                                        space as a quoted character if
                                        respecifying a paragraph.

  shell                  sh=

                                        Defines the shell for ! or :! com-
                                        mands.  The default is the value of
                                        the SHELL environment variable.

  shiftwidth             sw=

                                        Sets the distance for the software
                                        tab stops used by autoindent, the
                                        shift commands (> and <), and the
                                        text input commands (<Ctrl-d> and
                                        <Ctrl-t>) to allow the editor to
                                        indent text and move back to a pre-
                                        vious indentation.  The default is
                                        sw=8.

  [no]showmatch          sm

                                        Shows the matching open parenthesis
                                        (  or open brace { as you type the
                                        close parenthesis ) or close brace
                                        }.  The default is nosm.

  [no]showmode           smd

                                        Displays mode indicator at the bot-
                                        tom of the screen when in the
                                        insert or replace mode.  The
                                        default is nosmd.

  [no]slowopen           slow

                                        Postpones updating the display dur-
                                        ing inserts.  The default is
                                        noslow.

  tabstops               ts=

                                        Sets distance between tab stops
                                        when a file is displayed.  The
                                        default is ts=8.

  [no]tags               tag

                                        Specifies a list of possible
                                        filenames of tag files.  The
                                        default is tags /usr/lib/tags.

  term                   term=

                                        Sets the kind of display you are
                                        using.  The default is term=$TERM,
                                        where $TERM is the value of the
                                        TERM shell variable.

  [no]terse              terse

                                        Allows vi to display the short form
                                        of messages.  The default is
                                        noterse.

  [no]timeout            to

                                        Sets a time limit of 2 seconds on
                                        entry of characters.  This limit
                                        allows the characters in a macro to
                                        be entered and processed as
                                        separate characters when timeout is
                                        set.  To resume use of the macro,
                                        set notimeout.  The default is to.

  [no]warn               warn

                                        Displays a warning message before
                                        the ! subcommand executes a shell
                                        command if this is the first time
                                        you issued a shell command after a
                                        given set of changes were made in
                                        the editing buffer, but not written
                                        to a file.  The default is warn.

  window                 wi=

                                        Sets the number of lines displayed
                                        in one window of text.  The default
                                        is dependent on the baud rate at
                                        which you are operating:  600 baud
                                        or less / 8 lines, 1200 baud / 16
                                        lines, higher speeds / full screen
                                        minus 1.

  wrapmargin             wm=

                                        Sets the margin for automatic
                                        wordwrapping from one line to the
                                        next.  A value of 0 indicates no
                                        wordwrapping.  The default is wm=0.

  [no]wrapscan           ws

                                        Allows string searches to wrap from
                                        the end of the editing buffer to
                                        the beginning.  The default is ws.

  [no]writeany           wa

                                        Turns off the checks usually made
                                        before a write command.  The
                                        default is nowa.

  Defining Macros
  If you use a subcommand or sequence of subcommands frequently, you can
  create a macro that issues the subcommand or sequence when you call a
  macro.  To create a macro, enter the sequence of subcommands into an edit-
  ing buffer named with a letter of the alphabet.  When used as buffer names,
  lowercase ASCII letters a through z overlay the contents of the buffer,
  while uppercase ASCII letters A through Z append text to the previous con-
  tents of the buffer, allowing the building of a macro piece by piece.

  To invoke the macro, enter @x, where x is the letter name of the buffer.
  Enter @@  to repeat the last macro you invoked.

  Mapping Keys
  You can use the map command to set a keystroke to a subcommand or a
  sequence of subcommands.  To set a key mapping, enter :map key subcommand
  where key is the key to which you want to assign a subcommand or sequence
  of subcommands and subcommand is the subcommand or sequence of subcommands.
  For example, to set @ to delete lines, enter:
  :map  @  dd
  In this example, @ is the key to which the subcommand is assigned and dd is
  the subcommand.

  In the next example, a subcommand sequence is mapped to a key:
  :map * {>}
  The * (asterisk) is the key to which the subcommand sequence is assigned
  and {>} is the subcommand sequence.  The { (open brace) moves the cursor to
  the beginning of the paragraph and the > (right angle bracket) indents the
  paragraph to the next shiftwidth.

  To display the list of the current key mappings while you are in Command
  mode, enter the :map command.  You can also remove a key mapping.  To
  remove a key mapping, enter :unmap string or :unmap! string where string is
  the string used used after the :map command to set the key and subcommand
  sequence.  For example, to remove key mapping for the previous example,
  enter:
  :unmap *
  If function keys are defined for your terminal, they can be put in a map or
  unmap command by typing <Ctrl-v> then pressing the desired key.  In this
  way, function keys that are unused during editing can be mapped to useful
  editing subcommand sequences.

  Abbreviations
  You can define abbreviations for long phrases that you use often.  vi then
  automatically expands these abbreviations whenever you enter them in insert
  mode.

  To define an abbreviation, enter:
  :abbr abbreviation phrase

  where abbreviation is the abbreviation you specify for the longer text
  specified by phrase.  For example, to specify the abbreviation imho for the
  phrase In my humble opinion, enter:
  :abbr imho In my humble opinion
  Keeping a Customized Change
  When you customize vi from the vi command line, the customized editor is in
  effect until you exit the editor.  If you want such things as option set-
  tings and key mappings so you can reuse them, you must put them in the
  .exrc file in your home directory.  vi processes the commands given in the
  EXINT variable and then reads this file each time you invoke it.  When you
  type the commands in a file, do not type the : (colon) before each command.
  The : is required only if you are in the editor.  Here is an example of an
  .exrc file:
  set ai aw
  set wm=5
  map  @  dd

  The vi Character Sets
  The collation sequence, as defined by the value of the LC_COLLATE environ-
  ment variable, defines the alphanumeric set used by your system.  This
  table affects the performance of vi macros and subcommands.

  The vi editor uses the collation sequence to distinguish between a small
  word and a big word.  A small word is bounded by letters or numbers as
  defined in the collation table.  For example, isn't is two small words.
  The ' (apostrophe) is not a number or an alphabetic character, and it
  bounds both the small word t and the small word isn.  A big word is bounded
  by spaces, tabs, or newline indicators.  For example, stop is a big word.
  For more information, see the section Moving to Words.

SUBCOMMANDS

  Subcommand Syntax
  [named_buffer] [operator] [number] argument

  Surrounding brackets indicate optional items.

  [named_buffer]
      A temporary text storage area.

  [operator]
      Specifies the subcommand or action; instructs the vi editor.

  [number]
      A whole decimal value that specifies either the extent of the action or
      a line address.  The vi editor interprets this number in one of the
      following ways:

       1.
        Go to line number:
        5G
        10z<Return>
       2.
        Go forward number columns.
        25<Space>
       3.
        Scroll number of lines:
        10<Ctrl-d>
        10<Ctrl-u>
       4.
        Delete number lines:
        6dd
       5.
        % means all.  To yank all lines:
        %y

        (The preceding command replaces 1,$y.)

  argument
      Specifies what to act on.  This can be a text object (a character,
      word, sentence, paragraph, section, or character string) or a text
      position (a line, position in the current line, or screen position).

  Moving Within a File
  Enter the following subcommands in Command mode.  You can cancel an incom-
  plete subcommand by pressing <Esc>.

  <Left Arrow>, h, <Ctrl-h>
      Moves the cursor one character to the left.

  <Down Arrow>, j, <Ctrl-j>, <Ctrl-n>
      Moves the cursor down one line, remaining in the same column.

  <Up Arrow>, k, <Ctrl-p>
      Moves the cursor up one line, remaining in the same column.

  <Right Arrow>, l <Space>
      Moves the cursor one character to the right.
      Long lines:  Lines over one screen width are wrapped but not broken.
      When using the Up Arrow or Page Up key, @ lines are added at the bottom
      of the screen when too few physical lines are available to display the
      complete line.  The Down Arrow key moves the entire line off the screen
      at once.

  Character Positioning Within a Line
  Enter the following subcommands in Command mode.

  ^   Moves the cursor to the first nonspace character.

  0   Moves the cursor to the beginning of the line.

  $   Moves the cursor to the end of the line.

  fx  Moves the cursor to the next x character.

  Fx  Moves the cursor to the last x character.

  tx  Moves the cursor to one column before the next x character.

  Tx  Moves the cursor to one column after the last x character.

  ;   Repeats the last f, F, t, or T subcommand.

  ,   Repeats the last f, F, t, or T subcommand in the opposite direction.

  number<Space>
      Moves the cursor to the specified column.

  Moving to Words
  Enter the following subcommands in Command mode.

  w   Moves the cursor to the next small word.

  b   Moves the cursor to the previous small word.

  e   Moves the cursor to the end of the next small word.

  W   Moves the cursor to the next big word.

  B   Moves the cursor to the previous big word.

  E   Moves the cursor to the end of the next big word.

  Moving by Line Positioning
  Enter the following subcommands in Command mode.

  G   Moves to the line number given as preceding argument, or the end of the
      file if no preceding count is given.

  H   Moves the cursor to the top line on the screen.

  L   Moves the cursor to the last line on the screen.

  M   Moves the cursor to the middle line on the screen.

  +   Moves the cursor to the next line, at its first nonspace character.

  -   Moves the cursor to the previous line, at its first nonspace character.

  <Return>
      Moves the cursor to the next line, at its first nonspace character.

  Moving to Sentences, Paragraphs, or Sections
  Enter the following subcommands in Command mode.  You can cancel an incom-
  plete subcommand by pressing <Esc>.

  (   Places the cursor at the beginning of the previous sentence (or the
      previous S-expression if you are in LISP mode).

  )   Places the cursor at the beginning of the next sentence (or the next
      S-expression if you are in LISP mode).

  {   Places the cursor at the beginning of the previous paragraph (or at the
      next list if you are in LISP mode).

  }   Places the cursor at the beginning of the next paragraph, at the next
      section if you are in C mode, or at the next list if you are in LISP
      mode.

  |   Requires a count; the cursor is placed in that column (if possible).

  ]]  Places the cursor at the next section, or function if you are in LISP
      mode.

  [[  Places the cursor at the previous section, or function if you are in
      LISP mode.

  Paging and Scrolling
  <Ctrl-u>
      Scrolls up (default 12 lines).

  <Ctrl-d>
      Scrolls down (default 12 lines).

  <Ctrl-f>
      Pages forward one screen.

  <Ctrl-b>
      Pages backward one screen.

  <Ctrl-y>
      Scrolls the window up one line.

  <Ctrl-e>
      Scrolls the window down one line.

  <Ctrl-m>
      Moves to the first nonwhite character in the next line.  A count speci-
      fies the number of lines to go forward.

  <Ctrl-t>
      Inserts shiftwidth white space in input mode, if at the beginning of
      the line or preceded only by white space.  This inserted space can only
      be backed over using <Ctrl-d>.

  <Ctrl-[>
      Cancels a partially formed command; sounds the bell if there is none.
      In input mode, terminates input mode.
      When entering a command on the bottom line of the screen (ex command
      line or search pattern with \ or ?), terminates input and executes com-
      mand.

  z+  Pages up.

  z^  Pages down.

  Searching for Patterns
  The following commands allow you to search for patterns within a file.
  Patterns can be regular expressions as described for grep.

  /pattern
      Places the cursor at the next line containing pattern.

  ?pattern
      Places the cursor at the next previous line containing pattern.

  n   Repeats the last search for pattern in the same direction.

  N   Repeats the last search for pattern in the opposite direction.

  /pattern/+number
      Places the cursor at the numberth line after the line matching pattern.

  ?pattern?-number
      Places the cursor at the numberth line before the line matching pat-
      tern.

  %   Finds the parenthesis or brace that matches the one at the current cur-
      sor position.

  <Ctrl-t>
      Finds the word at the cursor in the tags file then edits the proper
      file, placing the cursor at the tag.  If the tag is in the current
      file, moves cursor to it.

  Marking and Returning

  Enter the following subcommands in Command mode.  You can cancel an incom-
  plete subcommand by pressing <Esc>.

  ``  Moves the cursor to the same cursor position of the previous current
      line.

  ''  Moves the cursor to the beginning of the previous current line.

  mx  Marks the current position with the letter specified by x.

  `x  Moves the cursor to the same cursor position of line marked x.

  'x  Moves the cursor to the beginning of the line marked x.

  Adjusting the Screen
  Enter the following subcommands in Command mode.  An incomplete subcommand
  can be cancelled by pressing <Esc>.

  <Ctrl-l>
      Clears and redraws the screen.

  <Ctrl-r>
      Redraws the screen and eliminates blank lines marked with a @.

  z<Return>
      Redraws the screen with the current line at the top of the screen.

  z-  Redraws the screen with the current line at the bottom of the screen.

  z.  Redraws the screen with the current line at the center of the screen.

  /pattern/z-
      Redraws the screen with the line containing pattern at the bottom.

  znumber<Return>
      Makes the window number lines long.

  Adding Text to a File--Text Input
  The following subcommands are entered in Command mode and bring the vi edi-
  tor into Text Input mode to allow you to add text to your file.  End Text
  Intput mode by pressing <Esc>.

  atext
      Inserts text after the cursor.

  Atext
      Adds text to the end of the line.

  itext
      Inserts text before the cursor.

  Itext
      Inserts text before the first nonspace character in the line.

  o   Adds an empty line below the current line.

  O   Adds an empty line above the current line.

  Changing Text While in Input Mode

  Use the following commands only while in Text Entry mode.  They have dif-
  ferent meanings in Command mode.

  <Ctrl-h>
      Erases the last character.

  <Ctrl-w>
      Erases the last small word.  (For more information about small words,
      see the section vi Character Sets.)

  \   Quotes the Erase and Kill characters.

  <Esc>
      Ends insertion, back to Command mode.

  Quit key sequence
      Interrupts, terminates insert or <Ctrl-d>.

  <Ctrl-d>
      Goes back to the previous autoindent stop.

  ^<Ctrl-d>
      Ends autoindent for this line only.

  0<Ctrl-d>
      Moves the cursor back to the left margin.

  <Ctrl-v>
      Quotes a nonprinting character.

  Changing Text from Command Mode
  Use the following subcommands in Command mode.  An incomplete subcommand
  can be cancelled by pressing <Esc>.

  C   Changes the rest of the line (c$).

  c   Must be followed by a movement command.  Deletes the specified region
      of text and enters input mode to replace it with the entered text.  If
      more than part of a single line is affected, the deleted text is saved
      in the numeric buffers.  If only part of the current line is affected,
      the last character to be deleted is marked with a $.  A count is passed
      through to the move command.  If the command is cc, the whole of the
      current line is changed.

  cc  Changes a line.

  cw  Changes a word.

  D   Deletes the rest of the line (d$) and puts it into the undo buffer.

  d   Must be followed by a movement command.  Deletes the specified region
      of text.  If more than part of a line is affected, the text is saved in
      the numeric buffers.  A count is passed through to the move command.
      If the command is dd, the whole of the current line is deleted.

  dd  Deletes a line and puts it into the undo buffer.

  dw  Deletes a word and puts it into the undo buffer.

  J   Joins lines.

  rx  Replaces the current character with the character specified by x.

  R   Overwrites characters.

  s   Substitutes characters (cl).

  S   Substitutes lines (cc).

  u   Undoes the previous change.

  x   Deletes a character.

  X   Deletes characters before cursor (dh).

  <<  Shifts one line to the left.

  <L  Shifts all lines from the cursor to the end of the screen to the left.
      (The < character describes a range upon which the L subcommand acts.)

  >>  Shifts one line to the right.

  >L  Shifts all lines from the cursor to the end of the screen to the right.
      (The > character describes a range upon which the L subcommand acts.)

  ~   Changes the letter at the cursor to the opposite case.

  Copying and Moving Text
  Use the following subcommands in Command mode.  An incomplete subcommand
  can be cancelled by pressing <Esc>.

  p (P)
      Puts back text in the undo buffer after (before) the cursor.

      Puts back text from the buffer x after (before) the cursor.

      Deletes object into the buffer x.

  yobject
      Yanks object into the undo buffer (for example, yw to yank a word).

      Yanks object into buffer x.

  Y   Places the line in the undo buffer.

  Restoring and Repeating Changes
  Use the following subcommands in Command mode.  An incomplete subcommand
  can be cancelled by pressing <Esc>.

  u   Undoes the last command.

  U   Restores the current line if the cursor has not left the line since the
      last change.

  .   Repeats the last change or increments the np command.
      Note that this command is not meant for use with a macro.  Enter @@ to
      repeat a macro.

      Retrieves the nth last delete of a complete line or block of lines.

  Saving Changes to a File
  Use the following subcommands in Command mode.  An incomplete subcommand
  can be cancelled by pressing <Esc>.  If you are using these subcommands
  within the ex editor, you do not need to type the : (colon).

  :w  Writes the editing buffer contents to the original file.

  :w file
      Writes the editing buffer contents to the named file.

  :w! file
      Overwrites file with the editing buffer contents.

  Interrupting, Cancelling, and Exiting vi
  Q   Enters the ex editor in Command mode.

  ZZ  Exits vi, saving changes, if any were made.

  :q  Quits vi.  If you have changed the contents of the editing buffer, vi
      displays a warning message and does not quit.

  :q! Quits vi, discarding the editing buffer with no warning.

  :sh Runs a shell.  You can return to vi by pressing <Ctrl-d>.

  :w !command
      Runs the file through the specified shell command (causes no change to
      the file).

  :!command
      Runs command, then returns.

  :!! Repeats the last :!command command.

  n!!command
      Executes the shell command identified by command and replaces the
      number of lines specified by n with the output of command.  If n is not
      specified, the default is 1.  If command expects standard input, the
      lines specified are used as input.  (10!!sort sorts the next 10 lines.)

  !linescommand
      Works like n!!command, except that lines is a line address (for exam-
      ple, !Gsort sorts the rest of the file).

  Quit key sequence
      Interrupts a subcommand.

  Editing a Second File
  Enter the following subcommands in Command mode.  An incomplete subcommand
  can be cancelled by pressing <Esc>.

  :e file
      Edits file.  If you are using this subcommand from the ex editor, you
      do not need to type the : (colon).

  :e! Reedits the current file and discards all changes.

  :e  +  file
      Edits file, starting at the end.

  :e  +number
      Edits file, starting at the line number.

  :e # and <Ctrl-a>
      Edits the alternate file.  The alternate file is usually the the previ-
      ous current filename.  However, if changes are pending on the current
      file when a new file is called, the new file becomes the alternate
      file.

  :r file
      Reads the file into the editing buffer by adding new lines below the
      current line.  If you are using this subcommand from the ex editor, you
      do not need to type the : (colon).

  :r !command
      Runs the shell command identified by command and places its output in
      the file by adding new lines below the current cursor position.

  :ta tag
      Edits a file containing tag at the location of tag.  If the tag is in
      another file and the current file has been changed (and noaw is set), a
      warning is posted.  To use this command, you must first create a data-
      base of function names and their locations using the ctags command.  If
      you are using this subcommand from the ex editor, you do not need to
      type the : (colon).

  <Ctrl-t>
      Finds the word at the cursor in the tags file and edits the indicated
      file, placing the cursor at the tag.  Same as :ta, but the tag is the
      word to the right of the cursor.

  Editing a List of Files
  Enter the following subcommands in Command mode.

  :n  Edits the next file in the list entered on the command line.

  :n file ...
      Specifies a new list of files to edit.

  Displaying File Information
  Enter the following subcommand in Command mode to show the current
  filename, the current line number, the number of lines in the file, and the
  percentage of lines of the file that are before the cursor:

  <Ctrl-g>

RELATED INFORMATION

  Commands:  ctags(1), ed(1)/red(1), edit(1), ex(1),
  grep(1)/fgrep(1)/egrep(1).


wc(1)                                                                   wc(1)

NAME

  wc - Counts the lines, words, and bytes in a file

SYNOPSIS

  wc [-cklw] [file ...]

  The wc command counts the lines, words, and bytes in a file, or in the
  standard input if you do not specify any files, and writes the results to
  standard output.  It also keeps a total count for all named files.

FLAGS

  -c  Counts bytes only.

  -k  Counts characters only.

  -l  Counts lines only.

  -w  Counts words only.

DESCRIPTION

  A word is defined as a string of characters delimited by spaces, tabs, or
  newline characters.

  The wc command counts lines, words, and bytes by default; use the appropri-
  ate flags to limit wc to one or two of the three totals.  Specifying wc
  without flags is the equivalent of specifying wc -lwc.

  The order in which line, word, and byte counts appear in the output line
  matches the order in which the flags are entered on the command line.  (If
  you do not specify any flags, the order is lines, words, bytes.)

  When you specify more than one file, wc displays the name of the file along
  with the counts.

EXAMPLES

   1.  To display the the number of lines, words, and bytes in the file text,
       enter:
       wc text

       This results in the following output:
       27 185 722 text
       The numbers 27, 185, and 722 are the number of lines, words, and
       bytes, respectively, in the file text.

   2.  To display only one or two of the three counts, or to display the
       counts you want in a particular order, include the appropriate flags
       in the order you want.  For example, the following command displays
       only byte and line counts:
       wc -cl text
       722 27 text
   3.  To count lines, words, and bytes in more than one file, use wc with
       more than one input file or with a filename pattern.  For example, the
       following command can be issued in a directory containing the files
       text, text1, and text2:
       wc -l text*
       27      text
       112     text1
       5       text2
       144     total

       The numbers 27, 112, and 5 are the numbers of lines in the files text,
       text1, and text2, respectively, and 144 is the total number of lines
       in the three files.

RELATED INFORMATION

  Commands: ls(1).


who(1)                                                                 who(1)

NAME

  who - Identifies users currently logged in

SYNOPSIS

  who [-a] | [-AbdhHlmpqrstTu] [file]

  who am i | who am I

  whoami

  The who command displays information about users and processes on the the
  local system.

FLAGS

  -a  Specifies all options; processes /var/adm/utmp or the named file with
      all flags on.

  -A  Displays accounting entries from the specified file.  By default, -A
      causes who to display entries from the /var/adm/utmp file.

  -b  Indicates the most recent system start-up time and date.  The LC_TIME
      environment variable controls the format of the login time and date.

  -d  Displays all processes that have expired without being regenerated by
      init.  The exit_status field appears for dead processes and contains
      the termination and exit values (as returned by wait) of the dead
      processes.  (This flag is useful for determining why a process ended.)

  -h  Displays a help message.

  -H  Displays a header (title).

  -l  Lists only terminals not in use.  The user field is LOGIN in such
      cases.  Other fields are the same as for user entries except that the
      state field does not appear.

  -m  Displays information about the current terminal (same as who am i).

  -p  Lists any active process that is currently active and was previously
      generated by init.

  -q  Prints a quick listing of users and the number of users on the local
      system.

  -r  Indicates the current run-level of the system.

  -s  Lists only the user, line, time, and host (if not null) fields.  (This
      is the default; thus, who and who -s are equivalent.) The LC_TIME
      environment variable controls the format of the time.

  -t  Indicates the last change to the system clock by the superuser using
      the date command.  The LC_TIME environment variable controls the format
      of the time.

  -T  Displays the status of the terminal line and indicates who can write to
      that terminal as follows:

      +   Writable by anyone.

      -   Writable only by the superuser or its owner.

      ?   Bad line encountered.

  -u  Displays the username, terminal name, login time, line activity, and
      process-ID of each current user.  The LC_TIME environment variable con-
      trols the format of the login time.

DESCRIPTION

  The who command displays the following information for the users and/or
  processes you specify:

    o  Login name

    o  Terminal name

    o  Date

    o  Time of login

    o  Host

  Entering who am i or who am I displays your login name, terminal name, date
  and time you logged in, and host.  Entering whoami displays your login name
  only.

  With flags, who can also display the elapsed time since line activity
  occurred, the process-ID of the command interpreter (shell), logins,
  logouts, restarts, and changes to the system clock, as well as other
  processes generated by the init process.

  The general output format of the who command is as follows:
  user [state] line time activity process_ID [exit_status]

  where:

    o  The user argument specifies the user's login name.

    o  The state argument indicates whether or not the line is readable by
       everyone (see the -T flag).

    o  The line argument specifies the name of the line as found in the /dev
       directory.

    o  The time argument specifies the time that user logged in.

    o  The activity argument specifies the hours and minutes since activity
       last occurred on that user's line.  A . (dot) here indicates line
       activity within the last minute.  If the line has been quiet more than
       24 hours or has not been used since the last system start-up, the
       entry is marked as old.

    o  The process_ID argument specifies the process-ID of the user's shell.

    o  The exit_status argument specifies the exit status of ended processes
       (see the -d flag).

  To obtain its information, who normally examines /var/adm/utmp.  If you
  specify another file, who examines the named file instead.  This file will
  usually be /var/adm/wtmp, which contains the history of all logins since
  the file was last created.

  Note that who only identifies users on the local node.

EXAMPLES

   1.  To display information about who is using the local system, enter:
       who

       Information similar to the following is displayed:
       george  console Jun 8  08:34  (abcpa.pasc.abc.c)
   2.  To display your username, enter:
       who am i
       huang   console Jun 8   08:34  (maguro)
   3.  To display a history of logins, logouts, system start-ups, and system
       shutdowns, enter:
       who  /var/adm/wtmp

       Information similar to the following is displayed:
       huang   console Jun 8   08:34
       john    console Jun 8   08:34
       rachel  console Jun 8   08:22
       spike   ttyp4   Jun 8   09:19
   4.  To display the run-level of the local system, enter:
       who -r
       Information similar to the following is displayed:
       .   run-level  3   Sept 12  04:15   3   0    S
   5.  To display any active process that is currently active and was previ-
       ously generated by init, enter:
       who -p

       Information similar to the following is displayed:
       .       tty4    Jun 8   04:15
       .       tty7    Jun 8   04:15
       .       tty14   Jun 8   04:15
FILES

  /var/adm/utmp
             Contains user and accounting information.

  /var/adm/wtmp
             Contains login history.

RELATED INFORMATION

  Commands:  date(1), init(8), login(1), mesg(1), su(1), users(1), w(1),
  whoami(1).

  Functions:  wait(2).

  Files:  utmp(4).


whoami(1)                                                           whoami(1)

NAME
  whoami - Displays the user's name

SYNOPSIS

  whoami

DESCRIPTION

  The whoami command displays the username associated with your current ID.

  Unlike who am i, this command tells you what your effective user ID is, and
  not who is logged on to your tty (it does not use /var/adm/utmp).

  If the current user ID is not in the password file, the message Intruder
  alert is displayed.

FILES

  /etc/passwd
             Contains usernames and IDs.

RELATED INFORMATION
  Commands:  who(1).