
.soopy

soopyLENSEiffel,StandardML򻲹ͤˡʤ٤ñʸˡ
ᤶƺ줿ץǤ

ÿʲˤˤäƤʤޤ

ץʸˡ
LispSmalltalkML­3ǳä褦ʷϵ
˭٤Ȥ߹߷
ѥޥå
饹ȤǰʤΤ˥֥Ȼظ
ؿȥ֥Ȼظ줬̯˺ä



ʤΥɥȤϵ͵ϺΡtxtCompileۤ
ѤƺƤޤա


..󥹥ȡ

¹ԥեsoopy(.exe)ѥΤȤäǥ쥯ȥ֤ޤ
ʾ塣


..

ʸμ
ñʼ
ʸ
å


ޤޤȤ߹߷


...ʸμ

soopyιʸñǤ礭櫓ȼΣǤ

Ѽʡܡݡˡandorˤʤɤñʼ
ʸ
å
湽¤ -- ʬ(if)ȷ֤(loop)
ؿ

줾ʸˤĤƴñޤ

....ñʼ

ñʼˤϡñ黻Ҥȣ黻Ҥޤ

Ѽ
ûʡܡˡʡݡˡݤʡˡ껻ʡˡ;ʡ

ɡandˡorˡʡ
͡ʡˡʤʡˡ
礭ʡˡʾʡˡʡˡʲʡ
ΤۤˡLispˤConsͤʡ˱黻Ҥ䡢黻Ҥʤɤޤ

黻Ҥ̤ͥϰʲΤȤǤʤŪˤ̤ͥ
Ѥǽ⤢롣ʸǤϿͤƤʤǡ^_^;ˡ

ͥ

<pre>
㤤or
and

==, !=
>, >=, <, <=
+, -
*, /, %
ݡñ
⤤.., ::, //, @
</pre>



....ʸ

.....̤

ʸϡʡˤǷФ줿դλؤ
դͤդޤ
ޡ³θˤϤ褯ĤǤ

㡣
<pre>
              pi = 3.14;

              msg = "Hello, world!";

              anArray(2,3) = 'c';

              square = {arg:[x]; do:[x * x];};

              anObject aFeature = "Hummm?";

</pre>
ʤɤʤɡ

.....¿

¿ϰ٤ʣξͤӤĤޤ

㡣
<pre>
              let (x,y,z) = (2, 'a', "hello");
</pre>


....å

֥ȻظˤȤäơäȤפʸǤ
ȤäƤ⡢˥֥Ȥ˥åǤɤ͡(^_^;
soopyǤϡؿåȤƼ¸Ƥޤ
soopyˤƤϡʲΤ褦ʹʸˤʤäƤޤ

㥪֥ȡ䡡å


㡣
<pre>
             "string" length;

             [1,2,3] map ({arg:[x]; do:[x+1];} eval);

             [3...7] each ({arg:[x]; do:[println x];} eval);

             {
               fun main(){do: println "Hello, world!";};
             } main();

             {
               a: 3;
               fun f(x){do:a+x;};
             } f 7;

</pre>

....

/*  */˰Ϥޤ줿ʬϥȤǤ
ޤǤ⥳ȤǤ




...ޤޤȤ߹߷

ʸǤϡʣʥץȤʤΤǡ
soopyˤϤޤޤʼȤ߹߷ѰդƤޤ

Int)
飹ο¤ӡ褯ġ

¿Real)
ȤȤ

Bool)
trueʿˤfalseʵˤɽ롣

ʸChar)
ǤȡǤǤϤޤ줿ʸΥ饯

ʸ
ɤȡɤǰϤޤ줿ʸ¤ӡ



ʲˡ¾ˤɤʷѰդƤ뤫񤤤Ƥޤ
ܤ<CLASS Reference>򻲾ȤƤ

    List(ꥹ), NameSpace(֥),
    Array, TextFileIn, TextFileOut,
    Primitive, Closure(



..
...󥿡ץ꥿εưȽλ

soopy󥿡ץ꥿ʤǵưȡ
ץץȡʡˤɽơ桼Ԥ
ʤޤ
ǡʸϤȡsoopy
ʸᤷ¹Ԥޤ
soopy򽪤ȤˤϡEOFWindowsʤCtrl-Zˤ
ϤƤ

ޤ餫Ѱդץե
¹ԤȤˤϡ

soopy filename [¤]

ǣϣˤǤ


...ǽΥץ

ȤС"Hello, world"Ǥ
soopyǤϤɤʤΤǤ礦
ĤˡϤޤǽϡ

(* 1 *)

println "Hello, World!";

ޤ
ޤ˳ФߤΤϡʸνˤɬ
ߥʡˤɬפȤȤǤ
ǤϡsoopyưƾʸϤƤߤ
ʸǸޤϤ顢ԥ
ޤ

soopyˤϡ5ʸʤ櫓Ǥ
ǤϤʸϣϤΤɤʸˤ
ΤǤ礦
狼Τ褦ˡñʼǤ⡢ʸʤɤǤ
ʤǤ顢åǤ
åϡĤͤ

㥪֥ȡ䡡å

Ȥ򤷤Ƥޤ顢ξ硢
println ֥ȡ"Hello, World!"
åˤʤޤǤϡ줾ɤʷ
֥ȤʤΤƤޤ礦ʥå
¤ñʤ륪֥ȤǤ
"Hello, World!"ϡʸString)פǤ
printlnϥ֥ȤȤƼ̤
ɽ֥ץߥƥ֡Ȥ߹ߴؿˡפǤ
Ǥ顢ʸϥץߥƥ֤ʸ
åȤäƤ櫓Ǥ
ʤߤˡprintlnͤϼʬȤǤΤǡ
ĤŤޤ˥ץȤˤϡ

println object1 object2 ... objectN;

ʤɤȽ񤱤ޤ


(* 2 *)

<pre>
{
  fun main(){do: println "Hello, World!";};
} main();
</pre>

ʸϡСȡѤ˰Ϥޤ줿ʬ֥Ȥ
ɽƤơΥ֥ȤmainȤܥ
äƤޤ
֥Ȥ˥ܥ뤬ȡΥ֥
Ʊ̾Ǥ֤ޤξ硢mainȤ̾
ؿʼºݤˤϥˤ֤äƤޤ
ơ֤äƤؿˤˡʡˡ̥롦֥Ȥ
åȤ뤳Ȥˤꡢؿ¹Ԥޤ

ɡ(*  *)ʸǤ⡢ʡˤʸƱͤˡ
"Hello, World!"ɽޤ



...ñʼ

ѼʤɤCʤɤȤۤѤ꤬ޤʤΤǾάˡ


...ꥹ

ꥹȤȤϡLispǤꥹȤȰǤ
LispΤʤƤꤢޤ[ ] ǰϤޤ줿
ñʤ륪֥Ȥ¤ӤǤʤҤȤĤҤȤĤǤ
(,)뤤ϥߥ(;)Ƕڤޤ
ꥹȤΤʤˤϿʸ
åʤǤޤ

㡣

<pre>
   [1,2,3];

   [45, "string", 'c', x + y, println "Hello"];
</pre>


ޤꥹȤüʷȤơ

<pre>
[͡..㽪͡]
</pre>

ȤΤΤޤϡ͡䤫㽪͡ޤǤ
ΥꥹȤƱ̣Ǥ㤨С  [1,2,3,4,5]ȡ[1..5]
Ʊ̣Ǥ
Ȥǡ㽪͡ϾάǽǤάȤɤʤ뤫
ȡ̵¥ꥹȤɽޤ
㤨С[27..] ϡ飱̵¤ΥꥹȤɽޤ

ˡ
<pre>
[͡..㼡͡..㽪͡]
</pre>

ȤС㼡͡ݡ͡䤺ꥹȤޤ
ξ⡢㽪͡Ͼά̵¥ꥹȤޤ


...ץȡ

ץȤϡ   ǰϤޤ줿<b>İʾ</b>Υ֥Ȥ¤ӤǤ
ʤҤȤĤҤȤĤǤϥ(,)Ƕڤޤ
ؿʣΰϤȤʤɤ˻Ȥޤ


...ؿ


<ol>
  <li>ؿ
    <blockquote>
      ؿϡʲη򤷤Ƥޤ
<pre>
        fun func_name(arg1, arg2,...,argN){<br>
          require: [statement list];<br>
          var: [symbol list];<br>
          do: [statement list];<br>
          ensure: [statement list];<br>
          rescue: [statement list];<br>
        };<br>
<pre>
      require: ˤϡؿλ¤ӡ<br>
      var: ˤϡѿ̾ʥܥˤΥꥹȡ<br>
      do: ˤϡؿ(ºݤ˼¹Ԥʸ)¤ӡ<br>
      ensure: ˤϡ¤ӡ<br>
      rescue: ˤϡؿΤ㳰˼¹Ԥʸ¤<br>
      롣<br>
    </blockquote>
<br>
<br>
</ol>

㡣
<pre>
      fun square(x){do: [x * x];};(*׻ؿsquare*)

fun func2(x,y){    (*ؿΤˤϤựϤʤ*)
        var: [n,m],(*ѿ*)
        do: [
          n = x + y;
          m = x * y;
          n - m  (*n - m ͤؿ͡*)
        ];
      };
</pre>

ޤؿ¹Ԥˤϡؿ˰¤٤
ץޤ

㡣
<pre>
      func ();

      square (4);

      someFunction (2,7);
</pre>

δؿ˰򣱸ĤϤʤä硢
顼ˤϤʤ餺ǽΰϤͤդ줿
δؿ֤ޤ
̤ʣΰȤؿˡʤ
ϤʤäϡϤ֤ΰΤߡͤӤĤ줿
ؿʥˤ֤äƤޤ

㡣
<pre>
      g = func2 7;  (*g ϡδؿ*)
      g 8;          (*ؿͤϡ-41 *)
</pre>



...֥Ȼظ
....͡ॹڡ(NameSpace)

soopyˤϼ¤ϥ饹Ȥǰޤ
Ǥ⡢֥ȡʥ󥹥󥹡ˤϺޤ
soopyǤϡ֥Ȥϥ͡ॹڡ
ƤФޤ͡ॹڡϡ̤θƤ򤹤
ϢȤ⤤ޤ

͡ॹڡˤϡСȡѤ˰Ϥޤ졢ߥ()
Ƕڤ줿ե¤ӤǤ
ե

㥷ܥ䡧ʸ
η򤷤Ƥ뤫
ޤϡ
ؿ
ޤϡ

ޤϡ
ץѥƥ
ޤϡ
ǡ
Ǥ


ʸϡ֥Ȥޤ
ʤ֥ȤΤΤǤϤޤ󡣡
<pre>
      { a: 3; b: x; }
</pre>

  ޤǡ֥ȤʸʤΤǡ
ʸ¹Ԥ뤿ӡ륪֥Ȥ
ʪǤ

äơ

<pre>
      fun f(){
        do: [
          {
            a: 7;
            fun printIt(){do: [println a]; };
          }
        ];
      };
</pre>

ΤȤ

<pre>
      x = f();
      y = f();
</pre>

Ȥȡȣλؤ֥ȤʪǤ
ȣι¤ƱǤ
ȤȤϡ饹ȤʤƤ⡢Ʊ
֥ȤǽȤȤǤޤؿ
áܡܤʤɤ̤Υ֥Ȼظˤ
󥹥ȥ饯ܤ򤷤Ƥ뤳Ȥ狼Ȼפޤ

椬ȤؿȤ顢ɤǤ礦
ޤޤʥ֥ȤΤǤϤʤǤ礦
äƤߤޤ礦

<pre>

  fun map(f,l){
    do: if(l){
          []:    [];
          x::xs: f x :: map(f,xs);
        };
  };

  fun con(list,func){
    do: [
      {
        fun run(){
          do: [
          map (func, list);
          ];
        };
      };
    ];
  };

  fun add1(x){
    do: [x + 1];
  };

  fun add2(x){
    do: [x + 2];
  };

  a = con([1,2,3,4,5], add1);
  b = con([1..5], add2);
  a run();
  b run();
</pre>




....ե㡼Υ

֥ȤΥե㡼ǡˤɤ߽Фˤ
֥Ȥɤ߽Фե㡼̾ʥܥˤ
åȤޤ

㡣
<pre>
      obj = {
        num:3;
        str:"Hello";
        fun func(x){do: [x*num]; };
      };
      obj num;  (*֤äƤ롡*)
      obj str;  (*"Hello"֤äƤ롡*)
      obj func; (*ˣ­ؿ֤äƤ롡*)
      f = obj func;
      f(7);     (* 10֤äƤ *)
</pre>


....ե㡼ι

֥ȤΥե㡼˽񤭹ʹˤˤϡ
ǤʸȤޤ
ե㡼ɤ߹Τ

㥪֥ȡ䡡ե㡼̾

Ǥ顢񤭹ߤ

㥪֥ȡ䡡ե㡼̾䡡ᡡ񤭹ߤ͡

ǤñǤ͡
LispΤäƤˤϡCommon Lisp  setf ͤƤ
Ȼפޤäự

㡣
<pre>
      obj = {
        num:3;
        str:"Hello";
        fun func(x){do: [x*num]; };
      };
      obj num;      (*֤äƤ롡*)
      obj num = 8;  (*num ͤ򹹿*)
      obj num;      (*֤äƤ롡*)
</pre>


....ץѥƥ

ץѥƥϡDelphiȤˤΤȹͤƱǤ

㡣
<pre>
a = {
        b: 1;

        fun getf(){do: b;};
        fun setf(x){do: b = x;};

        property c {
            set: setf;
            get: getf;
        };
    };
</pre>
ǡ

<pre>
  a c;
</pre>
ȥե㡼˥褦Ȥȡ
set:ǻꤵ줿ؿƤӽФ졢ͤ
ͤȤʤޤ

ޤ
<pre>
  a c = value;
</pre>
ȥե㡼褦Ȥȡ
get:ǻꤵ줿ؿvalueȤ
ƤӽФޤ


....ǡ

ǡסˤϡñʤΤϡC/C++ʤɤ
󷿤˻Ƥޤ

㡣
<pre>
  datatype day = Mon | Tue | Wed | Thi | Fri | Sat | Sun;
</pre>

ΤޤޤǤϡꤰ餤ˤʤޤΤ
äȳĥƤߤޤ礦
<pre>
datatype day =
  Mon {
    const workday = true;
  }
| Tue {
    const workday = true;
  }
| Wed {
    const workday = true;
  }
| Thi {
    const workday = true;
  }
| Fri {
    const workday = true;
  }
| Sat {
    const workday = false;
  }
| Sun {
    const workday = false;
  }
;
</pre>
Ȥȡ
<pre>
  Mon workday;  # true

  Sun workday;  # false
</pre>

Τ褦˻Ȥޤ
Τ褦ˡǡפϤ⥪֥ȤΤ褦
ޤޤʥե㡼Ƥޤե㡼ˤ
ؿѿʤɤѲǽǤ

ޤǡפϽͤƤޤ
<pre>
datatype fig =  Rect(x:int, y:int)| Circle(r:int);
</pre>
Ȥ뤳Ȥˤꡢ
<pre>
r = Rect(5,7);
c = Circle(8);

r x;  # 5
c r;  # 8
</pre>
Τ褦ˡͤ˥ޤ
ˡ
<pre>
datatype fig =
  Rect(x:int, y:int){
    fun area(){
      do: x * y;
    };
  }
| Circle(r:int){
    pi: 3;
    fun area(){
      do: r * r * pi;
    };
  }
;
</pre>
Ȥȡ
<pre>
r = Rect(5,7);
c = Circle(8);

r area();  # RectʤΤǡRectareaƤФ롣ͤϡ
c area();  # CircleʤΤǡCircleareaƤФ롣ͤϡ
</pre>
Τ褦˻Ȥޤ

Τ褦ˡSoopyΥǡפϡStandardML , Gofer ʤɤ
ؿĥΤˤʤäƤޤ


....Ѿ

soopyϷѾ򥵥ݡȤƤޤ
ѾѤ뵡ǽȤơ͡ॹڡƱΤ
û򥵥ݡȤƤޤ

㤨С
<pre>
  super_obj = {
    name: "ansi common lisp";
    writer: "paul";
  };
ΤȤ

<pre>
  child_obj = super_obj + {
    publisher: "Pearson";
  };
</pre>
Ȥ뤳Ȥˤꡢchild_obj ϡsuper_objǤ
ۤˡǤɲä֥Ȥˤʤޤ

ޤ
<pre>
  another_obj = child_obj + {
    name: "hack!";
  };
</pre>
ȤȡƱ̾(name)ϱƤޤ
ʤʤޤ
򤹤뤿ˤϡȤΥ֥Ȥ̾
Τ褦˥͡षޤ
<pre>
  yet_another_obj = child_obj rename {name: $rename_name;} + {
    name: "hack?";
  };
</pre>


....͡ॹڡؿ롣

͡ॹڡ˥åeval뤳Ȥˤꡢ
ؿĤ뤳Ȥޤ񼰤ϡؿˤۤ
ƱǤˡarg: ȤǤǤޤ
arg:ϰΥꥹȤǤ

㡣

<pre>
  f = {arg:[x]; do:[x * x]; } eval;
</pre>
ǡؿǤޤ


...
ʹ


...湽¤

湽¤ if  loop ΣǤ

....if

soopyˤifϡۤθȤϰ㤤
ѥޥåΤιʸǤ
̵̤ʬ⵭ҤǤޤ

̤ˡifϼη򤷤Ƥޤ

<pre>
  if(){
    ѥ󣱡 [ѥ󣱤˥ޥåȤ¹ԤʸΥꥹ];
    ѥ󣲡 [ѥ󣲤˥ޥåȤ¹ԤʸΥꥹ];
    ....
    ѥN [ѥN˥ޥåȤ¹ԤʸΥꥹ];
  };
</pre>

㡣
<pre>
    if(i > 10){
      true:  [Υꥹȣ];
      false: [Υꥹȣ];
    };
</pre>
⤷i > 10 ʤСtrueȥޥåơ
Υꥹȣ¹Ԥޤ⤷ʤС
falseȥޥåơΥꥹȣ¹Ԥޤ

ѥޥåäȤϤȯΤϡѥ
ѿޤޤȤǤ
<pre>
  if([2,3,4]){
    [x,y,z]; [println x y z]; # ϣϣϣ˥ХɤƤ顢
                              # ʸΥꥹȤ¹Ԥ롣
  };
</pre>

ѥˤϡޤޤʤΤޤ
<pre>
  if(variable){
    0:        [.....]; # ѥϡäꡢ
    'c':      [....];  # ʸäꡢ
    "string": [ ....]; # ʸäꡢ
    [x,y]:    [....];  # ꥹȤäꡢ
    (n,m,l):  [....];  # ץäꡢ
    true:     [....];  # ͤäꤷޤ
    other:    [....];  # ޤܥϤ٤ƤΥѥ˰פޤ
                       # ΤȤvariable ͤ other ˥Хɤޤ
  };
</pre>


....loop

loopϼη򤷤Ƥޤ

  loop Label Namespace;

Ūˤϡ

<pre>
  loop Label {
    from: [롼פ˼¹Ԥ뼰Υꥹ];
    step: [Υ롼פȤˡ¹Ԥ뼰Υꥹ];
    while: [ˤʤȥ롼פλ]; (ޤϡuntil: [])
    do: [
롼
    ];
    variant: [];롼ѲɽʸǤϰ̵̣
    invariant: [];롼ɽʸǤϰ̵̣
  };
</pre>

Ȥ򤷤ƤޤLabelϾάǽǤ
ޤ͡ॹڡΤ٤ƤǤάǽǤ

.....exit

롼ǡ

  exit;

Ȥɾȡ¦Υ롼פæФޤ
뤤ϡ

  Label.exit;

  ȤȡLabelפ롼פæФޤ
ˡ

  Label.exit();

ȤȡLabelפ롼פæФͤloop
ͤȤޤ
٥Τʤexit()Ǥ֤ͤޤ


.....next

  next; ϡ롼פƬޤ٥Ĥ
Labe.next;ϡLabelפ롼פƬޤ


...ե

եϤˤϡ줾openIn, openOut Ȥ
ץߥƥ֤Ȥޤ
openIn ϡѤΥե򳫤ޤ
openOut ϡѤΥե򳫤ޤ
Ȥäեɬclose åä
ĤƤޤ礦

㡣

<pre>
    fin = openIn "filename";(*ϥեΥץ*)
    line = fin readline;  (*ɤ߹ߡ*)
    ch  = fin readChar;         (*ʸɤ߹ *)
    fin close;                  (*ɬĤ롡*)

    fout = openOut "output";    (*ϥեΥץ*)
    fout writeChar 'A';         (*ʸϡ*)
    p = fout printline;         (*ѴؿѿȤΤsoopyή*)
    p "first line";             (*Խϡ*)
    p "second line";
    p "third line";
    fout close;                 (*ɬĤ롡*)
</pre>




..ե
...ͽ
soopyϰʲθͽȤƤޤ
ͽϻȤäƤϤޤ

object, number, int, real, bool, string, char, nil
fun, const, property, private, public
if, super, true, false, loop, next, redo, retry

...Primitive
....array
    array:type (dim1,dim2,....,dimN)
N롣:type Ͼάġ
typeꤵƤСꤵ줿Τߤˤʤ롣

....openIn
    openIn filename
ʸfilenameɽեѤ˳

....openOut
    openOut filename
ʸfilenameɽեѤ˳

....load
    load filename
եfilenamesoopyץȤƥɤ롣

....print
    print object
object̤ɽ
ͤϥ᥽åprintȡ

....println
    println object
object̤ɽθԤɽ롣
ͤϥ᥽åprintlnȡ




...CLASS Reference
....Array

      depth
μ֤

      dimension
μɽꥹȤ֤
㡣
<pre>
           ary = array (3,4,5);
           ary dimention;  (* [3,4,5] ֤ *)
</pre>



....List

      head
ꥹȤΥإåʬ(car)֤

      tail
ꥹȤΥơʬ(cdr)֤

      isList?
ꥹȤɤȽꡣ˿

      isNIL?
ꥹȤ̥뤫ɤȽꤹ롣

      nth n
ꥹȤnܤǤ֤ʺǽǤϣܡ

      each func
ꥹǤ٤ƤˡؿfuncŬѤ롣
֤ͤVoid

      foldl func
ꥹǤ٤Ƥˡδؿfunc
֤ŬѤ֤ͤ

      foldr
ꥹǤ٤Ƥˡδؿfunc
֤ŬѤ֤ͤ

      map func
ꥹǤ٤ƤˡؿfuncŬѤ
ꥹȤ֤




....Char
      isAlpha?, isAlphaNum?, isDigit?
      isHexDigit?, isLower?, isSpace?, isUpper?
줾ʸμȽꤹ롣

      lower
ʸ֤

      pred
ʸɤʸ֤

      succ
ʸɤʸ֤

      toInt
ʸTRONɤ֤

      toString
ʸ֤

      upper
ʸ֤



....Int
      toChar
(TRON)ɽʸ֤

      toReal
¿ˤ֤ͤ

      toString
ʸɽ֤

      repeat aNameSpace
aNameSpaceؿȤơ󷫤֤¹Ԥ롣

<pre>
        .   10 repeat {arg:[x]; do: [println "hello"];};

ʸߤη֤ȤϤΤǡ
ɬarg: ǡꤷʤФʤʤ
</pre>

....Real
      toInt
¿֤

      toString
¿ʸɽ֤

      abs
֤ͤޤ

      acos
ʵ;ˤ֤ޤ

      asin
ʵˤ֤ޤ

      atan
󥸥ȡʵܡˤ֤ޤ

      atan2 y
y/self Υ󥸥Ȥ֤ޤ
 selfˤϥå줿¿ȡ

      ceil
ʲڤ夲֤ͤޤ

      cos
;ˤ֤ޤ

      cosh
ϥѥܥåж;ˤ֤ޤ

      exp
ؿؿself֤ޤ

      floor
ʲڤΤƤ֤ͤޤ

      fmod y
selfyǳä;֤ޤ

      frexp
Ȼؿȡʣˤ֤ޤ

      hypot y
ľѻѷμդĹ׻ޤ

      ldexp exp
self * 2 ^exp ֤ޤ

      log
п֤ޤ

      log10
п֤ޤ

      pow y
self  y֤ޤ

      sin
ˤ֤ޤ

      sinh
ϥѥܥåжˤ֤ޤ

      sqrt
ʿ֤ޤ

      tan

      tanh
ϥѥܥå󥸥ȡжܡˤ֤ޤ


....String

      length
ʸĹ

      sub (i,j)
iܤʸ顢jʸʬʸ

      nth n
nܤʸ

      toInt̤
Ѵ

      toReal̤
¿Ѵ


....Tuple

      length
ץΥ

      first
1ܤǤȤ

      second
1ܤǤȤ

      third
1ܤǤȤ

      fourth
1ܤǤȤ

      fifth
1ܤǤȤ

      nth n
nܤǤȤ


....TextFileIn

      close
եĤ롣

      iseof?
ե뤬ǸޤǤäȽꤹ롣

      peekChar
ե뤫飱ʸɤߤ롣

      read
ե򤹤٤ɤ߹ࡣ

      readLine
ե򣱹ɤ߹ࡣ

      readLineS
ե뤫餹٤ƤιԤɤ߹ࡣ

      readChar
ե뤫飱ʸɤ߹ࡣ




....TextFileOut

      close
եĤ롣

      flush
Хåեեå夹롣

      terpri
ե˲Ԥ񤭽Ф

      writeChar aChar
եʸaChar񤭽Ф
ͤϥ᥽åwriteCharȡ

      write object
եobjectʸɽ񤭽Ф
ͤϥ᥽åwriteȡ

      writeLine object
եobjectʸɽȲԤ񤭽Ф
ͤϥ᥽åwriteLineȡ




..License

Copyright (C) 2002 by SUZUKI Jun. All rights reserved.

ΥեȥsoopyˤGPL(GNU General Public License)
äƤޤ
ƤθϺ(SUZUKI Jun)ݻƤޤ
ѡۤGPL˽¤꼫ͳǤۤˤϢפǤ

ʤԤѼԤܥեȥѤȤˤ
ʤ»ˤ⤽Ǥ餤ޤ



..ʸʤ

ͤˤ

LENS(<A HREF="http://prog.vub.ac.be/poolresearch/lens/contents.html" TARGET="_blank">http://prog.vub.ac.be/poolresearch/lens/contents.html</A>)

ͽ

Cޥ󡡣ǯ桡եȥХ󥯡ѥ֥å󥰴
ֳΥס



