From fca49a8a69a0f6bb4feae74c6cd0e93d7fac8b36 Mon Sep 17 00:00:00 2001 From: Yukihiro Matsumoto Date: Thu, 21 Dec 1995 00:56:57 +0900 Subject: version 0.95 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit https://cache.ruby-lang.org/pub/ruby/1.0/ruby-0.95.tar.gz Thu Dec 21 00:56:57 1995 Yukihiro Matsumoto * version 0.95 - fj.sourcesに * eval.c (rb_eval): rescueのロジックをrb_rescue()に一元化． Wed Dec 20 19:30:58 1995 Yukihiro Matsumoto * Makefile.in: 不要なコンパイルの回避(より完全に)． * class.c (singleton_class_new): `single'->`singleton' Tue Dec 19 07:14:33 1995 Yukihiro Matsumoto * io.c (closed?): IOがcloseされているかどうかを知る述語． * parse.y (primary): 特異メソッドの引数のlex_stateが不適切． * lib/tk.rb: tcl->rubyの変換関数の用意． * ext/extmk.rb.in (install): installの2重コンパイルの回避． * array.c (range_beg_len): range指定の不適切なエラーを訂正． * string.c (str_aref): range指定のバグを削除． * lib/tk.rb (tk_split_list): Tclのリストに対応． Mon Dec 18 09:58:12 1995 Yukihiro Matsumoto * version 0.94 * dln.c (dln_load): HP対応(未確認) * eval.c (Init_Proc): BlockをProcに改名． Sat Dec 16 13:46:14 1995 Yukihiro Matsumoto * eval.c (rb_eval): retryでイテレータの再実行ができるように． Fri Dec 15 17:14:30 1995 Yukihiro Matsumoto * eval.c: proc:lambdaの親しみやすい別名 Thu Dec 14 17:21:55 1995 Yukihiro Matsumoto * eval.c (dyna_var_asgn): イテレータブロック内で最初に初期化された ローカル変数の有効範囲をそのブロック内に限定．これでlambdaと呼べ ないことはない． Wed Dec 13 02:30:58 1995 Yukihiro Matsumoto * gc.c: autoloadのマークミス． * lib/tk.rb: wishからの複数行の戻り値に対応 * lib/tkcomposite.rb: 複合widget * variable.c (rb_class2path): ICLASSに対応してなかった． * eval.c (ruby_run): exit(0)のバグ Sat Dec 9 01:21:24 1995 Yukihiro Matsumoto * ext/marshal/marshal.c (dumps|load): 文字列に対する入出力を可能に した(ただし実はファイル経由なのだ)． Fri Dec 8 18:29:11 1995 Yukihiro Matsumoto * ext/marshal/marshal.c: シンボルを一度だけ初期化する． Thu Dec 7 07:58:50 1995 Yukihiro Matsumoto * parse.y (yylex): 第1引数の正規表現の認識にエラーがあった．同時に 状態数を減らした． * string.c (str_sub): 置換でスキップ幅が大きすぎた． Wed Dec 6 15:14:23 1995 Yukihiro Matsumoto * string.c (str_sub_method): sub/gsub(!なし)は置換が行なわれなかっ た時，置換前の文字列を返す． Tue Dec 5 00:55:15 1995 Yukihiro Matsumoto * parse.y (yylex): 括弧を省略した時の引数展開の`*'に対応． * eval.c (ruby_run): EXITハンドラ内での例外に対応． * bignum.c (big_cmp): BignumとFixnumの比較で落ちる． Mon Dec 4 14:21:18 1995 Yukihiro Matsumoto * parse.y (call_op): コンパイル時の定数式の展開をやめた．労多くし て益少ないと判断したので． Thu Nov 30 01:35:15 1995 Yukihiro Matsumoto * lib/tk.rb: {Radio,Check}Buttonのvariableの実装． * eval.c (rb_yield_0): Block.callがネストした時のバグ． * io.c (f_select): 常に配列3つをふくむ配列を返すように * lib/tk.rb: fileeventをruby側で実装． Wed Nov 29 17:53:23 1995 Yukihiro Matsumoto * variable.c (rb_ivar_get): selfを常に指定するように． Tue Nov 14 00:07:29 1995 Yukihiro Matsumoto * lib/tk.rb: Tk4.0対応 Mon Nov 13 16:23:32 1995 Yukihiro Matsumoto * version 0.93 Thu Nov 9 23:26:01 1995 Yukihiro Matsumoto * gc.c (gc_mark): モジュールのMixinのマーク忘れ． * parse.y (f_arglist): メソッド定義の引数を括弧で括らなくても良い ようにした． Wed Nov 8 00:17:51 1995 Yukihiro Matsumoto * eval.c (rb_yield_0): 未初期化のローカル変数があった． * eval.c (rb_eval): pendig signalのチェックをeval実行後に行うよう にした．でないとシグナルの発生と検出が遠く離れてしまう事がある． * parse.y: class文のsuperclass部を定数から式に拡張した． * lib/tk.rb: Tkのほぼ全ウィンドウクラスに対応．キャンバスとテキス ト上のオブジェクトが残っている． Tue Nov 7 08:18:37 1995 Yukihiro Matsumoto * signal.c (trap): ブロックを指定できるように． Mon Nov 6 16:44:00 1995 Yukihiro Matsumoto * eval.c (f_caller): 呼出元の情報を得る． * ext/tkutil/tkutil.c: wishのstderr出力を監視することで，エラー処 理を行う． * ext/tkutil/tkutil.c: wishとの通信部をCで記述． Sat Nov 4 01:12:59 1995 Yukihiro Matsumoto * sample/ruby-mode.el (ruby-calculate-indent): インデントの計算を もう少しスマートにした(正規表現のチェック，継続行のチェック)． * eval.c (rb_call): 無限再帰を避けるため，関数のネストレベルの制限 を行なう． * lib/tk.rb: Tkインターフェース．まだ不完全だが． * eval.c (rb_yield_0): 空のBlockのバグ． * sample/ruby-mode.el (ruby-calculate-indent): 行末の演算子による 行継続に対応． Fri Nov 3 12:56:21 1995 Yukihiro Matsumoto * eval.c (rb_call): 本体が空の関数の実行にバグ． * parse.y (var_extend): 文字列の末尾の変数展開のバグ． * variable.c (rb_gvar_set): traceの評価時にに変数値を与えるように． * eval.c (f_require): ruby scriptのrequireにbug． * variable.c (rb_const_get): モジュールのinclude対策． Thu Oct 19 13:56:06 1995 Yukihiro Matsumoto * dln.c (dln_load): HP対応でのtypo. Wed Oct 18 17:39:39 1995 Yukihiro Matsumoto * version 0.92 * object.c (krn_type): オブジェクトの動的な型を返すメソッド． Tue Oct 17 00:48:18 1995 Yukihiro Matsumoto * ruby.c (proc_options): -X オプション．chdirだけを行う． * re.c (reg_search): 漢字コードを途中で変更できるように．コンパイ ル時のコードが変更された時にはマッチの直前に正規表現の再コンパイ ルを行う．定数KCODEから変数$KCODEへ． * parse.y: ()のなかにcompexprを許す． * re.c (reg_search): メモリリークを直した． Fri Oct 13 13:19:19 1995 Yukihiro Matsumoto * string.c (str_sub): 文字列置換にバグ． * string.c (str_strip_bang): 文字列の後ろの長さの調整が行われてい なかった． * re.c (reg_search): $&, $1...のはローカルに束縛するようになった． 呼び出したメソッドでのマッチは現スコープの$&などの値に影響しない． マッチの情報をスコープ外で得たいときには$~を使って束縛情報を持ち 出す必要がある． Thu Oct 12 00:33:33 1995 Yukihiro Matsumoto * re.c (reg_search): String:split, String:indexでは$&, $1...が変化 しないようにした． * io.c (rb_str_setter): setterの仕様が変更になっていた． * variable.c (f_trace_var): 第2引数を省略してイテレータとして呼べ るように． Wed Oct 11 11:50:59 1995 Yukihiro Matsumoto * version 0.91 * variable.c (var_setter): 引数が間違っていた．致命的バグ． * io.c (pipe_open): $stderrの値が変更されている時にはそちらを 子プロセスのstderrに設定する． Mon Oct 9 13:06:33 1995 Yukihiro Matsumoto * object.c (mod_to_s): モジュール内のモジュールは`::'を使った表現 で表示されるように． * variable.c (rb_gvar_set): 代入によるループが発生しないように， trace内での代入ではtraceを評価しない． * struct.c (struct_equal): structのequal判定にクラスの一致を含めた． Sat Oct 7 00:18:32 1995 Yukihiro Matsumoto * eval.c (rb_eval): defined?の機能を拡張(yieldのチェック，superの 存在など)． Fri Oct 6 12:06:47 1995 Yukihiro Matsumoto * version 0.90 * st.c (st_foreach): 要素を削除した時に要素数が変化していなかった． * hash.c (hash_values): バグ修正．keysを返していた…． * parse.y (call_op): defined? の引数では定数の畳み込みを行わない (チェックする前にコンパイルエラーになっては困る)． * スコープ生成の一部見直し． Thu Oct 5 00:29:43 1995 Yukihiro Matsumoto * 関数とクラスの命名規則を変更した．関数名，変数名の全面書き換え． * gc.c (looks_pointerp): ヒープチェックの高速化． * struct.c (Fstruct_aset): 構造体に対する`[]='． (struct_set): 構造体メンバに対する代入． Wed Oct 4 09:54:07 1995 Yukihiro Matsumoto * version 0.89 * eval.c (Frequire): ダイナミックロードのエラーチェックを厳しく． * struct.c: structの構造を完全に書き換えた．以前は順序付きの id->valueの連想配列であったが，今度は構造体毎に新しいクラスを生 成するようにした． * parse.y: `::'の意味をAssocの生成からクラス(モジュール)内の定数ア クセスへ変更． * assoc.c: なくす． Tue Oct 3 13:31:08 1995 Yukihiro Matsumoto * variable.c (Ftrace_var): trace_var, 大域変数への書き込みhookを設 定する． * variable.c: global_entryの構成を書き換えた．これでtrace_varを実 装できる． * file.c (Ffile_stat): "&"で直前のfstatの結果も参照できるように． Fri Sep 29 14:15:13 1995 Yukihiro Matsumoto * version 0.88 * dln.c (dln_load): AIXとHPに対応したコードを入れた(動作は未確認)． * ext/extmk.rb.in: 必要に応じて，定数EXTLIBを定義するように． * dln.c (dln_load): dln独立に書き換える．将来の拡張用． (load_1): dln_a_outにおいてソースコードでライブラリを明示的にロー ドする必要がないように変更した． Thu Sep 28 13:31:37 1995 Yukihiro Matsumoto * sample/ruby-mode.el: もっとましなhilit19対応(正規表現)． Wed Sep 27 04:12:44 1995 Takahasi Mamoru * sample/test.rb: echoで-nを使わないように(SysV対策)． * ext/extmk.rb.in: sub -> sub! Tue Sep 26 19:12:42 1995 Yasuo OHBA * dln.c (dln_find_1): `.', `..'から始まるパスに対応した. Mon Sep 25 12:33:03 1995 Yukihiro Matsumoto * version 0.87 Sat Sep 23 10:00:18 1995 Yukihiro Matsumoto * eval.c (Fmod_modfunc): メソッドをprivateにし，同時に特異メソッド も定義するメソッド．パッケージ的使い方のモジュール用． Fri Sep 22 11:02:44 1995 Yukihiro Matsumoto * lib/find.rb: findを提供するライブラリ * variable.c (rb_define_variable): hookの設定を分離． (add_hook): 1変数に対して複数のhookを設定できるように． Thu Sep 21 00:22:11 1995 Yukihiro Matsumoto * string.c (Fstr_frozen): 文字列が更新不可かどうかをチェックする述 語メソッド． * hash.c (Fhash_aset): keyが文字列の時，キーの内容が変化しないよう に，dupしてfreezeする． Wed Sep 20 16:12:44 1995 Yukihiro Matsumoto * version 0.86 * ext/extmk.rb.in (have_header): キャッシュにバグ． * ext/extmk.rb.in (have_library): 引数の順序が変わった． Thu Sep 14 18:00:59 1995 Yukihiro Matsumoto * object.c (obj_is_instance_of): is_member_ofから名称変更． Wed Sep 13 15:44:35 1995 Yukihiro Matsumoto * string.c (Fstr_tr_bang): 範囲外の文字に対する変換バグ． Tue Sep 12 14:27:58 1995 Yukihiro Matsumoto * file.c (Sfile_expand_path): expand_file_name -> expand_pathに名 称変更． * enum.c (Fenum_member): includes? -> member? に名称変更． * string.c (Fstr_each_byte): StringはByteArrayであるという基本に戻っ て，eachの定義をeach_byteに変更した．今までのeachはeach_lineでア クセスできる． Mon Sep 11 18:31:17 1995 Yukihiro Matsumoto * file.c (cache_stat): ファイル名として"&"を指定すると直前の stat(2)の結果を再利用するように． Fri Sep 8 14:18:51 1995 Yukihiro Matsumoto * ruby.texi: `!', `?'に対応してアップデート． * parse.y: defined -> defined? * file.c: FileOpの一文字メソッドをなくす．一文字テストはtestメソッ ドにまかせる． * parse.y (yylex): 変数名の後ろに`?'も許す．述語メソッドの後ろに `?'を追加する． Thu Sep 7 20:01:33 1995 Yukihiro Matsumoto * string.c: 文字列の中身を更新するメソッドの名前の終りに`!'を付加． `!'の無いバージョンも用意した． * parse.y: 変数名の後ろに`!'を許す． Wed Sep 6 14:12:19 1995 Yukihiro Matsumoto * version 0.85 * string.c (Fstr_dup): 文字列の複製を作る (Fstr_freeze): 文字列の更新不可属性を設定できるように． (Fsub/Fgsub): $_の内容をdupしてから置換を行うように． * ruby.h (CLONESETUP): flagsの状態もコピー Tue Sep 5 01:27:50 1995 Yukihiro Matsumoto * sample/test.rb: 失敗の検出を厳しく． Fri Aug 25 14:31:02 1995 Yukihiro Matsumoto * process.c (Ffork): イテレータとしても動作するように． * version 0.84 * signal.c (sig_beg): ハンドラが設定されている時には再設定しない． * ext/extmk.rb.in (create_makefile): shared objectのリンクの際に `-l'オプションを指定するように． * signal.c (trap): `EXIT'で終了処理を行う設定が出来る． Wed Aug 16 00:13:22 1995 Yukihiro Matsumoto * signal.c (sig_beg): デフォルトではbegin節の中でだけSIGINTを捕捉 するように変更． * io.c (io_ctl): fcntlを持たないシステムにも対応． * 各ディレクトリに分散していたMANIFESTをまとめた．拡張モジュール毎 には必要． * string.c (Sstr_new,str_sub,Fstr_crypt): 引数を自動的に文字列に変 換するように． Sat Aug 12 00:44:02 1995 Yukihiro Matsumoto * string.c (Fstr_crypt): PD cryptを用意した． Fri Aug 11 14:37:03 1995 Yukihiro Matsumoto * assoc.c (Fassoc_clone): assocもcloneできるように． * io.c: マクロREAD_DATA_PENDINGの定義を変更(Linux対応) * io.c (io_fptr_finalize): ftprの開放時の処理を指定できるように． Wed Aug 9 16:52:41 1995 Yukihiro Matsumoto * eval.c (rb_provided): 複数のfeatureをロードすると無限ループに落 ちるという単純な(しかし凶悪な)ミス． * ext/extmk.rb.in (install): dlopen対応を行った．今までdlnにしか十 分に対応していなかった． Tue Aug 8 14:17:06 1995 Yukihiro Matsumoto * version 0.83 Mon Aug 7 12:47:41 1995 Yukihiro Matsumoto * parse.y: resque -> rescue．恥ずかしいがtypoを残しておくわけには いかないよなあ．なんで今まで気がつかなかったのか…． Thu Aug 3 18:18:05 1995 Yukihiro Matsumoto * missing/nt.c: NT移植用の関数群をまとめた． * variable.c (rb_const_get): また例外を発生するようにした．defined がある以上例外を発生させない理由がないので(例外が発生した方がタ イプミスの検出などの点で有利)． * variable.c (Fautoload): autoloadを実装．今度は使えるか． Mon Jul 31 15:44:21 1995 Yukihiro Matsumoto * parse.y (arg_ambiguous): 第1引数のあいまいさを警告(-vオプション で有効)． * eval.c (rb_eval): `-v'オプションをつけて`def'が呼ばれると不必要 なエラーメッセージが出た． * parse.y (yylex): メソッドの第1引数の判定をもうちょっと賢くした． Fri Jul 28 19:04:43 1995 Yukihiro Matsumoto * parse.y (yylex): `+/-/['の直前に空白が来るかどうかで動作を変更し た(混乱のもとか?) Wed Jul 26 09:21:23 1995 Yukihiro Matsumoto * version 0.82a * sprintf.c (Fsprintf): `%s'で'\0'を含む文字列に対応． * pack.c (Fpck_pack): packの要素確保のバグ． * eval.c (Floop): 無限ループのイテレータ． * io.c (next_argv): 存在しないファイル名が指定された時のエラー処理 が行われていなかった． Mon Jul 24 17:37:34 1995 Yukihiro Matsumoto * version 0.82 * ext/extmk.rb.in (install): 拡張モジュールをstatic linkする場合は そのモジュールが既にrequireされたのと同じようにfeatureを設定する． これで拡張モジュールの機能が必要な時には(static linkされているか どうかにかかわらず)requireすればよくなる． * eval.c (Frequire): `$"'に格納する文字列をフルパスでなくフィーチャ 名とする．rubyスクリプトをロードした時には`.rb'，オブジェクトを ロードした時には`.o'をフィーチャ名に付加する．lispのrequireと provideの働きに(少し)近い． Thu Jul 20 12:50:05 1995 Yukihiro Matsumoto * Makefile.in (test): make testができるように． * struct.c (struct_new): typo. * eval.c (rb_eval): `defined'を追加．メソッド/変数/定数の定義状態 を知る事が出来る． Wed Jul 19 18:04:01 1995 Yukihiro Matsumoto * version 0.81 Mon Jul 17 14:53:51 1995 Yukihiro Matsumoto * variable.c (rb_const_get): 未初期化のCONSTANTの値をnilにした．し かし，今後また例外に戻す可能性はある．要はoptionalなクラス/モジュー ルが存在するかチェックしたいだけなんだな． * st.c (int): grow_factorを固定にした(大嶋さんのマシンに対応)． Fri Jul 14 00:48:40 1995 Yukihiro Matsumoto * ext/extmk.rb.in: キャッシュのバグを修正． * parse.y (var_extend): #{$数字}に対応した． * dln.c (dln_load_1): `Init_FILENAME'だけを有効に．`init_*'は今後 実行しない． * ext/etc/etc.c : Etcモジュールを拡張モジュールとして分離．実はNT 対応への布石だったりするかもしれない． Tue Jul 11 17:12:48 1995 Yukihiro Matsumoto * gcc -Wallで出たwarningを元にソースを変更． * signal.c (trap): typo. Fri Jul 7 10:08:51 1995 Yukihiro Matsumoto * version 0.80 * ruby.texi: texinfo documentを提供．specとruby.1は無くなった． * signal.c (Ftrap): 割込み禁止中の例外発生に対応． * eval.c (Flambda): Blockオブジェクトを返す．Block.newと同義． Thu Jul 6 00:35:03 1995 Yukihiro Matsumoto * signal.c (Ftrap): SIG_DFLの処理を変更．SIGINTへのデフォルトハン ドラを用意(例外を発生する)． * file.c (Sfile_expand_fname): パス名を絶対パスに展開するメソッド． (Sfile_basename): basenameを得るメソッド．拡張子も外せる． (Sfile_dirname): basenameの反対． * eval.c (rb_call): argument評価中の例外発生に対応． * file.c (Ftest): `M', `A', `C'を追加. Tue Jul 4 12:36:33 1995 Yukihiro Matsumoto * file.c (Ftest): ファイルテスト用メソッド． * ruby.c (proc_options): `-r'オプションを追加． * parse.y (f_args): デフォルト引数を追加． * eval.c (rb_call): 該当する引数が無い時，rest引数の値をnilに． * numeric.c (num_equal): 数値以外との比較で例外が発生していた． FALSEを返すように． * eval.c (masign): 多重代入のrest部の動作がおかしかった． Sat Jun 17 01:03:16 1995 Yukihiro Matsumoto * parse.y (gettable): 未初期化のローカル変数の参照(独立した識別子) は正式にメソッド呼び出しとした． * parse.y (read_escape): tokenbufを使わないように修正．それにとも ない，`\C-x',`\M-x'などのエスケープ表現を復活．これでドキュメン トと実際の処理系が一致した． Thu Jun 15 15:42:00 1995 Yukihiro Matsumoto * re.c (re_regcomp): cacheのチェックを改善． Mon Jun 12 18:50:51 1995 Yukihiro Matsumoto * version 0.79 Sat Jun 10 00:25:01 1995 Yukihiro Matsumoto * re.c (re_regcomp): cache判定に`$='の値も反映させた． * sample/test.rb: test suite作成． Fri Jun 9 15:58:34 1995 Yukihiro Matsumoto * re.c (re_regcomp): cacheの判定が間違っていた． Fri Jun 9 00:01:35 1995 Yukihiro Matsumoto (matz@dyna) * eval.c (rb_yield): block構造体に初期化していないメンバ(iter)があっ たのでイテレータのネストが正しく動作しなかった． Thu Jun 8 00:59:03 1995 Yukihiro Matsumoto (matz@dyna) * re.c (=~): String以外との比較がFALSEを返すように(例外を発生して いた)． * extmk.rb.in: 判定した値をファイルにキャッシュするようにした． * assoc.c (to_a): to_aメソッドが再定義されていなかった． * eval.c (rb_eval): 初期化されていないローカル変数へのアクセスを引 数の無いメソッド呼び出しと解釈する．ただし，(現状では)メソッドが 定義されていない場合，エラーにせず変数未初期化のwaringを出して nilを返している．「ruby -pe print」などが実行できるという意味で はありがたいこの仕様は，しかし今後の検討が必要である．-- メソッ ド呼び出しとするのを止めるか(以前の仕様)，いつもメソッド呼び出し とする(未定義ならばエラー)か，今の仕様で行くか． * eval.c (rb_eval): 初期化されていないローカル変数へのアクセスで (evalなどで)初期化された事が分かった時には以後初期化されたローカ ル変数とみなす． Wed Jun 7 11:58:12 1995 Yukihiro Matsumoto * eval.c (rb_fail): 例外処理後も`$!'をクリアしないように． (rb_fail): `$!'変数に最後に改行を追加しない． * io.c (Fprint): privateメソッドに変更．引数を取らない時の動作を変 更(`$_'を出力する)． (Fio_print): 出力先指定のprintメソッド． (Fio_printf): 出力先指定のprintfメソッド． * parse.y: not演算子の追加．優先順位の低い`!'演算子． Mon Jun 5 19:00:55 1995 Yukihiro Matsumoto * version 0.78 Fri Jun 2 17:52:03 1995 Yukihiro Matsumoto * ruby.c (proc_options): -Iオプションで`$:'への追加される順番を修 正した． Fri Jun 2 00:36:34 1995 Yukihiro Matsumoto (matz@dyna) * parse.y: while修飾子の動作を通常のwhileと同じにした．ただし， begin式へのwhile修飾子だけはdo..while型のループとなる． Wed May 31 18:36:30 1995 Yukihiro Matsumoto * version 0.77 Mon May 29 18:39:37 1995 Yukihiro Matsumoto * ext/extmk.rb.in (install): 拡張モジュールもインストールできるよ うに． Fri May 26 14:43:01 1995 Yukihiro Matsumoto * process.c (Fsystem): 戻り値をサブプロセスの失敗/成功を表す真偽値 にした．終了ステータスは`$?'で得る． Tue May 23 10:58:11 1995 Yukihiro Matsumoto * string.c (Fstr_upto): 無限ループに陥らないように． * parse.y (cond): `||'などの右辺に制御式が書けるように，条件式がか ならずしも値を持たなくても良いようにした． * ext/marshal/marshal.c: オブジェクトの読み書きをメソッドの再定義 でコントロールできるように．インスタンスが`_dump_to'というメソッ ドを定義している時はそちらを使うように． * ext/extmk.rb.in: static linkも設定できるような仕様にした． ext/Setupというファイルにディレクトリ名を記述するとそのディレク トリに存在するモジュールはstatic linkされる(はず)． * eval.c (rb_eval): `..'を文法に組み込み，`..'と`...'の動作をperl に合わせた． Sat May 20 01:22:48 1995 Yukihiro Matsumoto (matz@dyna) * io.c (select): timeout時と割込み時の動作の明確化． Co-authored-by: Takahasi Mamoru Co-authored-by: Yasuo OHBA --- missing/nt.c | 1732 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1732 insertions(+) create mode 100644 missing/nt.c (limited to 'missing/nt.c') diff --git a/missing/nt.c b/missing/nt.c new file mode 100644 index 0000000000..e553abbe70 --- /dev/null +++ b/missing/nt.c @@ -0,0 +1,1732 @@ +/* + * Copyright (c) 1993, Intergraph Corporation + * + * You may distribute under the terms of either the GNU General Public + * License or the Artistic License, as specified in the perl README file. + * + * Various Unix compatibility functions and NT specific functions. + * + * Some of this code was derived from the MSDOS port(s) and the OS/2 port. + * + */ + +#include "ruby.h" +#include +#include +#include +#include +#include + +bool NtSyncProcess = FALSE; +extern char **environ; + +static bool NtHasRedirection (char *); +static int valid_filename(char *s); + +FILE *fdopen(int, char *); + +void +sleep(unsigned int len) +{ + time_t end; + + end = time((time_t *)0) + len; + while (time((time_t *)0) < end) + ; +} + +// +// Initialization stuff +// +void +NtInitialize(int *argc, char ***argv) { + + WORD version; + WSADATA retdata; + int ret; + + // + // subvert cmd.exe\'s feeble attempt at command line parsing + // + *argc = NtMakeCmdVector((char *)GetCommandLine(), argv, TRUE); + + // + // Now set up the correct time stuff + // + + tzset(); +} + + +char *getlogin() +{ + char buffer[200]; + int len = 200; + extern char *NTLoginName; + + if (NTLoginName == NULL) { + if (GetUserName(buffer, &len)) { + NTLoginName = ALLOC_N(char, len+1); + strncpy(NTLoginName, buffer, len); + NTLoginName[len] = '\0'; + } + else { + NTLoginName = ""; + } + } + return NTLoginName; +} + + + +// popen stuff + +// +// use these so I can remember which index is which +// + +#define NtPipeRead 0 // index of pipe read descriptor +#define NtPipeWrite 1 // index of pipe write descriptor + +#define NtPipeSize 1024 // size of pipe buffer + +#define MYPOPENSIZE 256 // size of book keeping structure + +struct { + int inuse; + int pid; + FILE *pipe; +} MyPopenRecord[MYPOPENSIZE]; + +FILE * +mypopen (char *cmd, char *mode) +{ + FILE *fp; + int saved, reading; + int pipemode; + int pipes[2]; + int pid; + int slot; + static initialized = 0; + + // + // if first time through, intialize our book keeping structure + // + + if (!initialized++) { + for (slot = 0; slot < MYPOPENSIZE; slot++) + MyPopenRecord[slot].inuse = FALSE; + } + + // + // find a free popen slot + // + + for (slot = 0; slot < MYPOPENSIZE && MyPopenRecord[slot].inuse; slot++) + ; + + if (slot > MYPOPENSIZE) { + return NULL; + } + + // + // Figure out what we\'re doing... + // + + reading = (*mode == 'r') ? TRUE : FALSE; + pipemode = (*(mode+1) == 'b') ? O_BINARY : O_TEXT; + + // + // Now get a pipe + // + + if (_pipe(pipes, NtPipeSize, pipemode) == -1) { + return NULL; + } + + if (reading) { + + // + // we\'re reading from the pipe, so we must hook up the + // write end of the pipe to the new processes stdout. + // To do this we must save our file handle from stdout + // by _dup\'ing it, then setting our stdout to be the pipe\'s + // write descriptor. We must also make the write handle + // inheritable so the new process can use it. + + if ((saved = _dup(fileno(stdout))) == -1) { + _close(pipes[NtPipeRead]); + _close(pipes[NtPipeWrite]); + return NULL; + } + if (_dup2 (pipes[NtPipeWrite], fileno(stdout)) == -1) { + _close(pipes[NtPipeRead]); + _close(pipes[NtPipeWrite]); + return NULL; + } + } + else { + // + // must be writing to the new process. Do the opposite of + // the above, i.e. hook up the processes stdin to the read + // end of the pipe. + // + + if ((saved = _dup(fileno(stdin))) == -1) { + _close(pipes[NtPipeRead]); + _close(pipes[NtPipeWrite]); + return NULL; + } + if (_dup2(pipes[NtPipeRead], fileno(stdin)) == -1) { + _close(pipes[NtPipeRead]); + _close(pipes[NtPipeWrite]); + return NULL; + } + } + + // + // Start the new process. Must set _fileinfo to non-zero value + // for file descriptors to be inherited. Reset after the process + // is started. + // + + if (NtHasRedirection(cmd)) { + docmd: + pid = spawnlpe(_P_NOWAIT, "cmd.exe", "/c", cmd, 0, environ); + if (pid == -1) { + _close(pipes[NtPipeRead]); + _close(pipes[NtPipeWrite]); + return NULL; + } + } + else { + char **vec; + int vecc = NtMakeCmdVector(cmd, &vec, FALSE); + + pid = spawnvpe (_P_NOWAIT, vec[0], vec, environ); + if (pid == -1) { + goto docmd; + } + Safefree (vec); + } + + if (reading) { + + // + // We need to close our instance of the inherited pipe write + // handle now that it's been inherited so that it will actually close + // when the child process ends. + // + + if (_close(pipes[NtPipeWrite]) == -1) { + _close(pipes[NtPipeRead]); + return NULL; + } + if (_dup2 (saved, fileno(stdout)) == -1) { + _close(pipes[NtPipeRead]); + return NULL; + } + _close(saved); + + // + // Now get a stream pointer to return to the calling program. + // + + if ((fp = (FILE *) fdopen(pipes[NtPipeRead], mode)) == NULL) { + return NULL; + } + } + else { + + // + // need to close our read end of the pipe so that it will go + // away when the write end is closed. + // + + if (_close(pipes[NtPipeRead]) == -1) { + _close(pipes[NtPipeWrite]); + return NULL; + } + if (_dup2 (saved, fileno(stdin)) == -1) { + _close(pipes[NtPipeWrite]); + return NULL; + } + _close(saved); + + // + // Now get a stream pointer to return to the calling program. + // + + if ((fp = (FILE *) fdopen(pipes[NtPipeWrite], mode)) == NULL) { + _close(pipes[NtPipeWrite]); + return NULL; + } + } + + // + // do the book keeping + // + + MyPopenRecord[slot].inuse = TRUE; + MyPopenRecord[slot].pipe = fp; + MyPopenRecord[slot].pid = pid; + + return fp; +} + +int +mypclose(FILE *fp) +{ + int i; + int exitcode; + + for (i = 0; i < MYPOPENSIZE; i++) { + if (MyPopenRecord[i].inuse && MyPopenRecord[i].pipe == fp) + break; + } + if (i >= MYPOPENSIZE) { + fprintf(stderr,"Invalid file pointer passed to mypclose!\n"); + abort(); + } + + // + // get the return status of the process + // + + if (_cwait(&exitcode, MyPopenRecord[i].pid, WAIT_CHILD) == -1) { + if (errno == ECHILD) { + fprintf(stderr, "mypclose: nosuch child as pid %x\n", + MyPopenRecord[i].pid); + } + } + + // + // close the pipe + // + + fclose(fp); + + // + // free this slot + // + + MyPopenRecord[i].inuse = FALSE; + + return exitcode; +} + + +/* + * The following code is based on the do_exec and do_aexec functions + * in file doio.c + */ + +int +do_spawn(cmd) +char *cmd; +{ + register char **a; + register char *s; + char **argv; + int status; + char *shell, *cmd2; + int mode = NtSyncProcess ? P_WAIT : P_NOWAIT; + + /* save an extra exec if possible */ + if ((shell = getenv("COMSPEC")) == 0) + shell = "cmd.exe"; + + /* see if there are shell metacharacters in it */ + if (NtHasRedirection(cmd)) { + doshell: + return spawnle(mode, shell, shell, "/c", cmd, (char*)0, environ); + } + + argv = ALLOC_N(char*, strlen(cmd) / 2 + 2); + cmd2 = ALOOC_N(char, strlen(cmd) + 1); + strcpy(cmd2, cmd); + a = argv; + for (s = cmd2; *s;) { + while (*s && isspace(*s)) s++; + if (*s) + *(a++) = s; + while (*s && !isspace(*s)) s++; + if (*s) + *s++ = '\0'; + } + *a = Qnil; + if (argv[0]) { + if ((status = spawnvpe(mode, argv[0], argv, environ)) == -1) { + free(argv); + free(cmd2); + goto doshell; + } + } + free(cmd2); + free(argv); + return status; +} + + + +typedef struct _NtCmdLineElement { + struct _NtCmdLineElement *next, *prev; + char *str; + int len; + int flags; +} NtCmdLineElement; + +// +// Possible values for flags +// + +#define NTGLOB 0x1 // element contains a wildcard +#define NTMALLOC 0x2 // string in element was malloc'ed +#define NTSTRING 0x4 // element contains a quoted string + +NtCmdLineElement *NtCmdHead = NULL, *NtCmdTail = NULL; + +void +NtFreeCmdLine(void) +{ + NtCmdLineElement *ptr; + + while(NtCmdHead) { + ptr = NtCmdHead; + NtCmdHead = NtCmdHead->next; + free(ptr); + } + NtCmdHead = NtCmdTail = NULL; +} + +// +// This function expands wild card characters that were spotted +// during the parse phase. The idea here is to call FindFirstFile and +// FindNextFile with the wildcard pattern specified, and splice in the +// resulting list of new names. If the wildcard pattern doesn\'t match +// any existing files, just leave it in the list. +// + +void +NtCmdGlob (NtCmdLineElement *patt) +{ + WIN32_FIND_DATA fd; + HANDLE fh; + char buffer[512]; + NtCmdLineElement *tmphead, *tmptail, *tmpcurr; + + strncpy(buffer, patt->str, patt->len); + buffer[patt->len] = '\0'; + if ((fh = FindFirstFile (buffer, &fd)) == INVALID_HANDLE_VALUE) { + return; + } + tmphead = tmptail = NULL; + do { + tmpcurr = ALLOC(NtCmdLineElement); + if (tmpcurr == NULL) { + fprintf(stderr, "Out of Memory in globbing!\n"); + while (tmphead) { + tmpcurr = tmphead; + tmphead = tmphead->next; + free(tmpcurr->str); + free(tmpcurr); + } + return; + } + memset (tmpcurr, 0, sizeof(*tmpcurr)); + tmpcurr->len = strlen(fd.cFileName); + tmpcurr->str = ALLOC_N(char, tmpcurr->len+1); + if (tmpcurr->str == NULL) { + fprintf(stderr, "Out of Memory in globbing!\n"); + while (tmphead) { + tmpcurr = tmphead; + tmphead = tmphead->next; + free(tmpcurr->str); + free(tmpcurr); + } + return; + } + strcpy(tmpcurr->str, fd.cFileName); + tmpcurr->flags |= NTMALLOC; + if (tmptail) { + tmptail->next = tmpcurr; + tmpcurr->prev = tmptail; + tmptail = tmpcurr; + } + else { + tmptail = tmphead = tmpcurr; + } + } while(FindNextFile(fh, &fd)); + + // + // ok, now we\'ve got a list of files that matched the wildcard + // specification. Put it in place of the pattern structure. + // + + tmphead->prev = patt->prev; + tmptail->next = patt->next; + + if (tmphead->prev) + tmphead->prev->next = tmphead; + + if (tmptail->next) + tmptail->next->prev = tmptail; + + // + // Now get rid of the pattern structure + // + + if (patt->flags & NTMALLOC) + free(patt->str); + free(patt); +} + +// +// Check a command string to determine if it has I/O redirection +// characters that require it to be executed by a command interpreter +// + +static bool +NtHasRedirection (char *cmd) +{ + int inquote = 0; + char quote = '\0'; + char *ptr ; + + // + // Scan the string, looking for redirection (< or >) or pipe + // characters (|) that are not in a quoted string + // + + for (ptr = cmd; *ptr; ptr++) { + + switch (*ptr) { + + case '\'': + case '\"': + if (inquote) { + if (quote == *ptr) { + inquote = 0; + quote = '\0'; + } + } + else { + quote = *ptr; + inquote++; + } + break; + + case '>': + case '<': + + if (!inquote) + return TRUE; + } + } + return FALSE; +} + + +int +NtMakeCmdVector (char *cmdline, char ***vec, int InputCmd) +{ + int cmdlen = strlen(cmdline); + int done, instring, globbing, quoted, len; + int newline, need_free = 0, i; + int elements, strsz; + int slashes = 0; + char *ptr, *base, *buffer; + char **vptr; + char quote; + NtCmdLineElement *curr; + + // + // just return if we don\'t have a command line + // + + if (cmdlen == 0) { + *vec = NULL; + return 0; + } + + // + // strip trailing white space + // + + ptr = cmdline+(cmdlen - 1); + while(ptr >= cmdline && isspace(*ptr)) + --ptr; + *++ptr = '\0'; + + // + // check for newlines and formfeeds. If we find any, make a new + // command string that replaces them with escaped sequences (\n or \f) + // + + for (ptr = cmdline, newline = 0; *ptr; ptr++) { + if (*ptr == '\n' || *ptr == '\f') + newline++; + } + + if (newline) { + base = ALLOC_N(char, strlen(cmdline) + 1 + newline + slashes); + if (base == NULL) { + fprintf(stderr, "malloc failed!\n"); + return 0; + } + for (i = 0, ptr = base; (unsigned) i < strlen(cmdline); i++) { + switch (cmdline[i]) { + case '\n': + *ptr++ = '\\'; + *ptr++ = 'n'; + break; + default: + *ptr++ = cmdline[i]; + } + } + *ptr = '\0'; + cmdline = base; + need_free++; + } + + // + // Ok, parse the command line, building a list of CmdLineElements. + // When we\'ve finished, and it\'s an input command (meaning that it\'s + // the processes argv), we\'ll do globing and then build the argument + // vector. + // The outer loop does one interation for each element seen. + // The inner loop does one interation for each character in the element. + // + + for (done = 0, ptr = cmdline; *ptr;) { + + // + // zap any leading whitespace + // + + while(isspace(*ptr)) + ptr++; + base = ptr; + + for (done = newline = globbing = instring = quoted = 0; + *ptr && !done; ptr++) { + + // + // Switch on the current character. We only care about the + // white-space characters, the wild-card characters, and the + // quote characters. + // + + switch (*ptr) { + case ' ': + case '\t': +#if 0 + case '/': // have to do this for NT/DOS option strings + + // + // check to see if we\'re parsing an option switch + // + + if (*ptr == '/' && base == ptr) + continue; +#endif + // + // if we\'re not in a string, then we\'re finished with this + // element + // + + if (!instring) + done++; + break; + + case '*': + case '?': + + // + // record the fact that this element has a wildcard character + // N.B. Don\'t glob if inside a single quoted string + // + + if (!(instring && quote == '\'')) + globbing++; + break; + + case '\n': + + // + // If this string contains a newline, mark it as such so + // we can replace it with the two character sequence "\n" + // (cmd.exe doesn\'t like raw newlines in strings...sigh). + // + + newline++; + break; + + case '\'': + case '\"': + + // + // if we\'re already in a string, see if this is the + // terminating close-quote. If it is, we\'re finished with + // the string, but not neccessarily with the element. + // If we\'re not already in a string, start one. + // + + if (instring) { + if (quote == *ptr) { + instring = 0; + quote = '\0'; + } + } + else { + instring++; + quote = *ptr; + quoted++; + } + break; + } + } + + // + // need to back up ptr by one due to last increment of for loop + // (if we got out by seeing white space) + // + + if (*ptr) + ptr--; + + // + // when we get here, we\'ve got a pair of pointers to the element, + // base and ptr. Base points to the start of the element while ptr + // points to the character following the element. + // + + curr = ALLOC(NtCmdLineElement); + if (curr == NULL) { + NtFreeCmdLine(); + fprintf(stderr, "Out of memory!!\n"); + *vec = NULL; + return 0; + } + memset (curr, 0, sizeof(*curr)); + + len = ptr - base; + + // + // if it\'s an input vector element and it\'s enclosed by quotes, + // we can remove them. + // + + if (InputCmd && + ((base[0] == '\"' && base[len-1] == '\"') || + (base[0] == '\'' && base[len-1] == '\''))) { + base++; + len -= 2; + } + + curr->str = base; + curr->len = len; + curr->flags |= (globbing ? NTGLOB : 0); + + // + // Now put it in the list of elements + // + if (NtCmdTail) { + NtCmdTail->next = curr; + curr->prev = NtCmdTail; + NtCmdTail = curr; + } + else { + NtCmdHead = NtCmdTail = curr; + } + } + + if (InputCmd) { + + // + // When we get here we\'ve finished parsing the command line. Now + // we need to run the list, expanding any globbing patterns. + // + + for(curr = NtCmdHead; curr; curr = curr->next) { + if (curr->flags & NTGLOB) { + NtCmdGlob(curr); + } + } + } + + // + // Almost done! + // Count up the elements, then allocate space for a vector of pointers + // (argv) and a string table for the elements. + // + + for (elements = 0, strsz = 0, curr = NtCmdHead; curr; curr = curr->next) { + elements++; + strsz += (curr->len + 1); + } + + len = (elements+1)*sizeof(char *) + strsz; + buffer = ALLOC_N(char, len); + if (buffer == NULL) { + fprintf(stderr, "Out of memory!!\n"); + NtFreeCmdLine(); + *vec = NULL; + return 0; + } + + memset (buffer, 0, len); + + // + // make vptr point to the start of the buffer + // and ptr point to the area we\'ll consider the string table. + // + + vptr = (char **) buffer; + + ptr = buffer + (elements+1) * sizeof(char *); + + for (curr = NtCmdHead; curr; curr = curr->next) { + strncpy (ptr, curr->str, curr->len); + ptr[curr->len] = '\0'; + *vptr++ = ptr; + ptr += curr->len + 1; + } + NtFreeCmdLine(); + *vec = (char **) buffer; + return elements; +} + + +// +// UNIX compatible directory access functions for NT +// + +// +// File names are converted to lowercase if the +// CONVERT_TO_LOWER_CASE variable is defined. +// + +#define CONVERT_TO_LOWER_CASE +#define PATHLEN 1024 + +// +// The idea here is to read all the directory names into a string table +// (separated by nulls) and when one of the other dir functions is called +// return the pointer to the current file name. +// + +DIR * +opendir(char *filename) +{ + DIR *p; + long len; + long idx; + char scannamespc[PATHLEN]; + char *scanname = scannamespc; + struct stat sbuf; + WIN32_FIND_DATA FindData; + HANDLE fh; + char root[PATHLEN]; + char volname[PATHLEN]; + DWORD serial, maxname, flags; + BOOL downcase; + char *dummy; + + // + // check to see if we\'ve got a directory + // + + if (stat (filename, &sbuf) < 0 || + sbuf.st_mode & _S_IFDIR == 0) { + return NULL; + } + + // + // check out the file system characteristics + // + if (GetFullPathName(filename, PATHLEN, root, &dummy)) { + if (dummy = strchr(root, '\\')) + *++dummy = '\0'; + if (GetVolumeInformation(root, volname, PATHLEN, + &serial, &maxname, &flags, 0, 0)) { + downcase = !(flags & FS_CASE_SENSITIVE); + } + } + else { + downcase = TRUE; + } + + // + // Get us a DIR structure + // + + p = xcalloc(sizeof(DIR), 1); + if (p == NULL) + return NULL; + + // + // Create the search pattern + // + + strcpy(scanname, filename); + + if (index("/\\", *(scanname + strlen(scanname) - 1)) == NULL) + strcat(scanname, "/*"); + else + strcat(scanname, "*"); + + // + // do the FindFirstFile call + // + + fh = FindFirstFile (scanname, &FindData); + if (fh == INVALID_HANDLE_VALUE) { + return NULL; + } + + // + // now allocate the first part of the string table for the + // filenames that we find. + // + + idx = strlen(FindData.cFileName)+1; + p->start = ALLOC_N(char, idx); + strcpy (p->start, FindData.cFileName); + if (downcase) + strlwr(p->start); + p->nfiles++; + + // + // loop finding all the files that match the wildcard + // (which should be all of them in this directory!). + // the variable idx should point one past the null terminator + // of the previous string found. + // + while (FindNextFile(fh, &FindData)) { + len = strlen (FindData.cFileName); + + // + // bump the string table size by enough for the + // new name and it's null terminator + // + + Renew (p->start, idx+len+1, char); + if (p->start == NULL) { + fatal ("opendir: malloc failed!\n"); + } + strcpy(&p->start[idx], FindData.cFileName); + if (downcase) + strlwr(&p->start[idx]); + p->nfiles++; + idx += len+1; + } + FindClose(fh); + p->size = idx; + p->curr = p->start; + return p; +} + + +// +// Readdir just returns the current string pointer and bumps the +// string pointer to the next entry. +// + +struct direct * +readdir(DIR *dirp) +{ + int len; + static int dummy = 0; + + if (dirp->curr) { + + // + // first set up the structure to return + // + + len = strlen(dirp->curr); + strcpy(dirp->dirstr.d_name, dirp->curr); + dirp->dirstr.d_namlen = len; + + // + // Fake inode + // + dirp->dirstr.d_ino = dummy++; + + // + // Now set up for the next call to readdir + // + + dirp->curr += len + 1; + if (dirp->curr >= (dirp->start + dirp->size)) { + dirp->curr = NULL; + } + + return &(dirp->dirstr); + + } else + return NULL; +} + +// +// Telldir returns the current string pointer position +// + +long +telldir(DIR *dirp) +{ + return (long) dirp->curr; /* ouch! pointer to long cast */ +} + +// +// Seekdir moves the string pointer to a previously saved position +// (Saved by telldir). + +void +seekdir(DIR *dirp, long loc) +{ + dirp->curr = (char *) loc; /* ouch! long to pointer cast */ +} + +// +// Rewinddir resets the string pointer to the start +// + +void +rewinddir(DIR *dirp) +{ + dirp->curr = dirp->start; +} + +// +// This just free\'s the memory allocated by opendir +// + +void +closedir(DIR *dirp) +{ + free(dirp->start); + free(dirp); +} + + + +// +// 98.2% of this code was lifted from the OS2 port. (JCW) +// + +/* + * Suffix appending for in-place editing under MS-DOS and OS/2 (and now NT!). + * + * Here are the rules: + * + * Style 0: Append the suffix exactly as standard perl would do it. + * If the filesystem groks it, use it. (HPFS will always + * grok it. So will NTFS. FAT will rarely accept it.) + * + * Style 1: The suffix begins with a '.'. The extension is replaced. + * If the name matches the original name, use the fallback method. + * + * Style 2: The suffix is a single character, not a '.'. Try to add the + * suffix to the following places, using the first one that works. + * [1] Append to extension. + * [2] Append to filename, + * [3] Replace end of extension, + * [4] Replace end of filename. + * If the name matches the original name, use the fallback method. + * + * Style 3: Any other case: Ignore the suffix completely and use the + * fallback method. + * + * Fallback method: Change the extension to ".$$$". If that matches the + * original name, then change the extension to ".~~~". + * + * If filename is more than 1000 characters long, we die a horrible + * death. Sorry. + * + * The filename restriction is a cheat so that we can use buf[] to store + * assorted temporary goo. + * + * Examples, assuming style 0 failed. + * + * suffix = ".bak" (style 1) + * foo.bar => foo.bak + * foo.bak => foo.$$$ (fallback) + * foo.$$$ => foo.~~~ (fallback) + * makefile => makefile.bak + * + * suffix = "~" (style 2) + * foo.c => foo.c~ + * foo.c~ => foo.c~~ + * foo.c~~ => foo~.c~~ + * foo~.c~~ => foo~~.c~~ + * foo~~~~~.c~~ => foo~~~~~.$$$ (fallback) + * + * foo.pas => foo~.pas + * makefile => makefile.~ + * longname.fil => longname.fi~ + * longname.fi~ => longnam~.fi~ + * longnam~.fi~ => longnam~.$$$ + * + */ + + +static char suffix1[] = ".$$$"; +static char suffix2[] = ".~~~"; + +#define ext (&buf[1000]) + +#define strEQ(s1,s2) (strcmp(s1,s2) == 0) + +void +add_suffix(struct RString *str, char *suffix) +{ + int baselen; + int extlen = strlen(suffix); + char *s, *t, *p; + int slen; + char buf[1024]; + + if (str->len > 1000) + Fatal("Cannot do inplace edit on long filename (%d characters)", str->len); + + /* Style 0 */ + slen = str->len; + str_cat(str, suffix, extlen); + if (valid_filename(str->ptr)) return; + + /* Fooey, style 0 failed. Fix str before continuing. */ + str->ptr[str->len = slen] = '\0'; + + slen = extlen; + t = buf; baselen = 0; s = str->ptr; + while ( (*t = *s) && *s != '.') { + baselen++; + if (*s == '\\' || *s == '/') baselen = 0; + s++; t++; + } + p = t; + + t = ext; extlen = 0; + while (*t++ = *s++) extlen++; + if (extlen == 0) { ext[0] = '.'; ext[1] = 0; extlen++; } + + if (*suffix == '.') { /* Style 1 */ + if (strEQ(ext, suffix)) goto fallback; + strcpy(p, suffix); + } else if (suffix[1] == '\0') { /* Style 2 */ + if (extlen < 4) { + ext[extlen] = *suffix; + ext[++extlen] = '\0'; + } else if (baselen < 8) { + *p++ = *suffix; + } else if (ext[3] != *suffix) { + ext[3] = *suffix; + } else if (buf[7] != *suffix) { + buf[7] = *suffix; + } else goto fallback; + strcpy(p, ext); + } else { /* Style 3: Panic */ +fallback: + (void)memcpy(p, strEQ(ext, suffix1) ? suffix2 : suffix1, 5); + } + str_grow(str, strlen(buf)); + memcpy(str->ptr, buf, str->len); +} + +static int +valid_filename(char *s) +{ + int fd; + + // + // if the file exists, then it\'s a valid filename! + // + + if (_access(s, 0) == 0) { + return 1; + } + + // + // It doesn\'t exist, so see if we can open it. + // + + if ((fd = _open(s, _O_CREAT, 0666)) >= 0) { + close(fd); + _unlink (s); // don\'t leave it laying around + return 1; + } + return 0; +} + + +// +// This is a clone of fdopen so that we can handle the +// brain damaged version of sockets that NT gets to use. +// +// The problem is that sockets are not real file handles and +// cannot be fdopen\'ed. This causes problems in the do_socket +// routine in doio.c, since it tries to create two file pointers +// for the socket just created. We\'ll fake out an fdopen and see +// if we can prevent perl from trying to do stdio on sockets. +// + +FILE * +fdopen (int fd, char *mode) +{ + FILE *fp; + char sockbuf[80]; + int optlen; + int retval; + extern int errno; + + retval = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen); + if (retval == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK) { + return (_fdopen(fd, mode)); + } + + // + // If we get here, then fd is actually a socket. + // + fp = xcalloc(sizeof(FILE), 1); +#if _MSC_VER < 800 + fileno(fp) = fd; +#else + fp->_file = fd; +#endif + if (*mode = 'r') + fp->_flag = _IOREAD; + else + fp->_flag = _IOWRT; + return fp; +} + + +// +// Since the errors returned by the socket error function +// WSAGetLastError() are not known by the library routine strerror +// we have to roll our own. +// + +#undef strerror + +char * +mystrerror(int e) +{ + static char buffer[512]; + extern int sys_nerr; + DWORD source = 0; + + if (e < 0 || e > sys_nerr) { + if (e < 0) + e = GetLastError(); + if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, &source, e, 0, + buffer, 512, NULL) == 0) { + strcpy (buffer, "Unknown Error"); + } + return buffer; + } + return strerror(e); + +} + +// +// various stubs +// + + +// Ownership +// +// Just pretend that everyone is a superuser. NT will let us know if +// we don\'t really have permission to do something. +// + +#define ROOT_UID 0 +#define ROOT_GID 0 + +UIDTYPE +getuid(void) +{ + return ROOT_UID; +} + +UIDTYPE +geteuid(void) +{ + return ROOT_UID; +} + +GIDTYPE +getgid(void) +{ + return ROOT_GID; +} + +GIDTYPE +getegid(void) +{ + return ROOT_GID; +} + +int +setuid(int uid) +{ + return (uid == ROOT_UID ? 0 : -1); +} + +int +setgid(int gid) +{ + return (gid == ROOT_GID ? 0 : -1); +} + +// +// File system stuff +// + +int +ioctl(int i, unsigned int u, char *data) +{ + return -1; +} + + +// +// Networking trampolines +// These are used to avoid socket startup/shutdown overhead in case +// the socket routines aren\'t used. +// + +#undef select + +static int NtSocketsInitialized = 0; + +long +myselect (int nfds, fd_set *rd, fd_set *wr, fd_set *ex, + struct timeval *timeout) +{ + long r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = select (nfds, rd, wr, ex, timeout)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +static void +StartSockets () { + WORD version; + WSADATA retdata; + int ret; + + // + // initalize the winsock interface and insure that it\'s + // cleaned up at exit. + // + version = MAKEWORD(1, 1); + if (ret = WSAStartup(version, &retdata)) + fatal ("Unable to locate winsock library!\n"); + if (LOBYTE(retdata.wVersion) != 1) + fatal("could not find version 1 of winsock dll\n"); + + if (HIBYTE(retdata.wVersion) != 1) + fatal("could not find version 1 of winsock dll\n"); + + atexit((void (*)(void)) WSACleanup); +} + +#undef accept + +SOCKET +myaccept (SOCKET s, struct sockaddr *addr, int *addrlen) +{ + SOCKET r; + + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = accept (s, addr, addrlen)) == INVALID_SOCKET) + errno = WSAGetLastError(); + return r; +} + +#undef bind + +int +mybind (SOCKET s, struct sockaddr *addr, int addrlen) +{ + int r; + + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = bind (s, addr, addrlen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef connect + +int +myconnect (SOCKET s, struct sockaddr *addr, int addrlen) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = connect (s, addr, addrlen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + + +#undef getpeername + +int +mygetpeername (SOCKET s, struct sockaddr *addr, int *addrlen) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = getpeername (s, addr, addrlen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef getsockname + +int +mygetsockname (SOCKET s, struct sockaddr *addr, int *addrlen) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = getsockname (s, addr, addrlen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef getsockopt + +int +mygetsockopt (SOCKET s, int level, int optname, char *optval, int *optlen) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = getsockopt (s, level, optname, optval, optlen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef ioctlsocket + +int +myioctlsocket (SOCKET s, long cmd, u_long *argp) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = ioctlsocket (s, cmd, argp)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef listen + +int +mylisten (SOCKET s, int backlog) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = listen (s, backlog)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef recv + +int +myrecv (SOCKET s, char *buf, int len, int flags) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = recv (s, buf, len, flags)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef recvfrom + +int +myrecvfrom (SOCKET s, char *buf, int len, int flags, + struct sockaddr *from, int *fromlen) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = recvfrom (s, buf, len, flags, from, fromlen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef send + +int +mysend (SOCKET s, char *buf, int len, int flags) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = send (s, buf, len, flags)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef sendto + +int +mysendto (SOCKET s, char *buf, int len, int flags, + struct sockaddr *to, int tolen) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = sendto (s, buf, len, flags, to, tolen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef setsockopt + +int +mysetsockopt (SOCKET s, int level, int optname, char *optval, int optlen) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = setsockopt (s, level, optname, optval, optlen)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef shutdown + +int +myshutdown (SOCKET s, int how) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = shutdown (s, how)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef socket + +SOCKET +mysocket (int af, int type, int protocol) +{ + SOCKET s; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((s = socket (af, type, protocol)) == INVALID_SOCKET) + errno = WSAGetLastError(); + return s; +} + +#undef gethostbyaddr + +struct hostent * +mygethostbyaddr (char *addr, int len, int type) +{ + struct hostent *r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = gethostbyaddr (addr, len, type)) == NULL) + errno = WSAGetLastError(); + return r; +} + +#undef gethostbyname + +struct hostent * +mygethostbyname (char *name) +{ + struct hostent *r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = gethostbyname (name)) == NULL) + errno = WSAGetLastError(); + return r; +} + +#undef gethostname + +int +mygethostname (char *name, int len) +{ + int r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = gethostname (name, len)) == SOCKET_ERROR) + errno = WSAGetLastError(); + return r; +} + +#undef getprotobyname + +struct protoent * +mygetprotobyname (char *name) +{ + struct protoent *r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = getprotobyname (name)) == NULL) + errno = WSAGetLastError(); + return r; +} + +#undef getprotobynumber + +struct protoent * +mygetprotobynumber (int num) +{ + struct protoent *r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = getprotobynumber (num)) == NULL) + errno = WSAGetLastError(); + return r; +} + +#undef getservbyname + +struct servent * +mygetservbyname (char *name, char *proto) +{ + struct servent *r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = getservbyname (name, proto)) == NULL) + errno = WSAGetLastError(); + return r; +} + +#undef getservbyport + +struct servent * +mygetservbyport (int port, char *proto) +{ + struct servent *r; + if (!NtSocketsInitialized++) { + StartSockets(); + } + if ((r = getservbyport (port, proto)) == NULL) + errno = WSAGetLastError(); + return r; +} + +// +// Networking stubs +// + +void endhostent() {} +void endnetent() {} +void endprotoent() {} +void endservent() {} + +struct netent *getnetent (void) {return (struct netent *) NULL;} + +struct netent *getnetbyaddr(char *name) {return (struct netent *)NULL;} + +struct netent *getnetbyname(long net, int type) {return (struct netent *)NULL;} + +struct protoent *getprotoent (void) {return (struct protoent *) NULL;} + +struct servent *getservent (void) {return (struct servent *) NULL;} + +void sethostent (int stayopen) {} + +void setnetent (int stayopen) {} + +void setprotoent (int stayopen) {} + +void setservent (int stayopen) {} + + +pid_t +waitpid (pid_t pid, int *stat_loc, int options) +{ + DWORD timeout; + + if (options == WNOHANG) { + timeout = 0; + } else { + timeout = INFINITE; + } + if (WaitForSingleObject((HANDLE) pid, timeout) == WAIT_OBJECT_0) { + pid = _cwait(stat_loc, pid, 0); + return pid; + } + return 0; +} + +#include + +void _cdecl +gettimeofday(struct timeval *tv, struct timezone *tz) +{ + struct timeb tb; + + ftime(&tb); + tv->tv_sec = tb.time; + tv->tv_usec = tb.millitm * 1000; +} + +char * +getcwd(buffer, size) + char *buffer; + int size; +{ + int length; + char *pb; + + if (_getcwd(buffer, size) == NULL) { + return NULL; + } + length = strlen(buffer); + if (length >= size) { + return NULL; + } + + for (bp = buffer; *bp != '\0'; bp++) { + if (*bp == '\\') { + *bp = '/'; + } + } + return buffer; +} -- cgit v1.2.3