Sun Studio 12: Fortran ライブラリ・リファレンス

第 1 章 Fortran ライブラリルーチン

この章では、Fortran のライブラリルーチンについて説明します。

本章で説明するルーチンにはすべて、対応するマニュアルページがマニュアルライブラリのセクション 3F に用意されています。たとえば、man -s 3F access を実行すると、access というライブラリルーチンに関するマニュアルページの内容が表示されます。

この章では、標準の Fortran 95 組み込み関数については説明しません。組み込み関数の詳細は、関連する Fortran 95 の標準ドキュメントを参照してください。

Fortran や C から呼び出しが可能な前述のもの以外の数学ルーチンについては、『数値計算ガイド』も参照してください。呼び出し可能な数学ルーチンには、libm や libsunmath の標準数学ライブラリルーチン (Intro(3M)) 参照)、これらのライブラリの最適化バージョン、SPARC ベクトル数学ライブラリ libmvec などがあります。

f95 コンパイラによって実装される、FORTRAN 77 および VMS の組み込み関数については、「2.3.4.2 メモリー関数」を参照してください。

1.1 データ型について

特に指示がない限り、本章に記載する関数ルーチンは、組み込みルーチンではありません。したがって、関数から返されるデータ型が、関数名だけを指定した場合に仮定されるデータ型と食い違う可能性がある場合は、ユーザーが明示的にデータ型を宣言する必要があります。たとえば、getpid() で INTEGER*4 を戻す場合は、INTEGER*4 getpid と宣言しないと、結果の正しい処理が保証されません。これは、データ型を明示的に指定しないと、関数名が g で始まっているためにデフォルトにより REAL (実数) 型の結果が仮定されるからです。なお、こういったルーチンについては、その機能要約で明示的な型宣言文が覚え書きの目的で記載されています。

引数のデータ型の宣言および戻り値の処理は、IMPLICIT 文やコンパイラオプションの -dbl と -xtypemap によっても変更されることに注意してください。これらのライブラリルーチンを呼び出す際に、期待するデータ型と実際のデータ型が一致していないと、プログラムは予期しない動きをします。コンパイラオプション -xtypemap、-dbl を指定すると、INTEGER 関数のデータ型は INTEGER*8 に、REAL 関数は REAL*8 に、DOUBLE 関数は DOUBLE*16 にそれぞれ変更されます。こういった問題を回避するには、ライブラリ呼び出しで指定する関数名と変数について、期待するそれらのサイズを明示的に指定する必要があります。次の例を参考にしてください。

        integer*4 seed, getuid
        real*4 ran
        ...
        seed = 70198
        val = getuid() + ran(seed)
        ...

前述の例のようにサイズを明示的に指定しておくと、コンパイラオプションとして -xtypemap と -dbl を指定しても、ライブラリ呼び出しの際にデータ型の変更が行われません。明示的な指定が行われない場合は、これらのコンパイラオプションによって、予期しない結果を招く可能性があります。これらのオプションの詳細については、『Fortran ユーザーズガイド』およびマニュアルページ f95(1) を参照してください。

Fortran 95 コンパイラの f95 は、ほとんどの非組み込みライブラリルーチンのインタフェースを定義するインクルードファイル system.inc を提供します。特にデフォルトのデータ型が -xtypemap を指定して変更された場合、このファイルをインクルードして、呼び出した関数やその引数が正しく入力されているか確認してください。

        include 'system.inc'
        integer(4) mypid
        mypid = getpid()
        print *, mypid

Fortran コンパイラの広域プログラムチェックオプション -Xlist を使用すると、ライブラリ呼び出し全体のデータ型のミスマッチに関連した多数の問題を把握できます。f95 コンパイラによる広域プログラムチェックについては、『Fortran ユーザーズガイド』、『Fortran プログラミングガイド』、およびマニュアルページ f95(1) で説明しています。

1.2 64 ビット環境

プログラムを 64 ビットのオペレーティング環境で動作するようにコンパイルすると (つまり、-m64 でコンパイルし、64 ビットの SPARC または x86 プラットフォームで実行可能ファイルを実行すると)、特定の関数の戻り値が変更されます。この特定の関数は、通常、malloc(3F) (「1.4.35 malloc、malloc64、 realloc、free: 記憶領域の割り当て/再割り当て/割り当て解除」参照) などの標準システムレベルのルーチンとのインタフェースとなり、その環境に応じて 32 ビット値または 64 ビット値をとったり、戻したりできます。32 ビットと 64 ビット環境間でコードに互換性を持たせるために、これらのルーチンの 64 ビットバージョンは、必ず 64 ビット値をとるまたは戻す (あるいはこの両方を行う) ように規定されています。次の表に、64 ビット環境で使用するために提供されたライブラリルーチンを表示します。

表 1–1 64 ビット環境向けライブラリルーチン


関数	内容の説明
`malloc64`	メモリーを割り当て、ポインタを戻す
`fseeko64`	大規模ファイルの再位置付け
`ftello64`	大規模ファイルの位置付け
`stat64, fstat64, lstat64`	ファイルの状態を決定する
`time64,ctime64,gmtime64,ltime64`	システム時間を取得し、文字に変換するか月、日などに分解する
`qsort64`	配列の要素をソートする

1.3 Fortran 数学関数

次の関数とサブルーチンは、Fortran 数学ライブラリの一部です。これらの関数とサブルーチンは、f95 でコンパイルしたすべてのプログラムで使用することができます。ルーチンには、引数として特定のデータ型をとり、それと同じデータ型を戻す非組み込み関数があります。非組み込み関数は、これを参照するルーチン内で宣言する必要があります。

こうしたルーチンの大半は、C 言語ライブラリのルーチンに対する Fortran のインタフェースである「ラッパー」であり、したがって、標準の Fortran ではありません。この中には、IEEE 推奨のサポート関数や特殊な乱数発生関数があります。これらのライブラリの詳細については、『数値計算ガイド』やマニュアルページ libm_single(3F)、libm_double(3F)、libm_quadruple(3F) を参照してください。

1.3.1 単精度関数

これらの副プログラムは、単精度の数学関数およびサブルーチンです。

通常、次に示す数学単精度関数にアクセスする関数は、Fortran 規格の総称組み込み関数とは対応していません。データ型は通常の型決定規則によって決定されます。

デフォルトの型宣言を保持しているかぎり、REAL 文でこれらの関数の型を明示的に指定する必要はありません。r で始まる名前は REAL 型、i で始まる名前は INTEGER 型になります。

これらのルーチンの詳細については、C 数学ライブラリのマニュアルページ (3M) を参照してください。たとえば、r_acos(x) の場合は、マニュアルページの acos(3M) を参照します。

表 1–2 数学単精度関数


関数名	結果の型	説明
`r_acos``( x )` `r_acosd``( x )` `r_acosh``( x )` `r_acosp``( x )` `r_acospi``( x )`	`REAL` `REAL` `REAL` `REAL` `REAL`	`逆余弦` `--` `逆双曲余弦` `--` `--`
`r_atan``( x )` `r_atand``( x )` `r_atanh``( x )` `r_atanp``( x )` `r_atanpi``( x )`	`REAL` `REAL` `REAL` `REAL` `REAL`	`逆正接` `--` `逆双曲正接` `--` `--`
`r_asin``( x )` `r_asind``( x )` `r_asinh``( x )` `r_asinp``( x )` `r_asinpi``( x )`	`REAL` `REAL` `REAL` `REAL` `REAL`	`逆正弦` `--` `逆双曲正弦` `--` `--`
`r_atan2``(( y, x )` `r_atan2d``( y, x )` `r_atan2pi``( y, x )`	`REAL` `REAL` `REAL`	`逆正接` `--` `--`
`r_cbrt``( x )` `r_ceil``( x )` `r_copysign``( x, y )`	`REAL` `REAL` `REAL`	`立方根` `小数点以下切り上げ` `--`
`r_cos``( x )` `r_cosd``( x )` `r_cosh``( x )` `r_cosp``( x )` `r_cospi``( x )`	`REAL` `REAL` `REAL` `REAL` `REAL`	`余弦` `--` `双曲余弦` `--` `--`
`r_erf``( x )` `r_erfc``( x )`	`REAL` `REAL`	`誤差関数` `--`
`r_expm1``( x )` `r_floor``( x )` `r_hypot``( x, y )` `r_infinity``( )`	`REAL` `REAL` `REAL` `REAL`	`(ex)-1` `小数点以下切捨て` `斜辺` `--`**
`r_j0( x )` `r_j1( x )` `r_jn(n, x )`	`REAL` `REAL` `REAL`	`ベッセル関数--` `--`
`ir_finite``( x )` `ir_fp_class``( x )` `ir_ilogb``( x )` `ir_irint``( x )` `ir_isinf``( x )` `ir_isnan``( x )` `ir_isnormal``( x )` `ir_issubnormal``( x )` `ir_iszero``( x )` `ir_signbit``( x )`	`INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER`	`--` `--` `--` `--` `--` `--` `--` `--` `--` `--`
`r_addran``()` `r_addrans``( x, p, l, u )` `r_lcran``()` `r_lcrans``( x, p, l, u )` `r_shufrans``(x, p, l, u)`	`REAL` `サブルーチン` `REAL` `サブルーチン` `サブルーチン`	`乱数発生関数`
`r_lgamma( x )` `r_logb``( x )` `r_log1p``( x )` `r_log2``( x )`	`REAL` `REAL` `REAL` `REAL`	`ガンマの対数` `--` `--` `--`
`r_max_normal``()` `r_max_subnormal``()` `r_min_normal``()` `r_min_subnormal``()` `r_nextafter``( x, y )` `r_quiet_nan``( n )` `r_remainder``( x, y )` `r_rint``( x )` `r_scalb``( x, y )` `r_scalbn``( x, n )` `r_signaling_nan``( n )` `r_significand``( x )`	`REAL` `REAL` `REAL` `REAL` `REAL` `REAL` `REAL` `REAL` `REAL` `REAL` `REAL` `REAL`
`r_sin``( x )` `r_sind``( x )` `r_sinh``( x )` `r_sinp``( x )` `r_sinpi``( x )`	`REAL` `REAL` `REAL` `REAL` `REAL`	`正弦` `--` `双曲正弦` `--` `--`
`r_sincos``( x, s, c )` `r_sincosd``( x, s, c )` `r_sincosp``( x, s, c )` `r_sincospi``( x, s, c )`	`サブルーチン` `サブルーチン` `サブルーチン` `サブルーチン`	`正弦と余弦` `--` `--` `--`
`r_tan``( x )` `r_tand``( x )` `r_tanh``( x )` `r_tanp``( x )` `r_tanpi``( x )`	`REAL` `REAL` `REAL` `REAL` `REAL`	`正接` `--` `双曲正接` `--` `--`
`r_y0( x )` `r_y1( x )` `r_yn( n, x )`	`REAL` `REAL` `REAL`	`ベッセル関数` `--` `--`

変数 c、l、p、s、u、x、y は、REAL 型です。変数 n は INTEGER 型です。
IMPLICIT 文が有効で、r で始まる名前を別のデータ型に対して指定する場合、これらの関数を REAL として明示的に指定します。
sind(x) や asind(x) などでは、ラジアンではなく度が使用されます。

参照: intro(3M)、『数値計算ガイド』

1.3.2 倍精度関数

次の副プログラムは、倍精度の数学関数およびサブルーチンです。

通常、これらの関数は Fortran 規格の総称的な組み込み関数とは対応していません。データ型は、通常のデータ型決定規則によって決定されます。

これらの DOUBLE PRECISION 関数は DOUBLE PRECISION 文に指定する必要があります。

詳細については、C ライブラリのマニュアルページを参照してください。d_acos(x) のマニュアルページは acos(3M) です。

表 1–3 数学倍精度関数


関数名	結果の型	説明
`d_acos``( x )` `d_acosd``( x )` `d_acosh``( x )` `d_acosp``( x )` `d_acospi``( x )`	`DOUBLE` `PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`逆余弦` `--` `逆双曲余弦` `--` `--`
`d_atan``( x )` `d_atand``( x )` `d_atanh``( x )` `d_atanp``( x )` `d_atanpi``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`逆正接` `--` `逆双曲正接` `--` `--`
`d_asin``( x )` `d_asind``( x )` `d_asinh``( x )` `d_asinp``( x )` `d_asinpi``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`逆正弦` `--` `逆双曲正弦` `--` `--`
`d_atan2``(( y, x )` `d_atan2d``( y, x )` `d_atan2pi``( y, x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`逆正接` `--` `--`
`d_cbrt``( x )` `d_ceil``( x )` `d_copysign``( x, x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`立方根` `小数点以下切り上げ` `--`
`d_cos``( x )` `d_cosd``( x )` `d_cosh``( x )` `d_cosp``( x )` `d_cospi``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`余弦` `--` `双曲余弦` `--` `--`
`d_erf``( x )` `d_erfc``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION`	`誤差関数` `--`
`d_expm1``( x )` `d_floor``( x )` `d_hypot``( x, y )` `d_infinity``( )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`(ex)-1` `小数点以下切り捨て` `斜辺` `--`**
`d_j0( x )` `d_j1( x )` `d_jn(n, x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`ベッセル関数` `--` `--`
`id_finite``( x )` `id_fp_class``( x )` `id_ilogb``( x )` `id_irint``( x )` `id_isinf``( x )` `id_isnan``( x )` `id_isnormal``( x )` `id_issubnormal``( x )` `id_iszero``( x )` `id_signbit``( x )`	`INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER`
`d_addran``()` `d_addrans``(x, p, l, u)` `d_lcran``()` `d_lcrans``(x, p, l, u )` `d_shufrans``(x, p, l,u)`	`DOUBLE PRECISION` `サブルーチン` `DOUBLE PRECISION` `サブルーチン` `サブルーチン`	`乱数発生関数`
`d_lgamma( x )` `d_logb``( x )` `d_log1p``( x )` `d_log2``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`ガンマの対数` `--` `--` `--`
`d_max_normal``()` `d_max_subnormal``()` `d_min_normal``()` `d_min_subnormal``()` `d_nextafter``( x, y )` `d_quiet_nan``( n )` `d_remainder``( x, y )` `d_rint``( x )` `d_scalb``( x, y )` `d_scalbn``( x, n )` `d_signaling_nan``( n )` `d_significand``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`
`d_sin``( x )` `d_sind``( x )` `d_sinh``( x )` `d_sinp``( x )` `d_sinpi``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`正弦` `--` `双曲正弦` `--` `--`
`d_sincos``( x, s, c )` `d_sincosd``( x, s, c )` `d_sincosp``( x, s, c )` `d_sincospi``( x, s, c )`	`サブルーチン` `サブルーチン` `サブルーチン` `サブルーチン`	`正弦と余弦` `--` `--`
`d_tan``( x )` `d_tand``( x )` `d_tanh``( x )` `d_tanp``( x )` `d_tanpi``( x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`正接` `--` `双曲正接` `--` `--`
`d_y0( x )` `d_y1( x )` `d_yn( n, x )`	`DOUBLE PRECISION` `DOUBLE PRECISION` `DOUBLE PRECISION`	`ベッセル関数` `--` `--`

変数 c、l、p、s、u、x、y は、DOUBLE PRECISION 型です。変数 n は INTEGER 型です。
DOUBLE PRECISION 文に、または適当な IMPLICIT 文でこれらの関数の型を明示的に指定します。
sind(x) や asind(x) などでは、ラジアンではなく度が使用されます。

参照: intro(3M)、『数値計算ガイド』

1.3.3 4 倍精度関数

これらの副プログラムは、4 倍精度 (REAL*16) の数学関数およびサブルーチンです。

通常、これらの関数は標準の総称組み込み関数とは対応していません。データ型は通常の型決定規則によって決定されます。

4 倍精度関数は REAL*16 文に指定してください。

表 1–4 4 倍精度 libm 関数


関数名	結果の型
`q_copysign``( x, y )` `q_fabs``( x )` `q_fmod``( x )` `q_infinity``( )`	*`REAL16` `REAL16`* *`REAL16` `REAL16`*
`iq_finite``( x )` `iq_fp_class``( x )` `iq_ilogb``( x )` `iq_isinf``( x )` `iq_isnan``( x )` `iq_isnormal``( x )` `iq_issubnormal``( x )` `iq_iszero``( x )` `iq_signbit``( x )`	`INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER` `INTEGER`
`q_max_normal``()` `q_max_subnormal``()` `q_min_normal``()` `q_min_subnormal``()` `q_nextafter``( x, y )` `q_quiet_nan``( n )` `q_remainder``( x, y )` `q_scalbn``( x, n )` `q_signaling_nan``( n )`	*`REAL16` `REAL16`* *`REAL16` `REAL16`* *`REAL16` `REAL16`* *`REAL16` `REAL16`* *`REAL16`**

変数 c、l、p、s、u、 x、y は 4 倍精度です。変数 n は INTEGER 型です。
REAL*16 文または適当な IMPLICIT 文でこれらの関数の型を明示的に指定します。
sind(x) や asind(x) などでは、ラジアンではなく度が使用されます。

そのほかの 4 倍精度 libm 関数を使用する必要がある場合、その呼び出しの前に $PRAGMA C <関数名> を使用してください。詳細については、『Fortran プログラミングガイド』の「C と Fortran のインタフェース」の章を参照してください。

1.4 Fortran ライブラリルーチンリファレンス

この節では、Sun Studio Fortran 95 に含まれているものの、標準の Fortran 95 にはない、Fortran ライブラリ内のサブルーチンと関数について詳述します。

呼び出し側のインタフェースの形式は、次の表形式で表記します。

データ宣言引数を含む呼び出しプロトタイプの形式
引数 1 名前	`データ型`	`入力/出力`	`説明`
引数 2 名前	`データ型`	`入力/出力`	`説明`
`戻り値`	`データ型`	出力	`説明`

Sun Studio マニュアルページのセクション 3f にその他のマニュアルページがあります。たとえば man -s 3f access というコマンドを入力すると、access() 関数のマニュアルページが表示されます。このマニュアルでは、マニュアルページの参照をマニュアルページ名 (セクション) の形式で表記します。たとえば access() 関数のマニュアルページの参照は access(3f)、Fortran 95 コンパイラのマニュアルページは f95(1) と表記しています。

1.4.1 `abort`: 終了とコアファイルへの書き込み

サブルーチンは、次のように呼び出します。

call abort

abort は、入出力バッファーをフラッシュしたあと、場合によっては、現在のディレクトリにコアファイルのメモリーダンプを作成します。コアダンプを制限、または行わないようにする方法については、limit(1) を参照してください。

1.4.2 `access`: ファイルのアクセス権または有無の検査

関数は、次のように呼び出します。

*`INTEGER4 access` `status = access (` name, mode `)`**
name	`character`	入力	ファイル名
mode	`character`	入力	アクセス権
戻り値	*`INTEGER4`**	出力	status=0: 正常、status>0: エラーコード

access は、name で指定したファイルに mode で指定したアクセス権でアクセスできるかどうかを決定します。mode で指定したアクセスが正常終了した場合は、ゼロが返されます。エラーコードを解釈する場合は、gerror(3F) も参照してください。

mode には、r、w、x を単独で指定することも、任意の順序で 2 つ以上組み合わせて指定することも、あるいは空白を指定することもできます。r、w、x の意味はそれぞれ次のとおりです。

`’r’`	読み取りアクセス権をテストする
`’w’`	書き込みアクセス権をテストする
`’x’`	実行アクセス権をテストする
`’ ’`	ファイルの有無をテストする

例 1: 読み取りおよび書き込みに関するアクセス権のテスト

      INTEGER*4  access, status
      status = access ( 'taccess.data', 'rw' )
      if ( status .eq. 0 ) write(*,*) "ok"
      if ( status .ne. 0 ) write(*,*) '読み取り/書き込み可', status

例 2: ファイルの有無のテスト

      INTEGER*4  access, status
      status = access ( 'taccess.data', ' ' )    ! 空白モード
      if ( status .eq. 0 ) write(*,*) "ファイル存在"
      if ( status .ne. 0 ) write(*,*) 'ファイルはない', status

1.4.3 `alarm`: 指定時間後のサブルーチンの呼び出し

関数は、次のように呼び出します。

*`INTEGER4 alarm` `n = alarm (` time`,` sbrtn `)`**
time	*`INTEGER4`**	入力	待ち時間の秒数 (0 の場合は呼び出さない)
sbrtn	ルーチン名	入力	実行する副プログラムは EXTERNAL 文で宣言しなければならない
戻り値	*`INTEGER4`**	出力	前回呼び出した alarm の残り時間

例: alarm の使用例 - 9 秒待機してから sbrtn を呼び出します。

       integer*4 alarm, time / 1 /
       common / alarmcom / i
       external sbrtn
       i = 9
       write(*,*) i
       nseconds =  alarm ( time, sbrtn )
       do n = 1,100000         ! alarm が sbrtn をアクティブにするまで待機
        r = n              ! (時間がかかる計算)
        x=sqrt(r)
       end do
       write(*,*) i
       end
       subroutine sbrtn
       common / alarmcom / i
       i = 3                     ! このルーチンでは I/O を行わない
       return
       end

参照: alarm(3C)、sleep(3F)、signal(3F)。次の制限事項に注意してください。

サブルーチンは自分自身の名前を alarm に渡すことはできません。
alarm ルーチンは、入出力に干渉する可能性のあるシグナルを発生させます。呼び出されたサブルーチン (sbrtn) では、いっさい入出力を実行してはいけません。
Fortran の並列プログラムまたはマルチスレッドプログラムから alarm() を呼び出すと、予期しない結果を招くことがあります。

1.4.4 `bit`: ビット関数: `and`、`or`、`bit`、 `setbit`

定義は次のとおりです。

`and(` `word1, word2` `)`	引数のビット単位の論理積を計算する
`or(` `word1`, `word2` `)`	引数のビット単位の論理和を計算する
`xor(` `word1`, `word2` `)`	引数のビット単位の排他的論理和を計算する
`not(` `word` `)`	引数のビット単位の補数を戻す
`lshift(` `word`, `nbits` `)`	循環桁上げなしで左へ論理シフトする
`rshift(` `word`, `nbits` `)`	符号拡張を行い右へ算術シフトする
`call` `bis(` `bitnum``,` `word` `)`	word の第 `bitnum` ビットを 1 に設定する。
`call` `bic(` `bitnum``,` `word` `)`	word の第 `bitnum` ビットを 0 にクリアする。
`bit(` `bitnum``,` `word` `)`	`word` の第 `bitnum` ビットを検査し、ビットが 1 であれば `.true.` を返し、ビットが 0 であれば `.false.` を戻す。
`call` `setbit(``bitnum``,``word``,``state``)`	state がゼロ以外であれば `word` の第 `bitnum` ビットを 1 に設定し、state がゼロであれば 0 にクリアする

MIL-STD-1753 の代替外部バージョンは次のとおりです。

`iand(` `m``,` `n` `)`	引数のビット単位の論理積を計算する
`ior(` `m``,` `n` `)`	引数のビット単位の論理和を計算する
`ieor(` `m``,` `n` `)`	引数のビット単位の排他的論理和を計算する
`ishft(` `m``,` `k` `)`	循環桁上げなしで論理シフトする (`k`>0 のときは左、`k`<0 のときは右へ)
`ishftc(` `m``,` `k``,` `ic` `)`	循環シフト: `m` の、右から `ic` ビットを左へ `k` ビット循環シフトする
`ibits(` `m``,` `i``,` `len` `)`	ビットの切り出し: `i` ビット目から始まる len ビット分を m から切り出す
`ibset(` `m``,` `i` `)`	ビットをセットする: ビット `i` が 1 であれば戻り値は `m` と同じ
`ibclr(` `m``,` `i` `)`	ビットをクリアする: ビット `i` が 0 であれば戻り値は `m` と同じ
`btest(` `m``,` `i` `)`	ビットのテスト: `m` の `i` 番目のビットをテストする。ビットが 1 のときは `LOGICAL .true.` を返し、ビットが 0 のときは `.false.` を戻す。

ビットフィールドを操作するその他の関数については、「1.4.36 mvbits: ビットフィールドの移動」、および第 2 章と 3 章を参照してください。

1.4.4.1 `and`、`or`、 `xor`、`not`、`rshift`、 `lshift` の使用法

組み込み関数の場合は、次のように使います。

x = and( word1, word2 )

x = or( word1, word2 )

x = xor( word1, word2 )

x = not( word )

x = rshift( word, nbits )

x = lshift( word, nbits )

word、word1、word2、nbits は、整数型の入力引数です。これらは組み込み関数で、コンパイラによりインライン展開されます。戻されるデータの型は、第 1 引数のデータ型です。

nbits の値が正当かどうかの検査は行われません。

例: and、or、xor、not:

demo% cat tandornot.f
        print 1, and(7,4), or(7,4), xor(7,4), not(4)
 1      format(4x 'and(7,4)', 5x 'or(7,4)', 4x 'xor(7,4)',
     1         6x 'not(4)'/4o12.11)
        end
demo% f95 tandornot.f
demo% a.out
    and(7,4)     or(7,4)    xor(7,4)      not(4)
 00000000004 00000000007 00000000003 37777777773
demo%

例: lshift、rshift:

demo% cat tlrshift.f
       integer*4 lshift, rshift
       print 1, lshift(7,1), rshift(4,1)
 1     format(1x 'lshift(7,1)', 1x 'rshift(4,1)'/2o12.11)
       end
demo% f95 tlrshift.f
demo% a.out
 lshift(7,1) rshift(4,1)
 00000000016 00000000002
demo%

1.4.4.2 `bic`、`bis`、 `bit`、`setbit` の使用法

サブルーチンと関数については、次を参照してください。

call bic( bitnum, word )

call bis( bitnum, word )

call setbit( bitnum, word, state )

LOGICAL bit

x = bit( bitnum, word )

bitnum、state、および word は、INTEGER*4 型の入力引数です。bit() 関数では、論理値が返されます。

ビットは、ビット 0 が最下位ビット、ビット 31 が最上位ビットになるように番号が付けられます。

bic、bis、および setbit は外部サブルーチン、bit は外部関数です。

例 3: bic、bis、setbit、bit:

        integer*4 bitnum/2/, state/0/, word/7/
        logical bit
        print 1, word
 1      format(13x 'word', o12.11)
        call bic( bitnum, word )
        print 2, word
 2      format('bic(2,word) のあと', o12.11)
        call bis( bitnum, word )
        print 3, word
 3      format('bis(2,word) のあと', o12.11)
        call setbit( bitnum, word, state )
        print 4, word
 4      format('setbit(2,word,0) のあと', o12.11)
        print 5, bit(bitnum, word)
 5      format('bit(2,word)', L )
        end
<出力>
             word 00000000007
bic(2,word) のあと 00000000003
bis(2,word) のあと 00000000007
setbit(2,word,0) のあと 00000000003
bit(2,word) F

1.4.5 `chdir`: デフォルトディレクトリの変更

関数は、次のように呼び出します。

INTEGER*4 chdir

n = chdir( dirname )

dirname

character

入力

ディレクトリ名

戻り値

INTEGER*4

出力

n=0: 正常、n>0: エラーコード

例: chdir - 現在のディレクトリを MyDir に変更します。

       INTEGER*4  chdir, n
       n =  chdir ( 'MyDir' )
       if ( n .ne. 0 ) stop 'chdir: error'
       end

参照: chdir(2)、cd(1)、gerror(3F) (エラーコードの解釈)

パス名は、<sys/param.h> で定義されている MAXPATHLEN より長くすることはできません。相対パス名でも、絶対パス名でもかまいません。

この関数を使用すると、装置による照会が失敗する場合があります。

いくつかの Fortran のファイル操作は、ファイルを名前で再オープンします。入出力動作中に chdir を使用すると、実行時システムが相対パス名で作成されたファイル (ファイル名を指定せずに open 文で作成されたファイルを含む) を見失ってしまうことがあります。

1.4.6 `chmod`: ファイルモードの変更

関数は、次のように呼び出します。

*`INTEGER4 chmod` n `= chmod(` `name``,` `mode` `)`**
`name`	`character`	入力	パス名
`mode`	`character`	入力	`chmod`(1) に認識されるモード (`o-w`、 `444` など)
戻り値	*`INTEGER4`**	出力	n = 0: 正常、`n`>0: システムエラー番号

例: chmod - 書き込み権を MyFile に追加します。

        character*18 name, mode
        INTEGER*4 chmod, n
        name = 'MyFile'
        mode = '+w'
        n =  chmod( name, mode )
        if ( n .ne. 0 ) stop 'chmod: error'
        end

参照: chmod(1)、gerror(3F) (エラーコードの解釈)

パス名は、<sys/param.h> で定義されているMAXPATHLEN より長くすることはできません。相対パス名でも、絶対パス名でもかまいません。

1.4.7 `date`: 文字列として現在の日付を取得

注 –

このルーチンは年を示す場合に 2 桁の値しか返さないので、「2000 年には無効」になります。このルーチンの出力を使用して日付間の差を計算するプログラムは、1999 年 12 月 31 日以降は正しく機能しなくなります。この date() ルーチンを使用しているプログラムは、ルーチンの初期呼び出し時に実行時警告メッセージを表示してユーザーに警告します。このルーチンの代わりに呼び出すことのできるルーチンとして、date_and_time() を参照してください。

サブルーチンは、次のように呼び出します。

`call` `date(` c `)`
`c`	*`CHARACTER9`**	出力	変数、配列、配列要素、あるいは部分列

戻される文字列 c の形式は、dd-mmm-yy です。ここで、dd は 2 桁の数値で表した日、mmm は 3 文字に省略した英語の月名、yy は 2 桁の数値で表した年 (2000 年には対応していない) です。

例: date:

demo% cat dat1.f
* dat1.f -- 日付を文字列として取得
        character c*9
        call date ( c )
        write(*,"(' 本日の日付は、', A9 )" ) c
        end
demo% f95 dat1.f
demo% a.out
Computing time differences using the 2 digit year from subroutine
        date is not safe after year 2000.
 本日の日付は、9-Jan-02
demo%

idate() および date_and_time() も参照してください。

1.4.7.1 `date_and_time`: 日付と時刻の取得

これは、Fortran 95 組み込みルーチンで、2000 年以降も有効です。

date_and_time サブルーチンはリアルタイムクロックと日付のデータを返します。現地時間のほかに、現地時間と世界標準時 (UTC: Universal Coordinated Time) (グリニッジ平均時 (GMT: Greenwich Mean Time) とも呼ぶ) の時差も返します。

date_and_time() サブルーチンは、次のように呼び出します。

`call date_and_time(` `date` , `time`, `zone`, `values` `)`
`date`	*`CHARACTER8`**	出力	日付。書式は CCYYMMDD。 CCYY は 4 桁の年、MM は 2 桁の月、DD は 2 桁の日。例: 19980709
`time`	*`CHARACTER10`**	出力	現在の時刻。書式は hhmmss.sss。hh は時、mm は分、ss.sss は秒とミリ秒
`zone`	*`CHARACTER5`**	出力	UTC を使用した場合の時差。時分で示す。書式は hhmm
`values`	*`INTEGER4` `VALUES(8)`**	出力	次に説明する 8 要素の整数配列

INTEGER*4 values に返される 8 つの値は次のとおりです。

`VALUES(1)`	4 桁の整数の年。たとえば、1998。
`VALUES(2)`	1 〜 12 の整数の月。
`VALUES(3)`	1 〜 31 の整数の日。
`VALUES(4)`	UTC を使用した場合の時差 (分)。
`VALUES(5)`	1 〜 23 の整数の時。
`VALUES(6)`	1 〜 59 の整数の分。
`VALUES(7)`	0 〜 60 の整数の秒。
`VALUES(8)`	0 〜 999 の範囲のミリ秒。

date_and_time の使用例

demo% cat dtm.f
       integer date_time(8)
       character*10 b(3)
       call date_and_time(b(1), b(2), b(3), date_time)
       print *,'date_time    配列の値'
       print *,'年=',date_time(1)
       print *,'month_of_year=',date_time(2)
       print *,'day_of_month=',date_time(3)
       print *,'時差 (分)time difference in minutes=',date_time(4)
       print *,'時=',date_time(5)
       print *,'分=',date_time(6)
       print *,'秒=',date_time(7)
       print *,'ミリ秒=',date_time(8)
       print *, 'DATE=',b(1)
       print *, 'TIME=',b(2)
       print *, 'ZONE=',b(3)
       end

2000 年 2 月 16 日にカリフォルニアで実行した場合の出力は次のとおりです。

 date_time    配列の値:
 年= 2000
 month_of_year= 2
 day_of_month= 16
 時差 (分)= -420
 時= 11
 分= 49
 秒= 29
 ミリ秒= 236
 DATE=20000216
 TIME=114929.236
 ZONE=-0700

1.4.8 `dtime`、`etime`: 経過実行時間

これらの 2 つの関数は、経過実行時間 (あるいはエラー指示子として -1.0) を返します。返される時間は秒単位です。

Fortran 95 が使用する dtime と etime のバージョンは、デフォルトではシステムの低分解能クロックを使用します。分解能は 100 分の 1 秒です。ただし、プログラムが Sun OS^TM オペレーティングシステムのユーティリティー ptime(1)、(/usr/proc/bin/ptime) の下で実行された場合は、高分解能クロックが使用されます。

1.4.8.1 `dtime`: 前回の `dtime` 呼び出しからの経過時間

dtime の場合、経過時間は次のとおりです。

最初の呼び出し: 実行開始からの経過時間
2 回目以降の呼び出し: 前回の dtime の呼び出しからの経過時間
シングルプロセッサ: CPU の使用時間
マルチプロセッサ: すべての CPU 使用合計時間。この合計時間は有用ではありません。etime を使用してください。

注 –
並列化ループ内から dtime を呼び出すと、決定性のない結果になります。経過時間カウンタが、ループに関与しているすべてのスレッドに対してグローバルであるためです。

関数は、次のように呼び出します。

e = dtime( tarray )

tarray

real(2)

出力

e= -1.0: エラー: tarray 値は未定義

e≠ -1.0: tarray(1) にユーザー時間 (エラーがない場合)。tarray(2) にシステム時間 (エラーがない場合)

戻り値

real

出力

e= -1.0: エラー

e≠ -1.0: tarray(1) と tarray(2) の合計時間

例: dtime()、シングルプロセッサ

demo% cat tdtime.f
       real e, dtime, t(2)
       print *, 'elapsed:', e, ', user:', t(1), ', sys:', t(2)
       do i = 1, 10000
        k=k+1
       end do
       e = dtime( t )
       print *, 'elapsed:', e, ', user:', t(1), ', sys:', t(2)
       end
demo% f95 tdtime.f
demo% a.out
elapsed: 0.0E+0 , user: 0.0E+0 , sys: 0.0E+0
 elapsed: 0.03 , user: 0.01 , sys: 0.02
demo%

1.4.8.2 `etime`: 実行開始からの経過時間

dtime の場合、経過時間は次のとおりです。

シングルプロセッサ実行: 呼び出したプロセスの CPU 時間
マルチプロセッサ実行: プログラムを処理している間の実時間

実行時ライブラリは、PARALLEL または OMP_NUM_THREADS 環境変数が 1 より大きい整数に定義される場合に、プログラムのマルチプロセッサモードでの実行を決定します。

関数は、次のように呼び出します。

e = etime( tarray )

tarray

real(2)

出力

e= -1.0: エラー: tarray 値は未定義

e≠ -1.0: シングルプロセッサ: tarray(1) にユーザー時間。tarray(2) にシステム時間

マルチプロセッサ: tarray(1) に実時間、tarray(2) に 0.0

戻り値

real

出力

e= -1.0: エラー

e≠ -1.0: tarray(1) と tarray(2) の合計時間

etime の初期呼び出しで返される結果は不正確です。初期呼び出しでは、単にシステムクロックを稼働させるだけなので、etime の初期呼び出しで返された値は使用しないでください。

例: etime()、シングルプロセッサ

demo% cat tetime.f
       real e, etime, t(2)
       e = etime(t)         !  Startup etime - do not use result
       do i = 1, 10000
        k=k+1
       end do
       e = etime( t )
       print *, 'elapsed:', e, ', user:', t(1), ', sys:', t(2)
       end
demo% f95 tetime.f
demo% a.out
elapsed: 0.02 , user: 0.01 , sys: 0.01
demo%

times(2) のマニュアルページ、および『Fortran プログラミングガイド』も参照してください。

1.4.9 `exit`: プロセスの終了および状態の設定

サブルーチンは、次のように呼び出します。

`call` `exit(` `status` `)`
`status`	*`INTEGER4`**	入力

例: exit():

     ...
       if(dx .lt. 0.) call exit( 0 )
    ...
       end

exit はフラッシュしてからプロセスのすべてのファイルを閉じ、その親プロセスが wait を実行している場合は親プロセスに通知します。

親プロセスは status の下位 8 ビットを使用できます。この 8 ビットは左に 8 ビットシフトされ、ほかのビットはすべてゼロになります (したがって status は 256 〜 65280 の範囲になります)。この呼び出しは復帰しません。

C の関数である exit によって、最終的にシステムを終了させる前に、クリーンアップアクションが実行されることがあります。

引数なしで exit を呼び出すとコンパイル時警告メッセージが出され、自動的に引数にゼロが与えられます。参照: exit(2)、fork(2)、fork(3F)、wait(2)、wait(3F)

1.4.10 `fdate`: ASCII 文字列で日付および時刻を返す

サブルーチンまたは関数は、次のように呼び出します。

`call` `fdate(` `string` `)`
`string`	*`character24`**	出力

または

CHARACTER fdate*24

string = fdate()

fdate を関数として使用する場合、それを呼び出すルーチンは fdate の型と長さを設定する必要があります。

戻り値

character*24

出力

例 1: fdate のサブルーチンとしての使用

       character*24 string
       call fdate( string )
       write(*,*) string
       end

前述の例の出力は次のようになります。

 Wed Aug  3 15:30:23 1994

例 2: fdate の関数としての使用。出力は前述の例と同じ。

       character*24 fdate
       write(*,*)  fdate()
       end

参照: ctime(3)、time(3F)、および idate(3F)

1.4.11 `flush`: 論理装置への出力のフラッシュ

関数は、次のように呼び出します。

INTEGER*4 flush

n = flush( lunit )

lunit

INTEGER*4

入力

論理装置

戻り値

INTEGER*4

出力

n = 0 エラーなし、n > 0 エラー番号

flush 関数は、論理装置 lunit に対するバッファーの内容を結合されているファイルにフラッシュします。このサブルーチンがもっとも役に立つのは、論理装置 0 と 6 がどちらもコンソールに結合されていて、それらの装置に対してこのサブルーチンを使用する場合です。関数はエラーが発生すると、正のエラー番号を返し、エラーが発生しないとゼロを返します。

参照: fclose(3S)

1.4.12 `fork`: 現プロセスのコピーの生成

関数は、次のように呼び出します。

INTEGER*4 fork

n = fork()

戻り値

INTEGER*4

出力

n>0: n= コピーのプロセス ID

n<0, n= システムエラーコード

fork 関数はそれを呼び出したプロセスのコピーを生成します。元のプロセスとコピーとの違いは、元のプロセス (親プロセスと呼ばれる) に返される値がコピーのプロセス ID であるということだけです。コピーは一般に子プロセスと呼ばれます。子プロセスに返される値はゼロです。

書き込み用に開いているすべての論理装置は、fork が実行される前にフラッシュされます。これは、入出力バッファーの内容が外部ファイルに重複して書き込まれるのを防ぎます。

例: fork():

       INTEGER*4 fork, pid
       pid = fork()
       if(pid.lt.0) stop 'フォーク失敗'
       if(pid.gt.0) then
              print *, '親プロセス'
       else
              print *, '子プロセス'
       endif

fork ルーチンと対をなす exec ルーチンは提供されていません。これは論理装置を開いたままで exec ルーチンに渡せる良い方法がないためです。ただし、system(3F) を使用すれば fork/exec の通常の機能を実行することができます。参照: fork(2)、wait(3F)、kill(3F)、system(3F)、および perror(3F)

1.4.13 `fseek`、`ftell`: ファイルのポインタの位置付けと再位置付け

fseek および ftell は、ファイルの再位置付けを可能にするルーチンです。ftell は、ファイルの現在位置をファイルの先頭からのオフセットを示すバイト数で返します。プログラムの後方で、この値を使用して fseek を呼ぶことにより、ファイルの読み込み位置を元に戻すことができます。

1.4.13.1 `fseek`: 論理装置上のファイルのポインタの再位置付け

関数は、次のように呼び出します。

*`INTEGER4 fseek` `n` `= fseek(` `lunit``,` `offset``,` `from` `)`**
`lunit`	*`INTEGER4`**	入力	開いている論理装置
`offset`	*`INTEGER4` または `INTEGER8`*	入力	from で指定された位置からのオフセットを示すバイト数
	64 ビット環境用にコンパイルする場合は、*`INTEGER8` オフセット値が必要です。定数表現を入力する場合は、それを 64 ビット定数にする必要があります。たとえば、`100_8`** とします。
`from`	*`INTEGER4`**	入力	0= ファイルの先頭 1= 現在の位置 2= ファイルの終了
戻り値	*`INTEGER4`**	出力	`n`=0: 正常、`n`>0: システムエラーコード

注 –

順編成ファイルでは、fseek に続く呼び出しのあとの出力操作 (WRITE など) は、fseek の位置に続くすべてのデータレコードの削除、新しいデータレコード (とファイルの終わりのマーク) での書き換えの原因となります。正しい位置へのレコードの書き換えは、直接アクセスファイルでのみ実行可能です。

例: fseek() - MyFile のポインタを先頭から 2 バイトの位置に再位置付けします。

        INTEGER*4 fseek, lunit/1/, offset/2/, from/0/, n
        open( UNIT=lunit, FILE='MyFile' )
        n = fseek( lunit, offset, from )
        if ( n .gt. 0 ) stop 'fseek エラー'
        end

例: 前述の例を 64 ビット環境で、-m64 を使ってコンパイルすると次のようになります。

        INTEGER*4 fseek, lunit/1/,  from/0/, n
        INTEGER*8 offset/2/
        open( UNIT=lunit, FILE='MyFile' )
        n = fseek( lunit, offset, from )
        if ( n .gt. 0 ) stop 'fseek エラー'
        end

1.4.13.2 `ftell`: ファイルの現在位置を戻す

関数は、次のように呼び出します。

INTEGER*4 ftell

n = ftell( lunit )

lunit

INTEGER*4

入力

開いている論理装置

戻り値

INTEGER*4

出力

n>=0: n= ファイルの先頭からのオフセットを示すバイト数

n<0: n= システムエラーコード

例: ftell():

       INTEGER*4 ftell, lunit/1/, n
       open( UNIT=lunit, FILE='MyFile' )
       ...
       n = ftell( lunit )
       if ( n .lt. 0 ) stop 'ftell エラー'
       ...

例: 前述の例を 64 ビット環境で、-m64 を使ってコンパイルすると次のようになります。

       INTEGER*4 lunit/1/
       INTEGER*8 ftell, n
       open( UNIT=lunit, FILE='MyFile' )
       ...
       n = ftell( lunit )
       if ( n .lt. 0 ) stop 'ftell エラー'
       ...

参照: fseek(3S)、perror(3F)、fseeko64(3F)、ftello64(3F)

1.4.14 `fseeko64`、`ftello64`: 大規模ファイルポインタの位置付けと再位置付け

fseeko64と ftello64 は、それぞれ fseek と ftell の「大規模ファイル」バージョンです。fseeko64 と ftello64 は、INTEGER*8 ファイル位置のオフセットを入出力します。「大規模ファイル」とは 2G バイトを超えるファイルのことで、バイト位置は 64 ビットの整数で示す必要があります。これらのバージョンを使用して、大規模ファイルのポインタの位置付けや再位置付けを行います。

1.4.14.1 `fseeko64`: 論理装置上のファイルのポインタ再位置付け

関数は、次のように呼び出します。

`INTEGER fseeko64` `n` `= fseeko64(` `lunit``,` `offset64``,` `from` `)`
`lunit`	*`INTEGER4`**	入力	開いている論理装置
`offset64`	*`INTEGER8`**	入力	from で指定された位置からの 64 ビットオフセットを示すバイト数
`from`	*`INTEGER4`**	入力	0= ファイルの先頭 1= 現在の位置 2= ファイルの終了
戻り値	*`INTEGER4`**	出力	`n`=0: 正常、`n`>0: システムエラーコード

注 –

順編成ファイルでは、fseeko64 に続く呼び出しのあとの出力操作 (WRITE など) は、fseek の位置に続くすべてのデータレコードの削除、新しいデータレコード (とファイルの終わりのマーク) での書き換えの原因となります。正しい位置へのレコードの書き換えは、直接アクセスファイルでのみ実行可能です。

例: fseeko64() - MyFile のポインタを先頭から 2 バイトの位置に再位置づけします。

       INTEGER fseeko64, lunit/1/, from/0/, n
       INTEGER*8 offset/200/
       open( UNIT=lunit, FILE='MyFile' )
       n = fseeko64( lunit, offset, from )
       if ( n .gt. 0 ) stop 'fseek エラー'
       end

1.4.14.2 `ftello64`: ファイルの現在位置を戻す

関数は、次のように呼び出します。

INTEGER*8 ftello64

n = ftello64( lunit )

lunit

INTEGER*4

入力

開いている論理装置

戻り値

INTEGER*8

出力

n≥0: n= ファイルの先頭からのオフセットを示すバイト数

n<0: n= システムエラーコード

例: ftello64():

       INTEGER*8 ftello64, lunit/1/, n
       open( UNIT=lunit, FILE='MyFile' )
       ...
       n = ftello64( lunit )
       if ( n .lt. 0 ) stop 'ftell エラー'
       ...

1.4.15 `getarg`、`iargc`: コマンド行の引数の取得

getarg と iargc は、コマンド行プリプロセッサによって展開されたコマンド行引数にアクセスします。

1.4.15.1 `getarg`: コマンド行の引数の取得

サブルーチンは、次のように呼び出します。

`call getarg(` `k``,` `arg` `)`
`k`	*`INTEGER4`**	入力	引数の索引 (0 = 最初の引数 = コマンド名)
`arg`	*`character`**`n`	出力	k 番目の引数
`n`	*`INTEGER4`**	引数のサイズ	もっとも長い引数が入るだけの大きさ

1.4.15.2 `iargc`: コマンド行の引数の個数の取得

関数は、次のように呼び出します。

`m` `=` `iargc()`
戻り値	*`INTEGER4`**	出力	コマンド行の引数の個数

例: iargc と getarg: 引数の個数を調べ、各引数を読み取ります。

demo% cat yarg.f
       character argv*10
       INTEGER*4 i, iargc, n
       n = iargc()
       do 1 i = 1, n
         call getarg( i, argv )
 1       write( *, '( i2, 1x, a )' ) i, argv
       end
demo% f95 yarg.f
demo% a.out *.f
1 first.f
2 yarg.f

参照: execve(2)、getenv(3F)

1.4.16 `getc`、`fgetc`: 次の文字の取得

getc と fgetc は、入力ストリームから次の文字を読み取ります。同じ論理装置上では、これらのルーチンの呼び出しを通常の Fortran の入出力と混合して使用しないでください。

1.4.16.1 `getc`: 標準入力からの次の文字の取得

関数は、次のように呼び出します。

INTEGER*4 getc

status = getc( char )

char

character

出力

次の文字

戻り値

INTEGER*4

出力

status=0: 正常

status=-1: ファイルの終了

status>0: システムエラーコードまたは f95 入出力エラーコード

例: getc でキーボードから文字を 1 文字ずつ入力します。 Control-D (^D) に注意してください。

       character char
       INTEGER*4 getc, status
       status = 0
       do while ( status .eq. 0 )
         status = getc( char )
         write(*, '(i3, o4.3)') status, char
       end do
       end

前述のソースプログラムを (コンパイル後に) 実行した例を次に示します。

demo% a.out
ab            プログラムが入力された文字を読み取る
0 141         プログラムが入力された文字の状態コードと 8 進値を出力する
0 142            141 は 'a' を、142 は 'b' を表す
0 012            012 はリターンキーを表す 
^D               Control-D キーで終了された
-1 377        次の読み取りが試行され Control-D が戻された
demo%

どの論理装置に対しても、通常の Fortran の入力と getc() を混在して使用しないでください。

1.4.16.2 `fgetc`: 指定した論理装置からの次の文字の取得

関数は、次のように呼び出します。

*`INTEGER4 fgetc` status `= fgetc(` `lunit``,` `char` `)`**
`lunit`	*`INTEGER4`**	入力	論理装置
`char`	`character`	出力	次の文字
戻り値	*`INTEGER4`**	出力	`status`=-1: ファイルの終了 `status`>0: システムエラーコードまたは `f95` 入出力エラーコード

例: fgetc で tfgetc.data から文字を 1 文字ずつ読み取ります。改行 (8 進の 012) に注意してください。

       character char
       INTEGER*4 fgetc, status
       open( unit=1, file='tfgetc.data' )
       status = 0
       do while ( status .eq. 0 )
          status = fgetc( 1, char )
          write(*, '(i3, o4.3)') status, char
       end do
       end

前述のソースプログラムを (コンパイル後に) 実行した例を次に示します。

demo% cat tfgetc.data
ab
yz
demo% a.out
0 141       'a' が読み取られる
0 142     'b' が読み取られる
0 012       改行が読み取られる
0 171       'y' が読み取られる
0 172      'z' が読み取られる
0 012       改行が読み取られる
-1 012      CONTROL-D が読み取られる
demo%

どの論理装置に対しても、通常の Fortran の入力と fgetc() を混在して使用しないでください。

参照: getc(3S)、intro(2)、および perror(3F)

1.4.17 `getcwd`: 現在の作業ディレクトリのパスの取得

関数は、次のように呼び出します。

INTEGER*4 getcwd

status = getcwd( dirname )

dirname

character*n

出力

現在のディレクトリのパスが返される。

現在のディレクトリのパス名。n は、もっとも長いパス名が入るのに十分な大きさであることが必要

戻り値

INTEGER*4

出力

status=0: 正常

status>0: エラーコード

例: getcwd:

       INTEGER*4 getcwd, status
       character*64 dirname
       status = getcwd( dirname )
       if ( status .ne. 0 ) stop 'getcwd: error'
       write(*,*) dirname
       end

参照: chdir(3F)、perror(3F)、および getwd(3)

注意: パス名は、<sys/param.h> で定義されている MAXPATHLEN より長くすることはできません。

1.4.18 `getenv`: 環境変数の値の取得

サブルーチンは、次のように呼び出します。

`call` `getenv(` `ename``,` `evalue` `)`
`ename`	*`character`**`n`	入力	検索する環境変数の名前
`evalue`	*`character`**`n`	出力	見つかった環境変数の値。見つからなかった場合は空

ename と evalue には、それぞれの文字列が十分入るだけの大きさが必要です。

evalue が小さすぎてすべての文字列を格納できない場合は、文字列は evalue の長さに合わせて切り捨てされます。

getenv サブルーチンは環境リストからename=evalue の形式の文字列を検索し、その文字列があった場合には evalue の値を返し、なかった場合には evalue を空白で埋めます。

例: $SHELL の値を印刷するには、getenv() を使用します。

       character*18  evalue
       call getenv( 'SHELL', evalue )
       write(*,*) "'", evalue, "'"
       end

参照: execve(2) および environ(5)

1.4.19 `getfd`: 外部装置番号に対するファイル記述子の取得

関数は、次のように呼び出します。

INTEGER*4 getfd

fildes = getfd( unitn )

unitn

INTEGER*4

入力

外部装置番号

戻り値

INTEGER*4 または INTEGER*8

出力

ファイルが結合されている場合はファイル記述子、結合されていない場合は -1。64 ビット環境用にコンパイルすると、結果として INTEGER*8 が戻る。

例: getfd():

       INTEGER*4 fildes, getfd, unitn/1/
       open( unitn, file='tgetfd.data' )
       fildes = getfd( unitn )
       if ( fildes .eq. -1 ) stop 'getfd: ファイルは結合されていません'
       write(*,*) 'ファイル記述子 = ', fildes
       end

参照: open(2)

1.4.20 `getfilep`: 外部装置番号に対するファイルポインタの取得

関数は、次のように呼び出します。

irtn `=` `c_read``( getfilep(` `unitn` `),` `inbyte``, 1 )`
`c_read`	C 関数	入力	この C 関数はユーザーが書く。次の例を参照
`unitn`	*`INTEGER4`**	入力	外部装置番号
`getfilep`	*`INTEGER4` または `INTEGER8`*	戻り値	ファイルが結合されている場合はファイルポインタ、結合されていない場合は -1。64 ビット環境用にコンパイルすると、*`INTEGER8`** の値が戻る

この関数は標準 Fortran の入出力と C の入出力を混在させるために使用します。このような混在は移植不可能であり、今後リリースされるオペレーティングシステムまたは Fortran で使用できる保証はありません。したがって、この関数の使用は勧められませんし、直接のインタフェースは提供されていません。ユーザーは getfilep が戻す値を使用するために独自の C ルーチンを作成する必要があります。C ルーチンの例を次に示します。

例: Fortran は C の関数に渡すのに getfilep を使用します。

demo% cat tgetfilepF.f

        character*1  inbyte
        integer*4    c_read,  getfilep, unitn / 5 /
        external     getfilep
        write(*,'(a,$)') '数字は何? '

        irtn = c_read( getfilep( unitn ), inbyte, 1 )

        write(*,9)  inbyte
   9    format('C の読み取った数字は ', a )
        end

getfilep を実際に使用する C 関数の例を次に示します。

demo% cat tgetfilepC.c

#include <stdio.h>
int c_read_ ( fd, buf, nbytes, buf_len )
FILE **fd ;
char *buf ;
int *nbytes, buf_len ;
{
         return fread( buf, 1, *nbytes, *fd ) ;
}

前述のソースプログラムをコンパイル、リンク、実行した例を次に示します。

demo% cc -c tgetfilepC.c
demo% f95 tgetfilepC.o tgetfilepF.f
demo% a.out
数字は何? 3
C の読み取った数字は 3
demo%

詳細については、『Fortran プログラミングガイド』の「C と Fortran のインタフェース」の章を参照してください。参照: open(2)

1.4.21 `getlog`: ユーザーのログイン名の取得

サブルーチンは、次のように呼び出します。

`call` `getlog(` `name` `)`
`name`	*`character`**`n`	出力	ユーザーのログイン名。プロセスが端末から切り離されて実行されている場合はすべて空白。`n` は、もっとも長い名前が入るのに十分な大きさであることが必要

例: getlog:

       character*18 name
       call getlog( name )
       write(*,*) "'", name, "'"
       end

参照: getlogin(3)

1.4.22 `getpid`: プロセス ID の取得

関数は、次のように呼び出します。

INTEGER*4 getpid

pid = getpid()

戻り値

INTEGER*4

出力

現在のプロセスのプロセス ID

例: getpid:

       INTEGER*4 getpid, pid
       pid = getpid()
       write(*,*) 'プロセス ID = ', pid
       end

参照: getpid(2)

1.4.23 `getuid`、`getgid`: プロセスのユーザー ID またはグループ ID の取得

getuid と getgid はそれぞれ、ユーザー ID またはグループ ID を読み取ります。

1.4.23.1 `getuid`: プロセスのユーザー ID の取得

関数は、次のように呼び出します。

INTEGER*4 getuid

uid = getuid()

戻り値

INTEGER*4

出力

プロセスのユーザー識別子 (ID)

1.4.23.2 `getgid`: プロセスのグループ ID の取得

関数は、次のように呼び出します。

INTEGER*4 getgid

gid = getgid()

戻り値

INTEGER*4

出力

プロセスのグループ識別子 (ID)

例: getuid() と getpid():

       INTEGER*4 getuid, getgid, gid, uid
       uid = getuid()
       gid = getgid()
       write(*,*) uid, gid
       end

参照: getuid(2).

1.4.24 `hostnm`: 現在のホスト名の取得

関数は、次のように呼び出します。

INTEGER*4 hostnm

status = hostnm( name )

name

character*n

出力

現在のホストの名前。n は、ホスト名が入るのに十分な大きさであることが必要

戻り値

INTEGER*4

出力

status=0: 正常

status>0: エラー

例: hostnm():

      INTEGER*4 hostnm, status
      character*8 name
      status = hostnm( name )
      write(*,*) 'ホスト名 = "', name, '"'
      end

参照: gethostname(2)

1.4.25 `idate`: 現在の日付を戻す

idate は、現在のシステム日付を 1 つの整数配列に日、月、年の順で入れます。

サブルーチンは、次のように呼び出します。

`call` `idate(` `iarray` `)` Standard Version
`iarray`	*`INTEGER4`**	出力	3 要素数の配列。日、月、年

例: idate (標準バージョン):

demo% cat tidate.f
       INTEGER*4 iarray(3)
       call idate( iarray )
       write(*, "(' 日付は: ',3i5)" )  iarray
       end
demo% f95 tidate.f
demo% a.out
 The date is: 10 8 1998
demo%

1.4.26 `ieee_flags、ieee_handler、sigfpe`: IEEE 算術演算

これらの副プログラムは、Fortran プログラムで ANSI/IEEE 規格 754-1985 の算術演算機能を十分に利用するために必要なモードと状態を提供します。これらの副プログラムは関数 ieee_flags(3M)、ieee_handler(3M)、および sigfpe(3) と密接に対応しています。

次に要約を示します。

表 1–5 IEEE 算術演算サポートルーチン


`ieeer = ieee_flags(` `action``,``mode``,``in``,``out` `)` `ieeer = ieee_handler(``action``,``exception``,``hdl` `)` `ieeer = sigfpe(` `code``,` `hdl` `)`
`action`	`character`	入力
`code`	`sigfpe_code_type`	入力
`mode`	`character`	入力
`in`	`character`	入力
`exception`	`character`	入力
`hdl`	`sigfpe_handler_type`	入力
`out`	`character`	出力
戻り値	*`INTEGER4`**	出力

これらの関数を効果的に使用する方法については、『数値計算ガイド』を参照してください。

sigfpe を使用する場合、浮動小数点状態レジスタ内の対応するトラップ可能マスクビットをユーザーが設定する必要があります。詳細は『SPARC アーキテクチャーマニュアルバージョン 8』(トッパン刊) で説明されています。libm 関数の ieee_handler を呼び出すと、トラップ可能マスクビットが自動的に設定されます。

mode と exception が受け付ける文字型のキーワードは、action の値によって異なります。

表 1–6 ieee_flags( action , mode , in , out) パラメータと動作


`action` = `’clearall’`	`mode`、`in`、`out` は未使用。戻り値は 0
`action` = `’clear’` clear `mode`, `in` `out` は未使用。戻り値は 0	`mode` = `’direction’`
	`mode` = `’exception’`	`in` = `’inexact’` `’division’` `’underflow’` `’overflow’` `’invalid’` `’all’` `’common’` のいずれか
`action` = `’set’` 浮動小数点の `mode` と `in` を設定する `out` は未使用。戻り値は 0	`mode` = `’direction’`	`in` = `’nearest’` `’tozero’` `’positive’` `’negative’` のいずれか
	`mode` = `’exception’`	`in` = `’inexact’` `’division’` `’underflow’` `’overflow’` `’invalid’` `’all’` `’common’` のいずれか
`action` = `’get’` `mode` の設定値を調査する in、out は、空白にするか、テスト対象の設定値の 1 つを設定する。in、out に設定値を設定すると、`mode` の設定値に従った現在の設定値または '`not available`' (無効) が戻る。関数は 0 を戻す。ただし、`mode` = '`exception`' の場合は、現在の例外フラグを戻す。	`mode` =`’direction’`	`out` = `’nearest’` `’tozero’` `’positive’` `’negative’` のいずれか
	`mode` =`’exception’`	`out` = `’inexact’` `’division’` `’underflow’` `’overflow’` `’invalid’` `’all’` `’common’` のいずれか

表 1–7 ieee_handler( action , in , out) パラメータ


action = `’clear’` in に指定したユーザー例外処理をクリアする。 out は未使用	`in` = `’inexact’` `’division’` `’underflow’` `’overflow’` `’invalid’` `’all’` `’common’` のいずれか
action = `’set’` in にユーザー例外処理を設定する。out は、ルーチンのアドレスまたは `floating point.h` に定義されている `SIGFPE_DEFAULT`、`SIGFPE_ABORT`、または `SIGFPE_IGNORE`。	`in` = `’inexact’` `’division’` `’underflow’` `’overflow’` `’invalid’` `’all’` `’common’` のいずれか

例 1: (ハードウェアが方向をもつ丸めモードをサポートしていない場合を除いて) 丸め方向をゼロの方向に設定します。

    INTEGER*4 ieeer
    character*1 mode, out, in
    ieeer = ieee_flags( 'set', 'direction', 'tozero', out )

例 2: 丸め方向をクリアします (デフォルトの方向、つまり四捨五入して丸めます)。

    character*1 out, in
    ieeer = ieee_flags('clear','direction', in, out )

例 3: 設定されている例外発生ビットをすべてクリアします。

    character*18 out
    ieeer = ieee_flags( 'clear', 'exception', 'all', out )

例 4: 例 3 でオーバーフロー例外が発生すると、次のように検出します。

    character*18 out
    ieeer = ieee_flags( 'get', 'exception', 'overflow', out )
    if (out .eq. 'overflow' ) stop 'overflow'

前述の例は、out を overflow に、ieeer を 25 に設定しています。ieeer の値は、プラットフォームによって異なります。同様にコーディングすれば、invalid や inexact のような例外を検出できます。

例 5: hand1.f の内容。シグナルハンドラを書き込み、使用しています。

       external hand
       real r / 14.2 /,  s / 0.0 /
       i = ieee_handler( 'set', 'division', hand )
       t = r/s
       end

       INTEGER*4 function hand ( sig, sip, uap )
       INTEGER*4 sig, address
       structure /fault/
           INTEGER*4 address
       end structure
       structure /siginfo/
           INTEGER*4 si_signo
           INTEGER*4 si_code
           INTEGER*4 si_errno
           record /fault/ fault
       end structure
       record /siginfo/ sip
       address = sip.fault.address
       write (*,10) address
 10    format('例外の起きたアドレス (16進) ', z8 )
       end

address と function hand の宣言を INTEGER*8 に変更すると、64 ビットの SPARC 環境 (-m64) で例 5 が実行できます。

『数値計算ガイド』を参照してください。参照: floatingpoint(3)、signal(3)、sigfpe(3)、floatingpoint(3F)、ieee_flags(3M)、および ieee_handler(3M)

1.4.26.1 `floatingpoint.h`: Fortran IEEE 定義

ヘッダーファイル floatingpoint.h は、ANSI/IEEE 規格 754-1985 に従って、標準浮動小数点の実装に使用される定数と型を定義します。

このファイルの Fortran 95 ソースプログラムへのインクルードは、次のように行います。

#include "floatingpoint.h"

このインクルードファイルを使用するには、Fortran のコンパイル前に前処理が必要になります。このインクルードファイルを参照するソースファイルは、名前の拡張子が F、F90、または F95 の場合に、自動的に前処理が行われます。

IEEE 丸めモード

fp_direction_type

IEEE 丸め方向モードの型。列挙の順序はハードウェアにより異なるので注意すること

SIGFPE 処理

`sigfpe_code_type`	`SIGFPE` コードの型
`sigfpe_handler_type`	ユーザー定義の `SIGFPE` 例外ハンドラの型。特定の `SIGFPE` コードを処理するために呼び出される。
`SIGFPE_DEFAULT`	デフォルトの `SIGFPE` 例外処理を指示するマクロ。IEEE 例外。デフォルトの結果で実行を継続させ、ほかの `SIGFPE` コードに対しては実行を異常終了させる。
`SIGFPE_IGNORE`	代替 `SIGFPE` 例外処理を指示するマクロ。無視して実行を継続させる。
`SIGFPE_ABORT`	代替 `SIGFPE` 例外処理を指示するマクロ。コアダンプを取り、実行を異常終了させる。

IEEE 例外処理

`N_IEEE_EXCEPTION`	IEEE 浮動小数点例外の数
`fp_exception_type`	`N_IEEE_EXCEPTION` 個の例外の型。各例外はビット番号を与えられる。
`fp_exception_field_type`	`fp_exception_type` により番号が与えられた IEEE 例外に対応する `N_IEEE_EXCEPTION` 個以上のビットをとることを目的とした型です。たとえば `fp_inexact` は最下位ビットに対応し、`fp_invalid` は最下位から 5 番目のビットに対応する。操作によっては 2 つ以上の例外を設定できる。

IEEE クラス分類

fp_class_type

IEEE 浮動小数点の値と記号のクラスの並び

『数値計算ガイド』を参照してください。参照: ieee_environment(3F)

1.4.27 `index、rindex、lnblnk`: 部分列のインデックスまたは長さ

これらの関数は、次のように文字列による探索を行います。

`index(``a1``,``a2``)`	文字列 `a1` の中で最初に出現する文字列 `a2` のインデックス
`rindex(``a1``,``a2``)`	文字列 `a1` の中で最後に出現する文字列 `a2` のインデックス
`lnblnk(``a1``)`	文字列 `a1` の中の空白以外の最後の文字のインデックス

index は次の形式をとります。

1.4.27.1 `index`: 文字列の中で最初に出現する部分列

index は、組み込み関数で次のように呼び出します。

`n` `= index(` `a1``,` `a2` `)`
`a1`	`character`	入力	文字列
`a2`	`character`	入力	部分列
戻り値	`INTEGER`	出力	`n`>0: `a1` の中で最初に出現する `a2` のインデックス `n`=0: `a1` の中に `a2` が出現しない

INTEGER*8 と宣言されている場合は、64 ビット環境用にコンパイルされ、さらに文字変数 a1 が非常に大きな文字列であるときに (2 G バイトを超えるもの)、index() は INTEGER*8 値を戻します。

1.4.27.2 `rindex`: 文字列の中で最後に出現する部分列

関数は、次のように呼び出します。

*`INTEGER4 rindex` n `= rindex(` `a1``,` `a2` `)`**
`a1`	`character`	入力	文字列
`a2`	`character`	入力	部分列
戻り値	*`INTEGER4` または `INTEGER8`*	出力	`n`>0: `a1` の中で最後に出現する `a2` のインデックス `n`=0: `a1` の中に `a2` が出現しない。64 ビット環境の場合は、*`INTEGER8`** が戻る。

1.4.27.3 `lnblnk`: 文字列の中の空白以外の最後の文字

関数は、次のように呼び出します。

n = lnblnk( a1 )

a1

character

入力

文字列

戻り値

INTEGER*4 または INTEGER*8

出力

n>0: a1 の中の空白以外の最後の文字のインデックス

n=0: a1 はすべて空白以外の文字。64 ビット環境の場合は、INTEGER*8 が戻る。

例: index()、rindex()、lnblnk():

demo% cat tindex.f
*                        123456789012345678901
       character s*24 / 'abcPDQxyz...abcPDQxyz' /
       INTEGER*4 declen, index, first, last, len, lnblnk, rindex
       declen = len( s )
       first = index( s, 'abc' )
       last = rindex( s, 'abc' )
       lastnb = lnblnk( s )
       write(*,*) declen, lastnb
       write(*,*) first, last
       end
demo% f95 tindex.f
demo% a.out
24 21     <- 組み込み関数 len() が宣言された s の長さを返すため、declen は 24
 1 13

注 –

64 ビット環境で動作するようコンパイルされたプログラムは、非常に大きな文字列を処理するには index、rindex 、および lnblnk (および返される変数) INTEGER*8 を宣言します。

1.4.28 `inmax`: 正の整数の最大値の返却

関数は、次のように呼び出します。

`m` `= inmax()`
戻り値	*`INTEGER4`**	出力	正の整数の最大値

例: inmax:

demo% cat tinmax.f
       INTEGER*4 inmax, m
       m = inmax()
       write(*,*) m
       end
demo% f95 tinmax.f
demo% a.out
   2147483647
demo%

参照: libm_single(3F) および libm_double(3F)、第 3 章で記述されている非標準 FORTRAN 77 組み込み関数 ephuge()。

1.4.29 `itime`: 現在の時刻

itime は、現在のシステム時刻の時、分、秒を整数配列に入れます。サブルーチンは、次のように呼び出します。

call itime( iarray )

iarray

INTEGER*4

出力

3 要素の配列:

iarray(1) = 時

iarray(2) = 分

iarray(3) = 秒

例: itime:

demo% cat titime.f
       INTEGER*4 iarray(3)
       call itime( iarray )
       write (*, "(' 時刻は: ',3i5)" )  iarray
       end
demo% f95 titime.f
demo% a.out
 時刻は: 15 42 35

参照: time(3F)、ctime(3F)、fdate(3F)

1.4.30 `kill`: プロセスへのシグナルの送信

関数は、次のように呼び出します。

`status` `= kill(` `pid``,` `signum` `)`
`pid`	*`INTEGER4`**	入力	ユーザーのプロセスのプロセス ID
`signum`	*`INTEGER4`**	入力	有効なシグナル番号。signal(3) を参照。
戻り値	*`INTEGER4`**	出力	`status`=0: 正常 `status`>0: エラーコード

例 (該当部分のみ): kill() を使用してメッセージを送ります。

       INTEGER*4 kill, pid, signum
*    …
       status = kill( pid, signum )
       if ( status .ne. 0 ) stop 'kill: error'
       write(*,*) 'シグナル', signum, ' をプロセス', pid,' に送付しました'
       end

関数は、signum という整数型の番号で表わされるシグナルを pid というプロセスに送ります。有効なシグナル番号は、/usr/include/sys/signal.h という C 言語のインクルードファイル中にリストされています。

参照: kill(2)、signal(3)、signal(3F)、fork(3F)、および perror(3F)

1.4.31 `link`、`symlnk`: 既存ファイルへのリンクの作成

link は既存ファイルへのリンクを作成します。symlink は既存ファイルへのシンボリックリンクを作成します。

関数は、次のように呼び出します。

status `= link(` `name1``,` `name2` `)`
*`INTEGER4 symlnk` `status` `= symlnk(` `name1``,` `name2` `)`**
`name1`	*`character`**`n`	入力	既存ファイルのパス名
`name2`	*`character`**`n`	入力	ファイル `name1` にリンクさせるパス名。ファイル `name2` は、既存ファイルであってはならない。
戻り値	*`INTEGER4`**	出力	`status`=0: 正常 `status`>0: システムエラーコード

1.4.31.1 `link:` 既存ファイルへのリンクの作成

例 1: link: ファイル tlink.db.data.1 に対して、data1 という名前のリンクを作成します。

demo% cat tlink.f
        character*34 name1/'tlink.db.data.1'/, name2/'data1'/
        integer*4 link, status
        status = link( name1, name2 )
        if ( status .ne. 0 ) stop 'link: error'
        end
demo% f95 tlink.f
demo% ls -l data1
data1 : ファイルもディレクトリもありません
demo% a.out
demo% ls -l data1
-rw-rw-r-- 2 generic 2 8 月 11 日 08:50 data1
demo%

1.4.31.2 `symlnk:` 既存ファイルへのシンボリックリンクの作成

例 2: symlnk: ファイル tlink.db.data.1 に対して、data1 という名前のシンボリックリンクを作成します。

demo% cat tsymlnk.f
       character*34 name1/'tlink.db.data.1'/, name2/'data1'/
       INTEGER*4 status, symlnk
       status = symlnk( name1, name2 )
       if ( status .ne. 0 ) stop 'symlnk: error'
       end
demo% f95 tsymlnk.f
demo% ls -l data1
data1 : ファイルもディレクトリもありません
demo% a.out
demo% ls -l data1
lrwxrwxrwx 1 generic 15 8 月 11 日 11:09 data1 -> tlink.db.data.1
demo%

参照: link(2)、symlink(2)、perror(3F)、および unlink(3F)

注意: パス名は、<sys/param.h> で定義されている MAXPATHLEN より長くすることはできません。

1.4.32 `loc`: オブジェクトのアドレスを戻す

この組み込み関数は、次のように呼び出します。

`k` `= loc(` arg `)`
`arg`	任意の型	入力	任意の変数、配列、または構造体の名前
戻り値	*`INTEGER4` または `INTEGER8`*	出力	`arg` のアドレス
	`-m64` を使って、64 ビット環境で動作するようにコンパイルした場合は、*`INTEGER8`** ポインタが戻る。次に示す注を参照。

例: loc:

       INTEGER*4 k, loc
       real arg / 9.0 /
       k = loc( arg )
       write(*,*) k
       end

注 –

64 ビット環境で動作するようコンパイルされたプログラムは、loc() 関数から出力を受け取る変数を INTEGER*8 と宣言します。

1.4.33 `long`、`short`: 整数オブジェクトの変換

long および short は INTEGER*4 と INTEGER*2 間で整数オブジェクトの変換を行います。この変換は、サブプログラム呼び出しリストでは特に有効です。

1.4.33.1 `long`: 短整数 (INTEGER2) から長整数 (INTEGER4) への変換

関数は、次のように呼び出します。

`call` `長整数をとるサブルーチン``( long(``int2``) )`
`int2`	*`INTEGER2`**	入力
戻り値	*`INTEGER4`**	出力

1.4.33.2 `short`: 長整数から短整数への変換

関数は、次のように呼び出します。

INTEGER*2 short

call 短整数をとるサブルーチン( short(int4) )

int4

INTEGER*4

入力

戻り値

INTEGER*2

出力

例 (該当部分のみ): long() と short()

       integer*4 int4/8/, long
       integer*2 int2/8/, short
       call ExpecLong( long(int2) )
       call ExpecShort( short(int4) )
       …
       end

ExpecLong はユーザープログラムによって呼び出されるサブルーチンで、長整数 (INTEGER*4) の引数をとります。ExpecShort は短整数 (INTEGER*2) の引数をとります。

long はライブラリルーチンの呼び出しに定数が使用され、-i2 オプションを指定してコードをコンパイルする場合に役立ちます。

short は、長い型のオブジェクトを短い型の整数として渡す必要がある場合に役立ちます。短い型に渡す整数が大きすぎた場合、エラーは発生しませんが、プログラムが予期しない動きをします。

1.4.34 `longjmp`、`isetjmp`: `isetjmp` で設定した位置に戻す

isetjmp は longjmp の位置を設定します。longjmp は isetjmp で設定した位置に戻ります。

1.4.34.1 `isetjmp`: `longjmp` の位置の設定

この組み込み関数は、次のように呼び出します。

ival = isetjmp( env )

env

INTEGER*4

出力

env は 12 要素の整数配列。64 ビット環境では、INTEGER*8 で宣言する必要がある

戻り値

INTEGER*4

出力

ival = 0、isetjmp が明示的に呼び出された場合

ival ≠ 0、isetjmp が longjmp から呼び出された場合

1.4.34.2 `longjmp`: `isetjmp` で設定した位置に戻す

サブルーチンは、次のように呼び出します。

call longjmp( env, ival )

env

INTEGER*4

入力

env は isetjmp で初期化された 12 語の整数配列。64 ビット環境では、INTEGER*8 で宣言する必要がある

ival

INTEGER*4

出力

ival = 0、isetjmp が明示的に呼び出された場合

ival ≠ 0、isetjmp が longjmp から呼び出された場合

説明

isetjmp と longjmp ルーチンは、プログラムの低レベルルーチンで遭遇するエラーや障害を処置するために使用します。この 2 つは、f95 の組み込み関数です。

これらのルーチンは、最後の手段としてのみ使用してください。これらの取り扱いには、十分注意してください。また、移植性はありません。バグやその他の詳細については、setjmp(3V) のマニュアルページを参照してください。

isetjmp は env にスタック環境を保存します。またレジスタ環境も保存します。

longjmp は、最後に isetjmp を呼び出して保存した環境を復元し、あたかも isetjmp の呼び出しが値 ival を返したかのように戻り、実行を継続します。

isetjmp から返された整数式 ival は、longjmp が呼び出されなければゼロです。longjmp が呼び出されれば、ゼロ以外になります。

例: isetjmp と longjmp を使用したコード部分

       INTEGER*4  env(12)
       common /jmpblk/ env
       j = isetjmp( env )
       if ( j .eq. 0 ) then
               call  sbrtnA
           else
          call error_processor
       end if
       end
       subroutine sbrtnA
       INTEGER*4  env(12)
       common /jmpblk/ env
       call longjmp( env, ival )
       return
       end

制限

longjmp を呼び出す前に isetjmp を起動します。
isetjmp と longjmp で使用される整数型の配列引数 env は、最低 12 個の要素からなる配列にします。
isetjmp を呼び出すルーチンから longjmp を呼び出すルーチンへ、共通ブロック経由であるいは引数として env 変数を渡します。
longjmp はスタックをクリーンアップしようとします。longjmp は isetjmp よりも低レベルのルーチンから呼び出します。
手続き名の引数として isetjmp を渡しても作用しません。

参照: setjmp(3V)

1.4.35 `malloc`、`malloc64`、 `realloc`、`free`: 記憶領域の割り当て/再割り当て/割り当て解除

malloc()、malloc64()、および realloc() 関数は、記憶領域のブロックを割り当て、ブロックの開始アドレスを戻します。戻り値は INTEGER や Cray-style の POINTER 変数の設定に使用できます。realloc() は既存の記憶領域ブロックを新しいサイズで再割り当てします。free() は malloc()、malloc64()、または realloc() により割り当てられた記憶領域ブロックの割り当てを解除します。

注 –

これらのルーチンは、f95 の組み込み関数として実装されていますが、f77 の外部関数でした。独自のバージョンのものを使う場合を除き、Fortran 95 プログラムの型宣言や EXTERNAL 文で使用すべきではありません。realloc() ルーチンは f95 のみに実装されています。

Fortran 95 規格合致プログラムは、ALLOCATE および DEALLOCATE 文を割り当て可能な配列に使用して、動的メモリー管理を実行しますが、malloc/realloc/free への直接呼び出しは行いません。

従来の FORTRAN 77 プログラムは malloc()/malloc64() を使用して、INTEGER 変数として同じデータ表現を持つ Cray-style の POINTER 変数に値を代入できました。Cray-style の POINTER 変数は f95 に実装され、FORTRAN 77 からの可搬性をサポートします。

1.4.35.1 記憶領域の割り当て: `malloc`、 `malloc64`

malloc() 関数は、次のように呼び出します。

`k` `= malloc(` `n` `)`
`n`	`INTEGER`	入力	記憶領域のバイト数
戻り値	`INTEGER``(Cray` `POINTER``)`	出力	`k`>0: `k` は割り当てられた記憶領域の開始アドレス `k`=0: エラー
	`-m64` を使って、64 ビット環境用にコンパイルした場合は、*`INTEGER8`** ポインタ値が戻る。次に示す注を参照。

注 –

この関数は、Fortran 95 では組み込み関数ですが、FORTRAN 77 では外部関数でした。64 ビット環境で動作するようにコンパイルされたプログラムでは、malloc() 関数とその出力を受け取る変数を INTEGER*8 と宣言する必要があります。関数 malloc64(3F) は、プログラムを 32 ビット環境と 64 ビット環境間で可搬性を持たせるために提供された関数です。

k = malloc64( n )

n

INTEGER*8

入力

記憶領域のバイト数

戻り値

INTEGER*8

(Cray POINTER)

出力

k>0: k は割り当てられた記憶領域の開始アドレス

k=0: エラー

これらの関数は、記憶領域を割り当て、その領域の開始アドレスを返します。64 ビット環境では、この返されたバイトアドレスは、INTEGER*4 の数値範囲外になる可能性があります。受け取り側の変数では INTEGER*8 と宣言し、メモリーアドレスが切り捨てられないようにする必要があります。この記憶領域は、初期化できません。そのため記憶領域が、ある値、特にゼロに事前設定されていることを前提としないでください。

例: malloc() を使用したコード部分

       parameter (NX=1000)
       integer ( p2X, X )
       real*4 X(1)
       …
       p2X = malloc( NX*4 )
       if ( p2X .eq. 0 ) stop 'malloc: 割り当て不可'
       do 11 i=1,NX
 11         X(i) = 0.
       …
       end

前述の例では、 p2X で指定される 4,000 バイトのメモリーを獲得し、この領域を 0 に初期化しています。

1.4.35.2 記憶領域の再割り当て: `realloc`

realloc() f95 組み込み関数は、次のように呼び出します。

k `= realloc(``ptr``,` n `)`
`ptr`	`INTEGER`	入力	既存の記憶領域へのポインタ (前述の `malloc()` または `realloc()` 呼び出しからの戻り値)。
n	`INTEGER`	入力	必要とされるブロックの新しいサイズ。バイト単位。
戻り値	`INTEGER` `(Cray` `POINTER``)`	出力	k>0: k は割り当てられた新しい記憶領域の開始アドレス k=0: エラー
	`-m64` を使って、64 ビット環境用にコンパイルした場合は、*`INTEGER8`** ポインタ値が戻る。次に示す注を参照。

realloc() 関数は ptr によって指定される記憶領域のサイズを n バイトに変更し、ポインタを (移動された可能性のある) 新しいブロックに戻します。記憶領域の中身は新規および古いサイズの最小までには変更されません。

ptr が 0 の場合、realloc() は malloc() と同じ処理を行い、新しく n バイトの記憶領域サイズを割り当てます。

n が 0 で ptr が 0 以外の場合、指定された記憶領域のブロックは将来の割り当てに対して有効にされ、アプリケーションが終了した場合のみ、システムに戻されます。

例: malloc() 、realloc()、および Cray-style POINTER 変数を使用した例を示します。

       PARAMETER (nsize=100001)
       POINTER (p2space,space)
       REAL*4 space(1)

       p2space = malloc(4*nsize)
       if(p2space .eq. 0) STOP 'malloc: 割り当てできません'
       ...
       p2space = realloc(p2space, 9*4*nsize)
       if(p2space .eq. 0) STOP 'realloc: 再割り当てできません'
       ...
       CALL free(p2space)
       ...

realloc() は f95 のみに実装されています。

1.4.35.3 `free`: Malloc により割り当てられた記憶領域の割り当て解除

サブルーチンは、次のように呼び出します。

`call free (` `ptr` `)`
`ptr`	`Cray` `POINTER`	入力

free は malloc や realloc() により割り当てられた記憶領域の割り当てを解除します。記憶領域はメモリーマネージャーに戻されます。これでユーザーのプログラムでは使用できなくなります。

例: free():

       real x
       pointer ( ptr, x )
       ptr = malloc ( 10000 )
       call free ( ptr )
       end

1.4.36 `mvbits`: ビットフィールドの移動

サブルーチンは、次のように呼び出します。

`call mvbits(` `src``,` `ini1``,` `nbits``,` `des``,` `ini2` `)`
`src`	*`INTEGER4`**	入力	移動元
`ini1`	*`INTEGER4`**	入力	移動元でのビットの初期位置
`nbits`	*`INTEGER4`**	入力	移動させるビット数
`des`	*`INTEGER4`**	出力	移動先
`ini2`	*`INTEGER4`**	入力	移動先でのビットの初期位置

例: mvbits:

demo% cat mvb1.f
* mvb1.f -- 移動元 src の初期ビット位置 0 から 3 ビットを des の 
*           ビット 3 へ移動
*    src    des
* 543210 543210 <- ビット番号
* 000111 000001 <- 移動前の値
* 000111 111001 <- 移動後の値
       INTEGER*4 src, ini1, nbits, des, ini2
       data src, ini1, nbits, des, ini2
     1    / 7,    0,     3,   1,    3 /
       call mvbits ( src, ini1, nbits, des, ini2 )
       write (*,"(5o3)") src, ini1, nbits, des, ini2
       end
demo% f95 mvb1.f
demo% a.out
  7  0  3 71  3
demo%

次の点に注意してください。

各ビットには、最下位ビットから最上位ビットまで、0 から 31 までの番号が付けられます。
mvbits は des のビット ini2 から ini2+nbits-1 までを変更し、src のビットは変更しません。
制限事項
- ini1 + nbits ≥ 32
- ini2 + nbits≤ 32

1.4.37 `perror`、`gerror`、`ierrno`: エラーメッセージの取得

これらのルーチンは、次の関数を実行します。

`perror`	Fortran 論理装置 0 (`stderr`) へのメッセージの出力
`gerror`	システムエラーメッセージ (最後に検出されたシステムエラー) の読み取り
`ierrno`	最後に検出されたシステムエラーのエラー番号の読み取り

1.4.37.1 `perror`: 論理装置 0 (`stderr`) へのメッセージ出力

サブルーチンは、次のように呼び出します。

`call perror(` `string` `)`
`string`	*`character`**`n`	入力	メッセージ。標準エラーメッセージに先だって出力される。最後に検出されたシステムエラーに対するメッセージ

例 1:

    call perror( "ファイルは書式付き入出力用" )

1.4.37.2 `gerror`: 最後に検出されたシステムエラーの取得

サブルーチンまたは関数は、次のように呼び出します。

`call gerror(` `string` `)`
`string`	*`character`**`n`	出力	最後に検出されたシステムエラーのメッセージ

例 2: gerror() のサブルーチンとしての使用

       character string*30
       …
       call gerror ( string )
       write(*,*) string

例 3: gerror() の関数としての使用 (この場合、string は使用しません)

       character gerror*30, z*30
       …
       z = gerror( )
       write(*,*) z

1.4.37.3 `ierrno`: 最後に検出されたシステムエラーの番号の取得

関数は、次のように呼び出します。

`n` `= ierrno()`
戻り値	*`INTEGER4`**	出力	最後に検出されたシステムエラーの番号

この番号はエラーが実際に起こった時にしか更新されません。このようなエラーを発生させるほとんどのルーチンと入出力文は、呼び出しのあとでエラーコードを返します。その値はエラー条件を引き起こした原因を示す信頼度の高いデータです。

例 4: ierrno():

       INTEGER*4 ierrno, n
       …
       n = ierrno()
       write(*,*) n

参照: intro(2)、perror(3)

注意:

perror を呼び出す際の string は、127 文字を超えてはいけません。
gerror により返される文字列の長さは、それを呼び出すプログラムにより決められます。
f95 の実行時入出力エラーについては、『Fortran ユーザーズガイド』に記載されています。

1.4.38 `putc`、`fputc`: 論理装置への 1 文字出力

putc は論理装置 6 に出力します。通常は制御端末への出力になります。

fputc は任意の論理装置に出力します。

これらの関数は、通常の Fortran 入出力をバイパスして、Fortran 論理装置に関連付けられているファイルに 1 文字を出力します。

同じ装置上では、通常の Fortran 出力とこれらの関数の出力を混在させて使用しないでください。

\n などの特殊な \ エスケープ文字を記述する場合は、-f77=backslash FORTRAN 77 互換オプションをつけてコンパイルする必要があります。

1.4.38.1 `putc`: 論理装置 6 への出力

関数は、次のように呼び出します。

INTEGER*4 putc

status = putc( char )

char

character

入力

装置に出力する文字

戻り値

INTEGER*4

出力

status=0: 正常

status>0: システムエラーコード

例: putc():

demo% cat tputc.f
       character char, s*10 / 'OK by putc' /
       INTEGER*4 putc, status
       do i = 1, 10
        char = s(i:i)
        status = putc( char )
       end do
       status = putc( '\n' )
       end
demo% f95 -f77=backslash tputc.f
demo% a.out
OK by putc
demo%

1.4.38.2 `fputc`: 指定した論理装置への出力

関数は、次のように呼び出します。

*`INTEGER4 fputc` `status` `= fputc(` `lunit``,``char` `)`**
`lunit`	*`INTEGER4`**	入力	出力先装置
`char`	`character`	入力	装置に出力する文字
戻り値	*`INTEGER4`**	出力	`status`=0: 正常 `status`>0: システムエラーコード

例: fputc():

demo% cat tfputc.f
       character char, s*11 / 'OK by fputc' /
       INTEGER*4 fputc, status
       open( 1, file='tfputc.data')
       do i = 1, 11
        char = s(i:i)
        status = fputc( 1, char )
       end do
       status = fputc( 1, '\n' )
       end
demo% f95 -f77=backslash tfputc.f
demo% a.out
demo% cat tfputc.data
OK by fputc
demo%

参照: putc(3S)、intro(2)、および perror(3F)

1.4.39 `qsort、qsort64`: 1 次元配列の要素のソート

サブルーチンは、次のように呼び出します。

`call qsort(` `array``,` `len``,` `isize``,` `compar` `)` `call qsort64(` `array``,` `len8``,` `isize8``,` `compar` `)`
`array`	`array`	入力	ソートする要素が入っている配列
`len`	*`INTEGER4`**	入力	配列内の要素の個数
`len8`	*`INTEGER8`**	入力	配列内の要素の個数
`isize`	*`INTEGER4`**	入力	要素のサイズ : 4= 整数または実数 8= 倍精度または複素数 16= 倍精度複素数文字配列の場合は文字オブジェクトの長さ
`isize8`	*`INTEGER8`**	入力	要素のサイズ : 4_8= 整数または実数 8_8= 倍精度または複素数 16_8= 倍精度複素数文字配列の場合は文字オブジェクトの長さ
`compar`	関数名	入力	ユーザーが提供する *`INTEGER2`** 型の関数の名前。ソート順を決定する: compar(`arg1,arg2`)

64 ビット環境においては、2 G バイトを超える配列には qsort64 を使用します。この場合、INTEGER*8 データとして、配列の長さは len8、要素サイズは isize8 に必ず指定してください。Fortran 95 型の定数を使用して INTEGER*8 定数を明示的に指定します。

compar の引数である arg1 と arg2 は、配列の要素であり、次の結果を返します。

負数	`arg1` は `arg2` の前に置かれると見なされる場合
ゼロ	`arg1` と `arg2` が等しい場合
正数	`arg1` は `arg2` のあとに置かれると見なされる場合

例:

demo% cat tqsort.f
       external compar
       integer*2 compar
       INTEGER*4 array(10)/5,1,9,0,8,7,3,4,6,2/,len/10/,
     1           isize/4/
       call qsort( array, len, isize, compar )
       write(*,'(10i3)') array
       end
       integer*2 function compar( a, b )
       INTEGER*4 a, b
       if ( a .lt. b ) compar = -1
       if ( a .eq. b ) compar = 0
       if ( a .gt. b ) compar = 1
       return
       end
demo% f95 tqsort.f
demo% a.out
  0 1 2 3 4 5 6 7 8 9

1.4.40 `ran`: 0 - 1 間の乱数の生成

反復して ran を呼び出すと、均一した分布で一連の乱数を生成します。lcrans(3m) を参照してください。

`r` = `ran`( `i` )
`i`	*`INTEGER4`**	入力	変数または配列要素
`r`	`REAL`	出力	変数または配列要素

例: ran:

demo% cat ran1.f
* ran1.f -- 乱数を生成する。
       INTEGER*4 i, n
       real r(10)
       i = 760013
       do n = 1, 10
        r(n) = ran ( i )
       end do
       write ( *, "( 5 f11.6 )" ) r
       end
demo% f95 ran1.f
demo% a.out
   0.222058 0.299851 0.390777 0.607055 0.653188
   0.060174 0.149466 0.444353 0.002982 0.976519
demo%

次の点に注意してください。

0.0 は範囲に含まれますが、1.0 は含まれません。
乗算合同型の一般乱数発生アルゴリズムを使用しています。
一般に、i の値は呼び出し元のプログラム実行中に一度だけ設定されます。
i の初期値は大きい奇数の整数でなければなりません。
ran を呼び出すごとに、次の乱数が順に得られます。
プログラムを実行するたびに異なる乱数の列を得るには、実行ごとに引数を異なる初期値に設定しなければなりません。
ran は引数を使用して、下記のアルゴリズムに従い、次の乱数を計算するための値を格納します。

    SEED = 6909 * SEED + 1 (MOD 2**32)

SEED は 32 ビット数値を含み、上位 24 ビットは浮動小数点に変換され、その値が返されます。

1.4.41 `rand`、`drand`、 `irand`: 乱数を戻す

rand は 0.0 から 1.0 の範囲の実数値の乱数を戻します。

drand は 0.0 から 1.0 の範囲の倍精度値の乱数を戻します。

irand は 0 から 2147483647 の範囲の正の整数値の乱数を戻します。

これらの関数は、random(3) を使用して乱数の列を発生させます。これらの 3 つの関数は、同じ 256 バイトの状態配列を共有します。3 つの関数の唯一の利点は、UNIX システムで幅広く利用できることです。乱数を生成するさらに優れた関数としては、lcrans、addrans、および shufrans があります。random(3) および『数値計算ガイド』も参照してください。

`i` = `irand`( `k` ) `r` = `rand`( `k` ) `d` = `drand`( `k` )
`k`	*`INTEGER4`**	入力	`k`=0: 次の乱数を乱数列から取り出す `k`=1: 乱数列を再開し、最初の数を戻す `k`>0: 新しい乱列数の種として使用し、最初の数を戻す
`rand`	*`REAL4`**	出力
`drand`	*`REAL8`**	出力
`irand`	*`INTEGER4`**	出力

例: irand():

demo% cat trand.f
       integer*4 v(5), iflag/0/
       do i = 1, 5
        v(i) = irand( iflag )
       end do
       write(*,*) v
       end
demo% f95 trand.f
demo% a.out
   2078917053 143302914 1027100827 1953210302 755253631
demo%

1.4.42 `rename`: ファイルの名称変更

関数は、次のように呼び出します。

*`INTEGER4 rename`** status = rename( from, to )
from	*`character`**n	入力	既存ファイルのパス名
to	*`character`**n	入力	ファイルの新しいパス名
戻り値	*`INTEGER4`**	出力	status=0: 正常 status>0: システムエラーコード

to で指定されたファイルがすでに存在する場合、from と to はどちらも同じタイプのファイルでなければならず、かつ同じファイルシステムに存在していなければなりません。to がすでに存在する場合、最初にそのファイルが削除されます。

例: rename() - ファイル trename.old の名前を trename.new に変更します。

demo% cat trename.f
       INTEGER*4 rename, status
       character*18 from/'trename.old'/, to/'trename.new'/
       status = rename( from, to )
       if ( status .ne. 0 ) stop 'rename: error'
       end
demo% f95 trename.f
demo% ls trename*
trename.f trename.old
demo% a.out
demo% ls trename*
trename.f trename.new
demo%

参照: rename(2)、perror(3F)

注意: パス名は、<sys/param.h> で定義されている MAXPATHLEN より長くすることはできません。

1.4.43 `secnds`: 秒単位のシステム時間 (マイナス引数) を取得

`t` `= secnds(` `t0` `)`
`t0`	`REAL`	入力	定数、変数、あるいは配列要素
戻り値	`REAL`	出力	午前 0 時からの秒数から `t0` を引いた値

例: secnds:

demo% cat sec1.f
       real elapsed, t0, t1, x, y
       t0 = 0.0
       t1 = secnds( t0 )
       y = 0.1
       do i = 1, 10000
        x = asin( y )
       end do
       elapsed = secnds( t1 )
       write ( *, 1 ) elapsed
  1    format ( ' 10000 arcsines: ', f12.6, ' sec' )
       end
demo% f95 sec1.f
demo% a.out
 10000 arcsines:     0.009064 sec
demo%

次の点に注意してください。

secnds からの戻り値は、0.01 秒の桁まで正確です。
値は午前零時からのシステム秒数で、次の午前零時まで正確です。
日の終り近くのわずかな期間だけ精度がいくらか失われることがあります。

1.4.44 `set_io_err_handler`、`get_io_err_handler`: 入出力エラーハンドラの設定と取得

set_io_err_handler() は、ユーザー定義のルーチンを宣言し、特定の入力論理装置でエラーが検出されたときにそのルーチンを呼び出せるようにします。

get_io_err_handler() は、現在宣言されているエラー処理ルーチンのアドレスを戻します。

これらのルーチンはモジュール化されたサブルーチンで、呼び出し側のルーチンに USE SUN_IO_HANDLERS が示されている場合のみアクセスすることができます。

`USE SUN_IO_HANDLERS` `call set_io_err_handler(``iu, subr_name, istat``)`
`iu`	*`INTEGER8`**	入力	論理装置番号
`subr_name`	`EXTERNAL`	入力	ユーザーが提供するエラーハンドラサブルーチンの名前
`istat`	*`INTEGER4`**	出力	状態を戻す

`USE SUN_IO_HANDLERS` `call get_io_err_handler(``iu, subr_pointer, istat``)`
`iu`	*`INTEGER8`**	入力	論理装置番号
`subr_pointer`	`POINTER`	出力	宣言されているハンドラルーチンのアドレス
`istat`	*`INTEGER4`**	出力	状態を戻す

SET_IO_ERR_HANDLER は、論理装置 iu で入力エラーが発生したときに入出力エラーハンドラとして使用できるようにユーザー定義のサブルーチン subr_name を設定します。iu は、フォーマットされたファイル用に接続された Fortran 論理装置である必要があります。エラーの場合は istat に 0 以外の値が設定され、エラー以外の場合は 0 が設定されます。

たとえば、論理装置 iu をオープンする前に SET_IO_ERR_HANDLER を呼び出すと、istat には 1001 ("不正な装置") が設定されます。subr_name に何も指定しない場合は、ユーザーのエラー処理がオフになり、プログラムは Fortran のデフォルトエラー処理に戻ります。

対象の論理装置のエラーハンドラとして現在使用されている関数のアドレスを取得するには、GET_IO_ERR_HANDLER を使用します。たとえば、ほかのハンドラルーチンに切り替える前に現在の入出力を保存するには、GET_IO_ERR_HANDLER を呼び出します。エラーハンドラはあとで、保存されていた値まで戻ることができます。

subr_name は、特定の論理装置 iu で入出力エラーを処理するためのユーザー定義ルーチンの名前です。実行時入出力ライブラリは、関連するすべての情報を subr_name へ渡し、ルーチンで問題点を診断し、可能であれば問題を修正してから処理を続行します。

ユーザー定義のエラーハンドラルーチンに対するインタフェースは次のとおりです。

`SUBROUTINE SUB_NAME(UNIT, SRC_FILE, SRC_LINE, DATA_FILE, FILE_POS,` `CURR_BUFF, CURR_ITEM, CORR_CHAR, CORR_ACTION )` `INTENT (IN) UNIT, SRC_FILE, SRC_LINE, DATA_FILE` `INTENT (IN) FILE_POS, CURR_BUFF, CURR_ITEM` `INTENT (OUT) CORR_CHAR, CORR_ACTION`
`UNIT`	*`INTEGER8`**	入力	エラーが検出された入力ファイルの論理装置番号
`SRC_FILE`	*`CHARACTER()`*	入力	入力操作を行なった、Fortran のソースファイル名
`SRC_LINE`	*`INTEGER8`**	入力	`SRC_FILE` で入力操作のエラーが検出された行番号
`DATA_FILE`	*`CHARACTER()`*	入力	読み取り中のデータファルの名前。このパラメータは、ファイルが、オープンされた外部ファイルの場合のみ使用できる。名前が無効 (論理装置 5 など) の場合は、 `DATA_FILE` に長さゼロの文字データ項目が設定される。
`FILE_POS`	*`INTEGER8`**	入力	入力ファイルの現在の位置 (バイト)。`DATA_FILE` の名前がわかっている場合のみ定義される。
`CURR_BUFF`	*`CHARACTER()`*	入力	入力レコードの残りのデータが含まれている文字列。文字列の先頭が不正な文字となっている。
`CURR_ITEM`	*`INTEGER8`**	入力	読み取られたレコードの入力項目数 (エラーが検出された場合の項目数も含む)。例: `READ(12,10)L,(ARR(I),I=1,L)` `CURR_ITEM` の値が 15 の場合は、 `ARR` の 14 番目の要素の読み取り中にエラーが発生したことを表す。`L` は最初の項目、`ARR(1)` は 2 番目の項目、のように順次に表す。
`CORR_CHAR`	`CHARACTER`	出力	ハンドラが返すように指定された、ユーザー定義の正しい文字。この値は、`CORR_ACTION` がゼロ以外の場合のみ使用する。`CORR_CHAR` が不正な文字の場合は、正しい文字が返されるまでハンドラが繰り返し呼び出される。これにより無限ループが発生する可能性があるが、無限ループにならないように注意する必要がある。
`CORR_ACTION`	`INTEGER`	出力	入出力ライブラリで行う修正措置を指定する。値がゼロの場合は特別な処理は不要で、ライブラリはデフォルトのエラー処理に戻る。値が 1 の場合は、入出力エラー処理ルーチンに `CORR_CHAR` を戻す。

1.4.44.1 制限事項

入出力ハンドラでできる処理は、1 文字をほかの文字に置き換えることだけです。1 文字を複数の文字に置き換えることはできません。

エラーリカバリのアルゴリズムでは、読み取り中の不正な文字を置き換えることのみ可能で、別のコンテキストですでに不正な文字として読み取られた文字を置き換えることはできません。たとえば、並びによる読み取りで、正しい入力が "1.2345 9.8765" である場合に入力が "1.234509.8765" であると、これは有効な数字でないため、入出力ライブラリは 2 つめのピリオドでエラーになります。ただし、その時点までは、後ろに戻って '0' を空白に戻すことはできません。

現在は、このエラー処理の機能は、namelist のとおりに読み取った入力に対しては機能していません。namelist のとおりに読み取った入力を処理している場合は、エラーが発生しても、指定した入出力エラーハンドラは呼び出されません。

入出力エラーハンドラは、(内部ファイルではなく) 外部ファイルに対してのみ設定されます。これは、内部ファイルには、関連付けられる論理装置がないためです。

入出力エラーハンドラは、構文エラーに対してのみ呼び出されます。システムエラーやセマンティックエラー (入力値のオーバーフローなど) では呼び出されません。

ユーザー定義の入出力エラーハンドラが、入出力ライブラリに不正な文字を渡すようになっている場合は、ユーザー定義の入出力エラーハンドラを繰り返し呼び出すことになり、無限ループが発生することがあります。ファイルの同じ位置でエラーが発生する場合、エラーハンドラは終了するべきです。このようにするには、CORR_ACTION をゼロに設定する方法があります。このようにすると、入出力ライブラリは通常のエラー処理を続行します。

1.4.45 `sh`: `sh` コマンドの高速実行

関数は、次のように呼び出します。

INTEGER*4 sh

status = sh( string )

string

character*n

入力

実行するコマンドを含んだ文字列

戻り値

INTEGER*4

出力

実行されたシェルの終了状態。この値の説明については wait(2) を参照。

例: sh():

       character*18 string / 'ls > MyOwnFile.names' /
       INTEGER*4 status, sh
       status = sh( string )
       if ( status .ne. 0 ) stop 'sh: error'
       ...
       end

関数 sh は、あたかも文字列がコマンドとしてキー入力されたかのように、sh シェルに string を渡します。

現プロセスはコマンドが終了するまで待機します。

関数 sh(3f) と system(3f) は引数の文字列を実行用のシェルへ渡します。引数の文字列を Fortran 文字の値から C 文字列の値に変換し、それを C ルーチン system(3c) へ渡します。ルーチン sh(3f) と system(3f) との相違点は、system は C ルーチン system を呼び出す前に Fortran 入出力バッファーをフラッシュするのに対し、sh はこれを行いません。バッファーのフラッシュにはかなり時間がかかるため、Fortran 出力が呼び出し結果と無関係な場合は、ルーチン system より、ルーチン sh を選択してください。

sh() はマルチスレッド対応ではありません。マルチスレッドプログラム、または並列プログラムからは呼び出さないでください。

参照: execve(2)、wait(2)、system(3c)

注意: string の長さは 1,024 文字を超えることができません。

1.4.46 `signal`: シグナルに対する動作の変更

関数は、次のように呼び出します。

*`INTEGER4 signal` または `INTEGER8 signal`* `n` `= signal(` `signum``,` `proc``,` `flag` `)`
`signum`	*`INTEGER4`**	入力	シグナル番号。`signal`(3) を参照
`proc`	ルーチン名	入力	ユーザーが作成したシグナル処理ルーチンの名前 (EXTERNAL 文で指定する必要がある)
`flag`	*`INTEGER4`**	入力	`flag` < 0: `proc` をシグナル処理として使用する。 `flag` ≥ 0: `proc` を無視する。`flag` を動作の定義として渡す `flag` `= 0`: デフォルトの動作を使用する。 `flag` = 1: このシグナルを無効にする。
戻り値	*`INTEGER4`**	出力	`n`=-1: システムエラー `n`>0: 変更前の動作の定義 `n`>1: `n` は呼び出されたルーチンのアドレス `n`<-1: `signum` が正しいシグナル番号の場合: n は呼び出されたルーチンのアドレス`signum` が正しいシグナル番号でない場合: n はエラー番号
	*`INTEGER8`**		64 ビット環境では、`signal` とその出力を受け取る変数は、*`INTEGER8`** と宣言する必要がある

proc が呼び出される場合、シグナル番号が整数の引数として渡されます。

プロセスがシグナルを受信した場合のデフォルトの動作は、通常はプロセスの終了処理と異常終了です。シグナル処理ルーチンは、特殊な処理を行うために特定の例外やインタラプトを得ることができます。

この関数の戻り値をあとで signal を呼び出す時に使用して、処理の定義を変更前に戻すことができます。

エラーがなくても負数の戻り値が返されることがあるので注意してください。有効なシグナル番号を signal() に渡して、戻り値が -1 未満であった場合は問題ありません。

floatingpoint.h では、SIGFPE_DEFAULT、 SIGFPE_IGNORE、および SIGFPE_ABORT という proc 値を定義しています。「1.4.26.1 floatingpoint.h: Fortran IEEE 定義」を参照してください。

64 ビット環境では、signal は、その出力を受け取る変数とともに INTEGER*8 と宣言し、返される可能性のあるアドレスが切り捨てられるのを防ぐ必要があります。

参照: kill(1)、signal(3)、kill(3F)、『数値計算ガイド』

1.4.47 `sleep`: 一定時間の実行中断

サブルーチンは、次のように呼び出します。

`call sleep(` `itime` `)`
`itime`	*`INTEGER4`**	入力	スリープする秒数

システム時間記録が粗いので、実際の時間は itime よりも最大で 1 秒短くなることがあります。

例: sleep():

       INTEGER*4 time / 5 /
       write(*,*) '開始'
       call sleep( time )
       write(*,*) '終了'
       end

参照: sleep(3)

1.4.48 `stat`、`lstat`、 `fstat`: ファイルの状態の取得

これらの関数が戻す情報は次のとおりです。

デバイス
i ノード番号
保護
ハードリンクの数
ユーザー ID
グループ ID
デバイスタイプ
サイズ
アクセス時刻
更新時刻
状態変更時刻
最適ブロックサイズ
割り当てられているブロック

stat と lstat は、どちらもファイル名を用いて問い合わせをします。fstat は論理装置を用いて問い合わせをします。

1.4.48.1 `stat`: ファイル名によるファイルの状態の取得

関数は、次のように呼び出します。

*`INTEGER4 stat` `ierr` `= stat (` `name``,` `statb` `)`**
`name`	*`character`**`n`	入力	ファイルの名前
`statb`	*`INTEGER4`**	出力	ファイル状態の情報が格納される要素数 13 の配列
戻り値	*`INTEGER4`**	出力	`ierr`=0: 正常 `ierr`>0: エラーコード

例 1: stat():

       character name*18 /'MyFile'/
       INTEGER*4 ierr, stat, lunit/1/, statb(13)
       open( unit=lunit, file=name )
       ierr = stat ( name, statb )
       if ( ierr .ne. 0 ) stop 'stat: error'
       write(*,*)'所有者の UID = ',statb(5),',
     1   ブロック数 = ',statb(13)
       end

1.4.48.2 `fstat`: 論理装置によるファイルの状態の取得

関数

*`INTEGER4 fstat` `ierr` `= fstat (` `lunit``,` `statb` `)`**
`lunit`	*`INTEGER4`**	入力	論理装置番号
`statb`	*`INTEGER4`**	出力	ファイル状態の情報が格納される要素数 13 の配列
戻り値	*`INTEGER4`**	出力	`ierr`=0: 正常 `ierr`>0: エラーコード

関数は、次のように呼び出します。

例 2: fstat():

       character name*18 /'MyFile'/
       INTEGER*4 fstat, lunit/1/, statb(13)
       open( unit=lunit, file=name )
       ierr = fstat ( lunit, statb )
       if ( ierr .ne. 0 ) stop 'fstat: error'
       write(*,*)'所有者の UID = ',statb(5),',
     1      ブロック数 = ',statb(13)
       end

1.4.48.3 `lstat`: ファイル名によるファイルの状態の取得

関数は、次のように呼び出します。

`ierr` `= lstat (` `name``,` `statb` `)`
`name`	*`character`**`n`	入力	ファイル名
`statb`	*`INTEGER4`**	出力	ファイル状態の情報が格納される要素数 13 の配列
戻り値	*`INTEGER4`**	出力	`ierr`=0: 正常 `ierr`>0: エラーコード

例 3: lstat():

       character name*18 /'MyFile'/
       INTEGER*4 lstat, lunit/1/, statb(13)
       open( unit=lunit, file=name )
       ierr = lstat ( name, statb )
       if ( ierr .ne. 0 ) stop 'lstat: error'
       write(*,*)'所有者の UID = ',statb(5),',
     1   ブロック数 = ',statb(13)
       end

1.4.48.4 ファイル状態を格納する配列の詳細

INTEGER*4 型の配列 statb に返される情報の意味は、stat(2) での構造体 stat の説明と同じです。

予備の値は含まれません。順序は次のとおりです。

statb(1)

statb(2)

statb(3)

statb(4)

statb(5)

statb(6)

statb(7)

statb(8)

statb(9)

statb(10)

statb(11)

statb(12)

statb(13)

i ノードが存在するデバイス

この i ノードの番号

保護

ファイルへのハードリンクの数

所有者のユーザー ID

所有者のグループ ID

i ノードに対応するデバイスのデバイスタイプ

ファイルの合計サイズ

ファイルの最終アクセス時刻

ファイルの最終更新時刻

ファイルの最終状態変更時刻

ファイルシステム入出力操作の最適ブロックサイズ

実際に割り当てられているブロックの数

参照: stat(2)、access(3F)、perror(3F)、および time(3F)

注意: パス名は、<sys/param.h> で定義されている MAXPATHLEN より長くすることはできません。

1.4.49 `stat64`、`lstat64`、 `fstat64`: ファイルの状態の取得

stat、lstat、fstat の 64 ビット「ロングファイル」バージョンです。これらのルーチンは、要素数 13 の配列 statb を INTEGER*8 と宣言しなければならない点を除いて、64 ビット以外のルーチンと同じです。

1.4.50 `system`: システムコマンドの実行

関数は、次のように呼び出します。

INTEGER*4 system

status = system( string )

string

character*n

入力

実行するコマンドを含んだ文字列

戻り値

INTEGER*4

出力

実行されたシェルの終了状態。この値の説明については wait(2) を参照。

例: system():

       character*8 string / ’ls s*’ /
       INTEGER*4 status, system
       status = system( string )
       if ( status .ne. 0 ) stop ’system: error’
       end

関数 system は、あたかもコマンドとしてキー入力されたかのように、ユーザーのシェルに文字列 string を渡します。注意: string の長さは 1,024 文字を超えることができません。

system が環境変数 SHELL を見つけた場合、system はコマンドインタプリタ (シェル) として SHELL の値を使用し、それ以外は sh(1) を使用します。

現プロセスはコマンドが終了するまで待機します。

従来、cc の開発は違う想定で行われています。

cc が system を呼び出す場合、シェルは通常、Bourne シェルです。

system 関数は開いているファイルをすべてフラッシュします。

出力ファイルの場合は、バッファーは実ファイルにフラッシュされます。
入力ファイルの場合は、ポインタの位置が予測不能になります。

参照: execve(2)、wait(2)、system(3)

system() はマルチスレッド対応ではありません。マルチスレッドプログラム、または並列プログラムからは呼び出さないでください。

1.4.51 `time`、`ctime`、`ltime`、`gmtime`: システム時間の取得

これらのルーチンは次の関数を実行します。

`time`	標準バージョン: システム時間を整数値 (0 GMT 1970/1/1 を起点とした秒数) として読み取る VMS バージョン: VMS バージョン: システム時間を文字 (hh:mm:ss) として読み取る
`ctime`	システム時間を ASCII 文字列に変換する
`ltime`	システム時間を現地時間の月、日などに分解する
`gmtime`	システム時間を GMT の月、日などに分解する

1.4.51.1 `time`: システム時間の取得

time() は、次のように呼び出します。

INTEGER*4 time または INTEGER*8

n = time() Standard Version

戻り値

INTEGER*4

出力

0: 0: 0 GMT 1970/1/1 を起点とした秒数

INTEGER*8

出力

64 ビット環境では、time は INTEGER*8 の値を戻す

関数 time() は、グリニッジ時間で 1970 年 1 月 1 日 00 時 00 分 00 秒からの時間を秒数で示す整数を返します。これはオペレーティングシステム時計の値です。

例: time() - オペレーティングシステムに付属する標準バージョン

demo% cat ttime.f
        INTEGER*4  n, time
        n = time()
        write(*,*) '1970/1/1 0 時 GMT からの秒数 = ', n
        end
demo% f95 ttime.f
demo% a.out
 1970/1/1 0 時 GMT からの秒数 =   913240205
demo%

1.4.51.2 `ctime`: システム時間を文字に変換

関数 ctime は、システム時間 stime を変換して、24 文字の ASCII 文字列として返します。

関数は、次のように呼び出します。

CHARACTER ctime*24

string = ctime( stime )

stime

INTEGER*4

入力

time() で読み取ったシステム時間 (標準バージョン)

戻り値

character*24

出力

文字列に変換されたシステム時間。ctime と string は character*24 として型宣言する

次に ctime が戻す値の書式を示します。詳細については、 ctime(3C) のマニュアルページを参照してください。

例: ctime():

demo% cat tctime.f
        character*24 ctime, string
        INTEGER*4  n, time
        n = time()
        string = ctime( n )
        write(*,*) ’ctime: ’, string
        end
demo% f95 tctime.f
demo% a.out
 ctime: Wed Dec  9 13:50:05 1998
demo%

1.4.51.3 `ltime`: システム時間の月、日など (現地時間) への分解

このルーチンはシステム時間を現地時間の月、日などに分解します。

サブルーチンは、次のように呼び出します。

`call ltime(` `stime``,` `tarray` `)`
`stime`	*`INTEGER4`**	入力	`time()` で読み取ったシステム時間 (標準バージョン)
`tarray`	*`INTEGER4(9)`**	出力	現地時間の日、月、年、... に分解されたシステム時間

tarray の要素の意味については、次のセクションを参照してください。

例: ltime():

demo% cat tltime.f
        integer*4  stime, tarray(9), time
        stime = time()
        call ltime( stime, tarray )
        write(*,*) ’ltime: ’, tarray
        end
demo% f95 tltime.f
demo% a.out
 ltime: 25 49 10 12 7 91 1 223 1
demo%

1.4.51.4 `gmtime`: システム時間の月、日など (GMT) への分解

このルーチンはシステム時間を GMT の月、日などに分解します。

サブルーチン

`call gmtime(` `stime``,` `tarray` `)`
`stime`	*`INTEGER4`**	入力	`time()` で読み取ったシステム時間 (標準バージョン)
`tarray`	*`INTEGER4(9)`**	出力	GMT の日、月、年、... に分解されたシステム時間

例: gmtime:

demo% cat tgmtime.f
        integer*4  stime, tarray(9), time
        stime = time()
        call gmtime( stime, tarray )
        write(*,*) ’gmtime: ’, tarray
        end
demo% f95t tgmtime.f
demo% a.out
 gmtime:   12  44  19  18  5  94  6  168  0
demo%

次に ltime と gmtime の tarray() の値 (インデックス、単位、範囲) を示します。

秒 (0 - 61)

分 (0 - 59)

時間 (0 - 23)

日 (1 - 31)

月 (0 - 11)

年 - 1900

曜日 (日曜 = 0)

日 (通年) (0 - 365)

夏時間: 夏時間が有効な場合、1

これらの値は、C ライブラリルーチン ctime(3C) で定義されています。システムが 59 を超える秒を返す理由についてもここで説明されています。参照: idate(3F)、および fdate(3F).

1.4.51.5 `ctime64`、`gmtime64`、`ltime64:` 64 ビット環境用のシステム時間ルーチン

これらは、ctime、gmtime、ltime の対応するバージョンで、64 ビット環境での移植性を実現します。変数 stime が INTEGER*8 であることを除けば、これらのルーチンは 32 ビット用と同じです。

32 ビット環境で INTEGER*8 の stime を指定して ctime64 を使用すると、stime の値が INTEGER*4 の範囲を超えている場合、すべてアスタリスク (*) が返されます。 gmtime と ltime の場合、tarray 配列が -1 で埋められます。

1.4.52 `ttynam`、`isatty`: 端末ポートの名前の読み取り

ttynam と isatty は、端末ポート名に関する処理を行います。

1.4.52.1 `ttynam`: 端末ポートの名前の読み取り

関数 ttynam は論理装置 lunit に結合されている端末デバイスのパス名を空白で埋めて返します。

関数は、次のように呼び出します。

CHARACTER ttynam*24

name = ttynam( lunit )

lunit

INTEGER*4

入力

論理装置

戻り値

character*n

出力

空白でない場合: name は lunit 上のデバイスのパス名。サイズ n は、もっとも長いパス名が入るのに十分な大きさにする

空の文字列 (すべて空白): lunit はディレクトリ /dev の中の端末デバイスと結合されていない

1.4.52.2 `isatty`: 装置が端末であるかどうかの確認

関数 isatty は、論理装置 lunit が端末装置かどうかによって、true または false を返します。

関数は、次のように呼び出します。

terminal = isatty( lunit )

lunit

INTEGER*4

入力

論理装置

戻り値

LOGICAL*4

出力

terminal = 真: 端末デバイスである

terminal = 偽: 端末デバイスではない

例: lunit が tty であるかどうかを確認します。

       character*12 name, ttynam
       INTEGER*4 lunit /5/
       logical*4 isatty, terminal
       terminal = isatty( lunit )
       name = ttynam( lunit )
       write(*,*) '端末 = ', terminal, ', 名前 = "', name, '"'
       end

出力は次のように表示されます。

 端末 = T, 名前 = "/dev/ttyp1  "

1.4.53 `unlink`: ファイルの削除

関数は、次のように呼び出します。

INTEGER*4 unlink

n = unlink ( patnam )

patnam

character*n

入力

ファイル名

戻り値

INTEGER*4

出力

n=0: 正常

n>0: エラー

関数 unlink は、パス名 patnam で指定されたファイルを削除します。これがこのファイルに対する最後のリンクである場合、ファイルの内容はすべて失われます。

例: unlink() - tunlink.data ファイルを削除します。

demo% cat tunlink.f
       call unlink( ’tunlink.data’ )
       end
demo% f95 tunlink.f
demo% ls tunl*
tunlink.f tunlink.data
demo% a.out
demo% ls tunl*
tunlink.f

参照: unlink(2)、link(3F)、perror(3F)注意: パス名は、<sys/param.h> で定義されている MAXPATHLEN より長くすることはできません。

1.4.54 `wait`: プロセス終了の待機

関数は、次のように呼び出します。

INTEGER*4 wait

n = wait( status )

status

INTEGER*4

出力

子プロセスの終了状態

戻り値

INTEGER*4

出力

n>0: 子プロセスのプロセス ID

n<0: n はシステムエラーコードです。wait(2) を参照してください。

wait は、シグナルを受信するか、またはその子プロセスの 1 つが終了するまで呼び出し元のプロセスを保留にします。最後の wait が呼び出されたあとで、子プロセスのどれかが終了した場合、wait はただちに戻ります。子プロセスがない場合、wait はエラーコードを伴ってただちに戻ります。

例: wait() を使用したコード部分

       INTEGER*4 n, status, wait
       …
       n = wait( status )
       if ( n .lt. 0 ) stop ’wait: error’
       …
       end

参照: wait(2)、signal(3F)、kill(3F)、perror(3F)

第 1 章 Fortran ライブラリルーチン

1.1 データ型について

1.2 64 ビット環境

1.3 Fortran 数学関数

1.3.1 単精度関数

1.3.2 倍精度関数

1.3.3 4 倍精度関数

1.4 Fortran ライブラリルーチンリファレンス

1.4.1 abort: 終了とコアファイルへの書き込み

1.4.2 access: ファイルのアクセス権または有無の検査

1.4.3 alarm: 指定時間後のサブルーチンの呼び出し

1.4.4 bit: ビット関数: and、or、bit、 setbit

1.4.4.1 and、or、 xor、not、rshift、 lshift の使用法

1.4.4.2 bic、bis、 bit、setbit の使用法

1.4.5 chdir: デフォルトディレクトリの変更

1.4.6 chmod: ファイルモードの変更

1.4.7 date: 文字列として現在の日付を取得

1.4.7.1 date_and_time: 日付と時刻の取得

1.4.8 dtime、etime: 経過実行時間

1.4.8.1 dtime: 前回の dtime 呼び出しからの経過時間

1.4.8.2 etime: 実行開始からの経過時間

1.4.9 exit: プロセスの終了および状態の設定

1.4.10 fdate: ASCII 文字列で日付および時刻を返す

1.4.11 flush: 論理装置への出力のフラッシュ

1.4.12 fork: 現プロセスのコピーの生成

1.4.13 fseek、ftell: ファイルのポインタの位置付けと再位置付け

1.4.13.1 fseek: 論理装置上のファイルのポインタの再位置付け

1.4.13.2 ftell: ファイルの現在位置を戻す

1.4.14 fseeko64、ftello64: 大規模ファイルポインタの位置付けと再位置付け

1.4.14.1 fseeko64: 論理装置上のファイルのポインタ再位置付け

1.4.14.2 ftello64: ファイルの現在位置を戻す

1.4.15 getarg、iargc: コマンド行の引数の取得

1.4.15.1 getarg: コマンド行の引数の取得

1.4.15.2 iargc: コマンド行の引数の個数の取得

1.4.16 getc、fgetc: 次の文字の取得

1.4.16.1 getc: 標準入力からの次の文字の取得

1.4.16.2 fgetc: 指定した論理装置からの次の文字の取得

1.4.17 getcwd: 現在の作業ディレクトリのパスの取得

1.4.18 getenv: 環境変数の値の取得

1.4.19 getfd: 外部装置番号に対するファイル記述子の取得

1.4.20 getfilep: 外部装置番号に対するファイルポインタの取得

1.4.21 getlog: ユーザーのログイン名の取得

1.4.22 getpid: プロセス ID の取得

1.4.23 getuid、getgid: プロセスのユーザー ID またはグループ ID の取得

1.4.23.1 getuid: プロセスのユーザー ID の取得

1.4.23.2 getgid: プロセスのグループ ID の取得

1.4.24 hostnm: 現在のホスト名の取得

1.4.25 idate: 現在の日付を戻す

1.4.26 ieee_flags、ieee_handler、sigfpe: IEEE 算術演算

1.4.26.1 floatingpoint.h: Fortran IEEE 定義

1.4.27 index、rindex、lnblnk: 部分列のインデックスまたは長さ

1.4.27.1 index: 文字列の中で最初に出現する部分列

1.4.27.2 rindex: 文字列の中で最後に出現する部分列

1.4.27.3 lnblnk: 文字列の中の空白以外の最後の文字

1.4.28 inmax: 正の整数の最大値の返却

1.4.29 itime: 現在の時刻

1.4.30 kill: プロセスへのシグナルの送信

1.4.31 link、symlnk: 既存ファイルへのリンクの作成

1.4.31.1 link: 既存ファイルへのリンクの作成

1.4.31.2 symlnk: 既存ファイルへのシンボリックリンクの作成

1.4.32 loc: オブジェクトのアドレスを戻す

1.4.33 long、short: 整数オブジェクトの変換

1.4.33.1 long: 短整数 (INTEGER*2) から長整数 (INTEGER*4) への変換

1.4.33.2 short: 長整数から短整数への変換

1.4.34 longjmp、isetjmp: isetjmp で設定した位置に戻す

1.4.34.1 isetjmp: longjmp の位置の設定

1.4.34.2 longjmp: isetjmp で設定した位置に戻す

説明

制限

1.4.35 malloc、malloc64、 realloc、free: 記憶領域の割り当て/再割り当て/割り当て解除

1.4.35.1 記憶領域の割り当て: malloc、 malloc64

1.4.35.2 記憶領域の再割り当て: realloc

1.4.35.3 free: Malloc により割り当てられた記憶領域の割り当て解除

1.4.36 mvbits: ビットフィールドの移動

1.4.37 perror、gerror、ierrno: エラーメッセージの取得

1.4.37.1 perror: 論理装置 0 (stderr) へのメッセージ出力

1.4.37.2 gerror: 最後に検出されたシステムエラーの取得

1.4.37.3 ierrno: 最後に検出されたシステムエラーの番号の取得

1.4.38 putc、fputc: 論理装置への 1 文字出力

1.4.38.1 putc: 論理装置 6 への出力

1.4.1 `abort`: 終了とコアファイルへの書き込み

1.4.2 `access`: ファイルのアクセス権または有無の検査

1.4.3 `alarm`: 指定時間後のサブルーチンの呼び出し

1.4.4 `bit`: ビット関数: `and`、`or`、`bit`、 `setbit`

1.4.4.1 `and`、`or`、 `xor`、`not`、`rshift`、 `lshift` の使用法

1.4.4.2 `bic`、`bis`、 `bit`、`setbit` の使用法

1.4.5 `chdir`: デフォルトディレクトリの変更

1.4.6 `chmod`: ファイルモードの変更

1.4.7 `date`: 文字列として現在の日付を取得

1.4.7.1 `date_and_time`: 日付と時刻の取得

1.4.8 `dtime`、`etime`: 経過実行時間

1.4.8.1 `dtime`: 前回の `dtime` 呼び出しからの経過時間

1.4.8.2 `etime`: 実行開始からの経過時間

1.4.9 `exit`: プロセスの終了および状態の設定

1.4.10 `fdate`: ASCII 文字列で日付および時刻を返す

1.4.11 `flush`: 論理装置への出力のフラッシュ

1.4.12 `fork`: 現プロセスのコピーの生成

1.4.13 `fseek`、`ftell`: ファイルのポインタの位置付けと再位置付け

1.4.13.1 `fseek`: 論理装置上のファイルのポインタの再位置付け

1.4.13.2 `ftell`: ファイルの現在位置を戻す

1.4.14 `fseeko64`、`ftello64`: 大規模ファイルポインタの位置付けと再位置付け

1.4.14.1 `fseeko64`: 論理装置上のファイルのポインタ再位置付け

1.4.14.2 `ftello64`: ファイルの現在位置を戻す

1.4.15 `getarg`、`iargc`: コマンド行の引数の取得

1.4.15.1 `getarg`: コマンド行の引数の取得

1.4.15.2 `iargc`: コマンド行の引数の個数の取得

1.4.16 `getc`、`fgetc`: 次の文字の取得

1.4.16.1 `getc`: 標準入力からの次の文字の取得

1.4.16.2 `fgetc`: 指定した論理装置からの次の文字の取得

1.4.17 `getcwd`: 現在の作業ディレクトリのパスの取得

1.4.18 `getenv`: 環境変数の値の取得

1.4.19 `getfd`: 外部装置番号に対するファイル記述子の取得

1.4.20 `getfilep`: 外部装置番号に対するファイルポインタの取得

1.4.21 `getlog`: ユーザーのログイン名の取得

1.4.22 `getpid`: プロセス ID の取得

1.4.23 `getuid`、`getgid`: プロセスのユーザー ID またはグループ ID の取得

1.4.23.1 `getuid`: プロセスのユーザー ID の取得

1.4.23.2 `getgid`: プロセスのグループ ID の取得

1.4.24 `hostnm`: 現在のホスト名の取得

1.4.25 `idate`: 現在の日付を戻す

1.4.26 `ieee_flags、ieee_handler、sigfpe`: IEEE 算術演算

1.4.26.1 `floatingpoint.h`: Fortran IEEE 定義

1.4.27 `index、rindex、lnblnk`: 部分列のインデックスまたは長さ

1.4.27.1 `index`: 文字列の中で最初に出現する部分列

1.4.27.2 `rindex`: 文字列の中で最後に出現する部分列

1.4.27.3 `lnblnk`: 文字列の中の空白以外の最後の文字

1.4.28 `inmax`: 正の整数の最大値の返却

1.4.29 `itime`: 現在の時刻

1.4.30 `kill`: プロセスへのシグナルの送信

1.4.31 `link`、`symlnk`: 既存ファイルへのリンクの作成

1.4.31.1 `link:` 既存ファイルへのリンクの作成

1.4.31.2 `symlnk:` 既存ファイルへのシンボリックリンクの作成

1.4.32 `loc`: オブジェクトのアドレスを戻す

1.4.33 `long`、`short`: 整数オブジェクトの変換

1.4.33.1 `long`: 短整数 (INTEGER2) から長整数 (INTEGER4) への変換

1.4.33.2 `short`: 長整数から短整数への変換

1.4.34 `longjmp`、`isetjmp`: `isetjmp` で設定した位置に戻す

1.4.34.1 `isetjmp`: `longjmp` の位置の設定

1.4.34.2 `longjmp`: `isetjmp` で設定した位置に戻す

1.4.35 `malloc`、`malloc64`、 `realloc`、`free`: 記憶領域の割り当て/再割り当て/割り当て解除

1.4.35.1 記憶領域の割り当て: `malloc`、 `malloc64`

1.4.35.2 記憶領域の再割り当て: `realloc`

1.4.35.3 `free`: Malloc により割り当てられた記憶領域の割り当て解除

1.4.36 `mvbits`: ビットフィールドの移動

1.4.37 `perror`、`gerror`、`ierrno`: エラーメッセージの取得

1.4.37.1 `perror`: 論理装置 0 (`stderr`) へのメッセージ出力

1.4.37.2 `gerror`: 最後に検出されたシステムエラーの取得

1.4.37.3 `ierrno`: 最後に検出されたシステムエラーの番号の取得

1.4.38 `putc`、`fputc`: 論理装置への 1 文字出力

1.4.38.1 `putc`: 論理装置 6 への出力

1.4.38.2 `fputc`: 指定した論理装置への出力

1.4.39 `qsort、qsort64`: 1 次元配列の要素のソート

1.4.40 `ran`: 0 - 1 間の乱数の生成

1.4.41 `rand`、`drand`、 `irand`: 乱数を戻す

1.4.42 `rename`: ファイルの名称変更

1.4.43 `secnds`: 秒単位のシステム時間 (マイナス引数) を取得

1.4.44 `set_io_err_handler`、`get_io_err_handler`: 入出力エラーハンドラの設定と取得

1.4.45 `sh`: `sh` コマンドの高速実行

1.4.46 `signal`: シグナルに対する動作の変更

1.4.47 `sleep`: 一定時間の実行中断