[BACK]Return to string.texi CVS log [TXT][DIR] Up to [local] / OpenXM / src / asir-doc / parts / builtin

Diff for /OpenXM/src/asir-doc/parts/builtin/string.texi between version 1.2 and 1.4

version 1.2, 1999/12/10 06:58:50 version 1.4, 2000/02/07 07:11:38
Line 1 
Line 1 
   @comment $OpenXM: OpenXM/src/asir-doc/parts/builtin/string.texi,v 1.3 1999/12/21 02:47:34 noro Exp $
   \BJP
 @node $BJ8;zNs$K4X$9$k1i;;(B,,, $BAH$_9~$_H!?t(B  @node $BJ8;zNs$K4X$9$k1i;;(B,,, $BAH$_9~$_H!?t(B
 @section $BJ8;zNs$K4X$9$k1i;;(B  @section $BJ8;zNs$K4X$9$k1i;;(B
   \E
   \BEG
   @node Strings,,, Built-in Function
   @section Strings
   \E
   
 @menu  @menu
 * rtostr::  * rtostr::
 * strtov::  * strtov::
 * eval_str::  * eval_str::
   * strtoascii asciitostr::
 @end menu  @end menu
   
 @node rtostr,,, $BJ8;zNs$K4X$9$k1i;;(B  \JP @node rtostr,,, $BJ8;zNs$K4X$9$k1i;;(B
   \EG @node rtostr,,, Strings
 @subsection @code{rtostr}  @subsection @code{rtostr}
 @findex rtostr  @findex rtostr
   
 @table @t  @table @t
 @item rtostr(@var{obj})  @item rtostr(@var{obj})
 :: @var{obj} $B$rJ8;zNs$KJQ$($k(B.  \JP :: @var{obj} $B$rJ8;zNs$KJQ$($k(B.
   \EG :: Convert @var{obj} into a string.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $BJ8;zNs(B  \JP $BJ8;zNs(B
   \EG string
 @item obj  @item obj
 $BG$0U(B  \JP $BG$0U(B
   \EG arbitrary
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 $BG$0U$N%*%V%8%'%/%H(B @var{obj} $B$rJ8;zNs$KJQ$($k(B.  $BG$0U$N%*%V%8%'%/%H(B @var{obj} $B$rJ8;zNs$KJQ$($k(B.
 @item  @item
Line 31 
Line 44 
 $BE:;zIU$-$NITDj85$r@8@.$9$k>l9g$KB?$/MQ$$$i$l$k(B.  $BE:;zIU$-$NITDj85$r@8@.$9$k>l9g$KB?$/MQ$$$i$l$k(B.
 @item  @item
 $B5U$K(B, $BJ8;zNs$rITDj85$KJQ49$9$k;~$K$O(B, @code{strtov} $B$rMQ$$$k(B.  $B5U$K(B, $BJ8;zNs$rITDj85$KJQ49$9$k;~$K$O(B, @code{strtov} $B$rMQ$$$k(B.
   \E
   \BEG
   @item
   Convert an arbitrary object @var{obj} into a string.
   @item
   This function is convenient to create variables with numbered
   (or indexed) names by converting integers into strings and appending them
   to some name strings.
   @item
   Use @code{strtov()} for inverse conversion from string to indeterminate.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 47  afo1
Line 71  afo1
 @end example  @end example
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
   \EG @item References
 @fref{strtov}, @fref{type}.  @fref{strtov}, @fref{type}.
 @end table  @end table
   
 @node strtov,,, $BJ8;zNs$K4X$9$k1i;;(B  \JP @node strtov,,, $BJ8;zNs$K4X$9$k1i;;(B
   \EG @node strtov,,, Strings
 @subsection @code{strtov}  @subsection @code{strtov}
 @findex strtov  @findex strtov
   
 @table @t  @table @t
 @item strtov(@var{str})  @item strtov(@var{str})
 :: @var{str} ($BJ8;zNs(B) $B$rITDj85$KJQ$($k(B.  \JP :: @var{str} ($BJ8;zNs(B) $B$rITDj85$KJQ$($k(B.
   \EG :: Convert a string @var{str} into an indeterminate.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $BITDj85(B  \JP $BITDj85(B
   \EG intederminate
 @item str  @item str
 $BITDj85$H$7$FJQ492DG=$JJ8;zNs(B  \JP $BITDj85$H$7$FJQ492DG=$JJ8;zNs(B
   \EG string which is valid to constitute an indeterminate.
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 $BITDj85$H$7$FJQ492DG=$JJ8;zNs$rITDj85$KJQ$($k(B.  $BITDj85$H$7$FJQ492DG=$JJ8;zNs$rITDj85$KJQ$($k(B.
 @item  @item
Line 76  afo1
Line 106  afo1
 @item  @item
 @code{rtostr()} $B$HAH9g$;$F(B, $B%W%m%0%i%`Cf$G<+F0E*$KITDj85$r@8@.$7$?$$;~$K(B  @code{rtostr()} $B$HAH9g$;$F(B, $B%W%m%0%i%`Cf$G<+F0E*$KITDj85$r@8@.$7$?$$;~$K(B
 $BMQ$$$i$l$k(B.  $BMQ$$$i$l$k(B.
   \E
   \BEG
   @item
   Convert a string that is valid for an indeterminate into an indeterminate
   which have @var{str} as its print name.
   @item
   The valid string for an indeterminate is such a string that begins
   with a small alphabetical letter possibly followed by any string composed
   of alphabetical letters, digits or a symbol @samp{_}.
   @item
   Use the command to create indeterminates dynamically in programs.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 88  afo
Line 130  afo
 @end example  @end example
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
   \EG @item References
 @fref{rtostr}, @fref{type}, @fref{uc}.  @fref{rtostr}, @fref{type}, @fref{uc}.
 @end table  @end table
   
 @node eval_str,,, $BJ8;zNs$K4X$9$k1i;;(B  \JP @node eval_str,,, $BJ8;zNs$K4X$9$k1i;;(B
   \EG @node eval_str,,, Strings
 @subsection @code{eval_str}  @subsection @code{eval_str}
 @findex eval_str  @findex eval_str
   
 @table @t  @table @t
 @item eval_str(@var{str})  @item eval_str(@var{str})
 :: @var{str} ($BJ8;zNs(B) $B$rI>2A$9$k(B.  \JP :: @var{str} ($BJ8;zNs(B) $B$rI>2A$9$k(B.
   \EG :: Evaluates a string @var{str}.
 @end table  @end table
   
 @table @var  @table @var
 @item return  @item return
 $B%*%V%8%'%/%H(B  \JP $B%*%V%8%'%/%H(B
   \EG object
 @item str  @item str
 @b{Asir} $B$N(B parser $B$,<uM}2DG=$JJ8;zNs(B  \JP @b{Asir} $B$N(B parser $B$,<uM}2DG=$JJ8;zNs(B
   \EG string which can be accepted by @b{Asir} parser
 @end table  @end table
   
 @itemize @bullet  @itemize @bullet
   \BJP
 @item  @item
 @b{Asir} $B$N(B parser $B$,<uM}2DG=$JJ8;zNs$rI>2A$7$F$=$N7k2L$rJV$9(B.  @b{Asir} $B$N(B parser $B$,<uM}2DG=$JJ8;zNs$rI>2A$7$F$=$N7k2L$rJV$9(B.
 @item  @item
 $BI>2A2DG=$JJ8;zNs$O(B, $B<0$rI=$9$b$N$K8B$k(B.  $BI>2A2DG=$JJ8;zNs$O(B, $B<0$rI=$9$b$N$K8B$k(B.
 @item  @item
 $BO@M}E*$K$O(B @code{rtostr()} $B$N5U4X?t$H$J$k(B.  $BO@M}E*$K$O(B @code{rtostr()} $B$N5U4X?t$H$J$k(B.
   \E
   \BEG
   @item
   This function evaluates a string which can be accepted by @b{Asir} parser
   and returns the result.
   @item
   The input string should represent an expression.
   @item
   This functions is the inversion function of @code{rtostr()}.
   \E
 @end itemize  @end itemize
   
 @example  @example
Line 125  afo
Line 183  afo
 @end example  @end example
   
 @table @t  @table @t
 @item $B;2>H(B  \JP @item $B;2>H(B
   \EG @item References
 @fref{rtostr}  @fref{rtostr}
 @end table  @end table
   
   \JP @node strtoascii asciitostr,,, $BJ8;zNs$K4X$9$k1i;;(B
   \EG @node strtoascii asciitostr,,, Strings
   @subsection @code{strtoascii}, @code{asciitostr}
   @findex strtoascii
   @findex asciitostr
   
   @table @t
   @item strtoascii(@var{str})
   \JP :: $BJ8;zNs$r%"%9%-!<%3!<%I$GI=$9(B.
   \EG :: Converts a string into a sequence of ASCII codes.
   @item asciitostr(@var{list})
   \JP :: $B%"%9%-!<%3!<%I$NNs$rJ8;zNs$KJQ49$9$k(B.
   \EG :: Converts a sequence of ASCII codes into a string.
   @end table
   
   @table @var
   @item return
   \JP @code{strtoascii()}:$B%j%9%H(B; @code{asciitostr()}:$BJ8;zNs(B
   \EG @code{strtoascii()}:list; @code{asciitostr()}:string
   @item str
   \JP $BJ8;zNs(B
   \EG string
   @item list
   \JP 1 $B0J>e(B 256 $BL$K~$N@0?t$+$i$J$k%j%9%H(B
   \EG list containing positive integers less than 256.
   @end table
   
   @itemize @bullet
   \BJP
   @item
   @code{strtoascii()} $B$OJ8;zNs$r@0?t$N%j%9%H$KJQ49$9$k(B. $B3F(B
   $B@0?t$OJ8;zNs$N%"%9%-!<%3!<%I$rI=$9(B.
   @item
   @code{asciitostr()} $B$O(B @code{asciitostr()} $B$N5U4X?t$G$"$k(B.
   \E
   \BEG
   @item
   @code{strtoascii()} converts a string into a list of integers
   which is a representation of the string by the ASCII code.
   @item
   @code{asciitostr()} is the inverse of @code{asciitostr()}.
   \E
   @end itemize
   
   @example
   [0] strtoascii("abcxyz");
   [97,98,99,120,121,122]
   [1] asciitostr(@@);
   abcxyz
   [2] asciitostr([256]);
   asciitostr : argument out of range
   return to toplevel
   @end example

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>