TSEXPR

　TSEXPRは、単に式の値を返す埋め込み用簡易計算言語で、主に、コマンドラインの引数の組み立てや、スクリプトの条件、引数置換などで使用する。
　コマンド（アプリケーション）の EXPR、EXPRTF、EXPRLN などでは、計算を記述する機能を担い、LEXTRA、CEXTRAなどでは、出力記述に計算機能を与えている。アプリケーションで TSEXPR を使用する多くの場合、アプリケーションによって異なるインタフェース関数や変数が定義される。
整数値、実数値、小数値、文字列、論理値を扱い、主として環境変数を変数として使用する。記述言語は大文字、小文字を区別しない。テキスト・インタプリタなので、実行速度は速くない。

　多くの場合は、単に関数を呼び出したり、文字列を連結するなど単純な操作だけで十分であることが多い。多くの場合は１行にも満たない記述である。関数を定義する機能、ライブラリを呼び出す機能などは記述の邪魔になるので持たず、ゆえに、デフォルトで呼び出せる組み込み関数が多くなっている。

エラーコードをホストアプリケーションに渡すだけなので、エラー情報が不親切になっている。環境変数「TSEXPR_ERRBALL」に値をセットすると、エラーが起きた付近までのソースコードを表示するようになる。

1.データ型

型操作

TYPE

int TYPE(
値
)

値の型を判別して整数値で返す。

引数の型	返す値
論理値	10
整数	20
小数	40
実数	30
文字列	100
バイナリ	200

TYPENAME

str TYPENAME(
値
)

値の型を文字列で返す。

引数の型	返す文字列
論理値	`BOOL`
整数	`INTEGER`
小数	`FIXNUM`
実数	`FLOAT`
文字列	`STRING`
バイナリ	`BYNARY`

BOOL

bool BOOL(
値
)

論理値に型変換する。

引数の型	結果
論理値	（変換しない）
整数	0 以外ならば真
小数	0c0 以外ならば真
実数	0.0 以外ならば真
文字列	先頭の一文字が半角の「`T`」または「`t`」ならば真

INT

int INT(
値
)

整数に型変換する。

引数の型	結果
論理値	真ならば 1 、偽ならば 0
整数	（変換しない）
小数	整数化した値
実数	整数化した値
文字列	整数として解釈した文字列表記。16進表記（0x...）、2進表記（0b...）も解釈する。

FIXNUM

float FIXNUM(
値
)

小数に型変換する。

引数の型	結果
論理値	真ならば 1 、偽ならば 0
整数	そのまま小数に変換
小数	（変換しない）
実数	そのまま小数に変換
文字列	小数として解釈した文字列表記

FLOAT

float FLOAT(
値
)

実数に型変換する。

引数の型	結果
論理値	真ならば 1.0 、偽ならば 0.0
整数	そのまま実数に変換。
小数	そのまま実数に変換。
実数	（変換しない）
文字列	実数として解釈した文字列表記。STRHEX()で出力する特殊な形式にも対応している。

STR

str STR(
値
[ , 値 ]*
)

値を文字列に変換する。
値を複数書くと、文字列に変換後、順に連結する。

引数の型	結果
論理値	真ならば "`TRUE`" 、偽ならば "`FALSE`"
整数	文字列表記
小数	文字列表記
実数	文字列表記
文字列	（そのまま）
バイナリ	値0のバイト以外はそのまま

BINARY

str BINARY(
値
[ , 値 ]*
)

値をバイナリに変換する。
値を複数書くと、バイナリに変換後、順に連結する。

引数の型	結果
論理値	４バイトの内部表記
整数	４バイトの内部表記
小数	１６バイトの内部表記
実数	８バイトの内部表記
文字列	そのまま
バイナリ	（そのまま）

BIN str BIN( 値 [ , 値 ]* )
値をバイナリに変換する。
BINARY(..)と同じ。

ISBOOL bool ISBOOL( 値 )
値の型が論理型ならば真を返す。

ISINT bool ISINT( 値 [ , int 比較値 ] )
値の型が整数型ならば真を返す。
比較値を指定すると、値が整数型で比較値と等しいとき真となる。

ISFIXNUM bool ISFIXNUM( 値 [ , fix 比較値 ] )
値の型が小数型ならば真を返す。
比較値を指定すると、値が小数型で比較値と等しいとき真となる。

ISFLOAT bool ISFLOAT( 値 [ , float 比較値 ] )
値の型が実数型ならば真を返す。
比較値を指定すると、値が実数型で比較値と等しいとき真となる。

ISSTR bool ISSTR( 値 [ , str 比較値 ] )
値の型が文字列型ならば真を返す。
比較値を指定すると、値が文字列型で比較値に等しいとき真となる。

ISBIN bool ISBIN( 値 [ , bin 比較値 ] )
値の型がバイナリならば真を返す。
比較値を指定すると、値がバイナリ型で比較値に等しいとき真となる。

HEXVAL

int HEXVAL(
str 値
)

文字列を１６進表記と解釈して数値に変換。
INT関数と異なり、文字列の先頭に "0x" が無くてよい。また、小文字での表記も可。記述が不正な場合の値は保証しない。

記述例　 HEXVAL('14AC') → 5292

BINVAL

int BINVAL(
str 値
)

文字列を２進表記と解釈して数値に変換。
INT関数と異なり、文字列の先頭に "0b" が無くてよい。記述が不正な場合の値は保証しない。

記述例　 BINVAL('1001') → 9

STRC

str STRC(
{ int 整数値
| str 文字列 }
[ , int 区切り間隔
[ , str 区切り文字 ]
]
)

整数を３桁区切コンマ文字列に変換する。
区切り間隔に 4 を指定すると４桁区切コンマ文字列変換などができる。値に文字列を与えると、正の数字列と仮定してコンマ区切処理を行う。
区切り文字を指定すると、その先頭の１文字を「,」の代わりに用いることができる。

記述例１　 strc(-12345) → -12,345

記述例２　 strc(12345,4) → 1,2345

記述例３　 strc(12345,3,'_') → 12_345

記述例４　 strc('ABCDEFG',2,'$') → A$BC$DE$FG

STR0

str STR0(
int 値
, int 桁数
[ , bool ＋フラグ ]
)

数値を先頭を０で埋めた形式の文字列に変換する。
桁数指定は正であること。
＋フラグを指定しなければ、値が負の場合だけ先頭の１文字が「-」に置き換わる。
＋フラグを指定すると、先頭の１文字は常に符号を表す。＋フラグ　が真ならば、値が正のとき「+」を符号とする。

記述例１　 str0(12,4) → 0012

記述例２　 str0(-12,4) → -012

記述例３　 str0(0,4) → 0000

記述例４　 str0(12,4,false) → 012

記述例５　 str0(-12,4,false) → -012

記述例６　 str0(0,4,false) → 000

記述例７　 str0(12,4,true) → +012

記述例８　 str0(-12,4,true) → -012

記述例９　 str0(0,4,true) → 000

STRSP

str STRSP(
int 値
, int 桁数
[ , bool ＋フラグ ]
)

数値を先頭を半角のスペースで埋めた形式の文字列に変換する。
桁数指定は正であること。＋フラグ　を指定すると、正のときに「+」を付加する

記述例１　 strsp(12,4) → 12
１６進表記では 20203132

記述例２　 strsp(-12,4) → -12
１６進表記では 202D3132

記述例３　 strsp(12,4,true) → +12
１６進表記では 202B3132

STRDW str STRDW( int 値 )
値をDWORDと解釈して文字列表記に変換する。

STRFIXNUM

str STRFIXNUM(
fix 値
, int 小数桁数
[ , int 区切り間隔
[ , str 区切り文字列  ]
]
)

小数を整形して文字列にする。
小数桁数は、小数部分の桁数を指定し、表示範囲外は切り捨てる。
区切り間隔を指定すると、整数部分に三桁コンマ区切りなどを適用できる。区切り間隔は区切りの幅を指定する。通常は、3（三桁区切り）、4（四桁区切り）を指定する。
区切り文字列は通常は指定しない。指定しなければ、「,」で区切るが、指定すれば、指定した文字列を「,」の代わりに使用する。

記述例１　 strfixnum(-0c12345.678,2) → -12345.67

記述例２　 strfixnum(0c12345.678,2,3) → 12,345.67

記述例３　 strfixnum(0c12345.678,2,3,'_') → 12_345.67

STRHEX

str STRHEX(
{ int 値
| float 値
| str 値
| bin 値
}
[ , 
{ bool 全桁フラグ
| int 桁指定
}
]
)

数値を１６進数に変換する。

引数の型
整数	通常はゼロサプレスされているが、全桁フラグを `TRUE` にすると全桁形式になる。桁を数値で指定することも出来る。桁指定は、1-8の範囲で指定する記述例１　 `strhex(1234)` → `4D2` 記述例２　 `strhex(1234,true)` → `000004D2` 記述例３　 `strhex(1234,2)` → `D2`
実数	先頭が0#で始まり１６文字続く文字列となる。全桁フラグと桁指定には意味がない。float 関数で実数に戻せる。記述例　 `strhex(1.234)` → `0#5839B4C876BEF33F`
文字列／バイナリ	先頭のバイトから順に１６進数に変換する。ASCII 関数で元の文字列に戻せる。全桁フラグを `TRUE` にするとバイトの間に半角スペースを挟む。記述例１　 `strhex('ABC')` → `414243` 記述例２　 `strhex('ABC',TRUE)` → `41 42 43`

STRBIN

str STRBIN( int 値 [ , bool 全桁フラグ ] )
数値を２進数表記に変換する。
通常はゼロサプレスされているが、全桁フラグを TRUE にすると全桁形式になる。

記述例１　 strbin(1045) → 10000010101

記述例２　 strbin(1045,true) → 00000000000000000000010000010101

str STRBIN( bin 値 [ , bool 区切りフラグ ] )
バイナリをバイト単位で２進数表記に変換する。
区切りフラグを TRUE にするとバイトとバイトの間に半角スペースを挟む。

記述例１　 strbin('ABC') → 010000010100001001000011

記述例２　 strbin('ABC',true) → 01000001 01000010 01000011

FORMSTR

str FORMSTR(
float 式
, int 小数桁数
)

実数を文字列に変換する。
小数部桁数を負に指定すると、自動変換形式。それ以外では小数形式での小数部の桁数を指定する。

記述例１　 formstr(sqrt(2),0) → 1

記述例２　 formstr(sqrt(2),3) → 1.414

記述例３　 formstr(sqrt(2),-1) → 1.4142135623730951

FLOATSTR

str FLOATSTR(
float 式
[, int 小数桁数 ]
)

実数を文字列に変換する。指数形式で表示する。
小数部桁数を省略するか、負の値を指定すると小数桁数は 6。

記述例１　 floatstr(sqrt(2),0) → 1e+000

記述例２　 floatstr(sqrt(2),3) → 1.414e+000

記述例３　 floatstr(sqrt(2),-1) → 1.414214e+000

ISTRUE bool ISTRUE( 値 )
値の型が論理型で値が真ならば真を返す。

ISFALSE bool ISFALSE( 値 )
値の型が論理型で値が偽ならば真を返す。

ISZERO bool ISZERO( 値 )
値の型が整数型 / 小数型 / 実数型で値が 0 ならば真を返す。

ISPLUS bool ISPLUS( 値 )
値の型が整数型 / 小数型 / 実数型で値が正ならば真を返す。

ISMINUS bool ISMINUS( 値 )
値の型が整数型 / 小数型 / 実数型で値が負ならば真を返す。

ISEVEN bool ISEVEN( 値 )
値の型が整数型 / 小数型 / 実数型で値が偶数ならば真を返す。
実数は整数に変換してから判定している。

ISODD bool ISODD( 値 )
値の型が整数型 / 小数型 / 実数型で値が奇数ならば真を返す。
実数は整数に変換してから判定している。

ISNULL bool ISNULL( 値 )
値の型が文字列またはバイナリで値が長さが 0 ならば真を返す。

EQUAL

bool EQUAL(
値１
, 値２
)

値１と値２の型と値が等しければ真を返す。

記述例１　 equal(12,12.0) → FALSE

記述例２　 equal(12,12) → TRUE

文字列操作（文字）

NULL

str NULL
長さ0の文字列を表わす。

str NULL( 式 [ , 式 ] )
引数の式は評価されるが、戻り値は常に長さ 0 の文字列。

LF

str LF
\n(0x0a) 一文字の文字列。
内部的な行の区切り。

str LF( [ str 引数 [ , str 引数_n ]* ] )
引数を文字列の行として行末にLF(\0x0a)を付加して連結する。
入力文字列の末尾に LF がある場合には LF を付加しない。引数を書かなければ長さ 0 の文字列を返す。

記述例　 lf('abc','def','ghi') →

abc↓
def↓
ghi↓

TAB

str TAB
TAB(0x09) 一文字の文字列。
行内の項目区切りに使われる。

str TAB( str 引数 [ , str 引数_n ]* )
引数を文字列として TAB(\t 0x09) を挟んで連結する。

記述例１　 tab('abc','def','ghi') →
abc→def→ghi

記述例２　 tab('abc') →
abc

CR str CR
１文字の復帰記号（0x0d）を表す。
通常は使わない。

TL str TL( str 引数 [ , str 引数 ]*
引数をtabを挟んで連結し、最後にlfを加えた文字列。

TLN str TLN( str 引数 [ , str 引数 ]*
引数をtabを挟んで連結し、最後にcrlfを加えた文字列。

ESC

str ESC
１文字のエスケープ記号（0x1b）を表す。
通常は使わない。

str ESC( str 文字列 )
文字列の先頭に１文字のエスケープ記号（0x1b）をつけた文字列。
通常は使わない。

EOL

str EOL
\r\n(0x0d 0x0a)の二文字からなる文字列。

str EOL( str 引数 [ , str 引数_n ]* )
引数を文字列の行として行末にCRLF(\0x0d\0x0a)を付加して連結する

記述例　 eol('abc','def','ghi') →

abc
def
ghi

１６進表記では 6162630D0A6465660D0A6768690D0A

CRLF

str CRLF
\r\n(0x0d 0x0a)の二文字からなる文字列。

str CRLF( str 引数 [ , str 引数_n ]* )
引数を文字列の行として行末にCRLF(\0x0d\0x0a)を付加して連結する

記述例　 crlf('abc','def','ghi') →

abc
def
ghi

１６進表記では 6162630D0A6465660D0A6768690D0A

SP

str SP
一文字の半角スペース。

str SP( int 文字数 )
指定の文字数の半角スペース。

記述例　 sp(4) →
１６進表記では 20202020

str SP( str 引数 [ , str 引数_n ]* )
引数をスペースを挟んで連結する。
最初の引数は文字列で無ければならない。

記述例　 sp('A','B','C') → A B C
１６進表記では 4120422043

SPC

str SPC
一文字の半角スペース。

str SPC( str 文字列 , int カウント )
文字列の前後をカウント数の半角スペースで挟む。

記述例　 spc('A',2) → A
１６進表記では 2020412020

SPK

str SPK
一文字の全角スペース。

str SPK( int 文字数 )
指定の文字数の全角スペース。

記述例　 spk(3) → 　　　
１６進表記では 814081408140

DQ

str DQ
１文字の複引用符（"）を表わす。

str DQ( str 文字列 )
文字列を複引用符（"）で囲んだ文字列を返す。文字列の中の複引用符（"）は二つ重ねて表される。

記述例１　 dq('abc') → "abc"

記述例２　 dq('a"c') → "a""c"

SQ

str SQ
１文字の単引用符（'）を表わす。

str SQ( str 文字列 )
文字列を単引用符（'）で囲んだ文字列を返す。文字列の中の単引用符（'）は二つ重ねて表される。

記述例１　 sq("abc") → 'abc'

記述例２　 sq("a'c") → 'a''c'

YEN

str YEN
１文字の円記号（\）を表わす。

str YEN( str 引数 [ , str 引数_n ]* )
引数を文字列として円記号(\) を挟んで連結する。

記述例　 yen('abc','def','hij') → abc\def\hij

BAR

str BAR
１文字の縦棒（|）を表わす。

str BAR( str引数 [ , str 引数_n ]* )
引数を文字列として縦棒(|) を挟んで連結する。

記述例　 bar('abc','def','hij') → abc|def|hij

BANG

str BANG
１文字の感嘆符（!）を表わす。

str BANG( str 文字列 [ , int 個数 ] )
文字列の後ろに感嘆符（!）をつけた文字列を返す。個数を指定すればその数だけ感嘆符を付加する。

記述例　 bang('Tokyo') → Tokyo!

EX

str EX
１文字の感嘆符（!）を表わす。

str EX( str 文字列 )
文字列の前に感嘆符（!）をつけた文字列を返す。

記述例　 ex('file.txt') → !file.txt

HATENA

str HATENA
１文字の疑問符（?）を表わす。

str HATENA( str 文字列 [ , int 個数 ] )
文字列の後ろに疑問符（!）をつけた文字列を返す。個数を指定すればその数だけ疑問符を付加する。

記述例　 hatena('socks') → socks?

CHRLT str CHRLT
１文字の小なり記号（<）を表わす。

CHRGT str CHRGT
１文字の大なり記号（>）を表わす。

EQL

str EQL
１文字の等号（=）を表わす。

str EQL( str 文字列 )
文字列の後ろに等号（=）をつけたもの。

記述例　 eql('abc') → abc=

str EQL( str 文字列 [ , str 文字列 ]* )
文字列を等号（=）で繋いだもの。

記述例　 eql('abc','def','hij') → abc=def=hij

COMMA

str COMMA
１文字のカンマ「,」。

str COMMA( str 式 [ , str 式 ]* )
式を「,」を挟んで連結したもの。

記述例　 comma('abc','def','hij') → abc,def,hij

DOT

str DOT
１文字のピリオド「.」。

str DOT( str 式 [ , str 式 ]* )
式を「.」を挟んで連結したもの。

記述例　 dot('abc','def','hij') → abc.def.hij

DOTS

str DOTS
２文字のピリオド「.」。

str DOTS( int 個数 )
個数分だけの「.」。

記述例　 dots(4) → ....

PERIOD

str PERIOD
１文字のピリオド「.」。

str PERIOD( str 式 [ , str 式 ]* )
式の後ろに「.」を付け、半角「' '」を挟んで連結したもの。

記述例　 period('a','b','c') → a. b. c.
１６進表記では 612E20622E20632E

COLON

str COLON
１文字のコロン（:）。

str COLON( str 文字列 )
文字列の後ろにコロン（:）をつけたもの。

記述例　 colon('label') → label:

str COLON( str 文字列１ , str 文字列２ )
文字列１+コロン（:）+ 文字列２+セミコロン (;)。

記述例　 colon('align','center') → align:center;

SEMICOLON

str SEMICOLON
１文字のセミコロン「;」。

str SEMICOLON( str 式 [ , str 式 ]* )
式の後ろに「;」を付けて連結したもの。

記述例　 semicolon('open()','close()') → open();close();

SC

str SC
１文字のセミコロン「;」。

str SC( str 式 [ , str 式 ]* )
式の後ろに「;」を付けて連結したもの。

記述例　 sc('start','end') → start;end;

BQ

str BQ
１文字の逆引用符（`）を表わす。

str BQ( str 文字列 )
文字列を逆引用符（`）で囲んだ文字列を返す。文字列の中の逆引用符（`）は二つ重ねて表す。

記述例　 bq('ab`cd') → `ab``cd`

AT

str AT
１文字のアットマーク「@」。

str AT( str 式 )
式の前に「@」を付ける。

記述例　 at('computer.com') → @computer.com

str AT( str 式１ , str 式２ )
式１と式２を「@」を挟んで連結。

記述例　 at('yourname','computer.com') → yourname@computer.com

DOLLAR str DOLLAR
１文字のドル記号（$）。

SHARP str SHARP
１文字の # 記号（#）。

PERCENT str PERCENT
１文字のパーセント記号（%）。

CARET str CARET
１文字の山記号（^）。

TILDA str TILDA
１文字のティルダ記号（~）。

ASTER str ASTER
１文字のアスタリスク記号（*）。

str ASTER( int 個数 )
指定個数のアスタリスク記号からなる文字列。

UL

str UL
１文字の下線記号（_）。

str UL( str 引数 )
引数の先頭に下線記号（_）を付けた文字列

str UL( str 引数 [ , str 引数 )
引数を下線記号（_）で繋いだ文字列。

記述例１　 ul → _

記述例２　 ul('mypoint') → _mypoint

記述例３　 ul('my','point') → my_point

KAKKO

str KAKKO
一文字の「(」。

str KAKKO( str 引数 [ , str 引数 ]* )
引数を「,」で区切って「()」で囲む。

記述例１　 kakko('abc') → (abc)

記述例２　 kakko('abc','def','hij') → (abc,def,hij)

KOKKA

str KOKKA
一文字の「)」。

str KOKKA( str 引数 [ , str 引数 ]* )
最初の引数のあとに、残りの引数を「,」で区切って「()」で囲んで繋げる。
残りの引数がない場合は、「()」を繋げる。

記述例１　 kokka('func') → func()

記述例２　 kokka('function','param1','parm2') → function(param1,parm2)

KADO

str KADO
一文字の「[」。

str KADO( str 引数 [ , str 引数 ]* )
引数を「,」で区切って「[]」で囲む。

記述例１　 kado('abc') → [abc]

記述例２　 kado('abc','def') → [abc,def]

DOKA

str DOKA
一文字の「]」。

str DOKA( str 引数 [ , str 引数 ]* )
最初の引数のあとに、残りの引数を「,」で区切って「[]」で囲んで繋げる。
残りの引数がない場合は、「[]」を繋げる。

記述例１　 doka('array') → array[]

記述例２　 doka('array','x','y') → array[x,y]

TOGE

str TOGE
一文字の「{」。

str TOGE( str 引数 [ , str 引数 ]* )
引数を「,」で区切って「{}」で囲む。

記述例１　 toge('1st') → {1st}

記述例２　 toge('1st','2nd','3rd') → {1st,2nd,3rd}

GETO

str GETO
一文字の「}」。

str GETO( str 引数 [ , str 引数 ]+ )
引数の後ろに「;」を付加して「{}」で囲む。

記述例　 geto('open()','close()') → {open();close();}

KAGI

str KAGI
一文字の「。

str KAGI( str 引数 [ , str 引数 ]+ )
引数の前後を「」で囲む。
引数が複数ある場合には、それぞれの引数の後ろに「。」がつく。

記述例１　 kagi → 「

記述例２　 kagi('漢字') → 「漢字」

記述例３　 kagi('漢字が大切','それもいい') → 「漢字が大切。それもいい。」

KAGI2

str KAGI2
一文字の『。

str KAGI2( str 引数 [ , str 引数 ]+ )
引数の前後を『』で囲む。
引数が複数ある場合には、それぞれの引数の後ろに『。』がつく。

記述例１　 kagi2 → 『

記述例２　 kagi2('漢字') → 『漢字』

記述例３　 kagi2('漢字が大切','それもいい') → 『漢字が大切。それもいい。』

文字列操作（コード判定）

ISHALFSIZE

bool ISHALFSIZE(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が１バイトコードなら真。
全検査フラグが真の場合は、すべての文字が１バイトコードなら真。

記述例１　 ishalfsize('ab漢字') → TRUE

記述例２　 ishalfsize('ab漢字',true) → FALSE

記述例３　 ishalfsize('abcdef'+lf,true) → TRUE

ISFULLSIZE

bool ISFULLSIZE(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が２バイトコードなら真。
全検査フラグが真の場合は、すべての文字が２バイトコードなら真。

記述例１　 isfullsize('漢字abc') → TRUE

記述例２　 isfullsize('漢字abc',true) → FALSE

記述例３　 isfullsize('漢字あいうえお',true) → TRUE

ISCTRL

bool ISCTRL(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が制御コードなら真。
全検査フラグが真の場合は、すべての文字が制御コードなら真。

記述例１　 isctrl(tab+'abc') → TRUE

記述例２　 isctrl(tab+'abc',true) → FALSE

記述例３　 isctrl(tab+crlf,true) → TRUE

ISHALF

bool ISHALF(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が半角文字なら真。
全検査フラグが真の場合は、すべての文字が半角文字なら真。

記述例１　 ishalf('a') → TRUE

記述例２　 ishalf(tab) → FALSE

記述例３　 ishalf('漢字') → FALSE

記述例４　 ishalf('abcdef',true) → TRUE

記述例５　 ishalf('abc漢字',true) → FALSE

ISFULL

bool ISFULL(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角文字なら真。
全検査フラグが真の場合は、すべての文字が全角文字なら真。

記述例１　 isfull('漢字abc') → TRUE

記述例２　 isfull('漢字abc',true) → FALSE

記述例３　 isfull('漢字あいうえお',true) → TRUE

ISUPPER

bool ISUPPER(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が半角英大文字なら真。
全検査フラグが真の場合は、すべての文字が半角英大文字なら真。

記述例１　 isupper('Abc') → TRUE

記述例２　 isupper('Abc',true) → FALSE

記述例３　 isupper('ABC',true) → TRUE

ISLOWER

bool ISLOWER(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が半角英小文字なら真。
全検査フラグが真の場合は、すべての文字が半角英小文字なら真。

記述例１　 islower('abC') → TRUE

記述例２　 islower('abC',true) → FALSE

記述例３　 islower('abc',true) → TRUE

ISUPPERALL bool ISUPPERALL( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が大文字なら真。
検査する文字種は、半角英字／全角英字／全角ギリシャ／全角ロシア／ローマ数字。
全検査フラグが真の場合は、すべての文字が半角英大文字なら真。

ISLOWERALL bool ISLOWERALL( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が小文字なら真。
検査する文字種は、半角英字／全角英字／全角ギリシャ／全角ロシア／ローマ数字。
全検査フラグが真の場合は、すべての文字が半角英小文字なら真。

ISALPHA

bool ISALPHA(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が半角英文字なら真。
全検査フラグが真の場合は、すべての文字が半角英文字なら真。

記述例１　 isalpha('A') → TRUE

記述例２　 isalpha('a') → TRUE

記述例３　 isalpha('a15',true) → FALSE

記述例４　 isalpha('Yamazaki',true) → TRUE

ISNUM

bool ISNUM(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が半角数字なら真。
全検査フラグが真の場合は、すべての文字が半角数字なら真。

記述例１　 isnum('15a') → TRUE

記述例２　 isnum('15a',true) → FALSE

記述例３　 isnum('2012',true) → TRUE

ISNUMALPHA

bool ISNUMALPHA(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が半角英数字なら真。
全検査フラグが真の場合は、すべての文字が半角英数字なら真。

記述例１　 isnumalpha('1') → TRUE

記述例２　 isnumalpha('a') → TRUE

記述例３　 isnumalpha('1256年') → TRUE

記述例４　 isnumalpha('1256年',true) → FALSE

記述例５　 isnumalpha('1256Years',true) → TRUE

ISFULLALPHA

bool ISFULLALPHA(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角英字なら真。
全検査フラグが真の場合は、すべての文字が全角英字なら真。

記述例１　 isfullalpha('ＡＢＣ順') → TRUE

記述例２　 isfullalpha('ＡＢＣ順',true) → FALSE

記述例３　 isfullalpha('Ｋｅｎｔｕｃｋｙ',true) → TRUE

ISFULLNUM

bool ISFULLNUM(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角数字なら真。
全検査フラグが真の場合は、すべての文字が全角数字なら真。

記述例１　 isfullnum('１．番号') → TRUE

記述例２　 isfullnum('１．番号',true) → FALSE

記述例３　 isfullnum('１６７８',true) → TRUE

ISFULLUPPER

bool ISFULLUPPER(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角英大文字なら真。
全検査フラグが真の場合は、すべての文字が全角英大文字なら真。

記述例１　 isfullupper('Ｔｏｋｙｏ') → TRUE

記述例２　 isfullupper('Ｔｏｋｙｏ',true) → FALSE

記述例３　 isfullupper('ＴＯＫＹＯ',true) → TRUE

ISFULLLOWER

bool ISFULLLOWER(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角英小文字なら真。
全検査フラグが真の場合は、すべての文字が全角英小文字なら真。

記述例１　 isfulllower('ａｌｐｈａＢ') → TRUE

記述例２　 isfulllower('ａｌｐｈａＢ',true) → FALSE

記述例３　 isfulllower('ａｌｐｈａ',true) → TRUE

ISGREEK

bool ISGREEK(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角ギリシャ文字なら真。
全検査フラグが真の場合は、すべての文字が全角ギリシャ文字なら真。

記述例１　 isgreek('α') → TRUE

記述例２　 isgreek('α線',true) → FALSE

記述例３　 isgreek('αΩ',true) → TRUE

ISGREEKUPPER bool ISGREEKUPPER( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が全角ギリシャ大文字のなら真。
全検査フラグが真の場合は、すべての文字が全角ギリシャ大文字なら真。

ISGREEKLOWER bool ISGREEKLOWER( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が全角ギリシャ子文字のなら真。
全検査フラグが真の場合は、すべての文字が全角ギリシャ子文字なら真。

ISROMAN bool ISROMAN( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が全角ローマ数字文字なら真。
全検査フラグが真の場合は、すべての文字が全角ローマ数字なら真。

ISROMANUPPER bool ISROMANUPPER( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が全角ローマ数字の大文字のなら真。
全検査フラグが真の場合は、すべての文字が全角ローマ数字の大文字なら真。

ISROMANLOWER bool ISROMANLOWER( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が全角ローマ数字の子文字のなら真。
全検査フラグが真の場合は、すべての文字が全角ローマ数字の子文字なら真。

ISRUSS

bool ISRUSS(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角ロシア文字なら真。
全検査フラグが真の場合は、すべての文字が全角ロシア文字なら真。

記述例１　 isruss('гゲー') → TRUE

記述例２　 isruss('гゲー',true) → FALSE

記述例３　 isruss('гф',true) → TRUE

ISRUSSUPPER bool ISRUSSUPPER( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が全角ロシア大文字のなら真。
全検査フラグが真の場合は、すべての文字が全角ロシア大文字なら真。

ISRUSSLOWER bool ISRUSSLOWER( str 文字 [ , bool 全検査フラグ ] )
先頭の一文字が全角ロシア子文字のなら真。
全検査フラグが真の場合は、すべての文字が全角ロシア子文字なら真。

ISHIRAGANA

bool ISHIRAGANA(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角ひらがななら真。
全検査フラグが真の場合は、すべての文字が全角ひらがななら真。

記述例１　 ishiragana('とうきょうクッキー') → TRUE

記述例２　 ishiragana('とうきょうクッキー',true) → FALSE

記述例３　 ishiragana('とうきょうまんじゅう',true) → TRUE

ISHIRABOU

bool ISHIRABOU(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角ひらがなか、長音記号なら真。
全検査フラグが真の場合は、すべての文字が全角ひらがな、長音記号なら真。

記述例１　 ishirabou('とうきょうケーキ') → TRUE

記述例２　 ishirabou('とうきょうけーき',true) → TRUE

記述例３　 ishirabou('とうきょうケーキ',true) → FALSE

ISHIRAGANAX

bool ISHIRAGANAX(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角ひらがな、長音記号、濁点、半濁点なら真。
全検査フラグが真の場合は、すべての文字が全角ひらがな、長音記号、半濁点なら真。

記述例１　 ishiraganax('あきは゛クッキー') → TRUE

記述例２　 ishiraganax('あきは゛クッキー',true) → FALSE

記述例３　 ishiraganax('あきは゛まんし゛ゅう',true) → TRUE

ISKATAKANA

bool ISKATAKANA(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角カタカナなら真。
全検査フラグが真の場合は、すべての文字が全角カタカナなら真。

記述例１　 iskatakana('サケ缶') → TRUE

記述例２　 iskatakana('サケ缶',TRUE) → FALSE

記述例３　 iskatakana('コロンボ') → TRUE

ISKATABOU

bool ISKATAKANA(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角カタカナか、長音記号なら真。
全検査フラグが真の場合は、すべての文字が全角カタカナあるいは長音記号なら真。

記述例１　 iskatabou('カントリーぼーい') → TRUE

記述例２　 iskatabou('カントリーぼーい',true) → FALSE

記述例３　 iskatabou('カントリーボーイ',true) → TRUE

ISKATAKANAX

bool ISKATAKANAX(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が全角カタカナか、長音記号、濁点、半濁点なら真。
全検査フラグが真の場合は、すべての文字が全角カタカナあるいは長音記号、濁点、半濁点なら真。

記述例１　 iskatakanax('カントリーぼーい') → TRUE

記述例２　 iskatakanax('カントリーぼーい',true) → FALSE

記述例３　 iskatakanax('カントリーホ゛ーイ',true) → TRUE

ISHALFKANA

bool ISHALFKANA(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が半角カタカナ（半角カタカナ記号を含む）なら真。
全検査フラグが真の場合は、すべての文字が半角カタカナなら真。

記述例１　 ishalfkana('ｴﾘｱ･ｺｰﾄﾞ615') → TRUE

記述例２　 ishalfkana('ｴﾘｱ･ｺｰﾄﾞ615',true) → FALSE

記述例３　 ishalfkana('｢ｴﾘｱ･ｺｰﾄﾞ｣',true) → TRUE

ISKANJI

bool ISKANJI(
str 文字
[ , bool 全検査フラグ ]
)

先頭の一文字が漢字なら真。
全検査フラグが真の場合は、すべての文字が漢字なら真。

記述例１　 iskanji('東京タワー') → TRUE

記述例２　 iskanji('東京タワー',true) → FALSE

記述例３　 iskanji('東京都武蔵野市',true) → TRUE

ISINSTR

bool ISINSTR(
str 文字
, str テーブル文字列
[ , bool 全検査フラグ ]
)

先頭の一文字がテーブル文字列に含まれれば真。
文字または、テーブル文字列が空ならば偽。全検査フラグが真の場合は、すべての文字がテーブル文字列に含まれるなら真。

記述例１　 isinstr('東京タワー','京東') → TRUE

記述例２　 isinstr('東京タワー','京東',true) → FALSE

記述例３　 isinstr('東京','京東',true) → TRUE

ISOUTSTR

bool ISOUTSTR(
str 文字
, str テーブル文字列
[ , bool 全検査フラグ ]
)

先頭の一文字がテーブル文字列に含まれ無ければ真。
文字または、テーブル文字列が空ならば真。全検査フラグが真の場合は、すべての文字がテーブル文字列に含まれないなら真。

記述例１　 isoutstr('東京タワー','タコ') → TRUE

記述例２　 isoutstr('東京タワー','タコ',true) → FALSE

記述例３　 isinstr('東京タワー','孫親',true) → FALSE

ISWORD

bool ISWORD(
str 文字列
[ , bool 先頭フラグ ]
)

文字列がすべて、半角英数字または、「_」でできていれば真。
先頭フラグを真にすると、先頭の一文字だけは、半角英字または、「_」であることが真の条件に加わる。

記述例１　 isword('book_127') → TRUE

記述例２　 isword('12years') → TRUE

記述例３　 isword('12years',true) → FALSE

ISSPACE

bool ISSPACE(
str 文字列
)

文字列に半角スペース以外の文字を含まなければ真。
長さ0の文字列も真と判定することに注意すること。

記述例１　 isspace(' ') → TRUE

記述例２　 isspace(' abc ') → FALSE

記述例３　 isspace(tab) → FALSE

記述例４　 isspace('') → TRUE

ISBLANK

bool ISBLANK(
str 文字列
)

文字列にブランク以外の文字を含まなければ真。
ここでいうブランクは、半角スペースと制御コードである。長さ0の文字列も真と判定することに注意すること。

記述例１　 isblank(' ') → TRUE

記述例２　 isblank(' abc ') → FALSE

記述例３　 isblank(tab) → TRUE

記述例４　 isblank('') → TRUE

ISBLANKV

bool ISBLANKV(
str 文字列
)

文字列に狭義のブランク以外の文字を含まなければ真。
ここでいう狭義のブランクは、タブ（0x09）や改行（0x0a）を含まない制御コードと、半角スペースである。長さ0の文字列も真と判定することに注意すること。

記述例１　 isblankv(' ') → TRUE

記述例２　 isblankv(' abc ') → FALSE

記述例３　 isblankv(tab) → FALSE

記述例４　 isblankv('') → TRUE

文字列操作（一般）

ASCII

str ASCII( int コード )
コードに対応する１文字の文字列を返す。
不正な文字列を作成する可能性があるので通常は使用すべきではない。

記述例　 ascii(97) → a

str ASCII( str １６進表記 )
１６進表記の文字列と捉え、文字列に変換する。
ここで使用する１６進文字列は STRHEX 関数で得ることができる。
不正な文字列を作成する可能性があるので通常は使用すべきではない。

記述例　 ascii('93FA967B8CEA') → 日本語

CODE

int CODE(
str 文字列
)

文字列先頭の一文字に対応するコードを返す。
長さ０の文字列では 0 を返す。

記述例　 code('Z') → 90

LEN

int LEN(
str 文字列
)

文字列の文字数。

記述例　 len('日本語mycard') → 9

STR_IX

str STR_IX(
str 文字列
, int 位置
)

文字列中の指定位置の一文字。
位置は文字列の先頭を0とする。文字が存在しない位置を指定すると長さ 0 の文字列を返す。

記述例　 str_ix('日本語mycard',3) → m

STR_IXSET

str STR_IXSET(
str 文字列
, int 位置
, str 置換式
)

文字列中の指定位置の一文字を置換式で置き換える。
置換式の中では、変数 IXで位置を、変数 SS で元の文字を参照できる。

記述例　 str_ixset('日本語mycard',3,kado(ss)) → 日本語[m]ycard

STR_FOR

int STR_FOR(
str 文字列
, 評価式
)

文字列内の一文字単位で評価式を評価する。
評価式の中では、特別な変数 SS で対象の文字を、IXで序数を参照できる。
評価式が BREAK になると処理を中断する。

記述例　文字列中の半角文字を数える
{c:=0;str_for('日本語mycard',c+=int(ishalf(ss)));c;} → 6

STR_REP

str STR_REP(
str 文字列
, str 置換式 
)

文字列内の一文字単位で置換式に置き換える。
置換式の中では、特別な変数 SS で対象の文字を、IXで序数を参照できる。

記述例１　半角文字を「*」で置き換える。
str_rep('日本語mycard',if(ishalf(ss),'*',ss)) → 日本語******

記述例２　すべての文字を括弧で囲む。
str_rep('日本語mycard',kakko(ss)) → (日)(本)(語)(m)(y)(c)(a)(r)(d)

STR_SEL

str STR_SEL(
str 文字列
, bool 判定式
)

文字列内の一文字単位で判定式が真になるものだけを連結する。
判定式の中では、特別な変数 SS で対象の文字を、IXで序数を参照できる。

記述例１　奇数番目の文字（先頭を1として）
str_sel('日本語mycard',iseven(ix)) → 日語yad

記述例２　全角文字だけ取り出す
str_sel('日本語mycard',isfull(ss)) → 日本語

STR_SCAN

int STR_SCAN(
str 文字列
, bool 判定式
)

文字列内の一文字単位で判定式で判定する。
判定式が真になった時点で繰返しを中止し、戻り値としてそのときのIXの値を返す。すべて偽の場合は、戻り値は-1。判定式の中では、特別な変数 SS で対象の文字を、IXで序数を参照できる。

記述例　 str_scan('日本語mycard',ishalf(ss)) → 3

STR_PRIME

 STR_PRIME(
str 文字列
, bool 判定式
)

文字列内の一文字単位で判定式で判定する。
判定式が真になった時点で繰返しを中止し、戻り値としてそのときの文字を返す。すべて偽の場合は、戻り値はFALSE。判定式の中では、特別な変数 SS で対象の文字を、IXで序数を参照できる。

記述例　 str_prime('日本語mycard',ishalf(ss)) → m

STR_SOME

bool STR_SOME(
str 文字列
, bool 判定式
)

文字列内の一文字単位で判定式で判定する。
判定式が真になった時点で繰返しを中止し、戻り値を真にする。すべて偽の場合のみ、戻り値は偽。判定式の中では、特別な変数 SS で対象の文字を、IXで序数を参照できる。

記述例１　 str_some('bluesguy',isupper(ss)) → FALSE

記述例２　 str_some('bluesGuy',isupper(ss)) → TRUE

STR_EVERY

bool STR_EVERY(
str 文字列
, bool 判定式
)

文字列内の一文字単位で判定式で判定する。
判定式が偽になった時点で繰返しを中止し、戻り値を偽にする。すべて真になった場合のみ、戻り値は真。判定式の中では、特別な変数 SS で対象の文字を、IXで序数を参照できる。

記述例１　 str_every('bluesGuy',isupper(ss)) → FALSE

記述例２　 str_every('BLUESGUY',isupper(ss)) → TRUE

STR_ROT

str STR_ROT(
str 文字列
[ , int カウント ]
)

文字列内の一文字単位でカウント分だけ回転した文字列。
カウントが正の場合は、左へ回転し、負の場合は右へ回転する。カウントを省略すると左へ１文字分回転する。

記述例１　 str_rot('algosampodo') → lgosampodoa

記述例２　 str_rot('algosampodo',2) → gosampodoal

記述例３　 str_rot('algosampodo',-2) → doalgosampo

STR_LAST

str STR_LAST(
str 文字列
)

文字列内の一文字。

記述例１　 str_last('algosampodo') → o

記述例２　 str_last('日本語') → 語

STR_CHOP

str STR_CHOP(
str 文字列
[ , bool 判別式 ]
)

最後の１文字を取り除いた文字列。
判別式を書くと、最後の１文字を取り除くか否かを判定できる。
判別式が真ならば最後の１文字を取り除く。判別式の中では特別な変数 SS で削除対象の文字を参照できる。

記述例１　 str_chop('algosampodo') → algosampod

記述例２　 str_chop('日本語') → 日本

記述例３　 str_chop('sampodo'+lf,ss==lf) → sampodo
１６進表記では 73616D706F646F

CHOPLF str CHOPLF( str 文字列 )
文字列の最後の1文字が LF ならば取り除く。

CHOPEOL str CHOPEOL( str 文字列 )
文字列の最後の2文字が CR LF ならば取り除く。

STRN2STR str STRN2STR( str 文字列 , int 文字数 , str セパレータ )
文字列を指定の文字数に分けて、セパレータを挟んで再連結する。

JTOP

str JTOP(
str 文字列
, int 文字数
)

文字列の左から文字数分だけを取り出す。足りない分は短くなる。

記述例１　 jtop('algosampodo',4) → algo

記述例２　 jtop('algo',8) → algo

記述例３　 jtop('日本語mycard',3) → 日本語

JBOTTOM

str JBOTTOM(
str 文字列
, int 文字数
)

文字列の右から文字数分だけを取り出す。足りない分は短くなる。

記述例１　 jbottom('algosampodo',4) → podo

記述例２　 jbottom('algo',8) → algo

記述例３　 jbottom('日本語',2) → 本語

JMID

str JMID(
str 文字列
, int 文字位置
[ , int 文字数 ]
)

文字列の文字位置から文字数の文字列を取り出す
文字数を省略すると、文字位置以降の文字列を取り出す。
文字位置は0から始まる。

記述例１　 jmid('algosampodo',4) → sampodo

記述例２　 jmid('algosampodo',4,2) → sa

記述例３　 jmid('東京都武蔵野市',3,3) → 武蔵野

SUBST

str SUBST(
str 文字列
, str 置換文字列
, int 文字位置
, int 文字数
)

文字列の指定位置から指定文字数の部分を置換文字列に置き換える。
文字位置は0から始まる。

記述例１　 subst('algosampodo','算法',4,5) → algo算法do

記述例２　 subst('algosampodo','',4,5) → algodo

記述例３　 subst('algosampodo','算法',4,0) → algo算法sampodo

記述例４　 subst('algosampodo','算法',0,0) → 算法algosampodo

記述例５　 subst('algosampodo','算法',1000,0) → algosampodo算法

記述例６　 subst('algosampodo','算法',0,1000) → 算法

TRIM

str TRIM(
str 文字列
[ , bool 拡大フラグ ]
)

文字列の先頭、末尾の連続した半角スペースを削除した文字列を返す。
拡大フラグに真を指定すると制御コードもスペースと同様に扱う。

記述例　 trim(' algo ') → algo
１６進表記では 616C676F

TRIMLEFT

str TRIMLEFT(
str 文字列
[ , bool 拡大フラグ ]
)

文字列の先頭の連続した半角スペースを削除した文字列を返す。
拡大フラグに真を指定すると制御コードもスペースと同様に扱う。

記述例　 trimleft(' algo ') → algo
１６進表記では 616C676F20

TRIMRIGHT

str TRIMRIGHT(
str 文字列
[ , bool 拡大フラグ ]
)

文字列の末尾の連続した半角スペースを削除した文字列を返す。
拡大フラグに真を指定すると制御コードもスペースと同様に扱う。

記述例　 trimright(' algo ') → algo
１６進表記では 20616C676F

TRIMSP

str TRIMSP(
str 文字列
[ , str 出力区切り ]
)

文字列の先頭、末尾の半角スペースと制御コードを削除し、中途の連続した半角スペースと制御コードを一文字の半角スペースに置き換える。
出力区切りで連続した半角スペースと制御コードの置き換え文字列を指定できる。

記述例１　 trimsp(' algo sampodo ') → algo sampodo
１６進表記では 616C676F2073616D706F646F

記述例２　 trimsp(' algo sampodo ',':') → algo:sampodo

DETAB

str DETAB(
str 文字列
[ , int タブ間隔 ]
)

タブを半角スペースで置き換える。
文字列内の行末コードは改行として扱う。タブ間隔は正の整数で指定する。タブ間隔を指定しなければタブ間隔は 8 。

記述例　 detab('loop:'+tab+'mov'+tab+'eax,edx') → loop: mov eax,edx

ENTAB

str ENTAB(
str 文字列
[
, int タブ間隔
[ , bool 先頭フラグ ]
]
)

半角スペースをタブで置き換える。
文字列内の行末コードは改行として扱う。タブ間隔は正の整数で指定する。タブ間隔を指定しなければタブ間隔は 8 。
先頭フラグを真にすると、行頭のスペースの連続だけがタブに置き換えられる。

記述例１　 entab('loop: mov eax,edx') →
loop:→mov→eax,edx

記述例２　 entab(' mov eax,edx',8,true) →
→mov eax,edx

STRING

str STRING(
str 文字列
, int 繰り返し数
)

文字列を回数だけ繰り返した文字列。

記述例　 string('hello',3) → hellohellohello

STRCONC

str STRCONC( str セパレータ [ , str 式 ]* )
式を文字列としてセパレータで繋いだ文字列。
セパレータが必要なければ、STR 関数を使う方が良い。。

記述例１　 strconc('/','hello','world') → hello/world

記述例２　 strconc('','hello','world') → helloworld

記述例３　 strconc('/','hello') → hello

str STRCONC( bool 行末フラグ [ , str 式 ]* )
行末フラグが真ならば、文字列の末尾に行末 (LF 0x0a) を付加して連結する。偽ならば、文字列を単純に連結する。

記述例　 strconc(true,'hello','world') →

hello↓
world↓

STRPACK

str STRPACK(
str トレーラ
[ , str 式 ]*
)

式の値の後ろにトレーラを付けて連結した文字列。

記述例　 strpack('!!','hello','world') → hello!!world!!

STRCONCIX

str STRCONCIX(
int 回数
, { str セパレータ
| bool 行末フラグ }
, str 評価式
)

指定の回数だけ評価式を評価し、結果を文字列に変換してセパレータを挟んで連結した文字列を返す。
セパレータ文字列でなく、行末フラグを指定できる。改行フラグが真ならば、評価式の後ろに行末 (LF 0x0a) を追加して文字列として連結する。行末フラグが偽ならば、セパレータを用いずに連結する。
評価式の中では、特殊な整数変数「IX」を使用できる。 IXには、繰返しに従って 0 から始まる序数が入っている。

記述例１　 strconcix(4,comma,ix+1) → 1,2,3,4

記述例２　 strconcix(4,'||',sqrt(ix+1)) → 1.0||1.4142135623730951||1.7320508075688772||2.0

記述例３　 strconcix(4,true,str_ix('abcdefg',ix)) →

a↓
b↓
c↓
d↓

STRCONCRANGE str STRCONCRANGE( int 開始値 , int 終了値 , { str セパレータ | bool 行末フラグ } , str 評価式 )
開始値から終了値まで評価式を評価し、結果を文字列に変換してセパレータを挟んで連結した文字列を返す。
セパレータ文字列でなく、行末フラグを指定できる。改行フラグが真ならば、評価式の後ろに行末 (LF 0x0a) を追加して文字列として連結する。行末フラグが偽ならば、セパレータを用いずに連結する。
評価式の中では、特殊な整数変数「IX」で開始値から始まる値を参照できる。

STRASB

str STRASB(
str 文字列Ａ
, str 文字列Ｓ
, str 文字列Ｂ
)

文字列の条件付連結。
文字列Ａが空でなければ、文字列Ａ + 文字列Ｓ + 文字列Ｂを返す。
文字列Ａが空ならば、文字列Ｂを返す。
文字列の繰返し連結に使用すると便利な関数。

記述例１　 strasb('',':','abc') → abc

記述例２　 strasb('xyz',':','abc') → xyz:abc

STRASBIF

str STRASBIF(
str 文字列Ａ
, str 文字列Ｓ
, str 文字列Ｂ
)

文字列の条件付連結。
文字列Ｂが空でなければ、文字列Ａ + 文字列Ｓ + 文字列Ｂを返す。
文字列Ｂが空ならば、文字列Ａを返す。

記述例１　 strasbif('xyz',':','abc') → xyz:abc

記述例２　 strasbif('xyz',':','') → xyz

STRNULL

str STRNULL(
str 検定文字列
, str 置換文字列
)

空文字列を置換。
検定文字列が空ならば置換文字列を返す。
検定文字列が空でなければ検定文字列を返す。このとき置換文字列は評価しない。

記述例１　 strnull('','abc') → abc

記述例２　 strnull('xyz','abc') → xyz

STRNOTNULL

str STRNOTNULL(
str 検定文字列
, str 置換文字列
)

非空文字列を置換。
検定文字列が空でなければ置換文字列を返す。
検定文字列が空ならば検定文字列（空文字列）を返す。このとき置換文字列は評価しない。

記述例１　 strnotnull('','abc') →

記述例２　 strnotnull('xyz','abc') → abc

STRNZ str STRNZ( str 検定文字列 , str 置換文字列 )
STRNOTNULL と同じ。
古いバージョンとの互換性を保つために存在する。使用すべきではない。

STRRANGE

str STRRANGE(
str 範囲指定
[ , bool 限定フラグ ]
)

範囲の文字列を返す。
範囲指定の文字列を二文字ずつ取り出し、範囲を表す。範囲は二つの文字の組み合わせとなるので、この文字コードの間に含む文字をすべて含む文字列を返す。
範囲が複数あれば、それらを繋げたものを返す。
範囲指定の長さが奇数である場合には、半端な範囲が生ずるが、このときは、最後の一文字だけでできた範囲はその文字そのものを返す。
限定フラグを真にすると、TAB(\t 0x09)、行末以外の制御コードを除外する。
範囲はコードの数値だけを調べているので、不連続な全角コードなどはうまく扱えない。半角文字、制御コードはうまく行く。
全角コードでうまく扱える範囲：「ぁん」「ァン」「０９」「ＡＺ」「ａｚ」「ΑΩ」「αω」など。

記述例　 strrange('az') → abcdefghijklmnopqrstuvwxyz

SPS2STR

str SPS2STR( str 文字列 [ , { str セパレータ | bool 行末フラグ } ] )
スペース区切り文字列の要素をセパレータで連結した文字列。
行末フラグが真の場合は、要素の末尾に行末 (LF 0x0a) を追加して連結する。
行末フラグが偽、あるいは、行末フラグ、セパレータが省略されると、何も挟まず連結する。

スペース区切り文字列は、各要素の間がスペース（制御コードを含む)で区切られた文字列。スペースの連続は一つのスペースとして扱う。
セパレータに TAB(\t 0x09) を指定すれば、スペース区切り文字列 → タブ区切り文字列（FIELD_**で扱う)の変換。
行末フラグをTRUEすれば、スペース区切り文字列 → 行文字列（LINE_**で扱う）の変換。

記述例１　 sps2str(' abc def g ',comma) → abc,def,g

記述例２　 sps2str('tokyo ohsaka'+lf+' nagoya',tab) →
tokyo→ohsaka→nagoya

記述例３　 sps2str('tokyo ohsaka nagoya',true) →

tokyo↓
ohsaka↓
nagoya↓

SQS2STR

str SQS2STR( str 文字列 [ , { str セパレータ | bool 行末フラグ } ] )
引用符を含むスペース区切り文字列の要素をセパレータで連結した文字列。
行末フラグが真の場合は、要素の末尾に行末 (LF 0x0a) を追加して連結する。
行末フラグが偽、あるいは、行末フラグ、セパレータが省略されると、何も挟まず連結する。

扱う文字列は、各要素の間がスペース（制御コードを含む)で区切られた文字列で、要素は複引用符「"」で囲まれていることもある。複引用符の中で複引用符は、「\"」、で表される。また、「\」は「\\」で表される。スペースの連続は一つのスペースとして扱う。

記述例　 sqs2str(' abc "def gh" i ',comma) → abc,def gh,i

SDQS2STR

str SDQS2STR( str 文字列 [ , { str セパレータ | bool 行末フラグ } ] )
引用符を含むスペース区切り文字列の要素をセパレータで連結した文字列。
行末フラグが真の場合は、要素の末尾に行末 (LF 0x0a) を追加して連結する。
行末フラグが偽、あるいは、行末フラグ、セパレータが省略されると、何も挟まず連結する。

扱う文字列は、各要素の間がスペース（制御コードを含む)で区切られた文字列で、要素は複引用符「"」で囲まれていることもある。複引用符の中で複引用符は、「""」、で表される。スペースの連続は一つのスペースとして扱う。

記述例　 sdqs2str(' abc "def""gh" i ',comma) → abc,def"gh,i

文字列操作（検索／置換）

REPARG

str REPARG( str テンプレート [ , str 引数 ]* )
テンプレートを引数置換置換に従って置換する。
引数を指定した場合は、引数は 1 から順に対応する。引数 0 は引数の数を与える。
引数を省略すると、TSEXPR 呼び出し元の引数を引き継ぐ。

記述例　単純置換
reparg('関数 %1; の値は %2; です','SQRT(2.0)',sqrt(2.0)) → 関数 SQRT(2.0) の値は 1.4142135623730951 です

% str テンプレート [ ( str 引数 [ , str 引数 ]* ) ]
文字列の前に「%」をつける略記法。
引数を指定した場合は、引数は 1 から順に対応する。引数 0 は引数の数を与える。
引数を省略すると、TSEXPR 呼び出し元の引数を引き継ぐ。

記述例　単純置換
{?func:='関数 %1; の値は %2; です'; %?func('SQRT(2.0)',sqrt(2.0));} → 関数 SQRT(2.0) の値は 1.4142135623730951 です

SEARCH

int SEARCH(
str 文字列
, str 検索文字列
)

文字列から検索文字列を探し出し、先頭からの文字位置を返す。
見つからなかった場合は負の値が返る。

記述例１　 search('Blue Grass Boys','Grass') → 5

記述例２　 search('Blue Grass Boys','grass') → -1

SEARCHI

int SEARCHI(
str 文字列
, str 検索文字列
)

文字列から検索文字列を探し出し、先頭からの文字位置を返す。検索の際に半角英字の大文字と小文字を区別しない
見つからなかった場合は負の値が返る。

記述例１　 searchi('Blue Grass Boys','Grass') → 5

記述例２　 searchi('Blue Grass Boys','grass') → 5

記述例３　 searchi('Blue Grass Boys','bill') → -1

SEARCHX int SEARCHX( str 文字列 , str 検索文字列 )
文字列から検索文字列を探し出し、先頭からの文字位置を返す。検索の際に半角英字の大文字小文字、全角英字などの大文字小文字を区別しない
見つからなかった場合は負の値が返る。

SEARCHCOUNT

int SEARCHCOUNT(
str 文字列
, str 検索文字列
)

文字列に含まれる検索文字列の数を返す。

記述例１　 searchcount('Hey,Hey,Hey','He') → 3

記述例２　 searchcount('Hey,hey,hey','he') → 2

SEARCHICOUNT

int SEARCHICOUNT(
str 文字列
, str 検索文字列
)

文字列に含まれる検索文字列の数を返す。
検索の際に半角英字の大文字と小文字を区別しない

記述例　 searchicount('Hey,hey,hey','he') → 3

SEARCHXCOUNT int SEARCHXCOUNT( str 文字列 , str 検索文字列 )
文字列に含まれる検索文字列の数を返す。
検索の際に半角全角共に大文字と小文字を区別しない

HAS

bool HAS(
str 対象文字列
, str 検索文字列
[ , int モード ]
)

対象文字列の中に検索文字列があれば真。
モードによって比較の方法が異なる。

0	デフォルト。通常の比較
1	半角英字の大文字小文字を区別しない
2	半角全角の大文字小文字を区別しない

記述例１　 has('日本語処理','語') → TRUE

記述例２　 has('SteelBar Blues','bar') → FALSE

記述例３　 has('SteelBar Blues','bar',1) → TRUE

HASHEAD

bool HASHEAD(
str 対象文字列
, str 先頭文字列
[ , int モード ]
)

対象文字列の先頭に先頭文字列があれば真。
モードによって比較の方法が異なる。

0	デフォルト。通常の比較
1	半角英字の大文字小文字を区別しない
2	半角全角の大文字小文字を区別しない

記述例１　 hashead('日本語処理','日本語') → TRUE

記述例２　 hashead('Steelbar','steel') → FALSE

記述例３　 hashead('Steelbar','steel',1) → TRUE

HASTAIL

bool HASTAIL(
str 対象文字列
, str 末尾文字列
[ , int モード ]
)

対象文字列の末尾に末尾文字列があれば真。
モードによって比較の方法が異なる。

0	デフォルト。通常の比較
1	半角英字の大文字小文字を区別しない
2	半角全角の大文字小文字を区別しない

記述例１　 hastail('日本語処理','処理') → TRUE

記述例２　 hastail('Steelbar','Bar') → FALSE

記述例３　 hastail('Steelbar','Bar',1) → TRUE

HASSOME

bool HASSOME(
str 対象文字列
[ , str 検索文字列 ]*
)

対象文字列の中に検索文字列が一つでもあれば真を返す。

記述例１　 hassome('Steelbar','bar','pick') → TRUE

記述例２　 hassome('Steelbar','pick','ball') → FALSE

HASISOME

bool HASISOME(
str 対象文字列
[ , str 検索文字列 ]*
)

対象文字列の中に検索文字列が一つでもあれば真を返す。
英字の大文字／小文字を区別しない。

記述例　 hasisome('SteelBar','bar','pick') → TRUE

HASXSOME bool HASXSOME( str 対象文字列 [ , str 検索文字列 ]* )
対象文字列の中に検索文字列が一つでもあれば真を返す。
半角／全角の大文字小文字を区別しない。

HASEVERY

bool HASEVERY(
str 対象文字列
[ , str 検索文字列 ]*
)

対象文字列の中に検索文字列がすべてあれば真を返す。

記述例１　 hasevery('Steelbar and stonewall','steel','stone') → FALSE

記述例２　 hasevery('Steelbar and stonewall','steel','wood') → FALSE

HASIEVERY

bool HASIEVERU(
str 対象文字列
[ , str 検索文字列 ]*
)

対象文字列の中に検索文字列がすべてあれば真を返す。
英字の大文字／小文字を区別しない。

記述例１　 hasievery('Steelbar and stonewall','Steel','Stone') → TRUE

HASXEVERY bool HASXEVERU( str 対象文字列 [ , str 検索文字列 ]* )
対象文字列の中に検索文字列がすべてあれば真を返す。
全角の大文字小文字を区別しない。

REPSTR

str REPSTR(
str 文字列
, str 検索文字列
, str 置換文字列
)

文字列中の検索文字列を置換文字列に置きかえる。

記述例　 repstr('My Book,My Sheet,my pen.','My','your') → your Book,your Sheet,my pen.

REPSTRI

str REPSTRI(
str 文字列
, str 検索文字列
, str 置換文字列
)

文字列中の検索文字列を置換文字列に置きかえる。
検索の際に半角英字の大文字と小文字を区別しない

記述例　 repstri('My Book,My Sheet,my pen.','My','your') → your Book,your Sheet,your pen.

REPSTRX str REPSTRX( str 文字列 , str 検索文字列 , str 置換文字列 )
文字列中の検索文字列を置換文字列に置きかえる。
検索の際に半角全角の大文字小文字を区別しない

REP1STR

str REP1STR(
str 文字列
, str 検索文字列
, str 置換文字列
)

文字列中の最初に見つかった検索文字列を置換文字列に置きかえる。

記述例　 rep1str('my Book,My Sheet,My pen.','My','your') → my Book,your Sheet,My pen.

REP1STRI

str REP1STRI(
str 文字列
, str 検索文字列
, str 置換文字列
)

文字列中の最初に見つかった検索文字列を置換文字列に置きかえる。
検索の際に半角英字の大文字と小文字を区別しない

記述例　 rep1stri('my Book,My Sheet,My pen.','My','your') → your Book,My Sheet,My pen.

REP1STRX str REP1STRX( str 文字列 , str 検索文字列 , str 置換文字列 )
文字列中の最初に見つかった検索文字列を置換文字列に置きかえる。
検索の際に半角全角の大文字小文字を区別しない

REPSTRIX

str REPSTRIX(
str 文字列
, str 検索文字列
, str 置換文字列
)

文字列中の検索文字列を置換文字列に置きかえる。
置換文字列は置換が必要なときに毎回評価される。置換文字列の中では、SS で検索文字列を、IX で 0 から始まる置換番号を参照できる。

記述例　 repstrix('my Book,My Sheet,My pen.','My',kado(comma(ix+1,'your',ss))) → my Book,[1,your,My] Sheet,[2,your,My] pen.

REPSTRIXI

str REPSTRIXI(
str 文字列
, str 検索文字列
, str 置換文字列
)

文字列中の検索文字列を置換文字列に置きかえる。
置換文字列は置換が必要なときに毎回評価される。置換文字列の中では、SS で検索文字列を、IX で 0 から始まる置換番号を参照できる。検索の際に半角英字の大文字と小文字を区別しない

記述例　 repstrixi('my Book,My Sheet,My pen.','My',kado(comma(ix+1,'your',ss))) → [1,your,My] Book,[2,your,My] Sheet,[3,your,My] pen.

REPSTRIXX str REPSTRIXX( str 文字列 , str 検索文字列 , str 置換文字列 )
文字列中の検索文字列を置換文字列に置きかえる。
置換文字列は置換が必要なときに毎回評価される。置換文字列の中では、SS で検索文字列を、IX で 0 から始まる置換番号を参照できる。検索の際に半角全角の大文字と小文字を区別しない

RP

str RP(
str テンプレート文字列
, str 差込文字列
[ , str 置換文字 ]
)

文字単位の差込。
テンプレート文字列の置換文字を差し込み文字列の先頭から順に置き換える。
置換文字の指定を省略するか、置換文字の長さが0の場合は、半角の「#」が置換文字となる。
置換文字は引数で指定した置換文字の先頭の一文字を使用する。
差込文字列が短すぎる場合は、置換文字の種類によって多少動作が違う。置換文字が半角の場合は半角スペースに置き換わる。全角の場合は二文字の半角スペースに置き換わる。置換文字が制御コードの場合は置き換えずに省略する。

記述例１　 rp('(####/##/##)','19201204') → (1920/12/04)

記述例２　 rp('($$$$/$$/$$)','192012','$') → (1920/12/ )

MISMATCH

int MISMATCH(
str 文字列1
, str 文字列2
)

二つの文字列を先頭から比較し、始めて異なった位置を返す。
位置は、文字列の先頭を0として数える。
結果的に先頭から一致した文字数を返すことになる。

記述例　 mismatch('algosampodo','alphapet') → 2

文字列操作（フィルタ）

LARGE

str LARGE(
str 文字列
[ , bool 文字種拡大 ]
)

文字列中の半角小文字を大文字に変換。
文字種拡大を TRUE にすると、全角英字／ギリシャ／ロシア／ローマ数字も扱う。

記述例　 large('algosampodo') → ALGOSAMPODO

CAP

str CAP(
str 文字列
[ , str 置換式 ]
)

文字列の先頭の１文字を半角小文字を大文字に変換する。
置換式を書くと文字列の先頭の一文字は置換式の値になる。置換式の中では SS で先頭の１文字を参照できる。

記述例１　 cap('algosampodo') → Algosampodo

記述例２　 cap('algosampodo',full(large(ss))) → Ａlgosampodo

SMALL

str SMALL(
str 文字列
[ , bool 文字種拡大 ]
)

文字列中の半角大文字を小文字に変換。
文字種拡大を TRUE にすると、全角英字／ギリシャ／ロシア／ローマ数字も扱う。

記述例　 small('ALGOSAMPODO') → algosampodo

FULL

str FULL(
str 文字列
)

文字列中の半角文字を全角文字に変換。
文字列中の濁点・半濁点のまとめ（は゜→ぱ　など）も行われる。

記述例１　 full('algosampodo') → ａｌｇｏｓａｍｐｏｄｏ

記述例２　 full('ﾊﾟﾛﾃﾞｨ') → パロディ

HALF

str HALF(
str 文字列
[ , bool 削除フラグ ]
)

文字列中の全角文字を半角文字にできるだけ変換する。
削除フラグを真に指定した場合は、変換できなかった文字は削除する。

記述例１　 half('日本語アルファベットａｂｃ') → 日本語ｱﾙﾌｧﾍﾞｯﾄabc

記述例２　 half('日本語アルファベットａｂｃ',true) → ｱﾙﾌｧﾍﾞｯﾄabc

HIRAGANA

str HIRAGANA(
str 文字列
)

文字列中の全角カタカナをひらがなに変換。

記述例　 hiragana('日本語とアルファベット') → 日本語とあるふぁべっと

KATAKANA

str KATAKANA(
str 文字列
)

文字列中のひらがなを全角カタカナに変換。
文字列中の濁点・半濁点のまとめ（は゜→ぱ　など）も行われる。

記述例１　 katakana('そふとくりーむ') → ソフトクリーム

記述例２　 katakana('はは゛ねらは゜ーま') → ハバネラパーマ

FLT_DIGIT str FLT_DIGIT( str 文字列 )
半角数字だけを残した文字列。

FLT_NUM str FLT_NUM( str 文字列 )
半角数字と「+」「-」「.」だけを残した文字列。

FLT_HALF str FLT_HALF( str 文字列 )
半角だけを残した文字列。
制御コードは含まない。

FLT_ALPHA str FLT_ALPHA( str 文字列 )
半角英字だけを残した文字列。

FLT_ALNUM str FLT_ALNUM( str 文字列 )
半角英数字だけを残した文字列。

LF2EOL

str LF2EOL(
str 文字列
)

文字列の行末 (LF 0x0a) を復帰改行コード (CRLF 0x0d 0x0a) に変更する。
文字列内の CRLF は変更しない。

記述例　 lf2eol(lf('abc','def')) →

abc
def

１６進表記では 6162630D0A6465660D0A

EOL2LF

str EOL2LF(
str 文字列
)

文字列の復帰改行コード (CRLF 0x0d 0x0a) を行末改行コード (LF 0x0a) に変更する。

記述例　 eol2lf(eol('abc','def')) →

abc
def

１６進表記では 6162630A6465660A

REVJ

str REVJ(
str 文字列
)

文字列を反転する。日本語文字列として扱う。

記述例　 revj('日本語MyCard') → draCyM語本日

TR

str TR(
str 文字列
, str 検索文字列
, str 置換文字列
)

文字単位の置換処理。
入力文字列のすべての文字について、検索文字列の中にその文字があれば、置換文字列の同じ位置の文字と置き換える。
検索文字列内の文字と置換文字列内の文字が位置において１対１対応する。置換文字列内に対応する文字がない場合は、対象の文字は削除される。

記述例１　 tr('MyCard','MC','ＭＣ') → ＭyＣard

記述例２　 tr('MyCard','MCar','ＭＣ') → ＭyＣd

TRC

str TRC(
str 文字列
, str 検索文字列
, str 置換文字列
[ , bool 圧縮フラグ ]
)

文字単位の置換処理。
入力文字列のすべての文字について、検索文字列の中にその文字が無ければ、置換文字列と置き換える。
圧縮フラグを真にすると、検索文字列の中にない文字の連続がまとめて、置換文字列と置き換えられる。

記述例１　 trc('MyCard','MC','*') → M*C***

記述例２　 trc('MyCard','MC','*',true) → M*C*

TRS

str TRS(
str 文字列
, str 検索文字列
[ , str 置換文字列 ]
)

文字単位の圧縮処理。
入力文字列のすべての文字について、検索文字列の中にその文字があるとき、同じ文字の連続は一文字にまとめられる。
置換文字列を書くと、検索文字列の中にある文字の連続がまとめて、置換文字列と置き換えられる。

記述例１　 trs('==++ABC++==','=+') → =+ABC+=

記述例２　 trs('==++ABC++==','=+','*') → *ABC*

CHRMASK

str CHRMASK(
str 文字列
, str 検索文字列
)

文字単位のフィルター処理。
入力文字列の文字のうち、検索文字列の中にその文字がある文字だけからなる文字列を返す。

記述例　 chrmask('Blue Grass Boys','ABCs') → BssBs

CHRMASKPAIR

str CHRMASKPAIR(
str 文字列
, str 検索文字列
[ , bool 削除フラグ ]
)

文字単位のフィルター処理。
入力文字列の文字のうち、検索文字列でその文字が示される文字だけからなる文字列を返す。
検索文字列は文字二つずつを組にして文字列範囲を示す。例えば、"09" ならば　0 - 9 （半角数字）を表す。 "09az" ならば　0-9（半角数字）または、a-z（半角英小文字）を表す。
削除フラグで真を示すと、検索文字列で示されない文字だけからなる文字列を返す。

記述例　 chrmaskpair('Blue Grass Boys','AG') → BGB

QUOTE

str QUOTE(
str 文字列
[ , str 引用符指定 ]
)

文字列の前後に複引用符（"）を付ける。
文字列内部に複引用符があれば、二つの複引用符に置きかえる。
引用符を指定できる。先頭の一文字が開き引用符、二文字目が閉じ引用符として用いられる。一文字だけならば、開き引用符と閉じ引用符は同じ文字である。

記述例１　 quote('algosampodo') → "algosampodo"

記述例２　 quote('your "shampoo" bottle') → "your ""shampoo"" bottle"

記述例３　 quote('algosampodo','|') → |algosampodo|

記述例４　 quote('algo|sampodo','|') → |algo||sampodo|

記述例５　 quote('algosampodo','()') → (algosampodo)

記述例６　 quote('al(go)sampodo','()') → (al(go))sampodo)

SQUOTE

str SQUOTE(
str 文字列
)

文字列の前後に単引用符（'）を付ける。
文字列内部に単引用符があれば、二つの単引用符に置きかえる。

記述例１　 squote("your books") → 'your books'

記述例２　 squote("Earl's breakdown") → 'Earl''s breakdown'

AQUOTE

str AQUOTE(
str 文字列
[ , str マーク文字列 ]
)

必要な場合に文字列の前後に複引用符（"）を付ける。
文字列の中に「"」「'」や、半角スペース、あるいは制御コードがあった場合に複引用符（"）で囲む。また、マーク文字列を指定した場合には、そこに含まれる文字があった場合も、複引用符で囲む。
文字列中の複引用符は二つの複引用符に置き換える。

記述例１　 aquote("books") → books

記述例２　 aquote('He said "hi". and ..') → "He said ""hi"". and .."

DEQUOTE

str DEQUOTE(
str 文字列
)

引用符を外す。
引用符の形式に適合していれば、引用符を外す。適合していなければ、何もしない。
引用符の形式は、最初と最後が同じ引用符で、文字列中に引用符がある場合は、引用符を二つ書く形式。
文字列の先頭一文字を引用符とみなして処理する。引用符として扱うのは「"」「'」に限らないことに注意すること。

記述例１　 dequote('"your books"') → your books

記述例２　 dequote("'don''s banjo'") → don's banjo

ISQUOTE

bool ISQUOTE(
str 文字列
[ , 記号指定 ]
)

引用符の形式として正しければ真を返す。
引用符の形式は、最初と最後が同じ引用符で、文字列中に引用符がある場合は、引用符を二つ書く形式。
記号指定で、引用符を指定できる。省略すると引用符は「"」。

記号指定	引用符
省略	「`"`」
TRUE	「`"`」
FALSE	「`'`」
0	検査対象文字列の最初の一文字
1	「`"`」
2	「`'`」
""	検査対象文字列の最初の一文字
文字列	記号指定文字列の最初の一文字

記述例１　 isquote('"your books"') → TRUE

記述例２　 isquote("'don''s banjo'","") → TRUE

SR

str SR(
str 文字列
)

文字列の前後に単引用符（'）を付ける。
文字列内部はＣ言語風の正規表現となる。

記述例　 sr(lf("Earl's Breakdown","Doggy Mountain Rag")) → 'Earl\'s Breakdown\nDoggy Mountain Rag\n'

DR

str DR(
str 文字列
)

文字列の前後に複引用符（"）を付ける。
文字列内部はＣ言語風の正規表現となる。

記述例　 dr(tab('Hello,"windy" city','Log Cabin Home')) → "Hello,\"windy\" city\tLog Cabin Home"

OP

str OP
一文字の「-」

str OP( str 文字列１ [ , str 文字列２ ] )
「-」、文字列１、文字列２の順に連結した文字列。
文字列２は省略できる。
コマンドラインで !^ 指定でオプションを記述する場合に便利な関数。

記述例１　 op('L') → -L

記述例２　 op('S',12*1024) → -S12288

DUC

str DUC(
str 文字指定
, str 文字列
)

文字列中にある、文字指定の先頭の文字を二重化した文字列を返す。

記述例１　 duc('/','abc/def') → abc//def

DUCS

str DUCS(
str 文字指定
, str 文字列１
[, str 文字列２
[, str 文字列３ ] ]
)

文字指定の先頭の文字を区切り文字として連結した文字列。
文字列１と文字列２の中にある区切り文字は二重化する。
この関数は偶然、extra.exeのsコマンドのオペランドに相当する。

記述例１　 ducs('/','abc','def') → /abc/def/

記述例２　 ducs('/','abc/def') → /abc//def/

記述例３　 ducs('/','abc/def','h/i') → /abc//def/h//i/

記述例４　 ducs('/','abc/def','h/i','x') → /abc//def/h//i/x

DUCSS

str DUCSS(
str 文字指定
, str 文字列１
[, str 文字列２
[, str 文字列３ ] ]
)

文字指定の先頭の文字を区切り文字として連結した文字列。
文字列１と文字列２を連結する際に、間に現れるのは、区切り文字、半角スペース、区切り文字である。文字列１と文字列２の中にある区切り文字は二重化する。
このコマンドは偶然、extra.exeのSコマンドのオペランドに相当する。

記述例１　 ducss('/','abc','def') → /abc/ /def/

記述例２　 ducss('/','abc/def') → /abc//def/

記述例３　 ducss('/','abc/def','h/i') → /abc//def/ /h//i/

記述例４　 ducss('/','abc/def','h/i','x') → /abc//def/ /h//i/x

BRACKET

str BRACKET(
[ str 括弧指定 , ]
str 引数
[ , str 引数 ]*
)

引数を括弧指定で囲む。
括弧指定の一文字目が開き括弧、二文字目が閉じ括弧、三文字目がセパレータを表す。
括弧指定が一文字の場合はその文字によって閉じ括弧文字の指定が異なる。セパレータは使用しない。括弧指定が一文字の場合の開きと閉じの対応は次の通り。下にない場合は同じ文字で囲む。

「()」、「[]」、「{}」、「<>」、「｢｣」、「（）」、「｛｝」、「［］」、「〔〕」、「【】」、「〈〉」、「《》」、「「」」、「『』」、「＜＞」、「≪≫」、「〝〟」、「“”」、「‘’」

括弧指定を省略するか、長さ０の文字列だった場合は、「()」で囲む。

記述例１　 bracket('fast liner') → (fast liner)

記述例２　 bracket('[','fast liner') → [fast liner]

記述例３　 bracket('「','fast','liner') → 「fastliner」

記述例４　 bracket('+-','fast','liner') → +fastliner-

記述例５　 bracket('[]|','fast','liner') → [fast|liner]

REG

str REG(
str 文字列
[ , int モード ]
)

正規表現に変換。モードに従って「正規表現」の内容を切り替える。
デフォルトのモードは 0 （半角スペースを\sに変換しない）。

0	正規表現（半角スペースを\sに変換しない）
1	クラシックな正規検索での正規表現（lxtra.exe、cxtra.exe）
2	モダンな正規検索での正規表現（lextra.exe、cextra.exe）
3	Ｃ言語風の文字列表記（１）
4	Ｃ言語風の文字列表記（２）
5	正規表現（半角スペースを\sに変換する）

Ｃ言語風の文字列表記で扱うエスケープメントは次の通り。
0x07 → \a / 0x08 → \b / 0x0c →\f / 0x0d → \r / 0x0a → \n /
0x09 → \t / 0x0b → \v / ' → \' / " → \" / \ → \\ / ? → \?
それ以外の制御コードは \x0nn（モード３）または、\xnn（モード４）

記述例　 reg('abc'+tab+'def'+eol) → abc\tdef\r\n

UNREG

str UNREG( str 文字列 )
正規表現から戻す。

記述例　 unreg('ABC\tDEF') → ABC DEF
１６進表記では 41424309444546

/ str 文字列
文字列の前に「/」をつける略記法である。

記述例　 /'ABC\tDEF' → ABC DEF
１６進表記では 41424309444546

ASTR

str ASTR( str 文字列 [ , int モード ] )
文字列中の漢字をエスケープする。
文字列中の漢字コードを\xnnまたは、\x0nnに置き換える。モードは省略すると 0。

mode	表記
0	\xnn。小文字で表記。\x1aなど
1	\x0nn。小文字で表記。\x01aなど
2	\xnn。大文字で表記。\x1Aなど
3	\x0nn。大文字で表記。\x01Aなど

記述例　 astr('日本語mycard') → \x93\xfa\x96\x7b\x8c\xeamycard

URL

str URL(
str 文字列
)

URL表現に変換。

記述例　 url('漢字ABC') → %8A%BF%8E%9AABC

UNURL

str UNURL(
str 文字列
)

URL表現から戻す。

記述例　 unurl('%8A%BF%8E%9AABC') → 漢字ABC

AMP

str AMP
「&」一文字。

str AMP( str 文字列 [ , bool スペースフラグ [ , bool 改行フラグ ] ] )
文字列中の&、<、>を &、<、>に変換する。
スペースフラグを真にすると半角スペースを、 に変換する。改行フラグを真にすると、LFコードを に置き換える。このとき、CRコードは無視する。

記述例　 amp('a&b') → a&b

TAG

str TAG(
str 文字列
[ , str 文字列 ]*
)

文字列をAMP()と同様の変換をしてから、<と>で囲む。
複数の文字列を書くと、スペースを挟んで連結してから<と>で囲む。

記述例１　 tag('body') → <body>

記述例２　 tag('table',eql('class',dq('fil'))) → <table class="fil">

ETAG

str ETAG(
str 文字列
[ , str 文字列 ]*
)

文字列をAMP()と同様の変換をしてから、</と>で囲む。
複数の文字列を書くと、スペースを挟んで連結してから</と>で囲む。

記述例　 etag('table') → </table>

STAG

str STAG(
str 文字列
[ , str 文字列 ]*
)

文字列をAMP()と同様の変換をしてから、<と/>で囲む。
複数の文字列を書くと、スペースを挟んで連結してから<と/>で囲む。

記述例１　 stag('br') →  

記述例２　 stag('img',eql('src',dq('noon.jpg'))) → <img src="noon.jpg"/>

PTAG

str PTAG(
str 内容
, str タグ
[ , str オプション ]*
)

内容をタグで挟んだ文字列。
タグとオプションは AMP()と同様の処理をするが、内容はそのまま。

<タグ>内容</タグ>

の型となる。オプションを書くと、

<タグオプション１オプション２>内容</タグ>

のように左側のタグの中にスペースで挟んで連結される。

記述例１　 ptag('sample text','p') → sample text

記述例２　 ptag('brit ','span',str('class=',dr('myclass'))) → brit 

QTAG

str QTAG(
str 内容
, str タグ
[ , str オプション ]*
)

内容をタグで挟んだ文字列。
タグとオプション、内容は AMP()と同様の処理をする。

<タグ>内容</タグ>

の型となる。オプションを書くと、

<タグオプション１オプション２>内容</タグ>

のように左側のタグの中にスペースで挟んで連結される。

記述例１　 qtag('sample text','p') → sample text

記述例２　 qtag('brit ','span',str('class=',dr('myclass'))) → brit 

SLASH

str SLASH
「/」一文字。

str SLASH( str 文字列 )
文字列中の\を/に置きかえる

記述例　 slash('E:\TEST') → E:/TEST

BSLASH

str BSLASH
「\」一文字。

str BSLASH( str 文字列 )
文字列中の/を\に置きかえる

記述例　 bslash('E:/TEST') → E:\TEST

ADJSTR

str ADJSTR(
str 文字列
)

文字列のうち、表示可能文字、タブ (TAB 0x09)、行末 (LF 0x0a) 以外を取り除いた文字列。

記述例　 adjstr('12'+ascii(11)+'A'+lf) →

12A

１６進表記では 3132410A

VSTR

str VSTR(
str 文字列
)

文字列のうち、表示可能文字以外を取り除いた文字列。

記述例　 vstr('12'+ascii(11)+'A'+lf) → 12A
１６進表記では 313241

文字列操作（タブ項目）

FIELDS

str FIELDS(
str 引数
[ ,  str 引数 ]*
)

引数を文字列としてタブ (TAB 0x09) で連結した文字列を返す。
TAB 関数も同様の機能。

記述例　 fields('abc','def','hij') →
abc→def→hij

FIELDS_IX str FIELDS_IX( int 回数 , str 式 )
指定回数だけ式を評価し、タブ(TAB 0x09)で連結した文字列を返す。
式の中では特別な変数IXで0から始まる序数を引用できる。

FIELDS_RANGE str FIELDS_RANGE( int 開始値 int 終了値 , str 式 )
参照値を開始値から終了値まで変化させながら、タブ(TAB 0x09)で連結した文字列を返す。
式の中では特別な変数IXで参照値を見ることができる。

FIELD

str FIELD(
str 文字列
, int 指標
)

文字列をタブ区切り項目として、指標で指定した項目の文字列を返す。

記述例　 { a:=fields('abc','def','hij'); field(a,2); } → hij

FLD

str FLD(
str 文字列
, int 指標
)

FIELD と同じ。

記述例　 { a:=tab('1st','2nd','3rd'); fld(a,1); } → 2nd

FIELD_COUNT

int FIELD_COUNT(
str 文字列
)

タブ区切りの項目数を返す。

記述例　 { a:=fields('1st','2nd','3rd'); field_count(a); } → 3

FIELD_ADJ

str FIELD_ADJ(
str 文字列
[ , bool ラストフラグ ]
)

タブ区切り項目として適正になるように文字列を調整する。
文字列中の制御コードは、タブ(0x09)と改行(0x0a)以外は削除する。制御コード以外はそのまま複写する。
タブはそのまま出力に現れる。
改行は、文字列の最後にある改行以外はタブに変換する。文字列最後の改行は削除する。これは行集合文字列からタブ区切り文字列への変換の利便を図った仕様。
ラストフラグを真にすると、文字列最後の改行も機械的にタブに変換する。

記述例１　 field_adj('abc'+ascii(3)+'def'+tab+'ghi') →
abcdef→ghi

記述例２　 field_adj('abc'+tab+'def'+lf+'x'+tab+'y'+lf) →
abc→def→x→y

FIELD_FOR

int FIELD_FOR(
str 文字列
, 式
)

文字列をタブ区切り項目として、項目ごとに式を評価する。
項目の数を返す。
処理中の項目番号（0 ～）は特別な変数 IX で参照できる。式の中では特別な変数 SS でフィールドの値を参照できる。
評価式が BREAK になると処理を中断する。

記述例　 { a:=fields('10','20','30'); s:=0; field_for(a,s+=int(ss)); s;} → 60

FIELD_REP

str FIELD_REP(
str 文字列
, str 置換式
)

文字列をタブ区切り項目として、各フィールドを置換式で置き換える。
置換式の中では特別な変数 SS でフィールドの値を参照できる。処理中の項目番号（0 ～）は特別な変数 IX で参照できる。

記述例　 { a:=fields('10','20','30'); field_rep(a,kakko(ss)); } →
(10)→(20)→(30)

FIELD_SEL

str FIELD_SEL(
str 文字列
, bool 判別式
)

文字列をタブ区切り項目として、判別式が真のフィールドを連結する。
判別式の中では特別な変数 SS でフィールドの値を参照できる。処理中の項目番号（0 ～）は特別な変数 IX で参照できる。

記述例１　 { a:=fields(10,20,30,40); field_sel(a,int(ss)<30); } →
10→20

記述例２　 { a:=fields(10,20,30,40); field_sel(a,ix>1); } →
30→40

FIELD_SCAN

int FIELD_SCAN(
str 文字列
, bool 評価式
)

文字列をタブ区切り項目として、項目ごとに評価式を評価する。
評価式が真になると繰返しを中断し、そのときの IX の値を返す。すべてが偽の場合には、戻り値は -1 。
処理中の項目番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS でフィールドの値を参照できる。

記述例　 { a:=fields('yamada','tanaka','murata','ohyama'); field_scan(a,ss='tanaka'); } → 1

FIELD_PRIME

FIELD_PRIME(
str 文字列
, bool 評価式
)

文字列をタブ区切り項目として、項目ごとに評価式を評価する。
評価式が真になると繰返しを中断し、そのときの項目の値を返す。すべてが偽の場合には、戻り値は FALSE 。
処理中の項目番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS でフィールドの値を参照できる。

記述例　 { a:=fields('yamada','tanaka','Murata','ohyama'); field_prime(a,isupper(ss)); } → Murata

FIELD_SOME

bool FIELD_SOME(
str 文字列
, bool 評価式
)

文字列をタブ区切り項目として、項目ごとに評価式を評価する。
評価式が真になると繰返しを中断し、真を返す。すべてが偽の場合には、偽を返す。
処理中の項目番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS でフィールドの値を参照できる。

記述例１　 { a:=fields(10,20,31,40); field_some(a,isodd(int(ss))); } → TRUE

記述例２　 { a:=fields(10,20,30,40); field_some(a,isodd(int(ss))); } → FALSE

FIELD_EVERY

bool FIELD_EVERY(
str 文字列
, bool 評価式
)

文字列をタブ区切り項目として、項目ごとに評価式で評価する。
評価式が偽になると繰返しを中断し、偽を返す。すべてが真の場合には、真を返す。
処理中の項目番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS でフィールドの値を参照できる。

記述例１　 { a:=fields(10,20,31,40); field_every(a,iseven(int(ss))); } → FALSE

記述例２　 { a:=fields(10,20,30,40); field_every(a,iseven(int(ss))); } → TRUE

FIELD_ROT

str FIELD_ROT(
str 対象文字列
[ , int カウント ]
)

対象文字列をタブ区切り項目として、項目の順序をカウント分だけ回転した文字列を返す。
カウントが正のとき、項目の番号が小さい方へ回転する（左回転）。カウントがふのとき、項目の番号が大きい方へ回転する（右回転）。
カウントを省略すると左へ１つだけ回転する。

記述例１　 { a:=fields(10,20,30,40,50); field_rot(a); } →
20→30→40→50→10

記述例２　 { a:=fields(10,20,30,40,50); field_rot(a,2); } →
30→40→50→10→20

記述例３　 { a:=fields(10,20,30,40,50); field_rot(a,-2); } →
40→50→10→20→30

FIELD_LAST

str FIELD_LAST(
str 文字列
)

対象文字列をタブ区切り項目とした、最後の項目。

記述例　 { a:=fields(10,20,30,40,50); field_last(a); } → 50

FIELD_CHOP

str FIELD_CHOP(
str 文字列
)

対象文字列をタブ区切り項目として、最後の項目を取り除いた文字列。

記述例　 { a:=fields(10,20,30,40,50); field_chop(a); } →
10→20→30→40

FIELD_REM

str FIELD_REM(
str 文字列
)

対象文字列をタブ区切り項目として、最初の項目を取り除いた文字列。

記述例　 { a:=fields(10,20,30,40,50); field_rem(a); } →
20→30→40→50

FIELD2STR

bool FIELD2STR(
str 文字列
[ ,
{ str 区切り文字列
| bool 改行フラグ }
]
)

タブ区切りの文字列を連結した文字列を返す。
区切り文字列を指定すると、区切り文字列を挟んで連結する。改行フラグが真の場合は、各要素の末尾に行末 (LF 0x0a) を付加してから連結する。改行フラグも区切り文字列も指定しないか、改行フラグが偽であれば、文字列は何も挟まず連結する。

記述例１　 { a:=fields('Tokyo','Ohsaka','Nagoya'); field2str(a,comma); } → Tokyo,Ohsaka,Nagoya

記述例２　 { a:=fields('Tokyo','Ohsaka','Nagoya'); field2str(a); } → TokyoOhsakaNagoya

記述例３　 { a:=fields('Tokyo','Ohsaka','Nagoya'); field2str(a,true); } →

Tokyo↓
Ohsaka↓
Nagoya↓

FIELD2STRIX

bool FIELD2STRIX(
str 文字列
,
{ str 区切り文字列
| bool 改行フラグ }
, str 評価式
)

タブ区切りの文字列を評価して連結した文字列を返す。
区切り文字列を指定すると、区切り文字列を挟んで連結する。改行フラグが真の場合は、各要素の末尾に行末 (LF 0x0a) を付加してから連結する。
各項目に対して評価式は繰返し評価される。評価式の中では、0 から始まる序数を IXで、項目を SS で参照できる。

記述例１　 { a:=fields('Tokyo','Ohsaka','Nagoya'); field2strix(a,comma,top(ss,2)+dot); } → To.,Oh.,Na.

記述例２　 { a:=fields('Tokyo','Ohsaka','Nagoya'); field2strix(a,sp,str(ix+1,colon,ss)); } → 1:Tokyo 2:Ohsaka 3:Nagoya

記述例３　 { a:=fields('Tokyo','Ohsaka','Nagoya'); field2strix(a,true,dot(ss,ix)); } →

Tokyo.0↓
Ohsaka.1↓
Nagoya.2↓

FIELD_ARG

str FIELD_ARG(
str 文字列
[ , str 式 ]*
)

式を順次評価してタブで繋いだ文字列。
式の中では、変数 IXで０から始まる序数、変数 SS では、文字列をタブ区切りとしたときの序数番目の項目を参照できる。
タブ区切り文字列では、各項目の処理が異なっていることが多いので、これを簡潔に書くために用意した関数。

記述例　 { a:=fields('Tokyo',45); field_arg(a,ss,int(ss)*0.795); } →
Tokyo→35.774999999999999

文字列操作（行集合）

LFY str LFY( str 引数 )
引数の文字列からTAB(0x09)、LF(0x0a)以外の制御コードと不正コードを取り除いた文字列。
文字列の長さが0以上で、最後の有効な文字がLF(0x0a)でなければ、最後にLF(0x0a)を追加する。
行集合文字列として正しい形に整える。

LINES

str LINES(
[
str 引数
[ , str 引数 ]* ]
)

引数の行末にLFを付けて連結した文字列を返す。
引数が無ければ長さ 0 の文字列（""）を返す。
LF 関数も同じように使用できる。

記述例　 lines('Tokyo','Ohsaka','Nagoya') →

Tokyo↓
Ohsaka↓
Nagoya↓

LINES_IX str LINES_IX( int 回数 , str 式 )
指定回数だけ式を評価し、行末を付加して連結したものを返す。
式の中では特別な変数IXで0から始まる序数を引用できる。

LINES_RANGE str LINES_RANGE( int 開始値 , int 終了値 , str 式 )
参照値を開始値から終了値まで変化させながら、行末を付加して連結したものを返す。
式の中では特別な変数IXで参照値を見ることができる。

LR str LR( int 開始値 int 終了値 [ , int 増分 ] )
開始値から終了値までの連続した整数値を文字列として、行末を付加して連結したもの。
増分を指定すると、開始値から増分だけ変化させながら、終了値を超えない値までを内容とする。増分は正の整数で指定すること。

LINE

str LINE(
str 文字列
, int 指標
)

文字列を行の連続として、指標で指定した行の文字列を返す。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya'); line(a,1);} → Ohsaka

LN

str LN(
str 文字列
, int 指標
)

LINE と同じ。

記述例　 { a:=lf('Tokyo','Ohsaka','Nagoya'); ln(a,1);} → Ohsaka

FILE

str FILE(
str ファイル名
[ , int mode ]
)

テキストファイルを一つの文字列として読み込む。
ファイル名が "" の場合には、標準入力から読む。
内部での行末コードは\n。ファイル末の不完全行には行末を付加する。
モードはデフォルトでは 0。

mode	説明
0	標準モード。不正なコードや、\n、\t以外の制御コードは読まない。
1	0以外のデータをそのまま読み込む
2	バイト単位で16進数に変換して読み込む
3	バイト単位で16進数に変換して読み込む。バイトのセパレータとしてカンマ「`,`」を使用する

記述例　 a:=file('test.txt')

FILELINE

str FILELINE[(
str ファイル名
)]

テキストファイルの先頭の一行を読む。
ファイル名が "" 、または、ファイル名を省略した場合には、標準入力から読む。
ファイルが空ならば、空行として扱い、""を返す。

記述例　 a:=fileline('test.txt')

FILEOUT

int FILEOUT(
str ファイル名
, str 値
[ , bool フラグ ]
)

文字列をファイルに出力する。出力は一つのファイルになる。
ファイル名が "" の場合には標準出力へ出力する。ファイル名が"#"の場合には標準エラー出力に出力する。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）
文字列内の制御コードは TAB (0x09) および LF (0x0a) のみ有効。LFは CRLFに変換して出力する。最後の行にLFがない場合はLFを付加する。
戻り値は行数。
フラグを真にすると文字列をそのまま出力し、出力バイト数を返す。

記述例１　ファイルへ書き出す
{ a:=lines('Tokyo','Ohsaka','Nagoya'); fileout('test.txt',a);}

記述例２　ファイルへ追加する
{ a:=lines('Tokyo','Ohsaka','Nagoya'); fileout('+test.txt',a);}

LINE_COUNT

int LINE_COUNT(
str 文字列
)

行数を返す。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya'); line_count(a);} → 3

LINE_FOR

int LINE_FOR(
str 文字列
, 評価式
)

文字列を行の連続として、各行に対して、式を評価する。行数を返す。
式の中では特別な変数 SS で行の値を参照できる。処理中の行番号（0 ～）は特別な変数 IX で参照できる。評価式が BREAK になると処理を中断する。

記述例　 { a:=lines(10,20,30,40,50); s:=0; line_for(a,s+=int(ss)); s;} → 150

LINE_REP

str LINE_REP(
str 文字列
, 置換式
)

文字列を行の連続として、各行を置換式で置き換える。
置換式の中では特別な変数 SS で行の値を参照できる。処理中の行番号（0 ～）は特別な変数 IX で参照できる。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya'); line_rep(a,if(hashead(ss,'O'),large(ss),ss));} →

Tokyo↓
OHSAKA↓
Nagoya↓

LINE_SEL

str LINE_SEL(
str 文字列
, bool 判別式
)

文字列を行の連続として、判別式が真の行を連結する。
判別式の中では特別な変数 SS で行の値を参照できる。処理中の行番号（0 ～）は特別な変数 IX で参照できる。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido'); line_sel(a,jtop(ss,1) le 'N');} →

Nagoya↓
Hokkaido↓

LINE_SCAN

int LINE_SCAN(
str 文字列
, bool 評価式
)

文字列を行の連続として、行ごとに評価式で評価する。
評価式が真を返すと繰返しを中断し、そのときの IX の値を返す。すべてのが偽の場合は、-1 を返す。処理中の行番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS で行の値を参照できる。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido'); line_scan(a,jtop(ss,1) le 'N');} → 2

LINE_PRIME

 LINE_PRIME(
str 文字列
, bool 評価式
)

文字列を行の連続として、行ごとに評価式で評価する。
評価式が真を返すと繰返しを中断し、そのときの行の内容を返す。すべてのが偽の場合は、FALSE を返す。処理中の行番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS で行の値を参照できる。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido'); line_prime(a,jtop(ss,1) le 'N');} → Nagoya

LINE_SOME

bool LINE_SOME(
str 文字列
, bool 評価式
)

文字列を行の連続として、行ごとに評価式で評価する。
評価式が真の場合は処理を中断し、真を返す。すべてが偽の場合のみ、偽を返す。処理中の行番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS でフィールドの値を参照できる。

記述例１　 { a:=lines('Tokyo','Ohsaka','10Nagoya','Hokkaido'); line_some(a,isnum(ss)); } → TRUE

記述例２　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido'); line_some(a,isnum(ss)); } → FALSE

LINE_EVERY

bool LINE_EVERY(
str 文字列
, bool 評価式
)

文字列を行の連続として、行ごとに評価式で評価する。
評価式が偽の場合は処理を中断し、偽を返す。すべてが真の場合のみ、真を返す。処理中の行番号（0 ～）は特別な変数 IX で参照できる。評価式の中では特別な変数 SS でフィールドの値を参照できる。

記述例１　 { a:=lines('Tokyo','Ohsaka','10Nagoya','Hokkaido'); line_every(a,isalpha(ss)); } → FALSE

記述例２　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido'); line_every(a,isalpha(ss)); } → TRUE

LINE_ROT

str LINE_ROT(
str 対象文字列
[ , int カウント ]
)

文字列を行の連続として、各行の順序をカウント分だけ回転した文字列を返す。
カウントが正のとき、行番号が小さい方へ回転する。カウントが負のとき、行番号が大きい方へ回転する。
カウントを省略すると行番号が小さい方へ１つだけ回転する。

記述例１　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line_rot(a); } →

Ohsaka↓
Nagoya↓
Hokkaido↓
Kanagawa↓
Tokyo↓

記述例２　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line_rot(a,2); } →

Nagoya↓
Hokkaido↓
Kanagawa↓
Tokyo↓
Ohsaka↓

記述例３　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line_rot(a,-2); } →

Hokkaido↓
Kanagawa↓
Tokyo↓
Ohsaka↓
Nagoya↓

LINE_LAST

str LINE_LAST(
str 文字列
)

文字列を行の連続とした、最後の行。
行末コードを含まない

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line_last(a); } → Kanagawa

LINE_CHOP

str LINE_CHOP(
str 文字列
)

文字列を行の連続として、最後の行を取り除いた文字列。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line_chop(a); } →

Tokyo
Ohsaka
Nagoya
Hokkaido

LINE_REM

str LINE_REM(
str 文字列
)

文字列を行の連続として、先頭の行を取り除いた文字列。

記述例　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line_rem(a); } →

Ohsaka
Nagoya
Hokkaido
Kanagawa

LINE2STR

bool LINE2STR(
str 文字列
[ , str 区切り文字列 ]
)

行連続の文字列を連結した文字列を返す。
区切り文字列を指定すると、各行を区切り文字列を挟んで連結する。区切り文字列を省略すると各行を何も挟まずに連結する。

記述例１　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line2str(a); } →

TokyoOhsakaNagoyaHokkaidoKanagawa

記述例２　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line2str(a,comma); } →

Tokyo,Ohsaka,Nagoya,Hokkaido,Kanagawa

LINE2STRIX

bool LINE2STRIX(
str 文字列
, str 区切り文字列
, str 評価式
)

行連続の文字列の各行を評価して連結した文字列を返す。
区切り文字列を指定すると、各行を区切り文字列を挟んで連結する。区切り文字列を省略すると各行を何も挟まずに連結する。
評価式は各行に対して評価する。評価式の中では、0 から始まる序数を IXで、行そのものを SS で参照できる。

記述例１　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line2strix(a,comma,top(ss,2)); } → To,Oh,Na,Ho,Ka

記述例２　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); line2strix(a,comma,str(ix,colon,ss)); } → 0:Tokyo,1:Ohsaka,2:Nagoya,3:Hokkaido,4:Kanagawa

POS2LINENUM

int POS2LINENUM(
str 文字列
, int 位置
)

文字位置から文字列中の行番号を得る。
位置、行番号は 0 から始まる。

記述例　 pos2linenum('abc'+lf+'def'+lf,5) → 1

LINENUM2POS

int LINENUM2POS(
str 文字列
, int 行番号
)

行番号から文字列中の位置を得る。
位置、行番号は 0 から始まる。

記述例　 linenum2pos('abc'+lf+'def'+lf,1) → 4

LINESORT

str LINESORT(
str 文字列
[ , int 方法
[ , bool 序数フラグ ]
]
)

文字列を行単位で並べなおした結果を返す。
方法は 0-5 の数値で指定する。省略すると 0 。
序数フラグを真にすると、元の行の並びの番号（0～)を行で連結した文字列を返す。

方法	内容
0	昇順
1	降順
2	英大小文字の区別をせずに、昇順
3	英大小文字の区別をせずに、降順
4	バイトの昇順
5	バイトの降順

記述例１　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); linesort(a); } →

Hokkaido↓
Kanagawa↓
Nagoya↓
Ohsaka↓
Tokyo↓

記述例２　 { a:=lines('Tokyo','Ohsaka','Nagoya','Hokkaido','Kanagawa'); linesort(a,0,true); } →

3↓
4↓
2↓
1↓
0↓

EXPANDSTR

str EXPANDSTR(
str文字列
[
, str モード
[ , str 区切り文字列 ]
]
)

文字列をコマンドラインのようにパラメータ展開した文字列を返す。
展開した要素はデフォルトでは行として連結する。モードの中で区切りを指定するか、あるいは区切り文字列を書けば、区切り文字列を挟んでつなげる。
モードを省略すると間接展開をしない。
引用符付加が指定されている場合、状況に応じて各項目を複引用符で囲む。引用符で囲むのは、区切りが指定されていて、項目の中に「"」「'」、半角スペース、あるいは制御コード、区切り文字列の先頭の一文字を含む場合である。
間接展開する場合は以下の文字の組み合わせで指定する。

方法	内容
!	!展開
#	#展開
@	@展開
^	^展開
t	tab区切り
T	tab区切り
s	半角スペース区切り
S	半角スペース区切り
c	コンマ(,)区切り
C	コンマ(,)区切り
q	引用符付加
Q	引用符付加

記述例１　 expandstr(" ABC 'DEF GHI' JKLM ") →

ABC↓
DEF GHI↓
JKLM↓

記述例２　 expandstr(" ABC 'DEF GHI' JKLM ","t") →
ABC→DEF GHI→JKLM

記述例３　 expandstr(" ABC 'DEF GHI' JKLM ","s") → ABC DEF GHI JKLM

記述例４　 expandstr(" ABC 'DEF GHI' JKLM ","c") → ABC,DEF GHI,JKLM

記述例５　 expandstr(" ABC 'DEF GHI' JKLM ","","/") → ABC/DEF GHI/JKLM

文字列操作（区切り指定）

SEPLINE

str SEPLINE(
str 入力セパレータ
, str 対象文字列
[ , str 出力セパレータ ]
)

対象文字列を入力セパレータで分割して、行末 (LF 0xa) を付加して連結する。
出力セパレータを指定すると各要素は行末を付加せず、出力セパレータを挟んで連結する。
入力セパレータが長さ０の文字列（""）の場合は、対象文字列は文字ごとに分割される。

記述例１　 sepline(':','東京:大阪:名古屋') →

東京
大阪
名古屋

記述例２　 sepline(':','東京:大阪:名古屋',tab) →
東京→大阪→名古屋

記述例３　 sepline('','東京:大阪:名古屋','-') → 東-京-:-大-阪-:-名-古-屋

SEP_COUNT

int SEP_COUNT(
str セパレータ
, str 対象文字列
)

対象文字列をセパレータで分割した要素の数。
セパレータが長さ０の場合は、セパレータは一文字のタブ (TAB 0x09) と解釈する。

記述例　 sep_count(':','東京:大阪:名古屋') → 3

SEP_IX

str SEP_IX(
str セパレータ
, str 対象文字列
, int 要素番号
)

対象文字列をセパレータで分割した要素のうち、要素番号で指定された要素。
番号は 0 から始まる序数。
セパレータが長さ０の場合は、セパレータは一文字のタブ (TAB 0x09) と解釈する。
指定番号の要素が存在しない場合は、空の文字列を返却する。

記述例　 sep_ix(':','東京:大阪:名古屋',2) → 名古屋

SEP_FOR

int SEP_FOR(
str セパレータ
, str 対象文字列
, 評価式
)

対象文字列をセパレータで分割した要素すべてに対して評価式を評価する。
要素数を返却する。
評価式の中では、IX で０から始まる序数を、SS で要素を参照できる。セパレータが長さ０の場合は、セパレータは一文字のタブ (TAB 0x09) と解釈する。
評価式が BREAKになると処理を中断する。

記述例　 { s:=0; sep_for('::','10::20::30::40::50',s+=int(ss)); s;} → 150

SEP_REP

str SEP_REP(
str セパレータ
, str 対象文字列
, bool 置換式
)

対象文字列をセパレータで分割した要素すべてに対し、置換式を評価しその値で要素を置き換える。
置換式の中では、IX で０から始まる序数を、SS で要素を参照できる。セパレータが長さ０の場合は、セパレータは一文字のタブ (TAB 0x09) と解釈する。

記述例　 sep_rep(',','tokyo,osaka,nagoya,fukuoka,nigata',if(jtop(ss,1)=='n',large(ss),ss)) → tokyo,osaka,NAGOYA,fukuoka,NIGATA

SEP_SEL

str SEP_SEL(
str セパレータ
, str 対象文字列
, bool 判別式
)

対象文字列をセパレータで分割した要素すべてに対し、判別式を評価し真の要素のみを残す。
判別式の中では、IX で０から始まる序数を、SS で要素を参照できる。セパレータが長さ０の場合は、セパレータは一文字のタブ (TAB 0x09) と解釈する。

記述例　 sep_sel(',','tokyo,osaka,nagoya,fukuoka,nigata',ss!='fukuoka') → tokyo,osaka,nagoya,nigata

SEP_SCAN

int SEP_SCAN(
str セパレータ
, str 対象文字列
, bool 評価式
)

対象文字列をセパレータで分割した要素すべてに対して評価式が真になる最初の要素の番号を返す。
評価式が真になった時点で繰返しを終了し、そのときの IX の値を返却する。
すべての評価が偽ならば、-1 を返却する。評価式の中では、IX で０から始まる序数を、SS で要素を参照できる。セパレータが長さ０の場合は、セパレータは一文字の TAB と解釈する。

記述例　 sep_scan(',','tokyo,osaka,nagoya,fukuoka,nigata',jtop(ss,1)='n') → 2

SEP_PRIME

int SEP_PRIME(
str セパレータ
, str 対象文字列
, bool 評価式
)

対象文字列をセパレータで分割した要素すべてに対して評価式が真になる最初の要素を返す。
評価式が真になった時点で繰返しを終了し、そのときの要素の値を返却する。
すべての評価が偽ならば、FALSE を返却する。評価式の中では、IX で０から始まる序数を、SS で要素を参照できる。セパレータが長さ０の場合は、セパレータは一文字の TAB と解釈する。

記述例　 sep_prime(',','tokyo,osaka,nagoya,fukuoka,nigata',jtop(ss,1)='n') → nagoya

SEP_SOME

bool SEP_SOME(
str セパレータ
, str 対象文字列
, bool 評価式
)

対象文字列をセパレータで分割した要素について評価式を順に評価し、真になったとき、繰返しを中断して真を返す。
評価式がすべて偽になったとき、偽を返す
すべての評価が偽ならば、-1 を返却する。評価式の中では、IX で０から始まる序数を、SS で要素を参照できる。セパレータが長さ０の場合は、セパレータは一文字の TAB と解釈する。

記述例１　 sep_some(',','tokyo,osaka,nagoya,01fukuoka,nigata',isnum(ss)) → TRUE

記述例２　 sep_some(',','tokyo,osaka,nagoya,fukuoka,nigata',isnum(ss)) → FALSE

SEP_EVERY

bool SEP_EVERY(
str セパレータ
, str 対象文字列
, bool 評価式
)

対象文字列をセパレータで分割した要素について評価式を順に評価し、偽になったとき、繰返しを中断して偽を返す。
評価式がすべて真になったとき、真を返す
すべての評価が偽ならば、-1 を返却する。評価式の中では、IX で０から始まる序数を、SS で要素を参照できる。セパレータが長さ０の場合は、セパレータは一文字の TAB と解釈する。

記述例１　 sep_every(',','tokyo,osaka,nagoya,01fukuoka,nigata',isalpha(ss)) → FALSE

記述例２　 sep_every(',','tokyo,osaka,nagoya,fukuoka,nigata',isalpha(ss)) → TRUE

SEP_ROT

str SEP_ROT(
str セパレータ
, str 対象文字列
[ , int カウント ]
)

対象文字列をセパレータで分割した要素の順序をカウント分だけ回転した文字列を返す。
カウントが正のとき、要素の番号が小さい方へ回転する（左回転）。カウントが負の場合は要素の番号が大きい方へ回転する（右回転）。
カウントを省略すると左へ１つだけ回転する。セパレータが長さ０の場合は、セパレータは一文字の TAB と解釈する。

記述例１　 sep_rot(',','tokyo,osaka,nagoya,fukuoka,nigata') → osaka,nagoya,fukuoka,nigata,tokyo

記述例２　 sep_rot(',','tokyo,osaka,nagoya,fukuoka,nigata',2) → nagoya,fukuoka,nigata,tokyo,osaka

記述例３　 sep_rot(',','tokyo,osaka,nagoya,fukuoka,nigata',-2) → fukuoka,nigata,tokyo,osaka,nagoya

SEP_LAST

str SEP_LAST(
str セパレータ
, str 対象文字列
)

対象文字列をセパレータで分割した最後の要素。

記述例　 sep_last(',','tokyo,osaka,nagoya,fukuoka,nigata') → nigata

SEP_CHOP

str SEP_CHOP(
str セパレータ
, str 対象文字列
)

対象文字列をセパレータで分割した最後の要素を取り除いた要素並び。

記述例　 sep_chop(',','tokyo,osaka,nagoya,fukuoka,nigata') → tokyo,osaka,nagoya,fukuoka

SEP_REM

str SEP_REM(
str セパレータ
, str 対象文字列
)

対象文字列をセパレータで分割した最初の要素を取り除いた要素並び。

記述例　 sep_rem(',','tokyo,osaka,nagoya,fukuoka,nigata') → osaka,nagoya,fukuoka,nigata

SEP_ARG

str SEP_ARG(
str セパレータ
, str 文字列
[ , str 式 ]*
)

式を順次評価してセパレータで繋いだ文字列。
式の中では、変数 IXで０から始まる序数、変数 SS では、文字列をセパレータ区切りとした序数番目の項目を参照できる。
セパレータ区切り文字列では、各項目の処理が異なっていることが多いので、これを簡潔に書くために用意した関数。

記述例　 { a:=strconc(',','Tokyo',45,150); sep_arg(',',a,kakko(ss),int(ss)*2,sqrt(float(ss))); } → (Tokyo),90,12.24744871391589

SEP_SORT

str SEP_SORT(
str セパレータ
str 文字列
[ , int 方法
[ , bool 序数フラグ ]
]
)

対象文字列をセパレータで分割した要素について並べなおした結果を返す。
方法は 0-5 の数値で指定する。省略すると 0 。
序数フラグを真にすると、元の要素の並びの番号（0～)をセパレータで連結した文字列を返す。セパレータが長さ０の場合は、セパレータは一文字の TAB と解釈する。

方法	内容
0	昇順
1	降順
2	英大小文字の区別をせずに、昇順
3	英大小文字の区別をせずに、降順
4	バイトの昇順
5	バイトの降順

記述例１　 sep_sort(',','tokyo,osaka,nagoya,fukuoka,nigata') → fukuoka,nagoya,nigata,osaka,tokyo

記述例２　 sep_sort(',','tokyo,osaka,nagoya,fukuoka,nigata',0,true) → 3,2,4,1,0

文字列操作（バイト位置）

以降のバイト単位で文字を取り扱う関数では、位置や長さの指定の関係で、全角の中央を指定してしまった場合、予想と異なるものが戻る可能性があるので、注意すること。

CHR

str CHR(
int コード
)

コードで示される１文字。
バイト単位で直接変換している。コードは 0 - 255の範囲。
コードが 0 の場合は残念ながら、長さ 0 の文字列になってしまう。
不正な漢字シーケンスを作成する可能性があるので通常は使用しない。

記述例　 chr(65) → A

ORD

int ORD(
str 文字列
)

文字列の先頭の１バイトのコードを返す。
長さ 0 の文字列では、"" を返す。

記述例　 ord('A') → 65

WIDTH

int WIDTH(
str 文字列
)

文字列のバイト幅。

記述例　 width('日本語') → 6

LEFT

str LEFT(
str 文字列
, int バイト数
[ , str スペーサー ]
)

文字列の左からバイト数分だけを取り出す。
足りない分は右に半角スペースを付加。
スペーサーを指定するとその先頭の半角文字をスペースの変わりに使用する。

記述例１　 left('日本語ABC',7) → 日本語A

記述例２　 left('日本語ABC',12) → 日本語ABC
１６進表記では 93FA967B8CEA414243202020

記述例３　 left('日本語ABC',12,'*') → 日本語ABC***

RIGHT

str RIGHT(
str 文字列
, int バイト数
[ , str スペーサー ]
)

文字列の右からバイト数分だけを取り出す。
足りない分は左に半角スペースを付加。
スペーサーを指定するとその先頭の半角文字をスペースの変わりに使用する。

記述例１　 right('日本語ABC',7) → 本語ABC

記述例２　 right('日本語ABC',12) → 日本語ABC
１６進表記では 20202093FA967B8CEA414243

記述例３　 right('日本語ABC',12,'.') → ...日本語ABC

RIGHTZ

str RIGHTZ(
str 文字列
, int バイト数
[ , str スペーサー ]
)

文字列の右からバイト数分だけを取り出す。
足りない分は左に '0' を付加。
スペーサーを指定するとその先頭の半角文字を '0' の変わりに使用する。

記述例１　 rightz('1234567890',7) → 4567890

記述例２　 rightz('1234',7) → 0001234

記述例３　 rightz('日本語ABC',12,'_') → ___日本語ABC

TOP

str TOP(
str 文字列
, int バイト数
)

文字列の左からバイト数分だけを取り出す。
足りない分は短くなる。

記述例１　 top('日本語ABC',7) → 日本語A

記述例２　 top('日本語ABC',10) → 日本語ABC

BOTTOM

str BOTTOM(
str 文字列
, int バイト数
)

文字列の右からバイト数分だけを取り出す。足りない分は短くなる。

記述例１　 bottom('日本語ABC',7) → 本語ABC

記述例２　 bottom('日本語ABC',10) → 日本語ABC

MID

str MID(
str 文字列
, int バイト位置
[ , int バイト数 ]
)

文字列のバイト位置からバイト幅の文字列を取り出す
バイト数を省略すると、バイト位置以降の文字列を取り出す。
バイト位置は0から始まる。
取り出し範囲が文字の切れ目をまたがないように注意すべきである。
切り出した領域の先頭または末尾が漢字の中央を差す場合は、その漢字の後半、あるいは、前半を半角のスペースに置き換える。

記述例１　 mid('日本語ABC',2) → 本語ABC

記述例２　 mid('日本語ABC',3) → 語ABC
１６進表記では 208CEA414243

記述例３　 mid('日本語ABC',2,5) → 本語A

CENTER

str CENTER(
str 文字列
, int バイト幅
[ , str スペーサー ]
)

指定の幅の中央に文字列がくるように前後に半角スペースを追加する。
文字列が指定幅より長ければ文字列をそのまま返す。
スペーサーを指定するとスペースを埋める文字を指定できる。スペーサーが一文字の場合は是後のスペースの代わりにこの文字を使用する。二文字以上の場合は、一文字目を左側、二文字目を右側のスペースの変わりに使用する。スペーサーに使用する文字は半角文字（1バイト）文字で無ければならない。

記述例１　 kakko(center('日本語',10)) → ( 日本語 )

記述例２　 kakko(center('日本語',10,'-')) → (--日本語--)

記述例３　 kakko(center('日本語',10,'[]')) → ([[日本語]])

FOLD

str FOLD(
str 文字列
int バイト幅
[ , str 区切り ]
)

文字列をバイト幅で区切る。
区切った文字列の後ろには行末を付加する。また、文字列内の制御コードは無視する。
区切りを指定すると、区切った文字列を区切りを挟んで連結する。

記述例１　 fold('abcdefghijk',5) →

abcde↓
fghij↓
k↓

SUBSTBP

str SUBSTBP(
str 文字列
str 置換文字列
, int 文字位置
int バイト幅
)

文字列の指定位置から指定バイト幅の部分を置換文字列に置き換える。
文字位置は0から始まり、バイト単位で位置を指定する
位置などが全角文字の中央にあると、それなりに処理するが、結果はあまり好ましくない。注意すること。

記述例１　 substbp('野菜の処理法','利用',4,6) → 野菜利用法

記述例２　 substbp('野菜の処理法','',4,6) → 野菜法

記述例３　 substbp('野菜の処理法','利用',4,0) → 野菜利用の処理法

記述例４　 substbp('野菜の処理法','利用',0,0) → 利用野菜の処理法

記述例５　 substbp('野菜の処理法','利用',1000,0) → 野菜の処理法利用

記述例６　 substbp('野菜の処理法','利用',0,1000) → 利用

REV

str REV(
str 文字列
)

文字列をバイト単位で反転する。
全角文字を含むと正常に動作しない。通常はこの関数を使用せず、REVJ を使用すべきである。

記述例　 rev('abcdefg') → gfedcba

SRCHSTR

int SRCHSTR(
str 文字列
, str 検索文字列
)

文字列から検索文字列を探し出し、先頭からのバイト位置を返す。
見つからなかった場合は負の値が返る。

記述例１　 srchstr('日本語starsystem','sys') → 10

記述例２　 srchstr('日本語starsystem','Sys') → -1

SRCHSTRI

int SRCHSTRI(
str 文字列
, str 検索文字列
)

文字列から検索文字列を探し出し、先頭からのバイト位置を返す。検索の際に半角英字の大文字と小文字を区別しない
見つからなかった場合は負の値が返る。

記述例１　 srchstri('日本語starsystem','Sys') → 10

記述例２　 srchstri('日本語starsystem','div') → -1

SRCHSTRX int SRCHSTRX( str 文字列 , str 検索文字列 )
文字列から検索文字列を探し出し、先頭からのバイト位置を返す。検索の際に半角全角の大文字と小文字を区別しない
見つからなかった場合は負の値が返る。

整数操作

RAND

int RAND(
[ int 初期値 ]
)

乱数の値。
乱数の範囲は、0-32767である。

RAND()
単純に乱数を返す。
RAND(0)
現在のシステムTICKを元に乱数を初期化して乱数返す。
RAND(数値)
数値を初期値として乱数を初期化し、乱数を返す。

LIMIT

LIMIT(
{ int 値
{ fix 値
{ float 値
}
, 最小値
, 最大値
)

最小値と最大値の範囲にクリップした値。
最小値、最大値は値と同じ型。

記述例１　 limit(10,20,30) → 20

記述例２　 limit(25,20,30) → 25

記述例３　 limit(50,20,30) → 30

LIMIT_INT int LIMIT_INT( { int 値 { fix 値 { float 値 } , 最小値 , 最大値 )
関数 LIMIT と同じ。互換性を保つために存在する。

LIMIT_FLOAT float LIMIT_FLOAT( { int 値 { fix 値 { float 値 } , 最小値 , 最大値 )
関数 LIMIT と同じ。互換性を保つために存在する。

BETWEEN

bool BETWEEN(
{
int 値
| fix 値
| float 値
}
, 最小値
, 最大値
)

最小値≦値≦と最大値ならば真。
最小値、最大値は値と同じ型として扱う。

記述例１　 between(10,20,30) → FALSE

記述例２　 between(25,20,30) → TRUE

記述例３　 between(50,20,30) → FALSE

ISSOSU

bool ISSOSU(
int 値
)

素数であれば真。
内部ではDWORDとして扱っている。

記述例１　 issosu(17) → TRUE

記述例２　 issosu(16) → FALSE

SOINSU

str SOINSU(
int 値
)

素因数分解した結果を乗算式の形で文字列出力。
内部ではDWORDとして扱っている。

記述例　 soinsu(29925) → 3*3*5*5*7*19

GCD

int GCD(
int 値
, int 値
)

最大公約数。
内部ではDWORDとして扱っている。

記述例　 gcd(39925,475) → 25

LCM

int LCM(
int 値
, int 値
)

最小公倍数。
内部ではDWORDとして扱っている。
DWORDの範囲を超えると正しい結果が得られない。この場合は、LCMSTR()を使用するとよい。

記述例　 lcm(10,4) → 20

LCMSTR

str LCMSTR(
int 値
, int 値
)

最小公倍数の文字列表記を返す。

記述例　 lcmstr(123456787,17326508) → 2139075007609796

BIT

int BIT(
int ビット番号
[ , int ビット番号 ]*
)

指定の番号のビットを 1 にした整数値。
ビット番号は　0 ～ 31 。

記述例　 bit(0,4) → 17
２進表記では 10001

BIT2STR

str BIT2STR(
int 値
)

値の、 1 になっているビットの番号を「,」で区切って繋いだ文字列。

記述例　 bit2str(14) → 1,2,3

BIT_SHL

int BIT_SHL(
int 値
, int 回数
)

回数分、左シフトする。

記述例　 bit_shl(14,3) → 112
２進表記では 1110000

BIT_LSR

int BIT_LSR(
int 値
, int 回数
)

回数分、右シフトする。

記述例　 bit_lsr(-15,2) → 1073741820
２進表記では 111111111111111111111111111100

BIT_ASR

int BIT_ASR(
int 値
, int 回数
)

回数分、算術右シフトする。

記述例　 bit_asr(-15,2) → -4
２進表記では 11111111111111111111111111111100

BIT_ROL

int BIT_ROL(
int 値
, int 回数
)

回数分、左回転する。

記述例　 bit_rol(-15,2) → -57
２進表記では 11111111111111111111111111000111

BIT_ROR

int BIT_ROR(
int 値
, int 回数
)

回数分、右回転する。

記述例　 bit_ror(-15,2) → 2147483644
２進表記では 1111111111111111111111111111100

BIT_NOT

int BIT_NOT(
int 値
)

数値のビット反転。

記述例　 bit_not(-15) → 14

BIT_AND

int BIT_AND(
int 値
[ , int 値 ]+
)

数値のビット毎のAND。

記述例　 bit_and(0xfe,0x83) → 130

BIT_OR

int BIT_OR(
int 値
[ , int 値 ]+
)

数値のビット毎のOR。

記述例　 bit_or(0xee,0x83) → 239

BIT_XOR

int BIT_XOR(
int 値
[ ,int 値 ]+
)

数値のビット毎のXOR。

記述例　 bit_xor(0xee,0x83) → 109
２進表記では 1101101

BIT_COUNT

int BIT_COUNT(
int 値
)

整数値の 1 になっているビットの数。
整数のビット長は32ビットなので、この数を 32 から引くと 0 のビットの数となる。

記述例　 bit_count(24199892) → 11
２進表記では 1011

BIT_OPR

int BIT_OPR(
int  演算コード
, int 値
[ , int 値 ]+
)

演算コードによるビット単位の二項演算をする。
演算コードは演算結果を表すビットの重ね合わせである。すべてのビットオペレーションを書くことができる。

A	B	ビット位置	値
0	0	0	1
0	1	1	2
1	0	2	4
1	1	3	8

OR ならば、0 になるのは 0_0 のみ。そこで 0B1110 、つまり、14 。
AND ならば、1 になるのは 1_1 のみ。そこで 0B1000 、つまり、8 。

記述例１　 bit_opr(14,0x80,0x11) → 145

記述例２　 bit_opr(8,0xf3,0xcc) → 192

DWORD78

int DWORD78(
int 値
)

7bitx4桁形式のDWORDを通常の8bitx4形式のDWORDに変換する。
入力の各バイトのmsbは無視する。
MIDIデータと通常データの変換に便利。

記述例　 strhex(dword78(0x12345676)) → 24D2B76

DWORD87

int DWORD87(
int 値
)

通常の8bitx4桁形式のDWORDを7bitx4形式のDWORDに変換する。
入力の上位4ビットは無視する。
MIDIデータと通常データの変換に便利。

記述例　 strhex(dword87(0x12345676)) → 11512C76

SWAPWORD

int SWAPWORD(
int 値
)

値の上 16bit と下 16bit を入れ替える。

記述例　 strhex(swapword(0x12345678)) → 56781234

SWAPNIBBLE

int SWAPNIBBLE(
int 値
)

値を8bitにして、上 4bit と下 4bit を入れ替える。

記述例　 strhex(swapnibble(0x4A)) → A4

SWAPBYTE

int SWAPBYTE(
int 値
)

値を16bitにして、上 8bit と下 8bit を入れ替える。

記述例　 strhex(swapbyte(0x1234)) → 3412

BYTEORDER

int BYTEORDER(
int 値
)

値を 8bit 単位で順番を反転する。

記述例　 strhex(byteorder(0x12345678)) → 78563412

NIBBLEORDER

int NIBBLEORDER(
int 値
)

値を 4bit 単位で順番を反転する。

記述例　 '0x'+strhex(NIBBLEORDER(0x12345678)) → 0x87654321

BITORDER

int BITORDER( int 値 )
値を bit 単位で順番を反転する。

記述例　 bitorder(0x12345678) → 510274632
２進表記では 11110011010100010110001001000

TBYTEORDER

int TBYTEORDER( int 値 )
値の下位3バイト相当部分をバイト単位で順番を反転する。最上位バイトは0になる。

記述例　 '0x'+strhex(tbyteorder(0x12345678)) → 0x785634

IXBITS

int IXBITS(
int 値
, int 位置
, int 長さ
)

値の下位から指定番目の指定ビット数の整数値として返す。

記述例　 strhex(ixbits(0x12345678,4,4)) → 7

SGNWORD

int SGNWORD( int 値 )
値を符号付WORDとして解釈して整数値を返す。

記述例　 strhex(sgnword(0x12348678)) → FFFF8678

SGNBYTE

int SGNBYTE( int 値 )
値を符号付BYTEとして解釈して整数値を返す。

記述例　 strhex(sgnbyte(0x89)) → FFFFFF89

IXWORD

int IXWORD(
int 値
, int 位置
)

値の下位から指定番目のワードの値を返す。

記述例　 strhex(ixword(0x12345678,1)) → 1234

IXBYTE

int IXBYTE(
int 値
, int 位置
)

値の下位から指定番目のバイトの値を返す。

記述例　 strhex(ixbyte(0x12345678,1)) → 56

IXNIBBLE

int IXNIBBLE(
int 値
, int 位置
)

値の下位から指定番目の桁の値を返す。

記述例　 strhex(ixnibble(0x12345678,1)) → 7

IXBIT

int IXBIT(
int 値
, int 位置
)

値の下からして指定番目のビットの値を返す。

記述例　 strhex(ixbit(0x12345678,3)) → 1

HWORD

int HWORD( int 値 )
上位のワード。

記述例　 strhex(hword(0x12345678)) → 1234

LWORD

int LWORD( int 値 )
下位のワード。

記述例　 strhex(lword(0x12345678)) → 5678

MASKBITS

int MASKBITS(
int 位置
, int 長さ
[ , bool 反転フラグ
]
)

下位からの指定位置の指定ビット数のマスクパターンを返す。
反転フラグが真ならばビット反転したマスクパターンを返す。

記述例　 strhex(maskbits(4,4),4) → 00F0

SETBITS

int SETBITS(
int 値
, int 位置
, int 長さ
, int 更新値
)

値を下位からの指定位置の指定ビット数の更新値で上書きする。

記述例　 strhex(setbits(0x12345678,4,8,0xfe),8) → 12345FE8

SETBIT

int SETBIT(
int 値
, int 位置
, int 更新値
)

値を下位からの指定位置の１ビットの更新値で上書きする。

記述例　 strhex(setbit(0x12345678,8,1),8) → 12345778

BITVAL bool BITVAL( int 値 , int 位置 )
値の下位からの指定位置の１ビットの値を返す。

TESTBIT bool TESTBIT( int 値 , int 位置 )
値の下位からの指定位置の１ビットが1ならば真を返す。

FLIPBIT int FLIPBIT( int 値 , int 位置 )
値の下位からの指定位置の１ビットを反転した値。

ANDBIT int ANDBIT( int 値 , int 位置 , int 更新値 )
値の下位からの指定位置の１ビットに更新値（1ビット）で論理積（AND）をした結果。

ORBIT int ORBIT( int 値 , int 位置 , int 更新値 )
値の下位からの指定位置の１ビットに更新値（1ビット）で論理和（OR）をした結果。

SETNIBBLE

int SETNIBBLE(
int 値
, int 位置
, int 更新値
)

値を下位からの指定位置の4ビットの更新値で上書きする。

記述例　 strhex(setnibble(0x12345678,4,0x0f),8) → 123F5678

SETBYTE

int SETBYTE(
int 値
, int 位置
, int 更新値
)

値を下位からの指定位置のBYTEの更新値で上書きする。

記述例　 strhex(setbyte(0x12345678,1,0xee),8) → 1234EE78

SETWORD

int SETWORD(
int 値
, int 位置
, int 更新値
)

値を下位からの指定位置のWORDの更新値で上書きする。

記述例　 strhex(setword(0x12345678,1,0xabcd),8) → ABCD5678

TONIBBLE

int TONIBBLE(
int 値
)

値の下位４桁部分を各バイトの下位桁にする。

記述例　 strhex(tonibble(0x12345678),8) → 05060708

FROMNIBBLE

int FROMNIBBLE(
int 値
)

各バイトの下位ニブルをまとめてWORDにする。

記述例　 strhex(fromnibble(0x01020304),8) → 00001234

LOGIC_OPR

bool LOGIC_OPR(
int  演算コード
, bool 値
[ , bool 値 ]+
)

演算コードによる論理値の二項演算をする。
演算コードは演算結果を表すビットの重ね合わせ。

A	B	ビット番号	値
F	F	0	1
F	T	1	2
T	F	2	4
T	T	3	8

OR ならば、F になるのは F_F のみ。そこで 0B1110 、つまり、14 。
AND ならば、T になるのは T_T のみ。そこで 0B1000 、つまり、8 。

記述例　 logic_opr(14,true,false) → TRUE

テキストファイル操作

FILE2FILE

int FILE2FILE(
str 入力ファイル名
, str 出力ファイル名
, str 評価式
)

入力ファイルを出力ファイルに複写する。
戻り値は読み込んだ行数。
入力ファイルから１行ずつ読み、評価式を実行してその値を出力ファイルに１行で書き出す。
評価式の結果が、値「SKIP」ならばその行は出力しない。値「BREAK」ならば、処理を終了する。入力ファイル名が「""」なら標準入力から読み込む。出力ファイル名が「""」なら標準出力へ書き出す。出力ファイル名が「#」なら標準エラー出力へ出力。
出力ファイル名の先頭に「+」があれば、ファイルに追加する。評価式の中では、0 から始まる序数(入力番号)を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file2file('test.txt','result.txt',kado(ss))

FILE2FILESEL

int FILE2FILESEL(
str 入力ファイル名
, str 出力ファイル名
, bool 判定式
, str 評価式
)

入力ファイルの行を選択しながら、出力ファイルに複写する。
戻り値は出力した行数。
入力ファイルから１行ずつ読み、判定式が真の場合は、評価式を実行してその値を出力ファイルに１行で書き出す。
入力ファイル名が「""」なら標準入力から読み込む。出力ファイル名が「""」なら標準出力へ書き出す。出力ファイル名が「"#"」なら標準エラー出力へ出力。
出力ファイル名の先頭に「+」があれば、ファイルに追加する。評価式、判定式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file2filesel('test.txt','result.txt',search(ss,'pic')>=0,kado(ss))

FILE2STRSEL str FILE2STRSEL( str 入力ファイル名 , bool 判定式 )
入力ファイルから選択した行を文字列で返す。
FILE_SELと同じ関数です。歴史的ないきさつからこの名前が残っています。

FILE_FOR

int FILE_FOR(
str 入力ファイル名
, 評価式
)

入力ファイルの各行に対して評価式を評価する。
処理した行数を返す。入力ファイル名が「""」なら標準入力から読み込む。
評価式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。評価式が BREAK になると処理を中断する。

記述例　 {c:=0;file_for('test.txt',when(search(ss,'pic')>=0,c++));c;}

FILE_SEL

str FILE_SEL(
str 入力ファイル名
, bool 判定式
)

入力ファイルから選択した行を文字列で返す。
入力ファイルから１行ずつ読み、判定式が真の文字列を行として連結する。
入力ファイル名が「""」なら標準入力から読み込む。
判定式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file_sel('test.txt',search(ss,'pic')>=0)

FILE_SCAN

int FILE_SCAN(
str 入力ファイル名
, bool 判定式
)

入力ファイルの各行に対して判定式を評価し、真になると中断する。
そのときの、IX の値を返す。中断が無ければ、-1 を返す。
入力ファイル名が「""」なら標準入力から読み込む。
判定式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file_scan('test.txt',search(ss,'pic')>=0)

FILE_PRIME

FILE_PRIME(
str 入力ファイル名
, bool 判定式
)

入力ファイルの各行に対して判定式を評価し、真になると中断する。
そのときの、行の値を返す。中断が無ければ、FALSE を返す。
入力ファイル名が「""」なら標準入力から読み込む。
判定式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file_prime('test.txt',search(ss,'pic')>=0)

FILE_SOME

bool FILE_SOME(
str 入力ファイル名
, bool 判定式
)

入力ファイルの各行に対して判定式を評価し、真になると中断する。
中断があれば、真を、無ければ偽を返す。
入力ファイル名が「""」なら標準入力から読み込む。
判定式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file_some('test.txt',search(ss,'pic')>=0)

FILE_EVERY

bool FILE_EVERY(
str 入力ファイル名
, bool 判定式
)

入力ファイルの各行に対して判定式を評価し、偽になると中断する。
中断があれば、偽を、無ければ真を返す。
入力ファイル名が「""」なら標準入力から読み込む。
判定式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file_every('test.txt',search(ss,'pic')>=0)

FILE_COUNT

int FILE_COUNT(
str 入力ファイル名
[ , bool 判定式 ]
)

入力ファイルの各行に対して判定式を評価し、真になった数を返却する。
判定式を省略すると入力ファイルの行数を返す。
入力ファイル名が「""」なら標準入力から読み込む。
判定式の中では、0 から始まる序数を変数 IX で、入力行を変数 SS で参照できる。

記述例　 file_count('test.txt',search(ss,'pic')>=0)

LOGMSG

BOOL LOGMSG( str ファイル名 , str メッセージ [ , bool 改行フラグ ] )
指定のファイルにメッセージを追加する。常に真を返す。
通常はメッセージに復帰改行を付加して出力するが、改行フラグを偽にすると復帰改行を付加しない。
ファイル名を「""」にすると標準出力に直接出力する。ファイル名を「"#"」にすると標準エラー出力に直接出力する。

記述例　 logmsg('log.txt','err:nodata')

BOOL LOGMSG( str メッセージ )
標準エラー出力にメッセージに復帰改行を付加して出力する。

記述例　 logmsg('err_nofile')

スイッチ操作

SW

bool SW(
int スイッチ番号
[ , bool 値 ]
)

値を設定するとスイッチに値を設定する。
戻り値は以前のスイッチの値。
値を省略すると現在のスイッチの値を読み出す。
スイッチ番号は0-31の範囲。スイッチはプログラムの範囲で共有される。

記述例　
sw(0) → FALSE
sw(0,true) → FALSE
sw(0) → TRUE

SWOLD

bool SWOLD(
int スイッチ番号
)

以前のスイッチの値を返す。

記述例　
sw(0) → FALSE
sw(0,true) → FALSE
swold(0) → FALSE

SWTR

bool SWTR(
int スイッチ番号
, bool 値
)

スイッチに値を設定する。
戻り値は、以前の値と等しくないときTRUE。それ以外では FALSE。
オンになったか、オフになったかの判定は、この関数が真になった後で、関数 SW を用いて現在の値を判定すればよい。

記述例　
sw(0,false) → FALSE
swtr(0,true) → TRUE
swtr(0,true) → FALSE

SWTRG

int SWTRG(
int スイッチ番号
, bool 値
)

スイッチに値を設定する。
戻り値で変化の状態を知ることが出来る。

変化なし	0
オンになった	1
オフになった	-1

記述例　
sw(0,false) → FALSE
swtrg(0,true) → 1
swtrg(0,true) → 0
swtrg(0,false) → -1
swtrg(0,false) → 0

SWSR bool SWSR( int スイッチ番号 , bool SET値 , bool RESET値 )
SWSRAと同じ関数。
互換性を保つために残してある。

SWSRA

bool SWSRA(
int スイッチ番号
, bool SET値
, bool RESET値
, [ 評価式 ]
)

SWの値に応じてSET/RESET動作をする。
戻り値は境界両端を含んで真。
評価式を書くこと、戻り値が真のときに評価式を評価する。
戻り値は、SWSRVAL で参照できる。

スイッチは、プログラムの範囲で有効な値なので、実行をまたいでの判断にも使用できる。
スイッチの値が偽の場合は、SET値を評価し、SET値が真になればスイッチの値を真にする。スイッチの値が真の場合は、RESET値を評価し、RESET値が真になればスイッチの値を偽にする。
時間経過で見ると、SET値でオンし、RESET値オフする。SETしてからRESETするまでの間がオン期間（値が真）となる。境界（SET時とRESET時）の戻り値によって、 SWSRA/SWSRB/SWSRC/SWSRD が用意されている

この関数の境界動作は次の通り

SET時	TRUE
内部	TRUE
RESET時	TRUE

動作表は次の通り

古いSWの値	SET値	RESET値	新しいswの値	戻り値
FALSE	TRUE	--	TRUE	TRUE
FALSE	FALSE	--	FALSE	FALSE
TRUE	--	TRUE	FALSE	TRUE
TRUE	--	FALSE	TRUE	TRUE

記述例　
sw(0,false) → FALSE
swsra(0,true,false) → TRUE
swsra(0,true,false) → TRUE
swsra(0,false,false) → TRUE
swsra(0,false,true) → TRUE
swsra(0,false,true) → FALSE

SWSRB

bool SWSRB(
int スイッチ番号
, bool SET値
, bool RESET値
, [ 評価式 ]
)

SWの値に応じてSET/RESET動作をする。
戻り値は境界両端を含まず真。
評価式を書くこと、戻り値が真のときに評価式を評価する。
戻り値は、SWSRVAL で参照できる。

この関数の境界動作は次の通り

SET時	FALSE
内部	TRUE
RESET時	FALSE

動作表は次の通り

古いSWの値	SET値	RESET値	新しいswの値	戻り値
FALSE	TRUE	--	TRUE	FALSE
FALSE	FALSE	--	FALSE	FALSE
TRUE	--	TRUE	FALSE	FALSE
TRUE	--	FALSE	TRUE	TRUE

記述例　
sw(0,false) → FALSE
swsrb(0,true,false) → FALSE
swsrb(0,true,false) → TRUE
swsrb(0,false,false) → TRUE
swsrb(0,false,true) → FALSE
swsrb(0,false,true) → FALSE

SWSRC

bool SWSRC(
int スイッチ番号
, bool SET値
, bool RESET値
, [ 評価式 ]
)

SWの値に応じてSET/RESET動作をする。
戻り値はSET境界を含んで真。
戻り値は、SWSRVAL で参照できる。
評価式を書くこと、戻り値が真のときに評価式を評価する。

この関数の境界動作は次の通り

SET時	TRUE
内部	TRUE
RESET時	FALSE

動作表は次の通り

古いSWの値	SET値	RESET値	新しいswの値	戻り値
FALSE	TRUE	--	TRUE	TRUE
FALSE	FALSE	--	FALSE	FALSE
TRUE	--	TRUE	FALSE	FALSE
TRUE	--	FALSE	TRUE	TRUE

記述例　
sw(0,false) → FALSE
swsrc(0,true,false) → TRUE
swsrc(0,true,false) → TRUE
swsrc(0,false,false) → TRUE
swsrc(0,false,true) → FALSE
swsrc(0,false,true) → FALSE

SWSRD

bool SWSRD(
int スイッチ番号
, bool SET値
, bool RESET値
, [ 評価式 ]
)

SWの値に応じてSET/RESET動作をする。
戻り値はRESET境界を含んで真。
戻り値は、SWSRVAL で参照できる。
評価式を書くこと、戻り値が真のときに評価式を評価する。

この関数の境界動作は次の通り

SET時	FALSE
内部	TRUE
RESET時	TRUE

動作表は次の通り

古いSWの値	SET値	RESET値	新しいswの値	戻り値
FALSE	TRUE	--	TRUE	FALSE
FALSE	FALSE	--	FALSE	FALSE
TRUE	--	TRUE	FALSE	TRUE
TRUE	--	FALSE	TRUE	TRUE

記述例　
sw(0,false) → FALSE
swsrd(0,true,false) → FALSE
swsrd(0,true,false) → TRUE
swsrd(0,false,false) → TRUE
swsrd(0,false,true) → TRUE
swsrd(0,false,true) → FALSE

SWSRVAL

int SWSRVAL(
int スイッチ番号
)

SWSR系列の結果を返す。

記述例　
sw(0,false) → FALSE
swsra(0,true,false) → TRUE
swsrval(0) → TRUE

SW_COUNT

int SW_COUNT(
int スイッチ番号
)

スイッチに値を設定した回数を返す。

記述例　
{ sw(0,false); sw_count(0);} → 1
{ sw(0,false); sw_count(0);} → 2
{ sw(0,true); sw_count(0);} → 3
{ sw(0,true); sw_count(0);} → 4

SW_ONCOUNT

int SW_ONCOUNT(
int スイッチ番号
)

スイッチに TRUE を設定した回数を返す。

記述例　
{ sw(0,false); sw_oncount(0);} → 0
{ sw(0,false); sw_oncount(0);} → 0
{ sw(0,true); sw_oncount(0);} → 1
{ sw(0,true); sw_oncount(0);} → 2

SW_OFFCOUNT

int SW_OFFCOUNT(
int スイッチ番号
)

スイッチに FALSE を設定した回数を返す。

記述例　
{ sw(0,false); sw_offcount(0);} → 1
{ sw(0,false); sw_offcount(0);} → 2
{ sw(0,true); sw_offcount(0);} → 2
{ sw(0,true); sw_offcount(0);} → 2

SW_PHASE

int SW_PHASE(
int スイッチ番号
)

オン／オフの連続期間中のインデックス番号を返す。
初期値は -1。連続期間の最初が 0 で、以降 1 ずつ増加する。

記述例　
{ sw_phase(0);} → -1
{ sw(0,false); sw_phase(0);} → 0
{ sw(0,false); sw_phase(0);} → 1
{ sw(0,true); sw_phase(0);} → 0
{ sw(0,true); sw_phase(0);} → 1

SW_DOWNCOUNT

int SW(
int スイッチ番号
[ , int 値 ]
)

値を設定するとスイッチのダウン・カウントに値を設定する。
戻り値は以前のスイッチのダウンカウントの値。
値を省略すると現在のスイッチのダウンカウント値を読み出す。
ダウンカウントは、スイッチに値を設定するごとに１ずつ減少する。

記述例　
{ sw_downcount(0,15);} → 0
{ sw(0,false); sw_downcount(0);} → 14
{ sw(0,false); sw_downcount(0);} → 13
{ sw(0,true); sw_downcount(0);} → 12
{ sw(0,true); sw_downcount(0);} → 11

SW_LN

int SW_LN(
int スイッチ番号
)

SWSR系列で連続した領域内での番号。負の値では領域の外。０が領域の先頭。

記述例　
sw(0,false) → FALSE
comma(sw(0),sw_ln(0)) → FALSE,-1024
comma(swsra(0,true,false),sw_ln(0)) → TRUE,0
comma(swsra(0,true,false),sw_ln(0)) → TRUE,1
comma(swsra(0,false,false),sw_ln(0)) → TRUE,2
comma(swsra(0,false,true),sw_ln(0)) → TRUE,3
comma(swsra(0,false,true),sw_ln(0)) → FALSE,-1024

SW_RN

int SW_RN(
int スイッチ番号
)

SWSR系列で連続した領域の番号。０から始まる。
SWSRxの値が真のときに使用すること。

記述例　
sw(0,false) → FALSE
comma(sw(0),sw_rn(0)) → FALSE,-1
comma(swsra(0,true,false),sw_rn(0)) → TRUE,0
comma(swsra(0,true,false),sw_rn(0)) → TRUE,0
comma(swsra(0,false,false),sw_rn(0)) → TRUE,0
comma(swsra(0,false,true),sw_rn(0)) → TRUE,0
comma(swsra(0,false,true),sw_rn(0)) → FALSE,0
comma(swsra(0,true,false),sw_rn(0)) → TRUE,1
comma(swsra(0,true,false),sw_rn(0)) → TRUE,1
comma(swsra(0,false,false),sw_rn(0)) → TRUE,1
comma(swsra(0,false,true),sw_rn(0)) → TRUE,1
comma(swsra(0,false,true),sw_rn(0)) → FALSE,1

SW_RESET

bool SW_RESET[(
int スイッチ番号
)]

スイッチの内部情報を初期化する。以前のスイッチの値を返す。
通常は使用しない。
スイッチ番号を省略すると、すべてのスイッチを初期化する。

記述例　 sw_reset(0) → FALSE

数学的関数

PI PI
円周率。

CONST_E CONST_E
自然対数の底。

CONST_C CONST_C
真空中の光の速度（ｍ・Ｓ^-1）。

CONST_G CONST_G
万有引力定数（Ｎ・ｍ²・ｋｇ^-2）。

CONST_SG CONST_SG
重力加速度（ｍ・Ｓ^-2）。

CONST_H CONST_H
プランク定数。（Ｊ・ｓ）

CONST_N CONST_N
アボガドロ定数。（ｍｏｌ^-1）

CONST_K CONST_K
ボルツマン定数。（Ｊ・Ｋ^-1）

CONST_F CONST_F
ファラデー定数。（Ｃ・ｍｏｌ^-1）

CONST_ME CONST_ME
電子の質量。（㎏）

CONST_MP CONST_MP
陽子の質量。（㎏）

CONST_MN CONST_MN
中性子の質量。（㎏）

CONST_MU CONST_MU
μ中間子の質量。（㎏）

ABS ABS( 値 )
数値の絶対値。
整数、小数、実数を扱う。
ただし、整数の場合、-2147483648の絶対値は残念ながら、-2147483648となってしまう。

ACOS float ACOS( float 式 )
アークコサインを計算する。

ACOSH float ACOSH( float 式 )
ハイパーボリックアークコサインを計算する。

ASIN float ASIN( float 式 )
アークサインを計算する。

ASINH float ASINH( float 式 )
ハイパーボリックアークサインを計算する。

ATAN float ATAN( float 式 )
アークタンジェントを計算する。

ATAN2 float ATAN2( float x , float y )
xとyからアークタンジェントを計算する。

ATANH float ATANH( float 式 )
ハイパーボリックアークタンジェントを計算する。

BESSEL_J0 float BESSEL_J0( float 式 )
ベッセル関数 j0を計算する。

BESSEL_J1 float BESSEL_J1( float 式 )
ベッセル関数 j1を計算する。

BESSEL_JN float BESSEL_JN( int order ,float val )
ベッセル関数 jnを計算する。

BESSEL_Y0 float BESSEL_Y0( float 式 )
ベッセル関数 y0を計算する。

BESSEL_Y1 float BESSEL_Y1( float 式 )
ベッセル関数 y1を計算する。

BESSEL_YN float BESSEL_YN( int order ,float val )
ベッセル関数 ynを計算する。

CBRT float CBRT( float 式 )
立方根を求める。

COMBINATION float COMBINATION( int n , int r )
組み合わせnCr。

CEIL float CEIL( float 式 )
整数の切り上げを求める。

COS float COS( float 式 )
コサインを計算する。

COSH float COSH( float 式 )
ハイパーボリックコサイン (双曲線余弦) を計算する。

CUBIC_EQ

int CUBIC_EQ(
配列名 
, float a
, float b
, float c
, float d
)

三次方程式の解を求める。戻り値は解の数。方程式は、次の形。

a x*x*x + b x*x + c x + d

解は指定の配列に格納する。

記述例　
cubic_eq(a,1.0,-6.0,11.0,-6.0) → 3
comma(a[0],a[1],a[2]) → 3.0,1.0000000000000004,1.9999999999999998

DEG float DEG( float ラジアン )
ラジアンを度に変換

DIFF

float DIFF(
float 関数
, float 計算点
, float 増分
)

数値微分。
関数は、通常の式で書き、変数は「X」を用いる。
計算点における微分係数を求める。実際には、計算点から増分だけ両側に離れた点同士の傾きを値としている。

記述例　 diff(x*x*x,1.0,0.001) → 3.0000009999997523

EQSOLVER

 EQSOLVER(
float 値１
, float 値２
, float 式
, int 繰返し数
)

二分法で一元方程式を解く。
解があれば実数を返す。解が無ければ偽を返す。
x を未知数とする方程式を解く。方程式は式=0 として解く。
値１と値２の間に解があるものとして回数だけ繰り返して解を求める。
値１と値２を式に代入した値の符号は異なっていなければならない

記述例　 eqsolver(1.5,3.0,x*x-3*x+2,16) → 1.9999923706054687

EXP float EXP( float 式 )
指数関数を計算する。

FINITE bool FINITE( float 式 )
式の値が有限数であれば真。

FLOOR float FLOOR( float 式 )
引数以下の数のうちで最大の整数を返す。

FMOD float FMOD( float x , float y )
浮動小数点数の剰余を求める。
x = i * y + f となる x / y の浮動小数点型の剰余 f を計算する。ここで i は整数。f は x と同じ符号であり、その絶対値は y の絶対値より小さい値。

FRACPART float FRACPART( float 式 )
引数の小数部分。

HYPOT float HYPOT( float x , float y )
直角三角形の斜辺を計算する。
( x の 2 乗 + y の 2 乗 ) の平方根

INTPART float INTPART( float 式 )
引数の整数部分。

INTEGRAL

float INTEGRAL(
float 原関数
, float 始点
, float 終点
, int 分割数
[ ,int 計算法 ]
)

定積分。
原関数は、通常の式で書き、変数は「X」を用いる。

1.0/sqrt(1-x*x)

分割数が大きすぎると、計算時間が長くなってしまうので注意すること。計算方法は現在、以下の６種類がサポートされている。いずれも、整数で指定する。計算法を省略するとシンプソン法が指定される。

値	計算法
1	中央値使用
2	台形公式
3	シンプソン法
4	４分法（高次のシンプソン法）
5	５分法（高次のシンプソン法）
6	６分法（高次のシンプソン法）

記述例１　 integral(x*x,0.0,1.0,16) → 0.33333333333333331

記述例２　 integral(1.0/sqrt(1-x*x),0.0,0.5,16,5) → 0.52359877559854995

LOG float LOG( float 式 )
自然対数。

LOG10 float LOG10( float 式 )
常用対数。

FACTORIAL float FACTORIAL( int n )
階乗n!。

PERMUTATION float PERMUTATION( int n , int r )
順列nPr。

POLYNOMIAL

float POLYNOMIAL(
float x
{ , float 係数 }+
)

多項式の値。係数は高次のものから順に記述する。

記述例１　x*x+2x+1.3 の x=1.2 での値
polynomial(1.2,1.0,2.0,1.3) → 5.1399999999999997

POW float POW( float x , float y )
べき乗を計算する。
x の y 乗

POW2 float POW2( float x , int y )
引数と 2 のべき乗の積を計算する。
x * ( 2^y)

PROD

float PROD(
int 開始値
, int 終了値
, float 式
)

総積を求める。
IX を開始値から終了値まで一つずつ増減しながら式を評価しその積を返す。式の中では、整数値 IX を参照できる。

記述例　 prod(1,5,ix) → 120.0

QUADRATIC_EQ

int QUADRATIC_EQ(
配列名
, float a
, float b
, float c
)

二次方程式の解を求める。戻り値は解の数。
方程式は、次の形。

a x*x + b x + c

解は、指定の配列に置く。

記述例　
quadratic_eq(a,1.0,2.0,0.5) → 2
comma(a[0],a[1]) → -0.29289321881345248,-1.7071067811865475

RAD float RAD( float 度 )
度をラジアンに変換

SIN float SIN( float 式 )
サインを計算する。

SINH float SINH( float 式 )
ハイパーボリックサイン (双曲線正弦) を計算する。

SQRT

 SQRT(
{
int 式
| fix 式
| float 式
}
)

平方根を求める。
引数の型が、整数、実数の場合は、実数として平方根を計算し、実数を返す。
引数の型が小数の場合は、小数として平方根を計算し、小数を返す。

記述例１　 sqrt(2.0) → 1.4142135623730951

記述例２　 sqrt(0c2.0) → 1.414213562373095

SUM

float SUM(
int 開始値
, int 終了値
, float 式
)

総和を求める。
IX を開始値から終了値まで一つずつ増減しながら式を評価しその和を返す。式の中では、整数値 IX を参照できる。

記述例　 sum(1,10,ix) → 55.0

TAN float TAN( float 式 )
タンジェントを計算する。

TANH float TANH( float 式 )
ハイパーボリックタンジェント (双曲線正接) を計算する。

小数型の関数

FIX_INT

fix FIX_INT(
fix 式
)

式の値を超えない最大の整数を返す。

記述例１　 fix_int(0c12.5) → 12

記述例２　 fix_int(-0c12.5) → -13

FIX_FRAC

fix FIX_FRAC(
fix 式
)

小数部分の値。

記述例１　 fix_frac(0c1.536) → 0.536

記述例２　 fix_frac(-0c12.34) → -0.34

FIX_CUT

fix FIX_CUT(
fix 式
, int 位置
)

結果が指定の位置となるように切り捨てる。位置は、小数点の位置が０。正の値は整数部、負の値は小数部を指定する。、

記述例１　 fix_cut(0c123456.78912,2) → 123400

記述例２　 fix_cut(0c123456.78912,0) → 123456

記述例３　 fix_cut(0c123456.78912,-2) → 123456.78

FIX_UP

fix FIX_UP(
fix 式
, int 位置
)

結果が指定の位置となるように切り上げる。位置は、小数点の位置が０。正の値は整数部、負の値は小数部を指定する。、

記述例１　 fix_up(0c123456.78912,2) → 123500

記述例２　 fix_up(0c123456.78912,0) → 123457

記述例３　 fix_up(0c123456.78912,-2) → 123456.79

FIX_ROUND

fix FIX_ROUND(
fix 式
, int 位置
)

結果が指定の位置となるように四捨五入する。位置は、小数点の位置が０。正の値は整数部、負の値は小数部を指定する。、

記述例１　 fix_round(0c123456.78912,3) → 123000

記述例２　 fix_round(0c123456.78912,0) → 123457

記述例３　 fix_round(0c123456.78912,-2) → 123456.79

バイナリ型の関数

ZB

bin ZB
１バイトの 0 。

bin ZB( int バイト数 )
バイト数個の 0 。

記述例　 strhex(zb) → 00

記述例　 strhex(zb(4),true) → 00 00 00 00

BINLEN

int BINLEN(
bin 値
)

バイナリのバイト長

記述例　 binlen(bin('ABC')) → 3

BYTE

bin BYTE(
[
値
[, 値 ]*
]
)

指定の値を持つバイトを繋いだバイナリ。
値が数値の場合は、整数に変換後、最下位バイトを持つ１バイトの要素。文字列、バイナリの場合は、そのままの値が要素となる。

記述例　 strhex(byte(10,20,'@ABC'),true) → 0A 14 40 41 42 43

BYTES

bin BYTES(
int 値
[, int 個数 ]
)

指定のバイト値を個数だけつなげたバイナリ。

記述例　 strhex(bytes(65,5),true) → 41 41 41 41 41

BYTEVAL

int BYTEVAL(
bin バイナリ
)

バイナリの先頭の１バイトのコードを返す。
バイナリの長さが０ならば、0 を返す。

記述例　 byteval(bin('ABC')) → 65

WORD

bin WORD(
[
int 値
[, int 値 ]*
]
)

指定の値を持つワードを繋いだバイナリ。

記述例　 strhex(word(10,20),true) → 0A 00 14 00

WORDS

bin WORDS(
int 値
[, int 個数 ]
)

指定のワード値を個数だけつなげたバイナリ。

記述例　 strhex(words(0x1234,5),true) → 34 12 34 12 34 12 34 12 34 12

WORDVAL

int WORDVAL(
bin バイナリ
)

バイナリの先頭の１ワードのコードを返す。
ワードの長さ（２）に満たない場合は後ろに必要なだけ 0 を補って計算する。

記述例　 strhex(wordval(byte(0x12,0x34))) → 3412

XWORD

bin XWORD(
[
int 値
[, int 値 ]*
]
)

指定の値を持つワードのモトローラ順バイナリを繋いだバイナリ。

記述例　 strhex(xword(10,20),true) → 00 0A 00 14

XWORDS

bin XWORDS(
int 値
[, int 個数 ]
)

指定のワード値のモトローラ順バイナリを個数だけつなげたバイナリ。

記述例　 strhex(xwords(0x1234,5),true) → 12 34 12 34 12 34 12 34 12 34

XWORDVAL

int XWORDVAL(
bin バイナリ
)

バイナリの先頭の１ワードのモトローラ順バイナリのコードを返す。

記述例　 strhex(xwordval(byte(0x12,0x34))) → 1234

TBYTE

bin TBYTE(
[
int 値
[, int 値 ]
]
)

指定の値を持つ24bitワードを繋いだバイナリ。

記述例　 strhex(tbyte(0x123456,0x789abcde),true) → 56 34 12 DE BC 9A

TBYTES

bin TBYTES(
int 値
[, int 個数 ]
)

指定の24bitワード値を個数だけつなげたバイナリ。

記述例　 strhex(tbytes(0x121314,2),true) → 14 13 12 14 13 12

TBYTEVAL

int TBYTEVAL(
bin バイナリ
)

バイナリの先頭の24bitワードのコードを返す。

記述例　 strhex(tbyteval(byte(0x11,0x22,0x33)),6) → 332211

XTBYTE

bin XTBYTE(
[
int 値
[, int 値 ]
]
)

指定の値を持つ24bitワードのモトローラ順バイナリを繋いだバイナリ。

記述例　 strhex(xtbyte(0x123456,0x789abcde),true) → 12 34 56 9A BC DE

XTBYTES

bin XTBYTES(
int 値
[, int 個数 ]
)

指定の24bitワード値のモトローラ順バイナリを個数だけつなげたバイナリ。

記述例　 strhex(xtbytes(0x121314,2),true) → 12 13 14 12 13 14

XTBYTEVAL

int XTBYTEVAL(
bin バイナリ
)

バイナリの先頭の24bitワードのモトローラ順バイナリのコードを返す。

記述例　 strhex(xtbyteval(byte(0x11,0x22,0x33)),6) → 112233

DWORD

bin DWORD(
[
int 値
[, int 値 ]*
]
)

指定の値を持つダブルワードを繋いだバイナリ。

記述例　 strhex(dword(10,20),true) → 0A 00 00 00 14 00 00 00

DWORDS

bin DWORDS(
int 値
[, int 個数 ]
)

指定のダブルワード値を個数だけつなげたバイナリ。

記述例　 strhex(dwords(0x12345678,2),true) → 78 56 34 12 78 56 34 12

DWORDVAL

int DWORDVAL(
bin バイナリ
)

バイナリの先頭の１ダブルワードのコードを返す。
ダブルワードの長さ（４）に満たない場合は後ろに必要なだけ 0 を補って計算する。

記述例　 strhex(dwordval(byte(0x12,0x34,0x56,0x78)),8) → 78563412

XDWORD

bin XDWORD(
[
int 値
[, int 値 ]*
]
)

指定の値を持つダブルワードのモトローラ順バイナリを繋いだバイナリ。

記述例　 strhex(xdword(10,20),true) → 00 00 00 0A 00 00 00 14

XDWORDS

bin XDWORDS(
int 値
[, int 個数 ]
)

指定のダブルワード値のモトローラ順バイナリを個数だけつなげたバイナリ。

記述例　 strhex(xdwords(0x12345678,2),true) → 12 34 56 78 12 34 56 78

XDWORDVAL

int XDWORDVAL(
bin バイナリ
)

バイナリの先頭の１ダブルワードのモトローラ順バイナリのコードを返す。

記述例　 strhex(xdwordval(byte(0x12,0x34,0x56,0x78)),8) → 12345678

BIN2SFLOAT

flt BIN2SFLOAT(
bin バイナリ
)

バイナリの先頭の単精度実数を返す。
実際に返却するのは通常の実数であることに留意すること。単精度実数の長さ( 4 バイト)に満たない場合は0.0を返す。

記述例　 bin2sfloat(byte(0x9a,0x99,0x99,0x3f)) → 1.2000000476837158

SFLOAT2BIN

bin SFLOAT2BIN(
[flt 数値
[ , 数値 ]* ]
)

数値を単精度整数としてバイナリに変換する。

記述例　 strhex(sfloat2bin(1.2)) → 9A99993F

記述例　 strhex(sfloat2bin(1.2,0.0)) → 9A99993F00000000

HEX2BIN

bin HEX2BIN(
str 16進表記
)

二桁の16進表記文字列をバイナリに変換する。
二桁の16進表記は1バイトを表す。これを直接連結して書いても良いし、「,」あるいは、任意の数のスペース以下のコードを間に挟んでもよい。

記述例　 strhex(hex2bin('1c004a')) → 1C004A

記述例　 strhex(hex2bin('1c,00,4a')) → 1C004A

記述例　 strhex(hex2bin('1c 00 4a')) → 1C004A

FILEBIN

bin FILEBIN(
str ファイル名
)

ファイルを一つのバイナリとして読み込む。
ファイル名が "" の場合には、標準入力から読む。

記述例　 a:=filebin('test.bin')

FILEBINOUT int FILEBINOUT( str ファイル名 , bin 値 )
バイナリをファイルに出力する。出力は一つのファイルになる。
ファイル名が "" の場合には標準出力へ出力する。ファイル名が"#"の場合には標準エラー出力に出力する。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）
戻り値は書き込んだバイト数。

BINPART

bin BINPART(
bin 値
[
, int 位置
, int バイト数
]*
[
, int 位置
[ , int バイト数 
]
)

バイナリの指定位置から指定バイトを取り出して繋いだバイナリ。

記述例　 strhex(binpart(bin('abcdefg'),2,3)) → 636465

BIN2AR int BIN2AR( 配列名 , bin データ [ , int バイト数 ]* )
バイナリを分割して配列に格納する。
バイト数の登場順に配列の最初の要素から順に代入する。
バイト数をまったく書かなかった場合には１バイトずつ格納する。
格納に先立って、配列はクリアされる。

BIN2ARAR int BIN2ARAR( 格納先配列名 , 参照配列名 , bin データ )
バイナリを分割して配列に格納する。
参照配列の相当する要素に書かれている値を長さとして格納先配列に順に格納する。格納先配列と参照配列は同じ配列でもよい。格納先配列と参照配列が異なっていれば、格納に先立って、配列はクリアされる。

AR2BIN int AR2BIN( 配列名 [ , int 要素番号 ]* )
配列の要素をバイナリデータとして連結してする。
要素番号を省略するとすべての要素を連結する。

AR2BINAR int AR2BINAR( データ配列名 , 参照配列名 )
データ配列の参照配列で指定される要素をバイナリデータとして結合する。

BIN_INS

bin BIN_INS(
bin 値
, int 位置
, bin 挿入値
)

バイナリの指定位置にバイナリを挿入する。

記述例　 bin_ins(bin('ABCDEFG'),2,'SS') → ABSSCDEFG

BIN_DEL

bin BIN_DEL(
bin 値
, int 位置
[, int 長さ ]
)

バイナリの指定位置から指定長さだけ削除する。
長さを省略すると指定位置以降を削除する。

記述例１　 bin_del(bin('ABCDEFG'),2,2) → ABEFG

記述例２　 bin_del(bin('ABCDEFG'),4) → ABCD

BIN_PUT

bin BIN_PUT(
bin 値
, int 位置
, bin 上書値
)

バイナリの指定位置にバイナリを上書きする。

記述例　 bin_put(bin('ABCDEFG'),2,'SS') → ABSSEFG

BIN_GET

bin BIN_GET(
bin 値
, int 位置
, int 長さ
[ , int フィルデータ ]
)

バイナリの指定位置から指定長さだけ取り出したバイナリ。
必ず指定の長さのバイナリを返す。元のデータが存在しない部分はフィルデータで埋める。フィルデータを省略した場合は 0 で埋める。

記述例１　 bin_get(bin('ABCDEFG'),2,2) → CD

BIN_FOR

int BIN_FOR(
bin 値
, 評価式
[ , int サイズ ]
)

バイナリの各要素に対して評価式を繰り返す。回数を返す。
サイズで要素の長さを指定する。省略すると長さは 1 。評価式の中では、SVで現在の要素、IXで繰返しの序数、BPで現在要素のバイナリの先頭からの位置を参照できる。評価式が BREAK になると処理を中断する。

記述例　 {ar_clear(a);bin_for(bin('abcdef'),a[ix]:=sv,2);ar2str(a);} → ab,cd,ef

BIN_REP

bin BIN_REP(
bin 値
, bin 評価式
[ , int サイズ ]
)

バイナリの各要素に対して評価式を評価し連結したバイナリ。
サイズで要素の長さを指定する。省略すると長さは 1 。評価式の中では、SVで現在の要素、IXで繰返しの序数、BPで現在要素のバイナリの先頭からの位置を参照できる。

記述例　 { bin_rep(bin('abcdef'),sv+sv,2);} → ababcdcdefef

BIN_SEL

bin BIN_SEL(
bin 値
, bool 評価式
[ , int サイズ ]
)

バイナリの各要素に対して評価式を評価し、結果が真になった要素を連結したバイナリ。
サイズで要素の長さを指定する。省略すると長さは 1 。評価式の中では、SVで現在の要素、IXで繰返しの序数、BPで現在要素のバイナリの先頭からの位置を参照できる。

記述例　 { bin_sel(bin('abcdef'),str(sv)>'c');} → def

BIN_SCAN

int BIN_SCAN(
bin 値
, bool 評価式
[ , int サイズ ]
)

バイナリの各要素を検索する。初めて評価式が真になった要素を先頭からのバイト位置を返す。
見つからなかったときは -1 を返す。
サイズで要素の長さを指定する。省略すると長さは 1 。評価式の中では、SVで現在の要素、IXで繰返しの序数、BPで現在要素のバイナリの先頭からの位置を参照できる。

記述例　 { bin_scan(bin('abcdef'),str(sv)=='c');} → 2

BIN_PRIME

BIN_PRIME(
bin 値
, bool 評価式
[ , int サイズ ]
)

バイナリの各要素を検索する。初めて評価式が真になった要素をを返す。
見つからなかったときは FALSE を返す。
サイズで要素の長さを指定する。省略すると長さは 1 。評価式の中では、SVで現在の要素、IXで繰返しの序数、BPで現在要素のバイナリの先頭からの位置を参照できる。

記述例　 { bin_prime(bin('abcdef'),str(sv)=='c');} → c

BIN_SOME

int BIN_SOME(
bin 値
, bool 評価式
[ , int サイズ ]
)

バイナリの各要素が一つでも条件を満たせば真。
全ての要素に対して評価式を評価し、真になったところで繰返しを終了し、真を返す。全ての要素に対して評価式が偽の場合だけ偽を返す。サイズで要素の長さを指定する。省略すると長さは 1 。評価式の中では、SVで現在の要素、IXで繰返しの序数、BPで現在要素のバイナリの先頭からの位置を参照できる。

記述例　 { bin_some(bin('abcdef'),str(sv)=='c');} → TRUE

記述例　 { bin_some(bin('abcdef'),str(sv)>'f');} → FALSE

BIN_EVERY

int BIN_EVERY(
bin 値
, bool 評価式
[ , int サイズ ]
)

バイナリの全ての要素が条件を満たせば真。
全ての要素に対して評価式を評価し、偽になったところで繰返しを終了し、偽を返す。全ての要素に対して評価式が真の場合だけ真を返す。サイズで要素の長さを指定する。省略すると長さは 1 。評価式の中では、SVで現在の要素、IXで繰返しの序数、BPで現在要素のバイナリの先頭からの位置を参照できる。

記述例　 { bin_every(bin('abcdef'),str(sv)<'f');} → FALSE

記述例　 { bin_every(bin('abcdef'),str(sv)<'g');} → TRUE

BIN_NOT

bin BIN_NOT(
bin 値
)

バイナリの全てのバイトのビットを反転したバイナリ。

記述例　 strhex(bin_not(byte(0x12,0x34)),true) → ED CB

BIN_SWAP1

bin BIN_SWAP1(
bin 値
)

バイナリの全てのバイトごとのビットの順序を反転したバイナリ。

記述例　 strhex(bin_swap1(byte(0x12,0x34)),true) → 48 2C

BIN_SWAP4

bin BIN_SWAP4(
bin 値
)

バイナリの全てのバイトごとの桁の順序を反転したバイナリ。

記述例　 strhex(bin_swap4(byte(0x12,0x34)),true) → 21 43

BIN_REV

bin BIN_REV(
bin 値
)

バイナリのバイト順を反転したバイナリ。

記述例　 strhex(bin_rev(byte(0x12,0x34)),true) → 34 12

BIN_B2N

bin BIN_B2N(
bin 値
[ , HLフラグ
]
)

各バイトの上下ニブルを二つのバイトに分ける。
通常は、Low / Hi の順に並べるが、HLフラグが真ならば Low / Hi の順に並べる。

記述例　 strhex(bin_b2n(byte(0x12,0x34,0x56)),true) → 02 01 04 03 06 05

BIN_N2B

bin BIN_N2N(
bin 値
[ , HLフラグ
]
)

二つのバイトに分けられた上下ニブルを一つのバイトに纏める。
元のニブルの順序は、Low / Hi のだが、HLフラグが真ならば Low / Hi とする。
値の長さは偶数であること。

記述例　 strhex(bin_n2b(byte(0x01,0x02,0x03,0x04)),true) → 21 43

BIN_AND

bin BIN_AND(
bin 値
[ , bin 値 ]*
)

バイナリのビットごとの論理積の結果のバイナリ。
長さが異なる場合は、短い方に合わせる。

記述例　 strhex(bin_and(byte(0x12,0x34),byte(0x0f,0xf0)),true) → 02 30

BIN_OR

bin BIN_OR(
bin 値
[ , bin 値 ]*
)

バイナリのビットごとの論理和の結果のバイナリ。
長さが異なる場合は、長い方に合わせる。

記述例　 strhex(bin_or(byte(0x12,0x34),byte(0x0f,0xf0)),true) → 1F F4

BIN_XOR

bin BIN_XOR(
bin 値
[ , bin 値 ]*
)

バイナリのビットごとの排他的論理和の結果のバイナリ。
長さが異なる場合は、長い方に合わせる。

記述例　 strhex(bin_xor(byte(0x12,0x34),byte(0x0f,0xf0)),true) → 1D C4

BIN_ADD

bin BIN_ADD(
bin 値
[ , bin 値 ]*
)

バイナリのバイトごとの加算の結果のバイナリ。
先頭から末尾方向に向って、キャリーが伝播する。長さが異なる場合は、長い方に合わせる。

記述例１　 strhex(bin_add(byte(0x12,0x34),byte(0x12,0x34)),true) → 24 68

記述例２　 strhex(bin_add(byte(0x80,0x34),byte(0x80,0x34)),true) → 00 69

BIN_SUB

bin BIN_SUB(
bin 値
[ , bin 値 ]*
)

バイナリのバイトごとの減算の結果のバイナリ。
先頭から末尾方向に向って、ボローが伝播する。長さが異なる場合は、長い方に合わせる。

記述例１　 strhex(bin_sub(byte(0x12,0x34),byte(0x11,0x12)),true) → 01 22

記述例２　 strhex(bin_sub(byte(0x12,0x34),byte(0x13,0x12)),true) → FF 21

BIN_SUM7

bin BIN_SUM7(
bin 値
[ , bin 値 ]*
[ , bool 連結フラグ ]
)

7ビットのチェックサムを求める。
連結フラグがセットされていると、引数の値の後ろにチェックサムを連結して返す。

記述例１　 strhex(bin_sum7(byte(0x12,0x7F)),true) → 11

記述例２　 strhex(bin_sum7(byte(0x12,0x7F),true),true) → 12 7F 11

BIN_SUM8

bin BIN_SUM8(
bin 値
[ , bin 値 ]*
[ , bool 連結フラグ ]
)

8ビットのチェックサムを求める。
連結フラグがセットされていると、引数の値の後ろにチェックサムを連結して返す。

記述例１　 strhex(bin_sum8(byte(0x12,0x7F)),true) → 91

記述例２　 strhex(bin_sum8(byte(0x12,0x7F),true),true) → 12 7F 91

BIN_CSUM7

bin BIN_CSUM7(
bin 値
[ , bin 値 ]*
[ , bool 連結フラグ ]
)

バイト集計の２の補数の下位7ビットをチェックサムとして求める。
連結フラグがセットされていると、引数の値の後ろにチェックサムを連結して返す。

記述例１　 strhex(bin_csum7(byte(0x12,0x7F)),true) → 6F

記述例２　 strhex(bin_csum7(byte(0x12,0x7F),true),true) → 12 7F 6F

BIN_CSUM8

bin BIN_CSUM8(
bin 値
[ , bin 値 ]*
[ , bool 連結フラグ ]
)

バイト集計の２の補数の下位8ビットをチェックサムとして求める。
連結フラグがセットされていると、引数の値の後ろにチェックサムを連結して返す。

記述例１　 strhex(bin_csum8(byte(0x12,0x7F)),true) → 6F

記述例２　 strhex(bin_csum8(byte(0x12,0x7F),true),true) → 12 7F 6F

BIN_KSUM7

bin BIN_KSUM7(
bin 値
[ , bin 値 ]*
[ , bool 連結フラグ ]
)

バイト集計に0xa5を加えた値の下位7ビットをチェックサムとして求める。
連結フラグがセットされていると、引数の値の後ろにチェックサムを連結して返す。

記述例１　 strhex(bin_sum8(byte(0x12,0x7F)),true) → 91

記述例２　 strhex(bin_sum8(byte(0x12,0x7F),true),true) → 12 7F 91

BIN78

bin BIN78(
bin 値
[ , bin 値 ]*
)

7bitパックされたデータを通常の形式に変換する。
7bitパック形式は、各バイトのmsbを使用しないように変換したもので、 8バイトのデータが7バイトを表す。
8バイトの先頭の1バイトがリードバイトで、以降のデータのmsb部分をlsbから順にmsbの方向へと格納している。

記述例１　 strhex(bin78(byte(0x7F,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x01,0x08)),true) → 81 82 83 84 85 86 87 88

BIN87

bin BIN87(
bin 値
[ , bin 値 ]*
)

通常のデータを7bitパックされたデータに変換する。
7バイトのデータが8バイトに変換される。 7bitパック形式については、BIN78()の項を参照。

記述例１　 strhex(bin87(byte(0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87)),true) → 7F 00 01 02 03 04 05 06 01 07

BINSYX int BINSYX( 配列名 ,bin 値 [ , bool 強制フラグ [ , bool 補正フラグ ] ] )
バイナリデータからMIDIのSYSEXを取り出して、配列に順に格納する。個数を返却する。
0xf0から0xf7に挟まれたブロックを取り出し格納する。0xf0と0xf7も格納する。
0xf0のあとmsbがセットされたバイトが現れるとそこまでをブロックとする。このとき、強制フラグが真ならばこのブロックは格納する。そうでなければ格納しない。
補正フラグが真ならば、最後が0xf7ではない場合に0xf7を追加する。

BIN_LOAD bin BIN_LOAD( str ファイル名 , float 位置 , int バイト数 )
ファイルの一部を読み込む。
ファイルサイズを超えた位置を指定すると長さ 0 のバイナリを返す。また、ファイルの指定位置以降に十分なデータがない場合は、読めた分だけのバイナリを返す。

BIN_SAVE int BIN_SAVE( str ファイル名 , bin 書き込みデータ , float 位置 [ , int クリアバイト ] )
ファイルの一部に書き込む。書き込みデータのバイト数を返す。
ファイルサイズを超えた位置を指定するとその位置までクリアバイト（ 0 - 255 ）を書き込む。

MIDI_CH int MIDI_CH
MIDIチャンネルメッセージ生成のデフォルトチャンネルを返す。
チャンネル番号は 0 - 15。
int MIDI_CH( int チャンネル )
MIDIチャンネルメッセージ生成のデフォルト値を設定する。

MIDI_NOTE bin MIDI_NOTE( [ int チャンネル , ] int ノート番号 , int ベロシティ )
MIDIノート・オン・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。
ここでベロシティを 0 とすれば、ノートオフメッセージとして扱われる。

MIDI_NOTEX bin MIDI_NOTEX( [ int チャンネル , ] int ノート番号 )
MIDIノート・オフ・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。
ノートオンのベロシティを 0 にした形のメッセージを生成する。

MIDI_NOTEXV bin MIDI_NOTEXV( [ int チャンネル , ] int ノート番号 , int ベロシティ )
MIDIノート・オフ・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。

MIDI_PAF bin MIDI_PAF( [ int チャンネル , ] int ノート番号 , int プレッシャー )
MIDIポリフォニック・アフタータッチ・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。

MIDI_CC bin MIDI_CC( [ int チャンネル , ] int コントローラ番号 , int 値 )
MIDIコントロールチェンジ・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。

MIDI_PC bin MIDI_PC( [ int チャンネル , ] int プログラム番号 )
MIDIプログラム・チェンジ・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。
プログラム番号は 0-127。楽器に表示される番号は1-128で表されることがあるので、注意すること。

MIDI_CAF bin MIDI_CAF( [ int チャンネル , ] int プレッシャー )
MIDIチャンネル・アフタータッチ・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。

MIDI_BEND bin MIDI_BEND( [ int チャンネル , ] int ベンド値 )
MIDIピッチ・ベンド・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。
ベンド値は、-8192 ～ 8191の整数。

MIDI_SYX bin MIDI_SYX( bin 内容 [ , bin 内容 ]* )
MIDIシステム・イクスクルーシブ・メッセージを生成する。
内容を連結した後、0xf0と0xf7で挟んだもの。

MIDI_BANKU bin MIDI_BANKU( [ int チャンネル , ] int バンクMSB )
MIDIバンクセレクト（MSB）・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。

MIDI_BANKL bin MIDI_BANKL( [ int チャンネル , ] int バンクLSB )
MIDIバンクセレクト（LSB）・メッセージを生成する。
チャンネル番号は 0 - 15。チャンネルを省略すると現在のデフォルトチャンネルを使用する。

NOTE str NOTE( int ノート番号 [ , int オフセット ] )
ノート番号をノート表記に変換する。
ノート番号の範囲は、0 - 127。デフォルトでは、ノート表記はヤマハ方式で、中央のc(60)は C3 と表記する。
オフセットを指定するとオクターブ原点が異なる表記にも対応する。ヤマハ方式ではオフセットは 2 を指定する。ローランド方式では 1 を指定する。

NOTEVAL int NOTEVAL( str ノート表記 )
ノート表記をノート番号に変換する。
デフォルトでは、ノート表記はヤマハ方式で、中央のc(60)は C3 と表記する。
オフセットを指定するとオクターブ原点が異なる表記にも対応する。ヤマハ方式ではオフセットは 2 を指定する。ローランド方式では 1 を指定する。

比較

比較関数は、値1と値2を比較し、結果により次の値を返す。

値1 > 値2	1
値1 = 値2	0
値1 < 値2	-1

COMPINT

int COMPINT(
int 値1
, int 値2
)

整数数値の比較。

記述例１　 compint(10,20) → -1

記述例２　 compint(20,20) → 0

記述例３　 compint(30,20) → 1

COMPDW

int COMPDW(
int 値1
, int 値2
)

整数数値のDWORDとしての比較。

記述例１　 compdw(0x10,0x20) → -1

記述例２　 compdw(0x20,0x20) → 0

記述例３　 compdw(0x80000010,0x20) → 1

COMPFIX

int COMPFIX(
fix 値1
, fix 値2
)

小数の比較。

記述例１　 compfix(0c10,0c20) → -1

記述例２　 compfix(0c20,0c20) → 0

記述例３　 compfix(0c30,0c20) → 1

COMPFLOAT

int COMPFLOAT(
float 値1
, float 値2
[ , float eps値 ]
)

実数の比較。
比較の許容量を eps値で指定できる。

記述例１　 compfloat(10.0,20.0) → -1

記述例２　 compfloat(20.0,20.0) → 0

記述例３　 compfloat(30.0,20.0) → 1

記述例４　 compfloat(20.015,20.0,0.1) → 0

COMPSTR

int COMPSTR(
str 値1
, str 値2
)

文字列の比較。

記述例１　 compstr('abc','def') → -1

記述例２　 compstr('def','def') → 0

記述例３　 compstr('hij','def') → 1

COMPSTRI

int COMPSTRI(
str 値1
, str 値2
)

文字列の比較。半角英字の大小の区別はしない。

記述例１　 compstri('abc','Def') → -1

記述例２　 compstri('def','Def') → 0

記述例３　 compstri('Hij','def') → 1

COMPSTRIEX int COMPSTRIEX( str 値1 , str 値2 )
文字列の比較。半角英字／全角英字／ロシア文字／ギリシャ文字／ローマ数字の大小の区別はしない。

COMPSTRB

int COMPSTRB(
str 値1
, str 値2
)

文字列の比較。バイト順による比較をする。

記述例１　 compstrb('abc','def') → -1

記述例２　 compstrb('def','def') → 0

記述例３　 compstrb('hij','def') → 1

COMPBIN

int COMPBIN(
bin 値1
, bin 値2
)

バイナリの比較。バイト順による比較をする。

記述例　 compbin(binary('a'),binary('c')) → -1

最大最小

ここで記述する関数は、１つ以上の不定個の引数を取り、その中の最大値、あるいは、最小値を返却する。
MAX_で始まる関数が最大値を、 MAX_で始まる関数が最小値を返す。

MAX_INT

int MAX_INT(
int 値
, [ int 値 ]*
)

最大の整数数値

記述例　 max_int(-1,45,62,-7) → 62

MIN_INT

int MIN_INT(
int 値
, [ int 値 ]*
)

最小の整数数値

記述例　 min_int(-1,45,62,-7) → -7

MAX_DW

int MAX_DW(
int 値
, [ int 値 ]*
)

DWORDとしての最大の整数数値

記述例　
max_dw(-1,45,62,-7) → -1
１６進数で表すと、-1 が最大であることがわかる

arg2str(strhex(sv),comma,-1,45,62,-7) → FFFFFFFF,2D,3E,FFFFFFF9

MIN_DW

int MIN_DW(
int 値
, [ int 値 ]*
)

DWORDとしての最小の整数数値

記述例　
min_dw(-1,45,62,-7) → 45
１６進数で表すと、45 が最小であることがわかる

arg2str(strhex(sv),comma,-1,45,62,-7) → FFFFFFFF,2D,3E,FFFFFFF9

MAX_FIX

fix MAX_FIX(
fix 値
, [ fix 値 ]*
)

最大の小数数値

記述例　 max_fix(-0c15,0c45.2,0c62.77,-0c7.0) → 62.77

MIN_FIX

fix MIN_FIX(
fix 値
, [ float 値 ]*
)

最小の小数数値

記述例　 min_fix(-0c15,0c45.2,0c62.77,-0c7.0) → -15

MAX_FLOAT

float MAX_FLOAT(
float 値
, [ float 値 ]*
)

最大の実数数値

記述例　 max_float(-15.0,45.2,62.77,-7.0) → 62.770000000000003

MIN_FLOAT

float MIN_FLOAT(
float 値
, [ float 値 ]*
)

最小の実数数値

記述例　 min_float(-15.0,45.2,62.77,-7.0) → -15.0

MAX_STR

str MAX_STR(
str 値
, [ str 値 ]*
)

最大の文字列

記述例　 max_str('abc','def','ABC','DEF') → def

MIN_STR

str MIN_STR(
str 値
, [ str 値 ]*
)

最小の文字列

記述例　 min_str('abc','def','ABC','DEF') → ABC

MAX_STRI

str MAX_STRI(
str 値
, [ str 値 ]*
)

最大の文字列。半角英字の大文字小文字を区別しない。

記述例　 max_stri('abc1','def2','ABC3','DEF4') → DEF4

MIN_STRI

str MIN_STRI(
str 値
, [ str 値 ]*
)

最小の文字列。半角英字の大文字小文字を区別しない

記述例　 min_stri('abc1','def2','ABC3','DEF4') → abc1

MAX_STRX str MAX_STRX( str 値 , [ str 値 ]* )
最大の文字列。半角全角の大文字小文字を区別しない。

MIN_STRX str MIN_STRX( str 値 , [ str 値 ]* )
最小の文字列。半角全角の大文字小文字を区別しない

システム情報

RESULT int RESULT
QSスクリプト ( TSスクリプトでも)中では、スクリプトが保持している実行結果の値を返す。
その他の場合はホストの状況に依存する。
また、コマンドラインの実行や、スクリプトの実行を行うとその結果の値が設定されるが、これは、起動された式の間だけ有効である。必要ならば、変数に書き込んでおくこと。

MODULE

str MODULE
現在実行中のプログラムのファイル名

記述例　 module → E:\dvl\BIN\BRIT.exe

CML

str CML
現在実行中のプログラムのコマンドライン

記述例　 cml → BRIT !! -b -O:E:\DVL\MANUAL -p -i

CMLARG_STD str CMLARG_STD( [ str 文字列 ] )
文字列をコマンドラインとして解析し、ファイル名を arg[]に、オプションを arg{}に格納する。
文字列を省略すると、起動プログラムのコマンドラインを解析対象とする。
文字列の最初のパラメータは起動ファイル名として扱い、これを戻り値とする。
オプションはarg{}に格納されるが、そのキーはオプションの先頭一文字で、半角英字ならば大文字に変換される。値は後続の文字列である。 -が単独で書かれた場合は、以降の項目はすべてファイル名として扱われる。
ファイル名、オプションの解析は、CML2ARG_STDと異なり、２番目の項目以降に対して行われる。
パラメータの間接展開は!、^、@の展開を行う。

CMLARG_ALL str CMLARG_ALL( [ str 文字列 ] )
文字列をコマンドラインとして解析する。
CMLARG_STDを参照のこと。
パラメータの間接展開は!、^、@、#の展開を行う。

CMLARG_NON str CMLARG_NON( [ str 文字列 ] )
文字列をコマンドラインとして解析する。
CMLARG_STDを参照のこと。
パラメータの間接展開は行わない。

CML2ARG_STD str CML2ARG_STD( [ str 文字列 ] )
文字列をコマンドラインとして解析し、ファイル名を arg[]に、オプションを arg{}に格納する。
文字列を省略すると、起動プログラムのコマンドラインを解析対象とする。
文字列の最初のパラメータは起動ファイル名として扱い、これを戻り値とする。二番目のパラメータはスクリプト名として扱う。
オプションはarg{}に格納されるが、そのキーはオプションの先頭一文字で、半角英字ならば大文字に変換される。値は後続の文字列である。 -が単独で書かれた場合は、以降の項目はすべてファイル名として扱われる。
ファイル名、オプションの解析は、CMLARG_STDと異なり、３番目の項目以降に対して行われる。
パラメータの間接展開は!、^、@の展開を行う。

CML2ARG_ALL str CML2ARG_ALL( [ str 文字列 ] )
文字列をコマンドラインとして解析する。
CML2ARG_STDを参照のこと。
パラメータの間接展開は!、^、@、#の展開を行う。

CML2ARG_NON str CML2ARG_NON( [ str 文字列 ] )
文字列をコマンドラインとして解析する。
CML2ARG_STDを参照のこと。
パラメータの間接展開は行わない。

VERSION

str VERSION
現在実行中のランタイムのバージョン番号

記述例　 version → 1.51

DOSDEVICE str DOSDEVICE( [ str デバイス名 ]
登録されているDosDevice情報を返す。
戻り値は、行の連続。
デバイス名を指定しなければ、登録されたデバイスを表す行の集まり。
デバイス名を指定すると、その情報を表す行の集まりを返す。デバイスが無い場合には長さ０の文字列を返す。

DOSDEVNAME str DOSDEVNAME
伝統的なDosDevice名を行の連続として返す。
CON、NUL、AUXなどファイル名に含まれるとデバイスとして解釈されるベース名。

BOOTDIR

str BOOTDIR
現在実行中のプログラムの起動ディレクトリ

記述例　 bootdir → E:\dvl\BIN

CURDIR

str CURDIR[(
str dirname
)]

カレントディレクトリの値。
引数を与えると指定のカレントディレクトリに切りかえる。カレントディレクトリのスコープは現在の実行中のプログラム内であることに留意すること。

記述例１　 curdir → e:\lab\comlab\manual

記述例２　 curdir('E:\00temp') → E:\00temp

CD str CD( str dirname )
カレントディレクトリを切り替える。
コマンドの CD に似せるために設けた関数。

TEMPFILE

str TEMPFILE[(
str dirname
[ ,  str prefix]
)]

テンポラリファイルを作成し、そのファイル名を得る。
dirnameのディレクトリにprefixで始まるテンポラリファイルを作成し、名称を返す。
dirnameを省略するとシステムのテンポラリディレクトリ。 prefixを省略すると、"SPD"をプリフィックスとする。
通常の使用ならば、dirname , prefix の指定は必要無い。

記述例１　 tempfile → C:\DOCUME~1\YOU~1\LOCALS~1\Temp\SPD72.tmp

記述例２　 tempfile('e:\00temp') → e:\00temp\SPD73.tmp

記述例３　 tempfile('e:\00temp','test') → e:\00temp\tes74.tmp

BRESCOUNT int BRESCOUNT( str filename )
指定のファイルの追加リソースの数。
追加リソースは、binadd.exeで追加したもの。この関数は通常は使用しない。非公開の関数。

BRES bin BRES( str filename , int num )
指定のファイルの指定番号の追加リソース。
追加リソースは、binadd.exeで追加したもの。この関数は通常は使用しない。非公開の関数。
最初のリソースの番号は 0。多くの場合はファイル名として起動ファイルを指定するので、このときは、module関数を使用すると良い。

TICK

int TICK[(
式
)]

システム起動時からのmS単位の時間。
本来はDWの値なので、周期の半分を過ぎると負の値になってしまう。式を指定すると、式実行にかかった時間をmS単位で返却する。

記述例１　 tick → 2385785

記述例２　 tick(repeat(100000,sqrt(2.0))) → 125

WAIT

int WAIT( int mS )
mS 処理を待つ。
戻り値は引数 mS そのまま。

記述例　 wait(200) → 200

PID

int PID
プロセス ID の値

記述例　 pid → 3888

COMPUTER

str COMPUTER
コンピュータ名

記述例　 computer → WIN7SAMPODO

USER

str USER
ユーザー名

記述例　 user → You

SYSMETRIC

str SYSMETRIC(
str パラメータ名
)

システムメトリックの値。

ARRANGE	最小化ウィンドウの配置方法を示す値
CLEANBOOT	システムがどのように起動されたかを示す値（0: Normal boot 1: Fail-safe boot 2: Fail-safe with network boot
CMONITORS	モニターディスプレーの数
SM_CMOUSEBUTTONS	マウスボタンの数 (マウスがないときは 0)
CXBORDER CYBORDER	非立体的なウィンドウの縁の幅と高さ
CXCURSOR CYCURSOR	マウスカーソルのサイズ
CXDLGFRAME CYDLGFRAME	CXFIXEDFRAME / CYFIXEDFRAME と同じ
CXDOUBLECLK CYDOUBLECLK	ダブルクリックにおける 2 回目のクリック位置の許容範囲。1 回目のクリックの後、許容範囲内かつ許容時間内にもう一度マウスをクリックすると、ダブルクリックが行れたものとみなされる
CXDRAG CYDRAG	ドラッグ操作の開始とはみなされない範囲。マウスボタンを押した後、この範囲を越えてマウスを動かすと、ドラッグ操作が開始されたものとみなされる
CXEDGE CYEDGE	立体的なウィンドウの縁の幅と高さ
CXFIXEDFRAME CYFIXEDFRAME	タイトルバーを持ち、かつ、サイズが変更できないウィンドウにおける枠の幅と高さ
CXFRAME CYFRAME	CXSIZEFRAME / CYSIZEFRAMEと同じ
CXFULLSCREEN CYFULLSCREEN	最大化されたウィンドウのクライアント領域のサイズ
CXHSCROLL CYHSCROLL	水平スクロールバーの矢印の幅、または、水平スクロールバーの高さ
CXHTHUMB	水平スクロールバーのつまみの幅
CXICON CYICON	アイコンのデフォルトのサイズ
CXICONSPACING CYICONSPACING	アイコンを整列するときに使われるグリッドのサイズ
CXMAXIMIZED CYMAXIMIZED	最大化されたウィンドウのサイズ
CXMAXTRACK CYMAXTRACK	ウィンドウの最大トラッキングサイズ
CXMENUCHECK CYMENUCHECK	メニューのチェックマークのサイズ
CXMENUSIZE CYMENUSIZE	メニューバーに表示されるボタンのサイズ
CXMIN CYMIN	ウィンドウの最小サイズ
CXMINIMIZED CYMINIMIZED	最小化されたウィンドウのデフォルトのサイズ
CXMINSPACING CYMINSPACING	最小化されたウィンドウの配置に使われるグリッドのサイズ
CXMINTRACK CYMINTRACK	ウィンドウの最小トラッキングサイズを取得します。このサイズよりも小さくウィンドウの枠をドラッグすることはできない
CXSCREEN CYSCREEN	画面全体のサイズ
CXSIZE CYSIZE	ウィンドウのタイトルバー内のボタンのサイズ
CXSIZEFRAME CYSIZEFRAME	サイズが変更できるウィンドウにおける枠の幅と高さ
CXSMICON CYSMICON	小さいアイコンの推奨サイズ
CXSMSIZE CYSMSIZE	小さいタイトルバー内のボタンのサイズ
CXVIRTUALSCREEN CYVIRTUALSCREEN	仮想スクリーンの大きさ
CXVSCROLL CYVSCROLL	垂直スクロールバーの幅、または、垂直スクロールバーの矢印の高さ
CYCAPTION	タイトルバーの高さ
CYKANJIWINDOW	画面下の漢字ウィンドウの高さ
CYMENU	一行分のメニューバーの高さ
CYSMCAPTION	小さなタイトルバーの高さ
CYVTHUMB	垂直スクロールバーのつまみの高さ
DBCSENABLED	USER.EXE がダブルバイト文字セット (DBCS) をサポートしているかどうかを示す値。サポートしているときは 0 以外の値、サポートしていないときは 0
DEBUG	USER.EXE がデバッグバージョンかどうかを示す値。デバッグバージョンのときは 0 以外の値、デバッグバージョンでないときは 0
MENUDROPALIGNMENT	メニューバーの項目に対して、ドロップダウンメニューが右寄せされるかどうかを示す値。右寄せされるときは 0 以外の値が、左寄せされるときは 0
MIDEASTENABLED	ヘブライ語やアラビア語が利用可能なシステムかどうかを示す値。利用できるときは TRUE
MOUSEPRESENT	マウスが接続されているかどうかを示す値。接続されているときは 0 以外の値が、接続されていないときは 0
MOUSEWHEELPRESENT	ホイールを持つマウスが接続されているかどうかを示す値。接続されているときは 0 以外の値が、接続されていないときは 0
NETWORK	ネットワークが存在するかどうかを示す値。存在するときは最下位ビットが 1 の値、そうでないときは最下位ビットが 0 の値。最下位ビット以外のビットは予約済み
PENWINDOWS	Window for Pen computing extensions がインストールされているかどうかを示す値。インストールされているときは 0 以外の値が、インストールされていないときは 0
SECURE	セキュリティが存在するかどうかを示す値。存在するときは TRUE が、存在しないときは FALSE
SAMEDISPLAYFORMAT	全てのディスプレーモニターが同じカラー形式かを示す値。同じならばTRUE
SHOWSOUNDS	ユーザー補助の「サウンド解説を使う」が有効になっているかどうかを調べる。有効になっているときは 0 以外の値、そうでないときは 0
SLOWMACHINE	コンピュータのプロセッサが遅いかどうかを示す値。遅いときは TRUE 、それ以外のときは FALSE
SWAPBUTTON	左右のマウスボタンの機能を交換しているかどうかを示す値を。交換しているときは 0 以外の値、交換していないときは 0
XVIRTUALSCREEN YVIRTUALSCREEN	仮想スクリーンの左上の座標

SYSFOLDER

string SYSFOLDER(
パラメータ名
)

パラメータ名に相当するシステムフォルダ名を返却する。
パラメータ名の英大文字小文字は区別しない。

APPDATA	File system directory that serves as a common repository for application-specific data.
BITBUCKET	File system directory containing file objects in the user's Recycle Bin. The location of this directory is not in the registry; it is marked with the hidden and system attributes to prevent the user from moving or deleting it.
COMMON_ALTSTARTUP	File system directory that corresponds to the nonlocalized Startup program group for all users.
COMMON_DESKTOPDIRECTORY	File system directory that contains files and folders that appear on the desktop for all users.
COMMON_FAVORITES	File system directory that serves as a common repository for all users' favorite items.
COMMON_PROGRAMS	File system directory that contains the directories for the common program groups that appear on the Start menu for all users.
COMMON_STARTMENU	File system directory that contains the programs and folders that appear on the Start menu for all users.
COMMON_STARTUP	File system directory that contains the programs that appear in the Startup folder for all users.
CONTROLS	Virtual folder containing icons for the Control Panel applications.
COOKIES	File system directory that serves as a common repository for Internet cookies.
DESKTOP	Windows Desktop--virtual folder at the root of the namespace.
DESKTOPDIRECTORY	File system directory used to physically store file objects on the desktop (not to be confused with the desktop folder itself).
DRIVES	My Computer--virtual folder containing everything on the local computer: storage devices, printers, and Control Panel. The folder may also contain mapped network drives.
FAVORITES	File system directory that serves as a common repository for the user's favorite items.
FONTS	Virtual folder containing fonts.
HISTORY	File system directory that serves as a common repository for Internet history items.
INTERNET	Virtual folder representing the Internet.
INTERNET_CACHE	File system directory that serves as a common repository for temporary Internet files.
NETHOOD	File system directory containing objects that appear in the network neighborhood.
NETWORK	Network Neighborhood Folder--virtual folder representing the top level of the network hierarchy.
PERSONAL	File system directory that serves as a common repository for documents.
PRINTERS	Virtual folder containing installed printers.
PRINTHOOD	File system directory that serves as a common repository for printer links.
PROGRAMS	File system directory that contains the user's program groups (which are also file system directories).
RECENT	File system directory that contains the user's most recently used documents.
SENDTO	File system directory that contains Send To menu items.
STARTMENU	File system directory containing Start menu items.
STARTUP	File system directory that corresponds to the user's Startup program group. The system starts these programs whenever any user logs onto Windows NT or starts Windows 95.
TEMPLATES	File system directory that serves as a common repository for document templates.

HITICK

flt HITICK[(
式
)]

高精度タイマーの値。
式を指定すると、式実行にかかった時間を返却する。この値を HITICKFREQ で割ると秒単位の時間となる。

記述例１　 hitick → 6586622842.0

記述例２　 hitick(repeat(100000,sqrt(2.0))) → 332588.0

記述例３　 hitick(repeat(100000,sqrt(2.0)))/hitickfreq → 0.11375568879892205

HITICKFREQ

int HITICKFREQ
高精度タイマーの１秒当りのカウント。
マシンによって異なる。

記述例　 hitickfreq → 2760029.0

CLIP

str CLIP(
str 文字列
)

文字列をクリップボードに入れる。
戻り値はその文字列。

記述例　 clip('abc') → abc

PASTE

str PASTE
クリップボードの文字列。

記述例　 paste → abc

SETSTDIN

str SETSTDIN(
str ファイル名
)

現在のプロセスの標準入力を指定のファイルに切り替える。
ファイル処理と矛盾無く使用するのは難しい。通常は使用しない。

記述例　 setstdin('input.txt')

SETSTDOUT

str SETSTDOUT(
[ str ファイル名 ]
)

現在のプロセスの標準出力を指定のファイルに切り替える。
ファイル名を省略すると標準出力は標準エラー出力に対して行う。
ファイル名の先頭に「+」をつけるとファイルに対して追加を行う。ファイル処理と矛盾無く使用するのは難しい。通常は使用しない。

記述例　 setstdout('output.txt')

SETSTDERR

str SETSTDERR(
[ str ファイル名 ]
)

現在のプロセスの標準エラー出力を指定のファイルに切り替える。
ファイル名の先頭に「+」をつけるとファイルに対して追加を行う。ファイル名を省略すると標準エラー出力を標準出力に対して行う。

記述例　 setstderr('error.txt')

STDOUT str STDOUT( str 文字列 )
文字列を標準出力に出力する。戻り値は引数の文字列。

ERROUT str ERROUT( str 文字列 )
文字列を標準エラー出力に出力する。戻り値は引数の文字列。

NOWTIME

str NOWTIME
現在時刻をFILETIME関数と同じ形式で返却する。

記述例　 nowtime → 01D0637BE4F78BA0

LOCALTIME

str LOCALTIME
現在時刻を YYYY/MM/DD HH:MM:SS の形で返す。

記述例　 localtime → 2015/03/21 11:08:16

NOW

str NOW
現在時刻を HH:MM:SS の形で返す。

記述例　 now → 11:08:16

TODAY

str TODAY
本日日付を YYYY/MM/DD の形で返す。

記述例　 today → 2015/03/21

ISDATE

bool ISDATE(
{
str 日付文字列
|
int 西暦年
, int 月
, int 日
}
)

日付が正しければ真を返す。

記述例１　 isdate('1972/01/31') → TRUE

記述例２　 isdate(1972,1,31) → TRUE

記述例３　 isdate(1972,2,31) → FALSE

ISLEAP

bool ISLEAP(
int 西暦年
)

うるう年なら真を返す。

記述例　 isleap(2012) → TRUE

YEARNUM

int YEARNUM(
int 西暦年
)

その年の元日の通算計算日を返す。

記述例　 yearnum(2012) → 734502

MONTHNUM

int MONTHNUM(
int 西暦年
, int 月
)

その月の一日の通算計算日を返す。

記述例　 monthnum(2012,4) → 734593

DAYNUM

int DAYNUM(
{
str 日付文字列
|
int 西暦年
, int 月
, int 日
}
)

その日の通算計算日を返す。

記述例１　 daynum('2012/3/15') → 734576

記述例２　 daynum(today) → 735677

記述例３　 daynum(2012,3,15) → 734576

DAYOFWEEK

 DAYOFWEEK(
{
str 日付文字列
|
int 西暦年
, int 月
, int 日
}
[ , int モード ]
)

その日の曜日を返す。
モード：0 では、曜日を表す数字を返す。
モード：1 では、日本語表示、モード:2 では、英語表示。

記述例１　 dayofweek('2012/3/15') → 4

記述例２　 dayofweek(today,1) → 土曜日

記述例３　 dayofweek(2012,3,15,2) → Thursday

DAYSOFMONTH

int DAYSOFMONTH(
int 西暦年
, int 月
)

その月の日数を返す。

記述例　 daysofmonth(2012,2) → 29

DATEFROMNUM

 str DATEFROMNUM(
int 通算日
[ , bool 日本語フラグ ]
)

通算日が表す日付文字列を返す。
日本語フラグを真にすると、できるだけ元号を用いて返す。

記述例１　 datefromnum(734576) → 2012/03/15

記述例２　 datefromnum(734576,true) → 平成24年3月15日

YEARSTR

 str YEARSTR(
int 西暦年
)

元号を用いた年表記を返す。
近年の年号にのみ対応している。

記述例　 yearstr(1900) → 明治33年

記述例　 yearstr(2012) → 平成24年

AGE

int AGE(
{
str 誕生日の日付文字列
|
int 誕生日の西暦年
, int 誕生日の月
, int 誕生日の日
}
, 
{
str 対象日付文字列
|
int 対象西暦年
, int 対象月
, int 対象日
}
)

年齢を計算して返す。

記述例　 age('昭和40年11月13日',today) → 49

記述例　 age(1990,1,1,2012,4,5) → 22

ETO12

 ETO12(
int 西暦年
[ , int モード ]
)

十二支をコードで返す。
モード:0 では数字で返す。
モード:1 では、ひらがな、モード:2 では漢字で返す。

記述例１　 eto12(2012) → 4

記述例２　 eto12(2012,1) → たつ

記述例３　 eto12(2012,2) → 辰

ETO10

 ETO10(
int 西暦年
[ , int モード ]
)

十干をコードで返す。
モード:0 では数字で返す。
モード:1 では、ひらがな、モード:2 では漢字で返す。

記述例　 eto10(2012) → 8

記述例　 eto10(2012,1) → みずのえ

記述例　 eto10(2012,2) → 壬

ファイルシステム

GLOB

str GLOB
または

str GLOB(
str パターン )

または

str GLOB(
str ディレクトリ名
, str パターン
[ , bool パスフラグ ]
）

または

str GLOB(
str ディレクトリ名
, bool パスフラグ
)

指定フォルダのファイル一覧を行単位で連結した文字列を返す。
ディレクトリ名を省略するとカレントフォルダ。
パターンは、ワイルドカードで指定する。省略、あるいは、"" では"*.*"。ディレクトリ名を付加しない場合はディレクトリ名つきで指定できる。
パスフラグを FALSE にすると出力にパスを付加しない。
この関数は、システム属性、隠し属性が設定されているファイルは出力しない。

記述例１　 glob →

result.bin↓
temp.txt↓
test.txt↓

記述例２　 glob('*.txt') →

temp.txt↓
test.txt↓

記述例３　 glob('e:\00temp\demo','*.txt',true) →

e:\00temp\demo\temp.txt↓
e:\00temp\demo\test.txt↓

GLOBEX str GLOBEX
または
str GLOBEX( str パターン )
または
str GLOBEX( str ディレクトリ名 , str パターン [ , bool パスフラグ ] ）
または
str GLOBEX( str ディレクトリ名 , bool パスフラグ )
指定フォルダのファイル一覧を行単位で連結した文字列を返す。
GLOB関数と同様に働くが、この関数は、システム属性、隠し属性が設定されているファイルも出力する。

GLOBDIR str GLOBDIR
または
str GLOBDIR( str パターン )
または
str GLOBDIR( str ディレクトリ名 , str パターン [ , bool パスフラグ ] ）
または
str GLOBDIR( str ディレクトリ名 , bool パスフラグ )
指定フォルダのフォルダ一覧を行単位で連結した文字列を返す。
システム属性、隠し属性が設定されているフォルダは出力しない。記述方法は GLOBと同じ。

GLOBDIREX str GLOBDIREX
または
str GLOBDIREX( str パターン )
または
str GLOBDIREX( str ディレクトリ名 , str パターン [ , bool パスフラグ ] ）
または
str GLOBDIREX( str ディレクトリ名 , bool パスフラグ )
指定フォルダのフォルダ一覧を行単位で連結した文字列を返す。
システム属性、隠し属性が設定されているフォルダも出力する。記述方法は GLOBと同じ。

GLOBS str GLOBS
または
str GLOBS( str パターン )
または
str GLOBS( str ディレクトリ名 , str パターン [ , bool パスフラグ ] ）
または
str GLOBS( str ディレクトリ名 , bool パスフラグ )
指定フォルダのフォルダ／ファイル一覧を行単位で連結した文字列を返す。
システム属性、隠し属性が設定されているフォルダ／ファイルは出力しない。記述方法は GLOBと同じ。

GLOBSEX str GLOBSEX
または
str GLOBSEX( str パターン )
または
str GLOBSEX( str ディレクトリ名 , str パターン [ , bool パスフラグ ] ）
または
str GLOBSEX( str ディレクトリ名 , bool パスフラグ )
指定フォルダのフォルダ／ファイル一覧を行単位で連結した文字列を返す。
システム属性、隠し属性が設定されているフォルダ／ファイルも出力する。記述方法は GLOBと同じ。

FILECOPY

int FILECOPY(
str 転送元ファイル名
, str 転送先ファイル名
[ , bool チェックフラグ ]
)

ファイルを複写する。
チェックフラグをTRUEにすると転送先のファイルが存在する場合には複写しない。
戻り値はエラーコード。正常に終了した場合には０を返す。

記述例１　 filecopy('dlx.txt','backup.txt') → 0

記述例２　ファイルが既に存在する場合、戻り値が
filecopy('dlx.txt','backup.txt',true) → 80

FILEDELETE

str FILEDELETE(
str ファイル名
)

ファイルを削除する。戻り値はファイル名。

記述例　 filedelete('backup.txt') → backup.txt

FILEMOVE

str FILEMOVE(
str 移動元名
, str 移動先名
)

ファイル、フォルダーを移動する。

記述例　 filemove('test.txt','test2.txt') → test.txt

DIRMAKE

str DIRMAKE(
str ディレクトリ名
[ , bool 強制フラグ ]
)

フォルダーを作る。
通常は、指定したディレクトリ名の親フォルダーがないとフォルダを作成できないが、強制フラグを真にすると、親の方向にたどって必要なフォルダも作成する。

記述例１　 dirmake('demo') → demo

記述例２　 filemove('my\demo',true) → my\demo

DIRDELETE

str DIRDELETE(
str ディレクトリ名
)

フォルダーを削除する。
フォルダーは空で無ければならない。

記述例　 dirdelete('demo') → demo

EXIST

bool EXIST(
str ファイル名
)

ファイルが存在すれば真。

記述例　 exist('test.txt') → TRUE

ISDIR

bool ISDIR(
str ディレクトリ名
)

ディレクトリが存在すれば真。

記述例　 isdir('demo') → TRUE

ISDRIVE

bool ISDRIVE(
str ドライブ名
)

ドライブが存在すれば真。
ドライブ名は英字＋「:」の形で指定する。

記述例　 isdrive('C:') → TRUE

ISREADY

bool ISREADY(
str ドライブ名
)

ドライブがレディであれば真。
ドライブ名は英字＋「:」の形で指定する。

記述例　 isdrive('C:') → TRUE

FILEDATE

str FILEDATE(
str ファイル名
[ , bool 時間フラグ ]
)

ファイルの日付を表わす８桁の文字列。YYYYMMDDの形式。
時間フラグを真にするとYYYY/MM/DD HH:MM:SS 形式で日付と時間を返す。

記述例１　 filedate('test.txt') → 20120403

記述例２　 filedate('result.txt',true) → 2012/04/03 13:43:25

FILESIZE

 FILESIZE(
str ファイル名
)

ファイルサイズ。
残念ながら以下の制限がある。

ファイルの大きさが2147483648未満の場合は整数値。
ファイルの大きさが2147483648以上の場合は実数値。
ファイルの扱いでエラーが生じた場合はエラーとなり、処理を中断する。

記述例　 filesize('test.txt') → 475

FILETIME

str FILETIME(
str ファイル名
)

ファイルのタイムスタンプを表わす１６桁の文字列。
大小関係でファイルの新旧が比較できるように保証されている。
ファイルの扱いでエラーが生じた場合は長さ0の文字列が返る。

記述例　 filetime('test.txt') → 01CD11544E34DDE8

ISUPDATE

bool ISUPDATE(
str ターゲットファイル名
, str 参照ファイル名
)

ターゲットファイルと参照ファイルの日付を比較して変更の有無を検証する。

参照ファイルが存在しなければ、FALSE
参照ファイルが存在し、ターゲットファイルが存在しなければ、TRUE
参照ファイルとtargが存在する場合は、ターゲットファイルの日付が参照ファイルより古い場合に TRUE
（等しい場合は FALSE ）

記述例　 isupdate('new.txt','old.txt') → TRUE

PATH

str PATH(
str パス名
)

パス名のうち、パス部分（ドライブ名＋ディレクトリ名）。
最後の「\」は省かれている。

記述例　 path('E:\TEST\SAMPLE.TXT') → E:\TEST

FILENAME

str FILENAME(
str パス
)

パスのうち、ファイル名部分（ベース名＋拡張子）。

記述例　 filename('e:\00temp\test.txt') → test.txt

BASENAME

str BASENAME(
str パス
)

パスのうち、ベース名部分。

記述例　 basename('e:\00temp\test.txt') → test

EXPNAME

str EXPNAME(
str パス
)

パスのうち、拡張子部分。

記述例１　 expname('e:\00temp\test.txt') → .txt

記述例２　 expname('e:\00temp\test') →

PATHNAME

str PATHNAME(
str パス
)

パスのうち、拡張子を除いた。

記述例１　 pathname('e:\00temp\test.txt') → e:\00temp\test

記述例２　 pathname('e:\00temp\test') → e:\00temp\test

PATHCONC

str PATHCONC(
str パス
, str ファイル名
)

パスとファイル名を結合する。
PATH()とFILENAME()で分解したものを再結合できる。
パスの末尾に \ が有っても良い

記述例　 pathconc('e:\00temp','test.txt') → e:\00temp\test.txt

ABSNAME

str ABSNAME(
str パス
)

絶対パス名に変換。

記述例　 absname('test.txt') → e:\00temp\test.txt

環境変数

ISENV

bool ISENV(
str 環境変数名
)

環境変数が存在して値があれば真。

記述例　 isenv('path') → TRUE

ENV

str ENV(
str 環境変数名
[ , str 値 ]
)

環境変数の値。
値を書くとそれを環境変数に代入する。環境変数の値を返す。
環境変数は、変数として引用、代入ができるが、代入した値をTSEXPR以外で利用する場合には、ENVを用いた方が良い。
また、ENVは、変数名より広い範囲の変数名を利用できるので、変数名の規約を外れた環境変数をアクセスする場合に使用できる。

記述例１　 env('myprog','first') → first

記述例２　 env('myprog') → first

CLRENV

bool CLRENV(
str 環境変数名
)

環境変数を削除する。
成功したら TRUE を返す。

記述例　 clrenv('myprog') → TRUE

ENVLIST

bool ENVLIST
現在の環境変数名のリスト。
環境変数名の末尾には行末 (LF 0x0a) が付加される。

記述例　 envlist

ENVPATH str ENVPATH [( [ str パス [ , bool 追加フラグ ] ] ) ]
環境変数 PATH の内容。
パスを書くと、環境変数 PATH の末尾にパスを追加する。追加フラグに FALSE を設定すると環境変数 PATH の先頭にパスを追加する。

QSCOUNT

int QSCOUNT
QS_ARGCを整数化した値。

記述例　 { qsarg('name','face'); qscount; } → 2

QSENV

str QSENV
[(
[ bool 全数フラグ ]
)]

QSC.EXEで実行されるスクリプトの引数を表す QS_ARGn を行末 (LF 0x0a) で連結した文字列。
全数フラグを偽にすると引数並びの後方の長さ０の引数は無視する。
引数の数は、QS_ARGC で求め、その範囲で QS_ARGn の値を求める。存在しない引数は、その値を空文字列として扱っている。

記述例１　 { qsarg('name','face'); qsenv; } →

name↓
face↓

記述例２　 { qsarg('name','face','',''); qsenv; } →

name↓
face↓
↓
↓

記述例３　 { qsarg('name','face','',''); qsenv(FALSE); } →

name↓
face↓

QSARG

int QSARG(
[
str 引数
[ , str 引数 ]*
]
)

引数を環境変数 QS_ARGn に代入する。
引数を書かなければ、QS_ARGnはすべてクリアされる。
引数の数は QS_ARGCに設定する。戻り値は引数の数。

記述例　 { qsarg('name','face'); comma($qs_argc,$qs_arg1,$qs_arg2); } → 2,name,face

AR2QSARG

int AR2QSARG(
[
配列名
[ , int 個数 ]
]
)

配列の要素を環境変数 QS_ARGn に代入する。
また、要素の数を QS_ARGCに設定する。戻り値は要素の数。
個数を指定すると先頭から指定個数だけ代入する。
引数を省略すると配列変数 ARG の内容を代入する。

記述例　
{ar_clear(a); a[0]:='name'; a[1]:='face'; ar2qsarg(a);} → 2
確認する　
comma($qs_argc,$qs_arg1,$qs_arg2) → 2,name,face

QSARG2AR

int QSARG2AR(
[ 配列名 ]
)

要素を環境変数 QS_ARGn すべてを文字列として配列に代入する。
配列名を省略すると、配列変数 ARG に代入する。配列は代入の前にクリアする。
代入する数は、実際は QS_ARGCで要素の数を判定している。

記述例　
{qsarg('computer','buf');qsarg2ar(a);} → 2
確認する　
ar2str(a) → computer,buf

QSSHIFT

int QSSHIFT
要素を環境変数 QS_ARGn を番号の若い方へ一つシフトする。
戻り値は、QS_ARGn の数。

記述例　
{qsarg('a','b','c','d'); strconcix(#(-1),comma,$(ix+1));} → a,b,c,d
{qsshift; strconcix(#(-1),comma,$(ix+1));} → b,c,d
{qsshift; strconcix(#(-1),comma,$(ix+1));} → c,d

int QSSHIFT( int シフト数 )
要素を環境変数 QS_ARGn を番号の若い方へシフト数分だけシフトする。
シフト数は正の整数であること。戻り値は、QS_ARGn の数。

記述例　
{qsarg('a','b','c','d'); strconcix(#(-1),comma,$(ix+1));} → a,b,c,d
{qsshift(2); strconcix(#(-1),comma,$(ix+1));} → c,d

PUSHQSARG

int PUSHQSARG[( )]
環境変数の要素 QS_ARGn をスタックに退避する。
退避した個数を返却する。

記述例　
{qsarg('seo','komo'); strconcix(#(-1),comma,$(ix+1));} → seo,komo
pushqsarg → 2
スタックの内容を確認する
{strconcix(3,comma,peep(ix));} → 2,komo,seo

POPQSARG

int POPQSARG[( )]
スタックから環境変数 QS_ARGn を回復する。
回復した環境変数の個数を返す。 PUSHQSARG に対応する使い方をすること。

記述例　
{ qsarg('seo','komo'); strconcix(#(-1),comma,$(ix+1));} → seo,komo
pushqsarg → 2
{ qsarg('aiai','holoholo');strconcix(#(-1),comma,$(ix+1));} → aiai,holoholo
popqsarg → 2
確認する




{ strconcix(#(-1),comma,$(ix+1));} →
seo,komo

QSOPTION bool QSOPTION( [ str オプション文字列 ] )
環境変数 QS_ARGn を解析してファイルとオプションに分類する。
オプション文字列は１文字が一つのオプションを表す。ここに記されていないオプションを指定した場合は偽を返す。
解析した後、ファイル名は、配列 ARGに格納する。配列 ARG の大きさがファイル名の個数である。
オプションは連想配列 ARG に格納する。キーはオプションの先頭の一文字で、後続の文字列が値である。キーは半角英字の場合は半角大文字に変換される。単独で「-」が現れた場合は、以降の項目はオプションではなくファイル名として扱う。引数で指定しなかったオプションも格納する。
オプション文字列を省略するとオプション文字列として""を使用する。この場合は戻り値は意味がない。

AR2ARG int AR2ARG( int 配列名 [ , int 開始位置 ] )
配列の要素を解析してファイルとオプションに分類する。結果のファイル名の個数を返す。
解析する要素の開始位置を指定できる。省略すると 0 （最初の要素）
解析した後、ファイル名は、配列 ARGに格納する。配列 ARG の大きさがファイル名の個数である。
オプションは連想配列 ARG に格納する。キーはオプションの先頭の一文字で、後続の文字列が値である。キーは半角英字の場合は半角大文字に変換される。単独で「-」が現れた場合は、以降の項目はオプションではなくファイル名として扱う。引数で指定しなかったオプションも格納する。

QSOPT bool QSOPT( str オプション文字 )
連想配列 ARG にオプション文字がキーとして登録されていれば真を、無ければ偽を返す。
ASAR_HASKEY(ARG,オプション文字)と等価な関数だが、簡易に書くために設けられている。
CMDARG_*** の一連の関数や、QSOPTION でオプション解析をした後、この関数を使うと簡易にオプションの存在を知ることが出来る。

QSOPTCK bool QSOPTCK( str オプション文字列 )
連想配列 ARG のすべてのキーが、オプション文字列に含まれていれば真を返す。
CMDARG_*** の一連の関数や、QSOPTION でオプション解析をした後、この関数を使うと簡易に不正なオプションを検出できる。

モダンな正規検索

PAT

int PAT( [int パターン番号 , ] str パターン [ , {int オプション | str オプション }] )
モダンな正規検索のパターンをコンパイルして、指定の番号（number）のパターンバッファにセットする。
パターンバッファはプログラム中では共通してアクセスできる。番号は、0 から 255 の範囲で指定する。
パターン番号を省略したり、負の値を指定すると、パターンを「自動割当」する。
オプションは、ビットフラグ、または、文字列でパターンへのオプションを表す。
パターン番号を返す。

　「自動割当」では、既存のパターンの中に、同じオプションかつ、同じパターン文字列を持つパターンがあれば、そのパターンを返す。このとき、コンパイルは行われない。
　既存のパターンの中に該当するものが無ければ、空いているパターンを使用する。空いているパターンがなければ最も古いパターンを使用する。

ビットフラグでのオプション指定

bit	value
0	1	半角英字の大文字小文字を同一視
1	2	全角英字の大文字小文字を同一視
2	4	空白無視モード

文字列でのオプション指定。指定するオプションを含む文字列。例："ix"

文字
i	半角英字の大文字小文字を同一視
I	半角英字の大文字小文字を同一視。全角英字の大文字小文字も同一視
x	空白無視モード

記述例１　 pat('\d+','i') → 0

記述例２　 pat(4,'^\d+') → 4

^ str パターン および
~ str パターン
パターンを表す文字列に「^」または、「~」をつける略記法である。
パターンを自動割当して、割り当てたパターン番号を返す。^は半角英字大文字小文字を区別しないが、~は区別する。

記述例１　 ^'\w+' → 1

記述例２　 ~'\w+' → 2

MATCH

bool MATCH(
int パターン番号
, str 検索対象
[ , int 検索開始位置 ]
)

指定番号のパターンで検索対象を正規検索する。
一致すると真を返し、不一致ならば、偽を返す。一致した場合は、以降で、後述の MATCHSTR などが利用できるようになる。
検索開始位置の指定を、省略すれば 0 、すなわち、文字列の先頭から検索を行う。位置が負の場合は、0 として扱う。

記述例１　パターンをその場で書く：パターン番号は自動で割り振られる
match(~'japan','all Japan') → TRUE

記述例２　パターンをその場で書く：パターン番号を自分で指定
match(pat(1,'japan','i'),'all japan') → TRUE

記述例３　パターンをあらかじめ用意する：事前にコンパイルしておけば、処理は速くなる。パターン番号は自動割当
{a:=~'japan'; match(a,'all Japan');} → TRUE

記述例４　パターンをあらかじめ用意する：固定のパターンを使用した場合。この場合も処理は速くなる
match(pat(1,'japan','i'),'all japan') → TRUE

FIND

FIND(
int パターン番号
, str 検索対象
[ , int 検索開始位置 ]
)

指定番号のパターンで検索対象を正規検索する。
一致すると一致した文字列を返し、一致しなければ論理値 FALSE を返す。

詳細はMatch()を参照のこと。

MATCHRESULT

int MATCHRESULT
直前の検索で一致したパターン番号を返却する。一致していない、あるいは検索されていない場合は負の値を返す。

記述例１　 { match(~'japan','all Japan'); matchresult; } → 1

記述例２　 { match(^'japan','all Japan'); matchresult; } → -1

MATCHSTR

str MATCHSTR または

str MATCHSTR(
int 機能番号
[ , int パターン番号 ]
)

直前の検索結果の部分文字列などを返す。
パターン番号を省略すると直前の検索結果を参照する。
MATCHSTR だけを書くと直線の検索結果の一致文字列を返す。

機能番号
-2	一致文字列より前の文字列
-1	一致文字列より後ろの文字列
0	一致文字列
1 以上	該当番号の部分文字列

記述例１　
{ match(~'of','All of Me'); matchstr; } → of
matchstr(-2) → All
matchstr(-1) → Me

記述例２　
match(~'([a-z]+) +(\d+)','old train 45') → TRUE
matchstr(0) → train 45
matchstr(1) → train
matchstr(2) → 45

MS str MS または
str MS( int 番号 [ , int パターン番号 ] )
MATCHSTR の略記

MS2AR int MS2Ar( 配列名 [ , int パターン番号 ] )
一致文字列と部分文字列を配列に格納する。戻り値は格納した数。
配列の最初の要素は一致文字列。二番目以降に部分文字列を格納する。

MATCHPOS

int MATCHPOS または

int MATCHPOS(
int 機能番号
[,int パターン番号 ]
)

直前の検索結果の部分文字列などの先頭位置を返す。
検索対象文字列先頭を 0 とする文字単位の位置。
パターン番号を省略すると直前の検索結果を参照する。
MATCHPOS だけを書くと直前の検索結果の一致文字列の先頭。
マッチしていない部分文字列などを指定すると-1を返す。

機能番号
0	一致文字列の先頭位置
1 以上	該当番号の部分文字列の先頭位置

記述例　
match(~'([a-z]+) +(\d+)','old train 45') → TRUE
comma(matchpos(0),matchstr(0)) → 4,train 45
comma(matchpos(1),matchstr(1)) → 4,train
comma(matchpos(2),matchstr(2)) → 10,45

MP int MP または
int MP( int 機能番号 [ , int パターン番号 ] )
MATCHPOS の略記。

MP2AR int MP2Ar( 配列名 [ , int パターン番号 ] )
一致文字列と部分文字列の先頭位置を配列に格納する。戻り値は格納した数。
配列の最初の要素は一致文字列の先頭位置。二番目以降に部分文字列の先頭位置を格納する。

MATCHEND

int MATCHEND または

int MATCHEND(
int 機能番号
[ , int パターン番号 ]
)

直前の検索結果の部分文字列などの末尾位置（次の文字）を返す。
検索対象文字列先頭を0とする文字単位の位置。
MATCHEND だけを書くと直前の検索結果の一致文字列の末尾。
パターン番号を省略すると直前の検索結果を参照する。
マッチしていない部分文字列などを指定すると-1を返す。

機能番号
0	一致文字列の末尾位置
1 以上	該当番号の部分文字列の末尾位置

記述例　
match(~'([a-z]+) +(\d+)','old train 45') → TRUE
comma(matchpos(0),matchend(0),matchstr(0)) → 4,12,train 45
comma(matchpos(1),matchend(1),matchstr(1)) → 4,9,train
comma(matchpos(2),matchend(2),matchstr(2)) → 10,12,45

ME int ME または
int ME( int 機能番号 [ , int パターン番号 ] )
MATCHEND の略記。

ME2AR int ME2Ar( 配列名 [ , int パターン番号 ] )
一致文字列と部分文字列の末尾位置を配列に格納する。戻り値は格納した数。
配列の最初の要素は一致文字列の末尾位置。二番目以降に部分文字列の末尾位置を格納する。

MATCHMARK

int MATCHMARK(
int 機能番号
[ , int パターン番号 ]
)

直前の検索結果のマーク（\/）位置を返す。
検索対象文字列先頭を0とする文字単位の位置。
パターン番号を省略すると直前の検索結果を参照する。
セットされていないマークを指定すると-1を返す。

機能番号
0	マークの数
1 以上	該当番号のマークの位置

記述例　
match(~'\/[a-z]+\/ +\d+','old train 45') → TRUE
comma(matchmark(0),matchmark(1),matchmark(2)) → 2,4,9

MM int MM( int 機能番号 [ , int パターン番号 ] )
MATCHMARK の略記。

MM2AR int MM2Ar( 配列名 [ , int パターン番号 ] )
マーク位置を配列に格納する。戻り値は格納した数。

REPLACE

str REPLACE(
int パターン番号
, str 検索対象
, str 置換式
)

指定番号のパターンで検索対象を正規検索し、一致部分を置換式で置き換える。
置換式の式中では相当する MATCHSTR / MATCHPOS / MATCHEND /MATCHMARK が使える。置換は一度だけ行う。

記述例　 replace(^'japan','all japan and japan animations',kakko(ms,'america')) → all (japan,america) and japan animations

REPLACEALL

str REPLACEALL(
int パターン番号
, str 検索対象
, str 置換式
)

指定番号のパターンで検索対象を正規検索し、一致部分すべてを置換式で置き換える。
置換式の式中では相当する MATCHSTR / MATCHPOS / MATCHEND / MATCHMARK が使える。また、IX で０から始まる序数を参照できる。一致部分が現れる度に置換式を再計算する。

記述例　 replaceall(^'japan','all japan and japan animations',kakko(ix+1,ms,'america')) → all (1,japan,america) and (2,japan,america) animations

MATCHALL

int MATCHALL(
int パターン番号
, str 検索対象
, 評価式
)

指定番号のパターンで検索対象を正規検索し、一致すると評価式を評価する。
最終的に一致した個数を返す。
評価式の中では相当する MATCHSTR / MATCHPOS / MATCHEND / MATCHMARK が使える。また、IX で０から始まる序数を参照できる。一致部分が現れる度に評価式を再計算する。

記述例　
{a:=''; matchall(^'japan','all japan and japan animations',a+=kado(mp,me,ms));} → 2
a → [4,9,japan][14,19,japan]

MATCHALL_AR int MATCHALL_AR( int パターン番号 , str 検索対象 , 配列名１ [ , 配列名２ [ , 配列名３ ] ] )
指定番号のパターンで検索対象を正規検索し、一致した文字列などを配列に格納する。
最終的に一致した個数を返す。
配列１には一致文字列を格納する。配列２には一致文字列の開始位置、配列２には一致文字列の終了位置を格納する。

SPLIT

str SPLIT(
int パターン番号
, str 対象文字列
, 配列名
)

指定番号のパターンをセパレータとして対象文字列を分割し、配列に格納する。
配列はクリアされる。

記述例　
split(~' *(:|;) *','abc;def : hij',a) → 3
ar2str(a) → abc,def,hij

SPLITLN

str SPLITLN(
int パターン番号
, str 対象文字列
[ , str 出力セパレータ ]
)

指定番号のパターンをセパレータとして対象文字列を分割する。
出力セパレータを記述した場合は、これらを出力セパレータを挟んで連結した文字列を返す。省略した場合は、行として末尾に行末 (LF 0x0a) をつけて連結した文字列を返す。

記述例１　 splitln(~' *(:|;) *','abc;def : hij') →

abc↓
def↓
hij↓

記述例２　 splitln(~' *(:|;) *','abc;def : hij',tab) →
abc→def→hij

記述例３　 splitln(~' *(:|;) *','abc;def : hij',comma) → abc,def,hij

SPLIT2SVAR

int SPLIT2SVAR(
int パターン番号
, str 対象文字列
[ , int 開始番号 ]
)

指定番号のパターンをセパレータとして対象文字列を分割し、開始番号から始まる番号の固有文字列変数に格納する。
分割した個数を返す。
過去のバージョンと互換性を保つために残してある機能。固有文字列変数は使用する必要がない。

記述例　
c:=split2svar(~' *(:|;) *','abc;def : hij') → 3
svar2field(0,c) →
abc→def→hij

コマンドライン実行機能

EXEC

str EXEC(
str コマンドライン
[
, str 入力文字列 ]
)

コマンドラインを実行し、その標準出力を文字列とする。
入力文字列を書けば、それをコマンドの標準入力とする。コマンドラインから受け取ったデータは行単位で扱い、各行末にはLF(0x0a）をつけて連結する。

記述例１　 exec('decho abc def') →

abc↓
def↓

記述例２　 exec('cshft -fC',lf('abc','def')) →

ABC↓
DEF↓

EXECQ

str EXECQ(
str コマンドライン
[ , str 入力文字列 ]
)

EXEC関数と同様だが、戻り値は、標準出力の１行目を返す。（行末コードは含まない）。

記述例　 execq('cshft -fC',lf('abc','def')) → ABC

EXEC_AR

int EXEC_AR(
配列名
, str コマンドライン
[ , str 入力文字列 ]
)

コマンドラインを実行し、その標準出力の各行を配列に格納する。
戻り値は格納した行数。
入力文字列を書けばそれをコマンドの標準入力とする。

記述例　
{exec_ar(a,'cshft -fC',lf('abc','def'));} → 2
ar2str(a) → ABC,DEF

EXECBIN bin EXECBIN( str コマンドライン [ , bin 入力データ ] )
コマンドラインを実行し、その標準出力をバイナリの戻り値とする。
入力データを書けば、それをコマンドの標準入力とする。

EXECUTE

int EXECUTE(
str コマンドライン
)

コマンドラインを実行し、コマンドラインの戻り値を返す。
標準入出力はホスト環境がそのまま使用される。戻り値は、RESULTで参照できる。

記述例　 execute('decho abc def')

QS

str QS(
str スクリプト
[ , str 入力文字列 ]
)

スクリプトを実行し、標準出力を文字列とする。
入力文字列を書けばそれをコマンドの標準入力とする。

記述例　 qs(file('sample.qs'),'all about')

QSBIN bin QSBIN( str スクリプト [ , bin 入力データ ] )
スクリプトを実行し、その標準出力をバイナリの戻り値とする。
入力データを書けばそれをコマンドの標準入力とする。

QS_AR

int QS_AR(
配列名
, str スクリプト
[ , str 入力文字列 ]
)

スクリプトを実行し、標準出力の各行を配列に格納する。行数を返す。
入力文字列を書けばそれをコマンドの標準入力とする。

記述例　 qs_ar(a,file('sample.qs'),'all about')

QSC

int QSC(
str スクリプト
)

スクリプトを実行し、結果を返す。
ホストアプリケーションの標準入出力を直接使うので通常は使用しない関数。

記述例　 qsc(file('sample.qs'))

LAUNCH

bool LAUNCH(
str コマンドライン
)

コマンドラインのプログラムを起動する。

記述例　 launch('C:\Program Files\Internet Explorer\iexplore.exe')

スタック操作

PUSH

int PUSH(
値
[ , 値 ]*
)

値をスタックに退避する。
退避した個数を返す。

記述例　
push(32,'abc') → 2
pop → abc
pop → 32

PUSHIX

int PUSHIX(
int 個数
[ , 評価式 ]*
)

指定の個数分だけ、評価式を評価してスタックに格納する。
評価した個数を返す。評価式の中では特殊な変数 IX で繰返しの序数を参照できる。

記述例　
pushix(3,colon(ix+1,sqrt(ix+1))) → 3
pop → 3:1.7320508075688772;
pop → 2:1.4142135623730951;
pop → 1:1.0;

POP

POP[()]
スタックから取り出す。

記述例　
push(1) → 1
push(2) → 1
pop → 2
pop → 1

PEEP

PEEP[(
[ int 位置 ]
)]

スタックの指定した位置の値を得る。
スタックの内容は変わらない。位置は、一番最後に積まれたものを 0 として数える正の整数。
位置を省略すると、スタックトップ（ 0 番目）の値。

記述例　
push(1) → 1
push('second') → 1
comma(peep(0),peep(1)) → second,1
pop → second
pop → 1

DROP

int DROP
スタックからして一つだけ落とす。
整数 1 を返す

記述例　
push(10,20,30) → 3
drop → 1
pop → 20
pop → 10

int DROP( int 個数 )
スタックからして個数分だけ落とす。
落とした個数を返す。

記述例　
push(10,20,30) → 3
drop(2) → 2
pop → 10

UNSHIFT

UNSFIHT(
値
)

スタック配列の先頭へ値を挿入。値をそのまま返す

記述例　
unshift(10) → 10
unshift(20) → 20
comma(peep(0),peep(1)) → 10,20
shift → 20
shift → 10

SHIFT

SHIFT
スタック配列の先頭から取り出す。

記述例　
push(10,20,30) → 3
shift → 10
comma(pop,pop) → 30,20
stackcount → 0

STACKCOUNT

STACKCOUNT
スタックの大きさ

記述例　
push(10,20,30) → 3
stackcount → 3
comma(pop,pop,pop) → 30,20,10
stackcount → 0

STACKINIT int STACKINT[()]
スタックを空にする。戻り値はクリア前のスタックの大きさ。

制御

BREAK BREAK
特殊な値 BREAKを返す。演算したり、代入したり出来ない。 PROG、PROGLOOP や SEQ_XXX 系の関数で中断を表すために使用する。

BREAKP BREAKP( 式 )
式の値が BREAK ならば TRUE、そうでなければ FALSE を返す。

BREAKIF BREAKIF( bool 判定式 [ , 返却式 ] )
判定式の値が TRUE ならば BREAK、FALSEならば、返却式を評価してその値を返す。
返却式を省略した場合は、FALSEの場合の戻り値はFALSE。

ALTBREAK

ALTBREAK(
値, 置換値
)

値が状態型のBREAKの場合は置換値、それ以外は値をそのまま返す。
値をそのまま返す場合には、置換値は評価しない。

記述例１　 altbreak('abc','def') → abc

記述例２　 altbreak(break,'def') → def

SKIP SKIP
特殊な値 SKIPを返す。演算したり、代入したり出来ない。 FILE2FILE関数でだけ使用する。

SKIPP SKIPP( 式 )
式の値が SKIP ならば TRUE、そうでなければ FALSE を返す。

SKIPIF SKIPIF( bool 判定式 [ , 返却式 ] )
判定式の値が TRUE ならば SKIP、FALSEならば返却式を評価してその値を返す。
返却式を省略した場合は、FALSEの場合の戻り値はFALSE。

ALTSKIP

ALTSKIP(
値, 置換値
)

値が状態型のSKIPの場合は置換値、それ以外は値をそのまま返す。
値をそのまま返す場合には、置換値は評価しない。

記述例１　 altskip('abc','def') → abc

記述例２　 altskip(skip,'def') → def

LOCAL

LOCAL(
単純変数名
[ , 単純変数名 ]* ;
式
[ , 式 ]*
)

単純変数名を保護して、式を実行する。
戻り値は最後に実行した式の値。式を実行する前に列挙された単純変数を退避する。実行後退避した単純変数を戻す。

記述例　
a:=123 → 123
local(a;a:=15) → 15
a → 123

IF

IF(
bool 条件
, 値1
[ , 値2 ]
)

条件が真ならば、値１を、偽ならば値２を返す。
戻り値の型は、値の型と同じである。
値2 を省略すると、条件が偽の場合、FALSE を返す。

記述例１　 if(true,1,2) → 1

記述例２　 if(false,1,2) → 2

記述例３　 if(true,1) → 1

記述例４　 if(false,1) → FALSE

IFP

bool IFP(
bool 条件
, 式１
[ , 式２ ]
)

条件が真ならば、式１を評価し、偽ならば式２を評価する。戻り値は条件の値。
式２が省略されていて条件が偽の場合は、何もせずに、FALSE を返す。

記述例１　 ifp(true,1,2) → TRUE

記述例２　 ifp(false,1,2) → FALSE

記述例３　 ifp(true,1) → TRUE

記述例４　 ifp(false,1) → FALSE

IFPN bool IFPN( bool 条件 , 式１ [ , 式２ ] )
条件が真ならば、式１を評価し、偽ならば式２を評価する。戻り値は条件の値を反転したもの。
式２が省略されていて条件が偽の場合は、何もせずに、TRUE を返す。
この関数は、not ifp(....)と等価である。

IFNOT

IFNOT(
bool 条件
, 値1
[ , 値2 ]
)

条件が偽ならば、値１を、偽ならば値２を返す。
戻り値の型は、値の型と同じである。
値2 を省略すると、条件が偽の場合、TRUE を返す。

記述例１　 ifnot(true,1,2) → 2

記述例２　 ifnot(false,1,2) → 1

記述例３　 ifnot(true,1) → TRUE

記述例４　 ifnot(false,1) → 1

IFTRUE

IFTRUE(
条件
, 値1
[ , 値2 ]
)

条件が論理値で真ならば、値１を、それ以外では値２を返す。
戻り値の型は、値の型と同じである。
値2 を省略すると、条件が成立しなかった場合、FALSE を返す。

記述例１　 iftrue(true,1,2) → 1

記述例２　 iftrue('a',1,2) → 2

記述例３　 iftrue(true,1) → 1

記述例４　 iftrue('b',1) → FALSE

IFFALSE

IFFALSE(
条件
, 値1
[ , 値2 ]
)

条件が論理値で偽ならば、値１を、それ以外では値２を返す。
戻り値の型は、値の型と同じである。
値2 を省略すると、条件が成立しなかった場合、FALSE を返す。

記述例１　 iffalse(false,1,2) → 1

記述例２　 iffalse('a',1,2) → 2

記述例３　 iffalse(false,1) → 1

記述例４　 iffalse('b',1) → FALSE

IFNULL

IFNULL(
条件
, 値1
[ , 値2 ]
)

条件が空文字列ならば、値１を、それ以外では値２を返す。
戻り値の型は、値の型と同じである。
値2 を省略すると、条件が成立しなかった場合、FALSE を返す。

記述例１　 ifnull('',1,2) → 1

記述例２　 ifnull(0,1,2) → 2

記述例３　 ifnull('',1) → 1

記述例４　 ifnull(1,1) → FALSE

ALTF

ALTF(
値, 置換値
)

値が論理型のFALSEの場合は置換値、それ以外は値をそのまま返す。
値をそのまま返す場合には、置換値は評価しない。

記述例１　 altf('abc','def') → abc

記述例２　 altf(false,'def') → def

COND

COND(
bool 判定式
, 式
[ , 
bool 判定式
, 式 ]*
)

先頭から順に判定式と式の組み合わせを検査し、判定式が真のとき、式の値を返す。
真になるものがない場合には、論理値 FALSE を返す。

記述例１　 {s:='img'; cond(s='br',10, s='img',20, true,99);} → 20

記述例２　 {s:='br'; cond(s='br',10, s='img',20, true,99);} → 10

記述例３　 {s:='p'; cond(s='br',10, s='img',20, true,99);} → 99

WHEN

WHEN(
bool 条件
, 式
[ , 式 ]*
)

条件が真ならば、式を順に評価、最後の式の値を返す。
条件が偽ならば、偽を返す。

記述例１　 when(true,150) → 150

記述例２　 when(false,150) → FALSE

UNLESS

UNLESS(
bool 条件
, 式
[ , 式 ]*
)

条件が偽ならば、式を順に評価、最後の式の値を返す。
条件が真ならば、真を返す。

記述例１　 unless(true,150) → TRUE

記述例２　 unless(false,150) → 150

DO DO( 式記述 [ , 式記述 ]* )
引数の式を順次評価し、最後の式の値を返す。
戻り値の型は、最後の式の値。
式の値が、BREAKかSKIPであれば、そこで処理を中断しその値を返す。

FIRST FIRST( 式記述 [ , 式記述 ]* )
引数の式を順次評価し、最初の式の値を返す。
戻り値の型は、最初の式の値。

FS FS( 式記述 [ , 式記述 ]* )
引数の式を順次評価し、最初の式の値を返す。
FIRST と同じ関数

AND

AND(
式記述
[ , 式記述 ]*
)

引数の式を順次評価し、偽になったら中断する。
最後に評価した式の値を返す。従って、中断した場合は偽を返し、中断が無ければ最後の評価値を返す。

記述例１　 {a:=15; and(a>5,a>150);} → FALSE

記述例２　 {a:=200; and(a>5,a>150);} → TRUE

AND_DO AND_DO( 式記述 [ , 式記述 ]* )
AND()と同じ。互換性を保つために残してある。

AND_LOOP bool AND_LOOP( 式記述 [ , 式記述 ]* )
式の値が論理値のFALSEになるまで、評価を繰り返す。戻り値は常にFALSE。無限ループする危ない関数。

OR

OR(
式記述
[, 式記述 ]*
)

引数の式を順次評価し、偽で無くなったら中断する。
最後に評価した式の値を返す。従って、中断した場合は評価値を返し、中断が無ければ偽を返す。

記述例１　 {a:=20; or(when(a>100,'1st'),when(a>10,'2nd'));} → 2nd

記述例２　 {a:=5; or(when(a>100,'1st'),when(a>10,'2nd'));} → FALSE

OR_DO OR_DO( 式記述 [, 式記述 ]* )
OR()と同じ。互換性を保つために残してある。

OR_LOOP bool OR_LOOP( 式記述 [ , 式記述 ]* )
式の値が論理値のTRUEになるまで、評価を繰り返す。戻り値は常にTRUE。無限ループする危ない関数。

WHILE

int WHILE(
bool 判定式
[ , 式記述 ]*
)

判定式が真ならば以降の式記述を実行する。
判定式が偽になるまで繰り返す。繰り返した回数を返却する
序数が特殊な変数 IX にセットされるので判定の基準に使用できる。

記述例　 (a:=0, while(ix<10,a+=(ix+1)), a) → 55

WHILE_COUNT int WHILE_COUNT
IX と同じ。
過去との互換性を保つために残されている。

UNTIL

int UNTIL(
bool 判定式
[ , 式記述 ]*
)

判定式が偽ならば以降の式記述を実行する。
判定式が真になるまで繰り返す。繰り返した回数を返却する
序数が特殊な変数 IX にセットされるので判定の基準に使用できる。

記述例　 (a:=0, until(ix>=10,a+=(ix+1)), a) → 55

UNTILFALSE

int UNTILFALSE(
判定式
[ , 式記述 ]*
)

判定式が論理値偽（FALSE）以外ならば以降の式記述を実行する。
判定式が論理値偽（FALSE）になるまで繰り返す。繰り返した回数を返却する
序数が特殊な変数 IX にセットされるので判定の基準に使用できる。

記述例　 (a:=0, untilfalse(ix<10,a+=(ix+1)), a) → 55

LOOP

int LOOP(
[ 式記述 , ]*
判定式
)

式を順に評価し、最後の式が論理値偽（FALSE）になるまで全体の評価を繰り返す。
繰り返した回数を返却する
序数が特殊な変数 IX にセットされるので判定の基準に使用できる。

記述例　 (a:=0, loop(a+=(ix+1),ix<10), a) → 66

PROGLOOP bool PROGLOOP( 式 [ , 式 ]* )
式評価を繰り返す。式の値が BREAK になると終了する。戻り値は常に TRUE 。
式の値がSKIPになると、その時点で繰返しの先頭に戻る。

PROG bool PROG( 式 [ , 式 ]* )
式を順に評価する。式の値が BREAKまたは、SKIP になると終了し FALSEを返す。BREAK や SKIP が返されなければ TRUE を返す。

REPEAT

REPEAT(
int 回数
, 式
[ , 式 ]*
)

指定した回数だけ、式を繰り返す。最後の式の値を返す。
回数が０以下を指定した場合は、いずれの式も実行されず、論理値 FALSE を返す。
指定した回数は、繰り返しごとに　-1 される。この値は、REPEAT_COUNT で参照できる。また、0 から始まり、繰返しごとに+1される、特別な整数変数 IX も参照できる。

記述例　 (a:=0, repeat(10,a+=(ix+1)), a) → 55

REPEAT_COUNT

int REPEAT_COUNT
REPEAT 関数の中で参照できる残りの繰り返し回数。
繰り返しごとに -1 される。

記述例　 (a:=null, repeat(10,a+=sc(repeat_count)), a) → 10;9;8;7;6;5;4;3;2;1;

REPEAT_INDEX int REPEAT_INDEX
IX と同じ。
過去との互換性を保つために残されている。

RANGE

RANGE(
int 初期値
, int 終了値
[ , 式 ]*
)

初期値から終了値まで式を繰り返す。繰り返した回数を返す。
特別な変数 IX で現在のインデックスを参照できる。

記述例　 (a:=0, range(10,15,a+=ix), a) → 75

SCAN

int SCAN(
int 回数
, bool 判定式
)

指定した回数だけ、判定式を繰り返す。
判定式が真になったとき、処理を中断する。戻り値は中断が起きたときの IX の値。中断が無かったときは -1を返す。
判定式の中では、特別な変数 IX を参照できる。IX は0から始まり、繰返しごとに +1 される。

記述例１　 scan(10,ix*ix>50) → 8

記述例２　 scan(10,ix*ix>150) → -1

SOME

bool SOME(
int 回数
, bool 判定式
)

指定した回数だけ、判定式を繰り返す。
判定式が真になったとき、繰返しを中断して真を返す。すべて偽の場合だけ偽を返す。判定式の中では、特別な変数 IX を参照できる。IX は0から始まり、繰返しごとに +1 される。

記述例１　 some(10,ix*ix>50) → TRUE

記述例２　 some(10,ix*ix>150) → FALSE

EVERY

bool EVERY(
int 回数
, bool 判定式
)

指定した回数だけ、判定式を繰り返す。
判定式が偽になったとき、繰返しを中断して偽を返す。すべて真の場合だけ真を返す。判定式の中では、特別な変数 IX を参照できる。IX は0から始まり、繰返しごとに +1 される。

記述例１　 every(10,ix*ix<50) → FALSE

記述例２　 every(10,ix*ix<150) → TRUE

FOR

int FOR(
[ 初期化式 ]
, bool 検定式
, 更新式
{ , 実行式 }+
)

初期化式を最初に実行後、検定式が真の間、実行式、更新式を繰返し評価する。
戻り値は繰り返した回数。
検定式、更新式、実行式は、特殊な変数 IX で 0 から始まる序数を参照できる。

記述例　
for( (i:=1,s:=0), i<=10, i++, s+=i) → 10
s → 55

OR_EQ

int OR_EQ(
式記述1
[ , 式記述n ]*
)

最初の値（式記述1）と同じ値になる後続の値（式記述n)を探す。
型と値が一致した場合には、その位置を番号で返す。番号は０から始まる。
一致しなかった場合には負の値（-1）を返す。
最初の値と、以降の値の型は同じでなければならない。文字列の比較は半角大文字小文字を区別して比較する。

記述例１　 or_eq('Mar','Jan','Feb','Mar','May') → 2

記述例２　 or_eq('De','Jan','Feb','Mar','May') → -1

OR_EQS

int OR_EQS(
式記述1
[ , 式記述n ]*
)

OR_EQ とほぼ同じ関数。
文字列の比較は半角大文字小文字を区別せずに比較する。

記述例　 or_eqs('mar','Jan','Feb','Mar','May') → 2

OR_EQX int OR_EQX( 式記述1 [ , 式記述n ]* )
OR_EQ とほぼ同じ関数。
文字列の比較は半角英字／全角英字／ロシア文字／ギリシャ文字／ローマ数字の大文字小文字を区別せずに比較する。

INDEX

INDEX(
int 指標式
, 式
[, 式 ]*
)

指標式で示した番号の後続の式の値を返す。番号は０から始まる。
指標式が負であったり、後続の式の数以上である場合には、いずれの式も式は実行されず、論理値 FALSE を返す。

記述例１　 index(2,'Jan','Feb','Mar','May') → Mar

記述例２　 index(5,'Jan','Feb','Mar','May') → FALSE

ARG_FOR

int ARG_FOR(
評価式
[, 値 ]*
)

値のすべてについて、評価式を繰返し評価する。
値の個数を返す。
評価式の中では特別な変数 IX で 0 から始まる序数を参照できる。また、 SV で値そのものを参照できる。
評価式がBREAKになると処理を中断する。

記述例　
{ s:=null; arg_for(s+=small(sv)+sc,'Jan','Feb','Mar','May');} → 4
s → jan;feb;mar;may;

ARG_SCAN

int ARG_SCAN(
bool 評価式
[, 値 ]*
)

値のすべてについて真になるまで、評価式を繰返し評価する。
評価式が真になると繰返しを中断し、そのときの IXの値を返す。すべてが偽の場合は、 -1 を返す。
評価式の中では特別な変数 IX で 0 から始まる序数を参照できる。また、 SV で値そのものを参照できる。

記述例１　 {arg_scan(isUpper(sv),'jan','feb','Mar','may');} → 2

記述例２　 {arg_scan(isUpper(sv),'jan','feb','mar','may');} → -1

ARG_PRIME

 ARG_PRIME(
bool 評価式
[, 値 ]*
)

値のすべてについて真になるまで、評価式を繰返し評価する。
評価式が真になると繰返しを中断し、そのときのの値を返す。すべてが偽の場合は、 FALSE を返す。
評価式の中では特別な変数 IX で 0 から始まる序数を参照できる。また、 SV で値そのものを参照できる。

記述例１　 {arg_prime(isUpper(sv),'jan','feb','Mar','may');} → Mar

記述例２　 {arg_prime(isUpper(sv),'jan','feb','mar','may');} → FALSE

ARG_SOME

bool ARG_SOME(
bool 評価式
[, 値 ]*
)

値のすべてについて真になるまで、評価式を繰返し評価する。
評価式が真になると繰返しを中断し、真を返す。すべてが偽の場合は、偽を返す。
評価式の中では特別な変数 IX で 0 から始まる序数を参照できる。また、 SV で値そのものを参照できる。

記述例１　 {arg_some(isUpper(sv),'jan','feb','Mar','may');} → TRUE

記述例２　 {arg_some(isUpper(sv),'jan','feb','mar','may');} → FALSE

ARG_EVERY

bool ARG_EVERY(
bool 評価式
[, 値 ]*
)

値のすべてについて偽になるまで、評価式を繰返し評価する。
評価式が偽になると繰返しを中断し、偽を返す。すべてが真の場合は、真を返す。
評価式の中では特別な変数 IX で 0 から始まる序数を参照できる。また、 SV で値そのものを参照できる。

記述例１　 {arg_every(isLower(sv),'jan','feb','Mar','may');} → FALSE

記述例２　 {arg_every(isLower(sv),'jan','feb','mar','may');} → TRUE

ARG2STR

str ARG2STR(
str 評価式
, { str 区切り文字列
| bool  行末フラグ
}
[, 値 ]*
)

値のすべてについて、評価式を繰返し評価し文字列として連結して返す。
行末フラグ真の場合は、それぞれの要素の後ろに行末 (LF 0x0a)を付けて連結する。。行末フラグが偽の場合は、何も挟まずにそれぞれの要素を連結する。区切り文字列を指定すると、その文字列を挟んで連結する。評価式の中では特別な変数 IX で 0 から始まる序数を参照できる。また、 SV で値そのものを参照できる。

記述例１　 arg2str(sqrt(sv),true,2,5,3,1) →

1.4142135623730951↓
2.2360679774997898↓
1.7320508075688772↓
1.0↓

記述例２　 arg2str(large(sv),tab,'jan','feb','mar','may') →
JAN→FEB→MAR→MAY

記述例３　 arg2str(kakko(sv),comma,'jan','feb','mar','may') → (jan),(feb),(mar),(may)

SEQ_FOR

int SEQ_FOR(
評価式
, アクセス式
[, 初期化式 ]
)

　アクセス式の値に対して評価式を繰返し評価する。戻り値は評価した回数。
アクセス式か評価式が BREAK になると処理を終了する。
アクセス式の中では、IX で繰返しの序数を参照できる。
評価式の中では、IX で繰返しの序数を、SV でアクセス式の結果を参照できる。

記述例　
seq_for(a+=sv,if(ix<10,ix+1,break),a:=0) → 10
a → 55

SEQ_SCAN

int SEQ_SCAN(
bool 評価式
, アクセス式
[, 初期化式 ]
)

　アクセス式の値に対して評価式が真になる序数を求める。
アクセス式が BREAK になると処理を終了する。
評価式が TRUE になると、処理を中断し、そのときの IXを返す。一度も評価式が TRUE にならなければ、 -1 を返す。アクセス式の中では、IX で繰返しの序数を参照できる。
評価式の中では、IX で繰返しの序数を、SV でアクセス式の結果を参照できる。

記述例　
arc(a,'inu','neko','hebi') → 3
c:=seq_scan(search(sv,'neko')>=0,if(ix<ar_count(a),a[ix],break)) → 1
if(c>=0,a[c],'unfound') → neko

SEQ_PRIME

 SEQ_PRIME(
bool 評価式
, アクセス式
[, 初期化式 ]
)

　アクセス式の値に対して評価式が真になる値を求める。
アクセス式が BREAK になると処理を終了する。
評価式が TRUE になると、処理を中断し、そのときのアクセス式の値を返す。一度も評価式が TRUE にならなければ、 FALSE を返す。アクセス式の中では、IX で繰返しの序数を参照できる。
評価式の中では、IX で繰返しの序数を、SV でアクセス式の結果を参照できる。

記述例　
arc(a,'inu','neko','hebi') → 3
c:=seq_prime(search(sv,'neko')>=0,if(ix<ar_count(a),a[ix],break)) → neko
if(c>=0,a[c],'unfound') → unfound

SEQ_SOME

bool SEQ_SOME(
bool 評価式
, アクセス式
[, 初期化式 ]
)

　アクセス式の値に対して真になる評価式があるか調べる。
アクセス式が BREAK になると処理を終了し、 FALSE を返す。
評価式が真になると処理を中断し、TRUE を返す。アクセス式の中では、IX で繰返しの序数を参照できる。
評価式の中では、IX で繰返しの序数を、SV でアクセス式の結果を参照できる。

記述例　
arc(a,'pull','push','pop') → 3
seq_some(match(~'o',sv),if(ix<ar_count(a),a[ix],break)) → TRUE
seq_some(match(~'m',sv),if(ix<ar_count(a),a[ix],break)) → FALSE

SEQ_EVERY

bool SEQ_EVERY(
bool 評価式
, アクセス式
[, 初期化式 ]
)

　アクセス式の値に対して評価式が全て真であるか調べる。
アクセス式が BREAK になると処理を終了し、 TRUE を返す。
評価式が偽になると処理を中断し、FALSE を返す。アクセス式の中では、IX で繰返しの序数を参照できる。
評価式の中では、IX で繰返しの序数を、SV でアクセス式の結果を参照できる。

記述例　
arc(a,'piki','piko','puki') → 3
seq_every(match(~'^p',sv),if(ix<ar_count(a),a[ix],break)) → TRUE
seq_every(match(~'^pi',sv),if(ix<ar_count(a),a[ix],break)) → FALSE

SEQ_COUNT

int SEQ_COUNT(
bool 評価式
, アクセス式
[, 初期化式 ]
)

　アクセス式の値に対して評価式が真になる数を返す。
アクセス式が BREAK になると処理を終了する。アクセス式の中では、IX で繰返しの序数を参照できる。
評価式の中では、IX で繰返しの序数を、SV でアクセス式の結果を参照できる。

記述例　
arc(a,'piki','piko','puki') → 3
seq_count(match(~'ki',sv),if(ix<ar_count(a),a[ix],break)) → 2

SEQ_REDUCE

 SEQ_REDUCE(
評価式
, アクセス式
[, 初期値式 ]
)

　アクセス式の値に対して評価式で累積演算をする。戻り値は累積値。
繰返しの中では、評価式の値が累積値に代入される
アクセス式が BREAK になると処理を終了する。アクセス式の中では、IX で繰返しの序数を参照できる。
評価式の中では、IX で繰返しの序数を、SV1 でアクセス式の結果を、 SV2で累積値を参照できる。
初期値式を書くと、これを評価し、累積値に値を代入する。
初期化式を書かないと、一度目のアクセス式の値は、評価式を経ずにそのまま累積値に代入される。二度目以降のアクセス式の値は、評価式で累積演算して累積値に代入する。

記述例　 seq_reduce(sv1+sv2,if(ix<10,ix+1,break)) → 55

IX int IX
制御関数の式の中で使用する着目番号を表す整数。
0 で始まり、繰返しごとに +1 される。代入は出来ない。

SS str SS
制御関数の式の中で使用する着目文字列。
代入は出来ない。

SV SV
制御関数などの式の中で使用する着目値。データの型はそのときの値の型。
代入は出来ない。

SV1 SV1
制御関数などの式の中で使用する着目値。データの型はそのときの値の型。
代入は出来ない。
二つの着目値を用いる関数の中で使用する。

SV2 SV2
SVの別名。
SV1と併用するときに、意味づけを明確にするために用いると良い。

BP int BP
バイナリ関係の制御関数の中で、着目位置を表す整数値。
0 から始まる。。

PASS

int PASS
パスカウントを＋1する。パスカウントが限界値に達したら、エラーとなる。戻り値は現在のパスカウント。
パスカウントは式評価のたびに 0 に戻される。ループ処理の中に PASS を書いておいて、無限ループの場合にはエラーと出来る。デバッグの際に使用するとよい。限界値はデフォルトでは、10000。

int PASS()
現在のパスカウントを返す。

int PASS( int 上限値 )
パスカウントの上限値を設定する。戻り値は現在のパスカウント。
パスカウントは 0 に初期化する。

MSG

MSG(
str 式
[ , str タイトル
[ , str ボタン指定
[ , str アイコン指定
] ] ]
)

式の値を文字列に変換してメッセージボックスに表示する。
タイトルを省略すると"TSEXPR"を表示する。戻り値は式の値。
以下の文字列でボタン指定が出来る。ボタン指定をすると、戻り値は押したボタンを表す文字列になる。ボタン指定の文字列は大文字／小文字を区別しない。

文字列	文字列	表示するボタン
O	OK	ＯＫ
OC	OKCANCEL	ＯＫ / キャンセル
YN	YESNO	はい / いいえ
YNC	YESNOCANCEL	はい / いいえ / キャンセル
ARI	ABORTRETRYIGNORE	中止 / 再試行 / 無視

押されたボタンによって以下の文字列を返す。

押されたボタン	文字列
ＯＫ	OK
キャンセル	CANCEL
はい	YES
いいえ	NO
中止	ABORT
再試行	RETRY
無視	IGNORE

アイコン指定によって、メッセージボックスに注意喚起の記号を表示できる。アイコン指定の文字列も大文字小文字を区別しない。

文字列	文字列	表示
E	!	感嘆符
I	INFORMATION	i マーク
Q	?	疑問符
X	STOP	×マーク

評価

EVAL

EVAL( str 式記述 [ , str 引数 ]* )
文字列の式記述を評価して値を返す。
戻り値の型は、実行した結果による。新たなTSEXPRを起動して評価を行っている。

後ろに引数を書かない場合：
SYS()関数は、ホスト側のSYS()関数をそのまま引き継ぐ。

引数を書いた場合：
SYS()関数は引数の引用に用いる。

機能番号	関数記述	変数名
0	`SYS(0)`	`??argc`	引数の数
n	`SYS(n)`		引数の値
		`??ss`	呼び出し側での `SS`の値
		`??sv`	呼び出し側での `SV`の値
		`??ix`	呼び出し側での `IX`の値

記述例１　 eval('sqrt(2.0)') → 1.4142135623730951

記述例２　 eval('comma(sqrt(&&1),sqrt(&&2))',2.0,3.0) → 1.4142135623730951,1.7320508075688772

EVALQ

int EVALQ( str 式記述 [ , str 引数 ]* )
文字列の式記述を評価する。戻り値はエラーコード。
エラーコードが 0 ならば、正常に実行されたことを示す。新たなTSEXPRを起動して評価を行っている。

後ろに引数を書かない場合：
SYS()関数は、ホスト側のSYS()関数をそのまま引き継ぐ。

引数を書いた場合：
SYS()関数は引数の引用に用いる。

機能番号	関数記述	変数名
0	`SYS(0)`	`??argc`	引数の数
n	`SYS(n)`		引数の値
		`??ss`	呼び出し側での `SS`の値
		`??sv`	呼び出し側での `SV`の値
		`??ix`	呼び出し側での `IX`の値

ERROR

BOOL ERROR( int エラーコード )
エラーコードを与えて式評価をエラー終了させる。
エラーコードは、EVALQ が返す値。エラーコードが 0 ならば、中断せず論理値真を返す。

EVALSTR

EVALSTR( str 式記述 [ ; [ 引数 [ , 引数 ] ] ] )
文字列の式記述を評価して値を返す。
戻り値の型は、実行した結果による。
EVAL と異なり、現在の TSEXPR の一部として式を評価する。
式の評価時に次の要素を使用できる。

FUNARGC	`FC`	引数の数
FUNARG[`n`]	`FA[n]`	0 から数えて n 番目の引数の値。存在しない番号を指定した場合は偽を返す。
FUNARG	`FA`	すべての引数をタブ (\t 0x09) で繋いだ文字列。

「;」を書いた場合
「;」以降に引数を書く。引数を書かなければ、0 個の引数があるものとして扱う。 FUNARGC / FUNARG ではここで書いた引数を参照する。
「;」を書かなかった場合：
上位の処理の引数をそのまま引き継ぐ。

記述例１　 evalstr('sqrt(2.0)') → 1.4142135623730951

記述例２　 {?myfunc:='sqrt(fa[0]+fa[1])'; evalstr(?myfunc; 2.0,1.5); } → 1.8708286933869707

* str 式記述 または
* str 式記述 ( 引数 [ , 引数 ]+ )
略記形式。
先頭に「*」をつけて書き、文字列値を式評価する。

「()」を書いた場合：
「()」の中に引数を書く。引数を書かなければ、0 個の引数があるものとして扱う。 FUNARGC / FUNARG ではここで書いた引数を参照する。
「()」を書かなかった場合：
上位の処理の引数をそのまま引き継ぐ。

記述例１　 *'sqrt(2.0)' → 1.4142135623730951

記述例２　 {?myfunc:='sqrt(fa[0]+fa[1])'; *?myfunc(2.0,1.5); } → 1.8708286933869707

FVAL FVAL( str 式記述 )
文字列の式記述を TSFXPR で評価して値を返す。
以前のバージョンとの互換性を保つために残してある。TSFXPRは使用する必要がない。
TSFXPR中のSYS()関数は、TSEXPR 中でのSYS()関数に対応する。
TSFXPR式は起動時に FVAR の値を一時変数に読み込むので、FVAR 経由で値を渡せる。

FVALSTR str FVALSTR( str 式記述 )
文字列の式記述を TSFXPR で評価して文字列を返す。
以前のバージョンとの互換性を保つために残してある。TSFXPRは使用する必要がない。
TSFXPR中のSYS()関数は、TSEXPR中でのSYS()関数に対応する。

FXPR FXPR( 式記述 )
式記述を TSFXPR で評価して値を返す。
以前のバージョンとの互換性を保つために残してある。TSFXPRは使用する必要がない。
ここでの式記述は、埋め込み形式の TSFXPR での記述であることに注意。
TSFXPR 中の SYS() 関数は、TSEXPR中での SYS() 関数に対応する。

FXPRSTR str FXPRSTR( 式記述 )
式記述を TSFXPR で評価して文字列を返す。
以前のバージョンとの互換性を保つために残してある。TSFXPRは使用する必要がない。
ここでの式記述は、埋め込み形式の TSFXPR での記述であることに注意。
TSFXPR 中のSYS()関数は、TSEXPR 中でのSYS()関数に対応する。

アプリ引数

SYS

str SYS(
int 式
)

アプリケーションから返される文字列。
アプリケーションが特に定義しなければ、長さ０の文字列を返す。
略記法（ @n、@(式) ）が用意されている。
SYSINT / SYSFIX / SYSFLOAT / SYSBOOL は、この関数に型変換を行ったもの。

記述例１　 sys(5)

記述例２　 @5

記述例３　 @(a+3)

SYSINT

int SYSINT(
int 式
)

アプリケーションから返される文字列を整数化した値。
INT(SYS(..))と同じ。
記述の簡略化のために設けた関数。
略記法（ &n、&(exp) ）が用意されている。

記述例１　 sysint(5)

記述例２　 &5

記述例３　 &(a+3)

SYSFIX

fix SYSFIX(
int 式
)

アプリケーションから返される文字列を小数化した値。
FIXNUM(SYS(..))と同じ。
記述の簡略化のために設けた関数。
略記法（ &@n、&@(exp) ）が用意されている。

記述例１　 sysfix(5)

記述例２　 &@5

記述例３　 &@(a+3)

SYSFLOAT

float SYSFLOAT(
int 式
)

アプリケーションから返される文字列を実数化した値。
FLOAT(SYS(..))と同じ。
記述の簡略化のために設けた関数。
略記法（ &&n、&&(exp) ）が用意されている。

記述例１　 sysfloat(5)

記述例２　 &&5

記述例３　 &&(a+3)

SYSBOOL bool SYSBOOL( int 式 )
SYS(n)を呼び出し、返した値がNULLではないときに、TRUEとなる。
通常は使用しないが、アプリケーションによってはこの関数の使い方に対応している。

SYSTALK str SYSTALK( int 式 , 値 )
アプリケーションにデータを送り、返答の文字列を返す。
アプリケーション側に対応する処理がない場合は空の文字列を返すことが多い。
この関数に対応していないアプリケーションではこの関数を使用しないこと。

SPOOL SPOOL( str値 [ , str値 ]* )
アプリケーションに文字列データを送る。
値を複数書くとそれらを連結した文字列をアプリケーションに送る。戻り値はアプリケーションによる。
アプリケーションでの出力機能に割り当てることを想定している関数。
この関数に対応していないアプリケーションでは使用しないこと。

汎用変数

LVAR

LVAR[
int 指標 ]
[ := 値 ]

　または

LVAR(
int 指標
[ , 値 ]
)

指標で指定した単純変数の値を返す。
値を書くと、値をセットする。
指標が数値の場合は、1-26の範囲で指定する。LVAR(1)は A と同じ。LVAR(26) は Z と同じ。
指標が文字列の場合は、一文字の英字で指定する。大文字小文字は区別しない。LVAR("A")、LVAR("a")は A と同じ。

記述例１　 {b:=15; lvar[2];} → 15

記述例２　 {lvar[4]:=30; d;} → 30

FILE2LVAR int FILE2LVAR( str ファイル名 [ , int 開始変数番号 [ , int 制限個数 ]] )
ファイルから単純変数に一括読み込み。
行単位で文字列として読み込み、値を変数にセットする。
ファイル名が "" ならば、標準入力から読み込む。開始変数番号の指定ができる。指定しなければ、１から順にセットする。
制限個数を指定できる。

LVAR2FILE int LVAR2FILE( str ファイル名 [ , int 開始変数番号 [ , int 個数 ]] )
単純変数を一括してファイルへ行単位で出力。
ファイル名が "" ならば、標準出力へ出力。ファイル名が"#"ならば、標準エラー出力へ出力。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）

配列変数

DIM

int DIM( 配列名
[ , int サイズ
[ ,  初期値 ]]
)

配列のサイズを設定する。。
戻り値はサイズ。
サイズを指定すると、指定のサイズの配列にする。内容はすべて初期化する。初期値の指定を省略すると整数の 0 で初期化する。
サイズ、初期値を省略すると配列の大きさを返す。配列のサイズを求める場合には、AR_COUNT() の使用を勧める。
また、要素に代入すると、配列はその要素の大きさまで自動的に拡張するので、DIM はあまり使用しない。

記述例１　単純な初期化
dim(a,15)

記述例２　初期値を与えた場合
dim(a,15,null)

DIMC int DIMC( 配列名 , int サイズ , int 要素バイト数 [ , 初期値 ] )
配列変数のサイズと、要素の大きさを指定する。
戻り値はサイズ。
高速化機能はサポートされなくなったので、この関数は廃止する。以前の版との互換性のためだけに残されている。

AR

int AR( 配列名
[ ,
{ 値
| { int 指標
, 値 }
}
]*
)

配列の先頭から順に代入する。
代入した個数を返す。
代入は、指標を指定する形式としない形式がある。
指標を指定しない形式は、単に値を書く。この場合、「現在の指標」で示される配列要素に代入する。現在の指標は一つ増加する。また、最初の「現在の指標」の値は 0 で最初の要素を示している。
{}で囲むと代入する位置（指標）を指定できる。「現在の指標」は、ここで指定した指標の次となるので、連続した要素への代入する場合は続く代入では指標を指定せずに値だけ書けばよい。
配列は初期化されないことに注意。

記述例１　 { ar_clear(a); ar(a,1,2,3); ar2str(a); } → 1,2,3

記述例２　 { ar_clear(a); ar(a,1,{4,2},3); ar2str(a); } → 1,0,0,0,2,3

ARC

int ARC( 配列名
[ ,
{ 値
| { int 指標
, 値 }
}
]*
)

記述例１　 { arc(a,1,2,3,4,5,6,7,8,9,10); ar2str(a); } → 1,2,3,4,5,6,7,8,9,10

記述例２　 { arc(a,1,{4,2},3); ar2str(a); } → 1,0,0,0,2,3

AR_COUNT

int AR_COUNT( 配列名 )
配列の要素数。

記述例　 { arc(a,1,2,3); ar_count(a); } → 3

AR_CLEAR

bool AR_CLEAR(
[ 配列名
[ , 配列名 ]*
]
)

配列をクリアする。
要素の数は 0 になる。配列名を省略すると、システムが使用していない配列（a-z）をクリアする。戻り値は常に真。

記述例　 ar_clear(a,b,c) → TRUE

AR_SETSIZE

int AR_SETSIZE( 配列名
, int 要素数
)

配列の大きさを変更する。
戻り値は常に真。

記述例　 ar_setsize(a,100) → 100

AR_COPY

int AR_COPY(
転送元配列名
,  転送先配列名
[ , int 転送元の開始位置
[ , int 転送個数 ]]
)

転送元配列を転送先配列に複写する。
転送先の要素数は転送個数と同じになる。戻り値は処理した要素数。
開始位置と転送個数を省略すると転送先の配列は転送元と同じになる。

記述例１　 {arc(a,1,2,3,4,5); ar_copy(a,b); ar2str(b);} → 1,2,3,4,5

記述例２　 {arc(a,1,2,3,4,5); ar_copy(a,b,2); ar2str(b);} → 3,4,5

記述例３　 {arc(a,1,2,3,4,5); ar_copy(a,b,2,5); ar2str(b);} → 3,4,5,0,0

COPY_AR int COPY_AR( 転送元配列名 , 転送先配列名 [ , int 転送元の開始位置 [ , int 転送個数 ]] )
AR_COPY と同じ。
互換性維持のために残してある関数。

AR_TRANS int AR_TRANS( 転送元配列名 , 転送先配列名 [ , int 転送先の開始位置 [ , int 転送元の開始位置 [ , int 転送個数 ]]] )
転送元配列を転送先配列に転送する。戻り値は転送した個数。
転送先の開始位置を省略すると、先頭から。負の値を指定すると配列の末尾から。
転送元の開始位置を省略すると、先頭から。
転送個数を省略するか、負の数を指定すると転送もとの開始位置より後ろのすべての要素の個数になる。
転送先／転送元の開始位置は、0が配列の先頭を表す。

AR_LETAR int AR_LETAR( 配列名 , int 位置 [ , 書き込み配列名 ]* )
配列の指定位置に記述した配列を書き込む。
配列の要素数を返す。

AR_APPEND int AR_APPEND( 配列名 [ , 値 ]* )
指定の配列の後ろに値を追加する。戻り値は追加した個数。

AR_APPENDAR int AR_APPENDAR( 配列名 [ , 追加配列名 ]* )
指定の配列の後ろに追加配列をすべて追加する。戻り値は追加した個数。

LINE2AR

int LINE2AR(
配列名
, str 文字列
[ , int 開始位置 ]
)

文字列から行単位で読み込み、配列に代入する。
戻り値は処理した個数。
開始位置を省略すると配列をクリアして、配列の先頭から代入する。
開始位置を指定すると、配列をクリアせずにその位置から代入する。開始位置は0が先頭を示す。
開始位置が負ならば現在の配列の末尾に追加して代入する。

記述例　
line2ar(a,lf('1st','2nd','3rd')) → 3
ar2str(a) → 1st,2nd,3rd

AR2LINE

str AR2LINE(
配列名
[ , int 個数 ]
)

配列の各要素を行として連結した文字列を返す。
個数で配列の先頭からの対象要素の数を指定する。個数を省略すると配列のすべての要素が対象。

記述例　 {arc(a,'1st','2nd','3rd'); ar2line(a); } →

1st↓
2nd↓
3rd↓

FIELD2AR

int FIELD2AR(
配列名
, str 文字列
)

文字列からタブ区切りで項目を読み込み、配列に代入する。戻り値は処理した個数。

記述例　
field2ar(a,tab('1st','2nd','3rd')) → 3
ar2str(a) → 1st,2nd,3rd

AR2FIELD

str AR2FIELD(
配列名
, [ , int 個数 ]
)

配列の各要素をタブで連結した文字列を返す。
個数で配列の先頭からの対象要素の数を指定する。個数を省略すると配列のすべての要素が対象。

記述例　 {arc(a,'1st','2nd','3rd'); ar2field(a); } →
1st→2nd→3rd

SPS2AR

int SPS2AR( 配列名 , str 文字列 )
スペース区切り文字列の要素を配列に格納する。
要素数を返却する。格納の前に配列はクリアする。

スペース区切り文字列は、各要素の間がスペース（制御コードを含む)で区切られた文字列。スペースの連続は一つのスペースとして扱う。

記述例　 {sps2ar(a,' abc def g ');ar2str(a)} → abc,def,g

SQS2AR

int SQS2AR( 配列名 , str 文字列 )
引用符を含むスペース区切り文字列の要素を配列に格納する。
要素数を返却する。格納の前に配列はクリアする。

扱う文字列は、各要素の間がスペース（制御コードを含む)で区切られた文字列で、要素は複引用符「"」で囲まれていることもある。複引用符の中で複引用符は、「\"」、で表される。また、「\」は「\\」で表される。。スペースの連続は一つのスペースとして扱う。

記述例　 {sqs2ar(a,' abc "def gh" i ');ar2str(a);} → abc,def gh,i

SDQS2AR

int SDQS2AR( 配列名 , str 文字列 )
引用符を含むスペース区切り文字列の要素を配列に格納する。
要素数を返却する。格納の前に配列はクリアする。

扱う文字列は、各要素の間がスペース（制御コードを含む)で区切られた文字列で、要素は複引用符「"」で囲まれていることもある。複引用符の中で複引用符は、「""」、で表される。。スペースの連続は一つのスペースとして扱う。

記述例　 {sdqs2ar(a,' abc "def""gh" i ');ar2str(a);} → abc,def"gh,i

STRN2AR

int STRN2AR( 配列名 , str 文字列 , int 文字数 )
文字列を指定の文字数に分けて配列に格納する。
要素数を返却する。格納の前に配列はクリアする。

FILE2AR

int FILE2AR(
配列名
, str ファイル名
[ , str ファイル名 ]*
)

ファイルから行単位で読み込み、配列の先頭から代入する。戻り値は処理した個数。
ファイル名が「""」の場合には標準入力から読み込む。ファイル名を複数書くとファイルを順に読み込む。
格納の前に配列はクリアする。

記述例　 file2ar(a,'value.txt')

FILE2ARIX

int FILE2ARIX(
配列名
, str ファイル名
, 置換式
)

ファイルから行単位で読み込み、置換式を評価した値を配列に代入する。戻り値は処理した個数。
ファイル名が「""」の場合には標準入力から読み込む。
評価式の中では変数 IX で 0 から始まる序数を、変数 SS で読み込んだ行を参照できる。格納の前に配列はクリアする。

記述例　 file2arix(a,'value.txt',strsp(ix,5)+sp+small(ss))

AR2FILE

int AR2FILE(
配列名
, str ファイル名
[ , int 個数 ]
)

配列の各要素を行としてファイルに書き込む。
ファイル名が「""」ならば、標準出力へ書き込む。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）
戻り値は処理した個数。
個数で配列の先頭からの対象要素の数を指定する。個数を省略すると配列のすべての要素が対象。

記述例　 ar2file(a,'result.txt')

AR2STR

str AR2STR(
配列名
[
, str セパレータ
[ , int 個数 ]
]
)

配列の各要素をセパレータを挟んで連結した文字列を返す。
セパレータを省略すると「,」をセパレータとする。個数で配列の先頭からの対象要素の数を指定する。個数を省略すると配列のすべての要素が対象。

記述例１　 {arc(a,1,2,3); ar2str(a);} → 1,2,3

記述例２　 {arc(a,1,2,3); ar2str(a,'x');} → 1x2x3

記述例３　 {arc(a,1,2,3); ar2str(a,tab);} →
1→2→3

AR2STRIX

STR AR2STRIX(
配列名
, { str セパレータ
| bool  改行フラグ
}
, str 置換式
)

配列のすべての要素に対して置換式を評価し連結した文字列を返す。
文字列のセパレータを指定すると、セパレータを挟んでキーを連結する。
改行フラグに TRUE を設定するとキーの最後に行末 (LF 0x0a) を付けて連結する。
改行フラグに FALSE を設定するとセパレータを使わずに連結する。
置換式の中では、ix で 0 から始まる序数を、sv で値を参照できる。

記述例　
{arc(a,'tokyo','sapporo','nagoya');} → 3
ar2strix(a,comma,colon(ix+1,sv)) → 1:tokyo;,2:sapporo;,3:nagoya;

ADD2AR

 ADD2AR(
配列名
, int 要素番号
, 値
)

配列に値を加算する。
演算は、引数の値の型で行う。配列要素が未定義の場合は値が代入され、配列要素の型が値の型と異なる場合は値と同じ型に変換してから演算を行う。演算の結果は引数の値の型と同じになり、その値を配列要素に代入する。演算結果を返す。
数値の型（整数、実数、小数）では加算が行われる。論理値では論理和（OR)演算、文字列では、連結を行う。

記述例　
arc(a,15,40.0,'名古屋') → 3
add2ar(a,0,200.0) → 215.0
add2ar(a,1,45) → 85
add2ar(a,2,'城') → 名古屋城
ar2str(a,comma) → 215.0,85,名古屋城

AR_CONC

str AR_CONC(
配列名
, int 要素番号
, str セパレータ
, str 文字列
)

配列要素に文字列を連結する。
変更された配列の値を返す
配列要素が空以外の文字列だった場合には、配列要素の後ろにセパレータ、文字列を連結する
それ以外の場合は文字列を代入する。

記述例　
ar_clear(a) → TRUE
ar_conc(a,0,comma,'abc') → abc
ar_conc(a,0,comma,'abc') → abc,abc

SEP

int SEP(
str 入力セパレータ
, str 対象文字列
, 配列名
)

対象文字列を入力セパレータで分割して、配列に格納し、個数を返す。
入力セパレータが長さ０の文字列（""）の場合は、対象文字列は文字ごとに分割される。
配列は事前にクリアされる。

記述例１　 {sep(':','1:2:3:4',a); ar2str(a);} → 1,2,3,4

記述例２　 {sep('','abc',a); ar2str(a);} → a,b,c

EXPAND_AR

int EXPAND_AR(
配列名
, str 文字列
[ , str モード ]
)

文字列をコマンドラインのようにパラメータ展開して配列に格納する。
個数を返す。
モードを省略すると間接展開をしない。
間接展開する場合は以下の文字の組み合わせで指定する。格納の前に配列はクリアする。

方法	内容
!	!展開
#	#展開
@	@展開
^	^展開

記述例　 {expand_ar(a,'a b c "d e" '); ar2str(a);} → a,b,c,d e

PUSHAR

int PUSHAR(
配列名
[ ,  値 ]*
)

配列の末尾に追加する。
追加した個数を返す。

記述例　
{ar_clear(a); pushar(a,10,20);} → 2
ar2str(a) → 10,20

POPAR

 POPAR(
配列名
)

配列の末尾から一つ取り出し、その値を返す。
配列の長さは一つ短くなる。

記述例　
{ar_clear(a); pushar(a,10,20);} → 2
comma(popar(a),popar(a)) → 20,10

SHIFTAR

 SHIFTAR(
配列名
)

配列の先頭から一つ取り出し、その値を返す。
配列の長さは一つ短くなる。

記述例　
{ar_clear(a); pushar(a,10,20);} → 2
ar2str(a) → 10,20
shiftar(a) → 10
ar2str(a) → 20
shiftar(a) → 20
ar2str(a) →

UNSHIFTAR

UNSHIFTAR(
配列名
, 値
)

配列の先頭に挿入する。
値を返す。

記述例　
{ar_clear(a); unshiftar(a,10);} → 10
ar2str(a) → 10
unshiftar(a,20) → 20
ar2str(a) → 20,10
comma(popar(a),popar(a)) → 10,20

INSAR int INSAR( 配列名 , int 位置 , int 個数 [ , 値 ] )
配列の指定位置に指定個数の要素を挿入する。
配列の要素数を返す。
挿入する値を指定できる。省略すると整数の0を書き込む。

INSDAR int INSDAR( 配列名 , int 位置 [ , 値 ]* )
配列の指定位置に記述した値を挿入する。
配列の要素数を返す。

INSIXAR int INSIXAR( 配列名 , int 位置 , int 個数 , 式 )
配列の指定位置に指定個数の要素を挿入する。挿入したの要素数を返す。
挿入する値を式で指定する。式は、代入のたびに評価され、特別な変数 IX で0から始まる序数を参照できる。

AR_INSAR int AR_INSAR( 配列名 , int 位置 [ , 挿入配列名 ]* )
配列の指定位置に記述した配列を挿入する。
配列の要素数を返す。

DELAR int DELAR( 配列名 , int 位置 [ , int 個数 ] )
配列の指定位置から指定個数の要素を削除する。
要素数を省略すると、位置以降のすべての要素を削除する。配列の要素数を返す。

REVERSE_AR

int REVERSE_AR(
配列名
)

配列の順序を逆にする。
配列の要素数を返す。

記述例　
arc(a,10,20,30,40) → 4
reverse_ar(a) → 4
ar2str(a) → 40,30,20,10

AR_FOR

int AR_FOR(
配列名
, 式
)

配列のすべての要素に関して式を評価する。
戻り値は繰返しの回数
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。評価式が BREAK になると処理を中断する。

記述例　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
{?count:=0; ar_for(a,when(isupper(sv),?count++));} → 4
?count → 2

AR_SEL

int AR_SEL(
配列名
, 転送先配列名
, bool 検定式
)

配列のすべての要素に関して検定式を評価し、真の場合は、現在の配列要素を転送先配列に追加する。
戻り値は追加した数。
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。

記述例　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
arc(b,'Nyanko','Wanwan') → 2
ar_sel(a,b,isupper(sv)) → 2
ar2str(b) → Nyanko,Wanwan,Osaka,Fukuoka

AR_REP

int AR_REP(
配列名
, 式
)

配列のすべての要素に式を代入する。
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。

記述例　
ar(a,'tokyo','osaka','nagoya','fukuoka') → 4
ar_rep(a,at(ix,large(sv))) → 4
ar2str(a) → 0@TOKYO,1@OSAKA,2@NAGOYA,3@FUKUOKA

AR_SCAN

int AR_SCAN(
配列名
, bool 評価式
)

配列の要素の数だけ、評価式を順に評価する。
評価が真になったら中断する。
戻り値は中断があったときは、そのときの変数 IX の値。中断が無ければ負の数(-1)。
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。

記述例　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
ar_scan(a,isupper(sv)) → 1

AR_PRIME

int AR_PRIME(
配列名
, bool 評価式
)

配列の要素の数だけ、評価式を順に評価する。
評価が真になったら中断する。
戻り値は中断があったときは、そのときの配列要素の値。中断が無ければFALSE。
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。

記述例　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
ar_prime(a,isupper(sv)) → Osaka

AR_SOME

bool AR_SOME(
配列名
, bool 評価式
)

配列の要素の数だけ、評価式を順に評価する。
評価が真になったら中断し、真を返す。
すべてが偽の場合のみ、偽を返す。
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。

記述例１　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
ar_some(a,isupper(sv)) → TRUE

記述例２　
arc(a,'tokyo','osaka','nagoya','fukuoka') → 4
ar_some(a,isupper(sv)) → FALSE

AR_EVERY

bool AR_EVERY(
配列名
, bool 評価式
)

配列の要素の数だけ、評価式を順に評価する。
評価が偽になったら中断し、偽を返す。
すべてが真の場合のみ、真を返す。
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。

記述例１　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
ar_every(a,isupper(sv)) → FALSE

記述例２　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
ar_every(a,isupper(sv)) → FALSE

AR_REDUCE

bool AR_REDUCE(
配列名
, 評価式
[, 初期値 ]
)

配列に対する累積演算をし、結果を返す。
評価式中では、特別な変数 SV1が累積値を表し、SV2 が配列の要素を表す。評価式の値がそのときの累積値となる。
初期値を指定しない場合、最初の累積値は配列の最初の要素で、評価は　[ 配列の大きさ -1 ] 回繰り返す。このとき、配列の要素が一つだけならば、評価は全く行わない。配列の要素が無ければ、論理値 FALSE を返す。
初期値を指定した場合、最初の累積値は初期値となり、評価は配列の大きさだけ繰り返す。
評価式の中では特別な変数 IXで着目中の配列要素（SV2）に対するインデックスを参照できる。

記述例１　
{ar_clear(a); repeat(10,a[ix]:=ix+1);} → 10
ar_reduce(a,sv1+sv2) → 10

記述例２　
{ar_clear(a); repeat(10,a[ix]:=ix+1);} → 10
ar_reduce(a,sv1-sv2,100) → -10

AR_MAP2

bool AR_MAP2(
格納先配列名
, 配列名１
, 配列名２
, 評価式
)

配列１と配列２の対応する要素を評価式して格納先配列に代入する。繰返しの回数を返す。
配列１と配列２の大きさが違う場合には、小さい方の大きさを繰返しの回数とする。
格納先配列は処理に先立ってクリアしない。
三つの配列は同一のものでも良い。
式の中では特別な変数 SV1 で配列１の要素を、SV2 で配列２の要素を、IXで 0 から始まる配列の指標を参照できる。

記述例１　
{ar_clear(a,b,c); repeat(10,a[ix]:=ix+1,b[ix]:=ix+11);} → 20
ar_map2(c,a,b,sv1+sv2) → 10
ar2str(c) → 11,12,13,14,15,16,17,18,19,20

AR_FILL

AR_FILL(
配列名
, 値
[
, int 個数
|
, int 開始位置
, int 個数
]
)

配列の全ての要素に同じ値を代入する。戻り値は代入した値。
個数を指定すると先頭から指定の個数だけ代入する。
開始位置と個数を指定すると、指定位置から指定の個数だけ代入する。開始位置を負の値で指定すると指定個数だけの追加をする。

記述例１　
{dim(a,5); ar_fill(a,'=');} → =
ar2str(a) → =,=,=,=,=

AR_SET

int AR_SET(
配列名
, 個数
, 式
)

配列の先頭要素から指定個数だけ式の値を代入する。
式は代入のたびに評価される。
式の中では特別な変数 IXで 0 から始まる指標を参照できる。特別な変数 SV では値を参照できる。

記述例１　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
{ar_set(a,2,str(ix+1));} → 2
ar2str(a) → 1,2,nagoya,Fukuoka

記述例２　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
{ar_set(a,5,large(str(sv)));} → 5
ar2str(a) → TOKYO,OSAKA,NAGOYA,FUKUOKA,0

SORT_AR

int SORT_AR(
対象配列名
, int 評価式
[ , 格納配列名 ]
)

対象の配列を整列する。個数を返す。
評価式が二つの配列要素の順序を決める。評価式では、配列要素は SV1 と SV2で参照し、大小関係によって -1 / 0 / 1 のいずれかを返す必要がある。

大小	戻り値
`SV1` < `SV2`	-1
`SV1` = `SV2`	0
`SV1` > `SV2`	1

評価式はテキストインタプリトされるので遅い。極力短い式を書く必要がある。単純な同じ型のデータの比較ならば、特化した関数（SORT_AR_STR など）を使用したほうが良い。
格納配列名を指定すると、対象配列は変更されず、格納配列に要素番号が格納される。

記述例１　
{ar_clear(a); repeat(10,a[ix]:=ix); } → 9
sort_ar(a,compint(sv2,sv1)) → 10
ar2str(a) → 5,0,2,3,4,1,6,7,8,9

SORT_AR_STR

int SORT_AR_STR(
対象配列名
[ , int 整列法
[ , 格納配列名 ]
]
)

対象の配列を文字列として整列する。個数を返す。
配列の中はすべて文字列になる。方法は0-5の数値で指定する。省略すると 0 。
格納配列名を指定すると、対象配列は変更されず、格納配列に要素番号が格納される。

方法	内容
0	昇順
1	降順
2	英大小文字の区別をせずに、昇順
3	英大小文字の区別をせずに、降順
4	バイトの昇順
5	バイトの降順

記述例１　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
sort_ar_str(a) → 4
ar2str(a) → Fukuoka,Osaka,nagoya,tokyo

記述例２　
arc(a,'tokyo','Osaka','nagoya','Fukuoka') → 4
{ar_clear(b); sort_ar_str(a,0,b);} → 4
ar2str(a) → tokyo,Osaka,nagoya,Fukuoka
ar2str(b) → 3,1,2,0

SORT_AR_INT

int SORT_AR_INT(
対象配列名
[ , bool 逆順フラグ
[ , 格納配列名 ]
]
)

整数値として整列する。個数を返す。
配列の中はすべて整数になる。
格納配列名を指定すると、対象配列は変更されず、格納配列に要素番号が格納される。

記述例１　
{ar_clear(a); ar_set(a,5,10-ix);} → 5
ar2str(a) → 10,9,8,7,6
sort_ar_int(a) → 5
ar2str(a) → 6,7,8,9,10

記述例２　
{ar_clear(a); ar_set(a,5,ix*10);} → 5
ar2str(a) → 0,10,20,30,40
{ar_clear(b); sort_ar_int(a,TRUE,b);} → 5
ar2str(a) → 0,10,20,30,40
ar2str(b) → 4,3,2,1,0

SORT_AR_FLOAT

int SORTAR_FLOAT(
対象配列名
[ ,  bool 逆順フラグ
[ ,  格納配列名 ]
]
)

実数値として整列する。個数を返す。
配列の中はすべて実数になる。
格納配列名を指定すると、対象配列は変更されず、格納配列に要素番号が格納される。

記述例１　
{ar_clear(a); ar_set(a,5,10.0-ix);} → 5
ar2str(a) → 10.0,9.0,8.0,7.0,6.0
sort_ar_float(a) → 5
ar2str(a) → 6.0,7.0,8.0,9.0,10.0

記述例２　
{ar_clear(a); ar_set(a,5,ix*10.0);} → 5
ar2str(a) → 0.0,10.0,20.0,30.0,40.0
{ar_clear(b); sort_ar_float(a,TRUE,b);} → 5
ar2str(a) → 0.0,10.0,20.0,30.0,40.0
ar2str(b) → 4,3,2,1,0

SORT_AR_FIX

int SORTAR_FIX(
配列名
[ ,  bool 逆順フラグ
[ ,  格納配列名 ]
]
)

小数値として整列する。個数を返す。
配列の中はすべて小数になる。
格納配列名を指定すると、対象配列は変更されず、格納配列に要素番号が格納される。

記述例１　
{ar_clear(a); ar_set(a,5,0c10-ix);} → 5
ar2str(a) → 10,9,8,7,6
sort_ar_fix(a) → 5
ar2str(a) → 6,7,8,9,10

記述例２　
{ar_clear(a); ar_set(a,5,ix*0c10);} → 5
ar2str(a) → 0,10,20,30,40
{ar_clear(b); sort_ar_fix(a,TRUE,b);} → 5
ar2str(a) → 0,10,20,30,40
ar2str(b) → 4,3,2,1,0

AR_ORDER

int AR_ORDER(
対象配列名
, 順位配列名
)

対象配列の要素を順位配列に従って並べなおす。戻り値は順位配列の大きさ。
順位配列には、0 から始まる整数値で要素番号を並べておく。この番号に従って、対象配列の該当する要素をそこに置く。整列の結果の要素番号を利用して実際に並べなおすときに使用する。

記述例１　
{ar_clear(a); ar(a,100,200,300);} → 3
{ar_clear(b); ar(b,2,1,0);} → 3
ar_order(a,b) → 3
ar2str(a) → 300,200,100

記述例２　
{ar_clear(a); ar(a,100,200,300);} → 3
{sort_ar_int(a,true,b);} → 3
ar_order(a,b) → 3
ar2str(a) → 300,200,100

PROD_AR

float PROD_AR(
配列名
[ , float 式 ]
)

実数値としての要素の総積。
式を書くと、配列の要素のすべてに対して式を評価し、その積を返す。式の中では、 IX では 0 から始まる序数を、 SVでは配列の値を参照できる。

記述例１　
{ar_clear(a); ar_set(a,5,ix+1.0);} → 5
ar2str(a) → 1.0,2.0,3.0,4.0,5.0
prod_ar(a) → 120.0

記述例２　
{ar_clear(a); ar_set(a,5,ix+1.0);} → 5
ar2str(a) → 1.0,2.0,3.0,4.0,5.0
prod_ar(a,sv+1.0) → 720.0

SUM_AR

float SUM_AR(
配列名
[ , float 式 ]
)

実数値としての要素の総和。
式を書くと、配列の要素のすべてに対して式を評価し、その和を返す。式の中では、 IX では 0 から始まる序数を、 SVでは配列の値を参照できる。

記述例１　
{ar_clear(a); ar_set(a,5,ix+1.0);} → 5
ar2str(a) → 1.0,2.0,3.0,4.0,5.0
sum_ar(a) → 15.0

記述例２　
{ar_clear(a); ar_set(a,5,ix+1.0);} → 5
ar2str(a) → 1.0,2.0,3.0,4.0,5.0
sum_ar(a,sqrt(sv)) → 8.3823323474417624

SUM2_AR

float SUM2_AR(
配列名
)

実数値としての要素の平方和。

記述例　
{ar_clear(a); ar_set(a,5,ix+1.0);} → 5
ar2str(a) → 1.0,2.0,3.0,4.0,5.0
sum2_ar(a) → 55.0

MEAN_AR

float MEAN_AR(
配列名
)

実数値としての要素の平均値。

記述例　
{ar_clear(a); ar_set(a,10,ix+1.0);} → 10
ar2str(a) → 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0
mean_ar(a) → 5.5

DIV_AR

float DIV_AR(
配列名
)

実数値としての要素の母集団分散。

記述例　
{ar_clear(a); ar_set(a,10,ix+1.0);} → 10
ar2str(a) → 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0
div_ar(a) → 8.25

DIV1_AR

float DIV1_AR(
配列名
)

実数値としての要素の標本集団分散。

記述例　
{ar_clear(a); ar_set(a,10,ix+1.0);} → 10
ar2str(a) → 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0
div1_ar(a) → 9.1666666666666661

SD_AR

float SD_AR(
配列名
)

実数値としての要素の母集団偏差。

記述例　
{ar_clear(a); ar_set(a,10,ix+1.0);} → 10
ar2str(a) → 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0
sd_ar(a) → 2.8722813232690143

SD1_AR

float SD1_AR(
配列名
)

実数値としての要素の標本集団偏差。

記述例　
{ar_clear(a); ar_set(a,10,ix+1.0);} → 10
ar2str(a) → 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0
sd1_ar(a) → 3.0276503540974917

MIN_AR

float MIN_AR(
配列名
)

実数値としての要素の最小値。

記述例　
{ar_clear(a); ar_set(a,10,ix+1.0);} → 10
ar2str(a) → 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0
min_ar(a) → 1.0

MAX_AR

float MAX_AR(
配列名
)

実数値としての要素の最大値。

記述例　
{ar_clear(a); ar_set(a,10,ix+1.0);} → 10
ar2str(a) → 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0
max_ar(a) → 10.0

連想配列変数

ASAR_DIM

int ASAR_DIM(
連想配列名
, int 要素数
)

連想配列の内部テーブルを予約する。
設定した要素数を返す。
動作速度を改善するためにメモリ割り当てを先行して行う。通常は使用しなくても良い。

記述例　 asar_dim(a,30) → 30

ASAR_DIMC int ASAR_DIM( 連想配列名 , int 要素数 , int キーサイズ , [ int データサイズ ] )
連想配列の内部テーブル、キーテーブル、データテーブルを予約する。
設定した要素数を返す。
この処理は廃止された。以前のバージョンとの互換性のために残されている。

ASAR

int ASAR(
連想配列名
[ ,
{
{ strキー
[ , 値 ]
}
|
strキー
}
]*
)

連想配列に代入する。
戻り値は代入した個数。
キーと値の組で与えるが、値を省略すると、整数値の 0 を値とする。キーだけを与えるときには「{}」は書かなくても良い。

記述例１　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',24});} → 3
asar2str(a,',',':') → nagoya:24,sapporo:40,tokyo:15

記述例２　
{asar_clear(a); asar(a,'tokyo','sapporo','nagoya');} → 3
asar2str(a,',',':') → nagoya:0,sapporo:0,tokyo:0

ASARC int ASARC( 連想配列名 [ , { { strキー [ , 値 ] } | strキー } ]* )
連想配列に代入する。
戻り値は代入した個数。
ASAR()と同様だが、代入の前に連想配列をクリアする。

ASAR_WT int ASAR_WT( 連想配列名 [ , strキー ]* )
連想配列にキーを代入する。
戻り値は登録数。
キーを登録する。値は、そのときの登録数となる。この結果、登録順に従って、0 から始まる整数が値になる。代入の前に、連想配列をクリアしない。

ASAR_WTC int ASAR_WTC( 連想配列名 [ , strキー ]* )
連想配列にキーを代入する。戻り値は登録数。
ASAR_WT()と同様だが、代入の前に連想配列をクリアする。

ASAR_CLEAR

bool ASAR_CLEAR(
連想配列名
[ , 連想配列名 ]*
)

連想配列を空にする。戻り値は常に真。

記述例　 asar_clear(a,b,c) → TRUE

ASAR_COPY

int ASAR_COPY(
転送元連想配列名
, 転送先連想配列名
)

連想配列を複写する。戻り値は要素数。

記述例　 asar_copy(a,b) → 0

ASAR_COUNT

int ASAR_COUNT(
連想配列名
)

連想配列の要素数を返す。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',24});} → 3
asar_count(a) → 3

ASAR_REF

ASAR_REF(
連想配列名
, str キー
, 未定値
)

連想配列にキーが登録されていればその値を返し、登録されていなければ、未定値を評価して返す。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',24});} → 3
asar_ref(a,'tokyo',0) → 15
asar_ref(a,'oosaka',0) → 0

ASAR_SET

bool ASAR_SET(
連想配列名
, str キー
, 値
)

連想配列にキーが登録されていれば値を書き込み真を返す。
登録されていなければ、偽を返す。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',24});} → 3
asar_set(a,'tokyo',200) → TRUE
asar_set(a,'oosaka',45) → FALSE
asar2str(a,',',':') → nagoya:24,sapporo:40,tokyo:200

ADD2ASAR

 ADD2ASAR(
連想配列名
, str キー
, 値
)

連想配列に値を加算する。
演算は、引数の値の型で行う。配列要素が未定義の場合は値が代入され、配列要素の型が値の型と異なる場合は値と同じ型に変換してから演算を行う。演算の結果は引数の値の型と同じになり、その値を配列要素に代入する。演算結果を返す。
数値の型（整数、実数、小数）では加算が行われる。論理値では論理和（OR)演算、文字列では、連結を行う。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40.0},{'nagoya','名古屋'});} → 3
add2asar(a,'tokyo',200.0) → 215.0
add2asar(a,'sapporo',45) → 85
add2asar(a,'nagoya','城') → 名古屋城
asar2str(a,',',':') → nagoya:名古屋城,sapporo:85,tokyo:215.0

ASAR_CONC

str ASAR_CONC(
連想配列名
, str キー
, str セパレータ
, str 値
)

連想配列に文字列を追加する。
キーが存在しない、または、空文字列だった場合には、値をそのまま書き込む。
キーが存在して空文字列ではなかった場合には、指定要素の値を文字列にして、後ろに、セパレータ、値を連結する。

記述例　
asar_clear(a) → TRUE
asar_conc(a,'tokyo','/',200) → 200
asar2str(a,',',':') → tokyo:200
asar_conc(a,'tokyo','/',450) → 200/450
asar2str(a,',',':') → tokyo:200/450

ASAR_DEL

bool ASAR_DEL(
連想配列名
[ , str キー ]*
)

連想配列のキーで指定されている要素を削除する。
キーが存在すれば真を返し、存在していなければ偽を返す。
キーを複数書いた場合は、すべてのキーが存在したときに真を返す

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
asar_del(a,'tokyo') → TRUE
asar_del(a,'oosaka') → FALSE
asar2str(a,',',':') → nagoya:30,sapporo:40

HASKEY

BOOL HASKEY(
連想配列名
, str キー
)

連想配列にキーが登録されていれば真を返す。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
haskey(a,'tokyo') → TRUE
haskey(a,'oosaka') → FALSE

ASAR_HASKEY

BOOL ASAR_HASKEY(
連想配列名
, str キー
)

連想配列にキーが登録されていれば真を返す。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
asar_haskey(a,'tokyo') → TRUE
asar_haskey(a,'oosaka') → FALSE

ASAR2STR

STR ASAR2STR(
連想配列名
[
, { str セパレータ１
| bool  改行フラグ
}
[ , str セパレータ２ ] ]
)

連想配列に登録されているキーを連結した文字列を返す。
セパレータを省略すると「,」を挟んで連結する。
文字列のセパレータ１を指定すると、セパレータ１を挟んでキーを連結する。
改行フラグに TRUE を設定するとキーの最後に行末 (LF 0x0a) を付けて連結する。
改行フラグに FALSE を設定するとセパレータを使わずに連結する。
セパレータ２を指定すると、キーの替わりにキーと値をセパレータ２で連結したもの要素として用いる。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
asar2str(a) → nagoya,sapporo,tokyo
asar2str(a,':') → nagoya:sapporo:tokyo
asar2str(a,true) →

nagoya↓
sapporo↓
tokyo↓

asar2str(a,',',':') → nagoya:30,sapporo:40,tokyo:15
asar2str(a,true,eql) →

nagoya=30↓
sapporo=40↓
tokyo=15↓

ASAR2STRIX

STR ASAR2STRIX(
連想配列名
, { str セパレータ
| bool  改行フラグ
}
, str 置換式
)

連想配列のすべての要素に対して置換式を評価し連結した文字列を返す。
文字列のセパレータを指定すると、セパレータを挟んでキーを連結する。
改行フラグに TRUE を設定するとキーの最後に行末 (LF 0x0a) を付けて連結する。
改行フラグに FALSE を設定するとセパレータを使わずに連結する。
置換式の中では、ix で 0 から始まる序数を、ss でキーを、sv で値を参照できる。
置換式の中で処理中の連想配列に要素を登録削除してはならない。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
asar2strix(a,' : ',comma(ix+1,ss,sv)) → 1,nagoya,30 : 2,sapporo,40 : 3,tokyo,15

ASAR2LINE

str ASAR2LINE(
連想配列名
)

連想配列に登録されているキーと値を組にして連結した文字列を返す。
キーと値の間はタブ (TAB 0x09) で連結し、最後に行末 (LF 0x0a) を付加する。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
asar2line(a) →

nagoya→30↓
sapporo→40↓
tokyo→15↓

LINE2ASAR

int LINE2ASAR(
連想配列名
, str 文字列
)

文字列の各行を連想配列に登録する。
登録個数を返す。行は行末で区切られるが、そのうち最初の　タブ（あるいはタブが無ければ行末）までをキーとし、その後ろを値とする。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
s:=lines(fields('oosaka',45),fields('fukuoka',98)) →

oosaka→45↓
fukuoka→98↓

line2asar(a,s) → 2
asar2str(a,',',':') → fukuoka:98,nagoya:30,oosaka:45,sapporo:40,tokyo:15

LINE2ASARSUM

int LINE2ASARSUM(
連想配列名
, str 文字列
)

文字列の各行を連想配列に集計する。
行はキー　TAB 値　[TAB ...]* LF の形を想定している。集計するのは最初の値。

記述例　
asar_clear(a) → TRUE
s:=lines(fields('oosaka',45),fields('fukuoka',98),fields('oosaka',99)) →

oosaka→45↓
fukuoka→98↓
oosaka→99↓

line2asarsum(a,s) → 3
asar2str(a,',',':') → fukuoka:98.0,oosaka:144.0

FILE2ASAR

int FILE2ASAR(
連想配列名
, str ファイル名
[, str ファイル名 ]*
)

ファイルの内容を行ごとに連想配列に登録する。
戻り値は登録した個数を返却する。
行は行末で区切られるが、そのうち最初の　タブ（あるいはタブが無ければ行末）までをキーとし、その後ろを値とする。ファイル名が "" ならば標準入力から読み込む。
連想配列はクリアせずに代入するので常に追加登録となることに留意すること。

記述例　 file2asar(a,'test.txt')

FILE2ASARIX

int FILE2ASARIX(
連想配列名
, str ファイル名
, 評価式
)

ファイルの内容を行ごとに、評価式を評価して値とし、連想配列に登録する。
戻り値は登録した個数を返却する。
行は行末で区切られるが、そのうち最初の　タブ（あるいはタブが無ければ行末）までをキーとし、その後ろを値とする。
評価式の中では、変数 IXで 0 から始まる序数を、変数 SSで読み込んだ値を参照できる。

記述例　 file2asarix(a,'test.txt',kakko(ss))

ASAR2FILE

int ASAR2FILE(
連想配列名
, str ファイル名
)

連想配列に登録されているすべてのキーを値を組にしてファイルへ出力する。
ファイル名が「""」ならば、標準出力へ出力。ファイル名が「"#"」ならば標準エラー出力へ出力。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）
戻り値は出力した数。
キーと値をタブ (TAB 0x09) で連結して行として出力する。

記述例　 asar2file(a,'test.txt')

ASAR2AR

int ASAR2AR(
連想配列名
, 転送先配列名
[ , bool 値フラグ ]
)

連想配列に登録されているキーをすべて、転送先配列に書き込む。戻り値はキーの数。
値フラグを真にすると、キーの代わりに対応する値を書き込む。
転送先配列は、事前にクリアするので、その大きさは連想配列のキーの数と同じになる。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
asar2str(a,',',':') → nagoya:30,sapporo:40,tokyo:15
asar2ar(a,b) → 3
ar2str(b) → nagoya,sapporo,tokyo
asar2ar(a,c,true) → 3
ar2str(c) → 30,40,15

KEYS

int KEYS(
連想配列名
, 転送先配列名
)

連想配列に登録されているキーをすべて、転送先配列に書き込む。戻り値はキーの数。
転送先配列は、事前にクリアするので、その大きさは連想配列のキーの数と同じになる。
asar2ar(from,to) と同じ。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
keys(a,b) → 3
ar2str(b) → nagoya,sapporo,tokyo

VALUES

int VALUES(
連想配列名
, 転送先配列名
)

連想配列に登録されている値をすべて、転送先配列に書き込む。戻り値は値の数。
転送先配列は、事前にクリアするので、その大きさは連想配列の値の数と同じになる。
asar2ar(from,to,true) と同じ。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
values(a,b) → 3
ar2str(b) → 30,40,15

AR2ASAR

int AR2ASAR(
転送元キー配列名
[ , 転送元値配列名 ]
, 転送先連想配列名
)

転送元キー配列の各要素をキー、転送元値配列の相当する要素を値として転送先連想配列に書き込む。戻り値は、転送先連想配列の要素数
転送元値配列名を省略すると数値 0 を値として書き込む。
処理に先立って転送先連想配列をクリアする。

記述例　
{ar_clear(a,b); ar(a,'tokyo','sapporo','nagoya');} → 3
{ar(b,100,200,300);} → 3
ar2asar(a,b,c) → 3
asar2str(c,comma,colon) → nagoya:300,sapporo:200,tokyo:100

ABBREV

int ABBREV(
配列名
, 連想配列名
)

配列に入っている文字列群の短縮形を列挙して連想配列に格納する。戻り値は連想配列の大きさ
連想配列のキーが短縮形、値が本来の文字列を表す。処理に先立って連想配列はクリアされる。
配列の中の文字列に重複があると正しく動作しない。

記述例　
{ar_clear(a); ar(a,'print','prompt');} → 2
abbrev(a,b) → 7
asar2str(b,comma,colon) → pri:print,prin:print,print:print,pro:prompt,prom:prompt,promp:prompt,prompt:prompt

FOREACH

int FOREACH(
連想配列名
, 評価式
)

連想配列に登録されているすべてのキーに対して評価式を実行する。戻り値はキーの数。
評価式の中では特殊な変数 SS でキーを、 IX で 0 から始まる序数を参照できる。キーを呼び出す順序は保障されない。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
{s:=0; foreach(a,when(a{ss}>20,s+=a{ss}));} → 3
s → 70

ASAR_FOR

int ASAR_FOR(
連想配列名
, 評価式
)

連想配列に登録されているすべてのキーに対して評価式を実行する。戻り値はキーの数。
評価式の中では特殊な変数 SS でキーを、 SV で値を、 IX で 0 から始まる序数を参照できる。キーを呼び出す順序は保障されない。
この関数では、最初にキーと値の組を退避してから繰返しを実行するので安全だが、遅い！評価式が BREAK になると処理を中断する。

記述例　
{asar_clear(a); asar(a,{'tokyo',15},{'sapporo',40},{'nagoya',30});} → 3
{s:=0; asar_for(a,when(sv>20,s+=sv));} → 3
s → 70

固有整数変数

過去のバージョンと互換性を保つために残してある機能。固有整数変数を使用する必要はない。

IVAR int IVAR[ int 指標 ] [ := int 値 ]　または
int IVAR( int 指標 [ , int 値 ] )
指標で示すの固有整数変数の値を返す。
値を書くと、値をセットする。
指標は 0 から数える。
固有変数は一つのプログラム内で共通の値を持つ。

IVARSET int IVARSET( int 指標 , int 値 )
指標が示す固有整数変数に値をセットする。
以前の値を返す。

PUSHIVAR int PUSHIVAR( int 値 )
引数の数値を固有整数変数に格納する。
内部インデックスは１増加する。数値を返す。

互換性を維持するために内部インデックスを操作する以下の書式がサポートされているが、代わりに IVARINDEX を用いることを勧める。
int PUSHIVAR
内部インデックスの値を返す。
int PUSHIVAR( bool TRUE ,int 開始位置 )
内部インデックスを設定する。

POPIVAR int POPIVAR
内部インデックスより一つ小さい値で示される固有整数変数の値。
内部インデックスは１減少する。
PUSHIVARに対応する。

IVARINDEX int IVARINDEX [( int 位置 )]
内部インデックスの値。
引数を指定すると内部インデックスに位置を設定する。位置は 0 以上の整数。
PUSHIVAR / POPIVAR に対応する。

FILE2IVAR int FILE2IVAR( str ファイル名 [ , int 開始変数番号 [ , int 制限個数 ]] )
ファイルから固有整数変数に一括読み込み。
行単位で読み込み、値を変数にセットする。読み込んだ行数を返却。
ファイル名が "" ならば、標準入力から読み込む。開始変数番号の指定ができる。指定しなければ、０から順にセットする。
制限個数を指定できる。

IVAR2FILE int IVAR2FILE( str ファイル名 [ , int 開始変数番号 [ , int 個数 ]] )
固有整数変数をファイルに出力。
一つの変数が一行。書き込んだ行数を返却。
ファイル名が「""」ならば、標準出力へ書き込む。ファイル名が"#"ならば、標準エラー出力へ出力。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）
開始変数番号を省略すると最初の変数から、内部インデックスの前まで出力。
開始変数番号を指定して、個数を指定しなければ１６個出力する。

固有実数変数

過去のバージョンと互換性を保つために残してある機能。固有実数変数を使用する必要はない。

FVAR float FVAR[ int 指標 ] [:= float 値 ]　または
float FVAR( int 指標 [ , float 値 ] )
指標が示す固有実数変数の値を返す。
値を書くと、値をセットする。
指標は 0 から数える。
固有変数は一つのプログラム内で共通の値を持つ。

FVARSET float FVARSET( int 指標 , float 値 )
index番目の固有実数変数に値をセットする。
以前の値を返す。

PUSHFVAR float PUSHFVAR( float 値 )
引数の数値を固有実数変数に格納する。
内部インデックスは１増加する。数値を返す。

互換性を維持するためにインデックスを操作する以下の書式をサポートしているが、代わりに FVARINDEX を使用することを勧める。
int PUSHFVAR
内部インデックスの値
int PUSHFVAR( bool TRUE , int 開始位置 )
内部インデックスに位置をセットする。

POPFVAR float POPFVAR
内部インデックスより一つ小さい値で示される固有実数変数の値。
内部インデックスは１減少する。
PUSHFVARに対応する。

FVARINDEX int FVARINDEX[( int 位置 )]
内部インデックスの値。
引数を指定すると内部インデックスに位置を設定する。位置は 0 以上の整数。
PUSHFVAR / POPFVAR に対応する。

FILE2FVAR int FILE2FVAR( str ファイル名 [ , int 開始変数番号 [ , int 制限個数 ] ] )
ファイルから固有実数変数に一括読み込み。
行単位で読み込み、値を変数にセットする。読み込んだ行数を返却。
ファイル名が "" ならば、標準入力から読み込む。開始変数番号の指定ができる。指定しなければ、０から順にセットする。
制限個数を指定できる。
固有実数変数は、FXPRで使用する。

FVAR2FILE int FVAR2FILE( str ファイル名 [ , int 開始変数番号 [ , int 個数 ] ] )
固有実数変数をファイルに出力。
一つの変数が一行。書き込んだ行数を返却。
ファイル名が "" ならば、標準出力へ出力。ファイル名が"#"ならば、標準エラー出力へ出力。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）
開始変数番号を省略すると最初の変数から、内部インデックスの前まで出力。
開始変数番号を指定して、個数を指定しなければ１６個出力する。

固有文字列変数

過去のバージョンと互換性を取るために残している機能。固有文字列変数を使用する必要はない。

SVAR str SVAR[ int 指標 ] [ := str 値 ]　または
str SVAR( int 指標 [ , str 値 ] )
指標が示す固有文字列変数の値を返す。
値を書くと、値をセットする。
指標は 0 から数える。
固有変数は一つのプログラム内で共通の値を持つ。

SVARSET str SVARSET( int 指標 , str 値 )
index番目の固有文字列変数に値をセットする。
以前の値を返す。

FIELD2SVAR int FIELD2SVAR( str 文字列 [ , int 開始位置 [ , int 上限個数 ]] )
文字列をタブ区切り項目として、各フィールドを固有文字列変数に順に格納する。
開始位置で格納開始位置、上限個数で格納個数制限を指定できる。個数を返却する。

SVAR2FIELD str SVAR2FIELD( int 開始位置 , int 個数 [ , bool 判別式 ] )
固有文字列変数をタブ区切りで連結する。
開始位置で格納開始位置、個数で格納個数を指定する。
判別式を書くと判別式が真の場合だけ連結対象にする。このとき、特別な変数 SS に該当する固有文字列変数の値が格納されている。

LINE2SVAR int LINE2SVAR( str 文字列 [ , int 開始位置 [ , int 上限個数 ]] )
文字列をLF区切りとした行として、各行を固有文字列変数に順に格納する。
開始位置で格納開始位置、上限個数で格納個数制限を指定できる。
格納した個数を指定する。

SVAR2LINE str SVAR2LINE( int 開始位置 , int 個数 [ , bool 判別式 ] )
固有文字列変数をLFで連結する。文字列の最後にもLFが追加される。
開始位置で格納開始位置、個数で格納個数を指定する。
判別式を書くと判別式が真の場合だけ連結対象にする。このとき、特別な変数 SS に該当する固有文字列変数の値が格納されている。

SVARCONC

str SVARCONC(
str セパレータ
, int 開始位置
, int 終了位置
)

指定範囲の固有文字列変数をセパレータで連結して返す。

svarconc(tab,0,5)

0番から5番までの６つの変数をtabで連結したもの。

SVARCONCLIST str SVARCONCLIST( str セパレータ [ , int 番号 ]* )
指定番号の固有文字列変数をセパレータで連結して返す。

SVAR_REP int SVAR_REP( int 開始位置 , int 個数 , str 置換式 )
開始位置から指定の個数分の固有文字列変数の内容を置換式で置き換える。
置換式では、特殊な変数 SS で該当する固有文字列変数の値を参照できる。
特殊な変数 IX では 0 から始まる序数を参照できる。

SVAR_SCAN int SVAR_SCAN( int 開始位置 , int 個数 , bool 判定式 )
開始位置から指定の個数分の固有文字列変数の内容を判定式で判定する。
判定式が真になると繰返しを中断し、そのときのIXの値を返す。すべてが偽の場合は、-1 を返す。
判定式では、特殊な変数 SS で該当する固有文字列変数の値を参照できる。特殊な変数 IX では 0 から始まる序数を参照できる。

SVAR_SOME bool SVAR_SOME( int 開始位置 , int 個数 , bool 判定式 )
開始位置から指定の個数分の固有文字列変数の内容を判定式で判定する。
判定式が真になると繰返しを中断し、真を返す。すべてが偽の場合のみ、偽を返す。
判定式では、特殊な変数 SS で該当する固有文字列変数の値を参照できる。特殊な変数 IX では 0 から始まる序数を参照できる。

SVAR_EVERY int SVAR_EVERY int 開始位置 , int 個数 , bool 判定式 )
開始位置から指定の個数分の固有文字列変数の内容を判定式で判定する。
判定式が偽になると繰返しを中断し、偽を返す。すべてが真の場合のみ、真を返す。
判定式では、特殊な変数 SS で該当する固有文字列変数の値を参照できる。特殊な変数 IX では 0 から始まる序数を参照できる。

PUSHSVAR str PUSHSVAR( str 文字列 )
引数の文字列を固有文字列変数に格納する。
内部インデックスは１増加する。文字列を返す。

互換性を維持するため、内部インデックスを操作する以下の書式もサポートしているが、代わりに SVARINDEX を使用することを勧める。
int PUSHSVAR
内部インデックスの値を返す。
int PUSHSVAR ( int 開始位置 )
内部インデックスを設定する。

POPSVAR str POPSVAR
内部インデックスより一つ小さい値で示される固有文字列変数の値。
内部インデックスは１減少する。
PUSHSVARに対応する。

SVARINDEX int SVARINDEX[( int 位置 )]
内部インデックスの値。
引数を指定すると内部インデックスに位置を設定する。位置は 0 以上の整数。
PUSHSVAR / POPSVAR に対応する。

FILE2SVAR int FILE2SVAR( str ファイル名 [ , int 開始変数番号 [ , int 制限個数 ] ] )
ファイルから固有文字列変数に一括読み込み。
行単位で読み込み、値を変数にセットする。読み込んだ行数を返却。
ファイル名が "" ならば、標準入力から読み込む。開始変数番号の指定ができる。指定しなければ、０から順にセットする。
制限個数を指定できる。

SVAR2FILE int SVAR2FILE( str ファイル名 [ , int 開始変数番号 [ , int 個数 ] ] )
固有文字列変数をファイルに出力。
一つの変数が一行。書き込んだ行数を返却。
ファイル名が "" ならば、標準出力へ出力。ファイル名が"#"ならば、標準エラー出力へ出力。
ファイル名の先頭に「+」があると、追加モードで出力する。（ファイル名には「+」は含まれない。）
開始変数番号を省略すると最初の変数から、内部インデックスの前まで出力。
開始変数番号を指定して、個数を指定しなければ１６個出力する。

SVARSORT

int SVARSORT(
int 開始変数番号
, int 個数
[ , int 方法 ]
)

指定範囲の固有文字列変数を並べ直す。個数を返す。
方法は0-5の数値で指定する。省略すると 0 。

方法	内容
0	昇順
1	降順
2	英大小文字の区別をせずに、昇順
3	英大小文字の区別をせずに、降順
4	バイトの昇順
5	バイトの降順

EXPAND

int EXPAND(
int 開始変数番号
, str 文字列
[, str モード ]
)

文字列をコマンドラインのようにパラメータ展開して固有文字列変数に個数分だけ格納する。
個数を返す。
モードを省略すると間接展開をしません。
間接展開する場合は以下の文字の組み合わせで指定する。

方法	内容
!	!展開
#	#展開
@	@展開
^	^展開

スロットファイル

FILEFREE int FILEFREE[()]
空いているスロット番号を返す。
開いているスロットが無ければ負の値（-1）を返す。
スロットを自動で選ぶ際に使用すると良い。

CLOSE

bool CLOSE(
int スロット番号
)

スロットを閉じる。
戻り値は常に真。

記述例　 close(2)

OPENOLD

bool OPENOLD( str ファイル名 )
bool OPENOLD( int スロット番号 , str ファイル名 [ , int ラインモード ] )
スロットにファイルを読み込みモードで開く。
戻り値は常に真。
ファイル名が「""」の場合は標準入力を開く。スロット番号を省略するとスロット 0 を選ぶ。
スロットは　0～15までの１６個用意されている。
ラインモードは 0 ～ 4 の数値。指定しなければ 0 が選ばれる。通常は 0 で良い。

mode	行末	除去	READLNの型	CUR...
0	LF	LF/TAB以外の制御コード不正なコード	STR	CURLINE	通常はこのモードを使用する。
1	CRLF	0x00	STR	CURLINE	厳密に行末をCRLFとする。
2	LF	0x00	STR	CURLINE	行末をLFとする。
3	CRLF	--	BIN	CURLINEBIN	厳密に行末をCRLFとする。
4	LF	--	BIN	CURLINEBIN	行末をLFとする。

記述例１　 openold('test.txt')

記述例２　 openold(2,'test.txt')

OPENNEW

bool OPENNEW(
[ int スロット番号 , ]
str ファイル名
)

スロットにファイルを上書きモードで開く。
ファイル名が「""」の場合は標準出力を開く。ファイル名が「"#"」の場合は標準エラー出力を開く。ファイル名の先頭に「+」があると、追加モードで開く（ファイル名には「+」は含まれない。）。
戻り値は常に真。
上書きモードでは、ファイルは常に新たに作られる。スロット番号を省略するとスロット 1 を選ぶ。

記述例　 opennew('test.txt')

記述例　 opennew(2,'test.txt')

CLOSE

bool CLOSE(
int スロット番号
)

スロットを閉じる。
戻り値は常に真。

記述例　 close(2)

CLOSEOLD

bool CLOSEOLD[(
[ int スロット番号 ]
)]

スロットを閉じる。
戻り値は常に真。
スロット番号を省略するとスロット 0 を選ぶ。

記述例　 closeold()

CLOSENEW

bool CLOSENEW[(
[ int スロット番号 ]
)]

スロットを閉じる。
戻り値は常に真。
スロット番号を省略するとスロット 1 を選ぶ。

記述例　 closenew()

CLOSEALL

bool CLOSEALL[()]
すべてのスロットを閉じる。
戻り値は常に真。

記述例　 closeall()

ISUSED

bool ISUSED(
int スロット番号
)

スロットが使われていれば真。

記述例　 isused(0)

CANREAD

bool CANREAD(
int スロット番号
)

スロットが読み込み可能ならば真。

記述例　 canread(0)

CANWRITE

bool CANWRITE(
int スロット番号
)

スロットが書き込み可能ならば真。

記述例　 canwrite(0)

EOF

bool EOF[(
[ int スロット番号 ]
)]

ファイル末ならば真。
スロット番号を省略するとスロット 0 を選ぶ。

記述例１　 eof()

記述例２　 eof(2)

READLN

{ str| bool } READLN[(
[ int スロット番号 ]
)]

一行読み込んで文字列を返す。
スロット番号を省略するとスロット 0 を選ぶ。
ファイル末に達した場合は、論理値 FALSEを返す。文字列には行末コードは含まれない。ファイル末の検出のためには、EOF()と組にして使用すると便利だ。

記述例　 { openold('test.txt'); while( !eof(), readln() ); closeold(); }

GETLINE

int GETLINE[(
[ int スロット番号 ]
)]

一行読み込んで結果を返す。
スロット番号を省略するとスロット 0 を選ぶ。
結果は、整数値で表される。読み込んだ内容はCURLINE()で得ることが出来る。

返した値
負の値	ファイル末を検出した
10	改行まで読み込んだ
0	ファイル末で改行がない行を読んだ場合

記述例　 { openold('test.txt'); while( getline()>=0, a:=curline() ); closeold(); }

CURLINE

str CURLINE[(
[ int スロット番号 ]
)]

直前の操作で読み込んだ行を文字列で返す。
スロット番号を省略するとスロット 0 を選ぶ。
文字列には行末コードは含まれない。

記述例　 { openold('test.txt'); while( getline()>=0, a:=curline() ); closeold(); }

CURLINEBIN

bin CURLINEBIN[(
[ int スロット番号 ]
)]

直前の操作で読み込んだ行をバイナリで返す。
スロット番号を省略するとスロット 0 を選ぶ。
文字列には行末コードは含まれない。
行モードが 3/4 のときに使用すると、 0x00 を含めて読み込める。

記述例　 { openold('test.txt',1); while( getline()>=0, a:=curline() ); closeold(); }

READCOUNT int READCOUNT[( [ int スロット番号 ] )]
処理した行数を返す。
スロット番号を省略するとスロット 0 を選ぶ。

READBIN bin READBIN( [ int スロット番号 ,] int サイズ )
指定サイズを読み取りバイナリを返す。
スロット番号を省略するとスロット 0 を選ぶ。
ファイルの残りが指定サイズより小さい場合は、読メルだけ読んでバイナリとして返す。ファイル末に達した後に読み込むと長さ０のバイナリを返す。ファイル末の検出に、EOF()は使えない。

WRITE

 WRITE(
[ int スロット番号 , ]
値
)

値を文字列として書き込む。値を返す。
スロット番号を省略するとスロット 1 を選ぶ。
値がバイナリの場合は、バイナリの値をそのまま書き込む。

記述例　 { opennew('result.txt'); repeat(10,write(ix) ); closenew(); }

WRITELN

 WRITELN(
[int スロット番号 , ]
値
)

値を文字列として行末（CRLF）を付加して書き込む。
値を返す。
スロット番号を省略するとスロット 1 を選ぶ。

記述例　 { opennew('result.txt'); repeat(10,writeln(ix) ); closenew(); }

WRITECOUNT int WRITECOUNT[( [ int スロット番号 ] )]
処理した行数を返す。
スロット番号を省略するとスロット 1 を選ぶ。
出力スロットに対しては、単にWRITELNを実行した回数を数えている。

FILESHELF bool FILESHELF( str 出力ファイル名 , str 行 ] )
指定のファイルに行を追加する。ファイルを開いたときは真を返す。
初めて出力するときは、ファイルを作成する。ファイル名は単純に文字列として同じファイルを決めているので、注意すること。スロットファイルを自動的に使うので他のスロットファイル処理と同時に使用できない。ファイル名の先頭に"+"があると、追加モードでファイルを開く。
連想配列SHHELFをファイル名の保持に使っている。

FILESHELF_STR bool FILESHELF_STR( str 出力ファイル名 , str 文字列 ] )
指定のファイルに文字列を追加する。ファイルを開いたときは真を返す。
行末が付加されないことを除き、FILESHELFと同じ。

FILESHELF_CLOSE int FILESHELF_CLOSE( [ str 出力ファイル名 ] )
FILESHELF / FILESHELF_STRで開いているファイルを閉じる。閉じたファイルの数を返す。
ファイル名を省略すると、すべてのファイルを閉じる。プログラムの終了時には自動的に閉じられるので、通常は記述しなくても良い。

インデックスファイル

IXS_FREE int IXS_FREE[( )]
空いているスロット番号を返す。
スロットに空きが無ければ負の値（-1）を返す。
スロット番号を自動で割り当てる際に使用すると良い。

IXS_OPEN int IXS_OPEN( str ファイル名 [, int ファイルスロット ] )
ファイルスロットにインデックスファイルを用意する。
戻り値はファイルスロット番号。
ファイルスロットを省略すると０番のスロットが選ばれる。
通常、インデックスファイルは、IXSTRBUILD.EXEで作成したファイルで、アクセスするためには IXS_SRCH() / IXS_SRCHMLT() を用いる。
特殊なインデックスファイルとして IXSBUILD.EXE で作成したファイルがあり、こちらは、IXS_SRCHNUM() / IXS_SRCHNUMMLT() でアクセスする。
文字列を値とする（IXSTRBUILD）と数値を値とする（IXBUILD）は歴史的経緯から、区別する情報を持たない。使用する場合には、どちらのファイルを扱っているかに注意すること。一般的には文字列を値とするものだけを使えばよい。

IXS_CLOSE int IXS_CLOSE( [int ファイルスロット ] )
インデックスファイルを閉じてファイルスロットを解放する。
戻り値はファイルスロット番号。
ファイルスロットを省略すると０番のスロットが選ばれる。

IXS_SRCH IXS_SRCH( str キー [ , int ファイルスロット ] )
スロットにあるインデックスファイルに対して、キーで検索し、結果の文字列を返す。
見つからなければ、論理値偽を返す。
インデックスファイルがキーの重複を許している場合には、複数の結果が考えられるが、その場合でも、一つだけの値を返す。従って、この関数は重複を許さないキーファイルに使用する。
ファイルスロットを省略すると０番のスロットが選ばれる。
IXSTRBUILD.EXE で作成されたファイルに用いる。

IXS_SRCHMLT int IXS_SRCHMLT( 配列名 , str キー [ , int ファイルスロット ] ] )
スロットにあるインデックスファイルに対して、キーで検索し、結果の文字列を配列に格納する。
戻り値は、結果の個数。
見つからなければ、格納はせず、０を返す。
インデックスファイルがキーの重複を許している場合は、複数の結果がありうるが、そのすべてを指定の変数番号以降に順に格納する。
ファイルスロットを省略すると０番のスロットが選ばれる。
IXSTRBUILD.EXE で作成されたファイルに用いる。

IXS_SRCHNUM IXS_SRCHNUM( str キー [ , int ファイルスロット ] )
スロットにあるインデックスファイルに対して、キーで検索し、結果の数値を返す。
見つからなければ、論理値偽を返す。
インデックスファイルがキーの重複を許している場合には、複数の結果が考えられるが、その場合でも、一つだけの値を返す。従って、この関数は重複を許さないキーファイルに使用する。
ファイルスロットを省略すると０番のスロットが選ばれる。
IXSBUILD.EXE で作成されたファイルに用いる。

IXS_SRCHNUMMLT int IXS_SRCHNUMMLT( 配列名 , str キー [ , int ファイルスロット ] ] )
スロットにあるインデックスファイルに対して、キーで検索し、結果の数値を配列に格納する。
戻り値は、結果の個数。
見つからなければ、格納はせず、０を返す。
インデックスファイルがキーの重複を許している場合は、複数の結果がありうるが、そのすべてを指定の変数番号以降に順に格納する。
ファイルスロットを省略すると０番のスロットが選ばれる。
IXSBUILD.EXE で作成されたファイルに用いる。

テキストブロックファイル

IXT_FREE int IXT_FREE[( )]
空いているスロット番号を返す。
スロットに空きが無ければ負の値（-1）を返す。
スロット番号を自動で割り当てる際に使用すると良い。

IXT_OPEN int IXT_OPEN( str ファイル名 [, int ファイルスロット ] )
ファイルスロットにテキストブロックファイルを用意する。
戻り値はファイルスロット番号。
ファイルスロットを省略すると０番のスロットが選ばれる。
テキストブロックファイルは、TXT2IXT.EXEで作成したファイルで、テキストに対するランダムアクセス機能を提供する。

IXT_CLOSE int IXT_CLOSE( [int ファイルスロット ] )
テキストブロックファイルを閉じてファイルスロットを解放する。
戻り値はファイルスロット番号。
ファイルスロットを省略すると０番のスロットが選ばれる。

IXT_COUNT IXS_COUNT( [ , int ファイルスロット ] )
スロットにあるテキストブロックファイルのレコード数を返す。

IXT_READ int IXT_READ( int レコード番号 [ , int ファイルスロット [ bool 生コードフラグ ] ] )
スロットにあるテキストブロックファイルにの指定のレコードを読み出す。
通常は、行末コードを含まない。
生コードフラグを真に指定すると、行末を含む全てのコードを返す。

バイナリブロックファイル

IXB_FREE int IXB_FREE[( )]
空いているスロット番号を返す。
スロットに空きが無ければ負の値（-1）を返す。
スロット番号を自動で割り当てる際に使用すると良い。

IXB_OPEN int IXB_OPEN( str ファイル名 [, int ファイルスロット ] )
ファイルスロットにバイナリブロックファイルを用意する。
戻り値はファイルスロット番号。
ファイルスロットを省略すると０番のスロットが選ばれる。
バイナリブロックファイルは、BINCONC.EXEでオプション -I を指定して作成したファイルで、バイナリデータに対するランダムアクセス機能を提供する。

IXB_CLOSE int IXB_CLOSE( [int ファイルスロット ] )
バイナリブロックファイルを閉じてファイルスロットを解放する。
戻り値はファイルスロット番号。
ファイルスロットを省略すると０番のスロットが選ばれる。

IXB_COUNT IXB_COUNT( [ , int ファイルスロット ] )
スロットにあるバイナリブロックファイルのレコード数を返す。

IXB_READ bin IXB_READ( int レコード番号 [ , int ファイルスロット ] )
スロットにあるバイナリブロックファイルにの指定のレコードを読み出す。

論理定数	`TRUE`、`FALSE`
整数定数	数字の連続。「`0x`」で始めると16進表記が出来る。「`0b`」で始めると２進表記が出来る。記述例１　１０進数 `1248` 記述例２　１６進数 `0x3f42` 記述例３　２進数 `0b1011`
実数定数	1.25 など小数の形式と、1.3e15などの指数形式。円周率 `PI` 、自然対数の底 `CONST_E` など記述例１　 `3.16` 記述例２　 `3.5e-12`
小数定数	数値表記の前に「`0c`」を付けて表す。「`0C`」でもよい。数値表記では整数または小数表記が許される。記述例１　 `0c1234` 記述例２　 `0c0.185`
文字列定数	引用符を使用した記法　引用符（「`"`」「`'`」「`」）で囲んだ文字列。文字列を囲んでいる引用符と同じ文字を書く場合には、それを二つ続けて書く。記述例１　 `"ABC"` 記述例２　引用符の中に引用符を書く例。 `'AB''C'` 記述例３　引用符の種類が違えば中に書ける。 `AB'C` 拡張記法１また、次の特殊記法もサポートしている。 `_区切文字 .... 内容 .... 区切文字` 　「`_`」の直後に書いた文字が文字列の末尾の区切りとする。区切り文字を文字列に含める場合は二つ続けて書く。「(」のように「)」が期待されるような文字は、それが末尾の区切りとなる。この記法では、区切り文字として、「"」「'」「`」「_」は使用できない。区切りの特殊なペアは次の通り。「`()`」、「`[]`」、「`{}`」、「`<>`」、「`｢｣`」、「`（）`」、「`｛｝`」、「`［］`」、「`〔〕`」、「`【】`」、「`〈〉`」、「`《》`」、「`「」`」、「`『』`」、「`＜＞`」、「`≪≫`」、「`〝〟`」、「`“”`」、「`‘’`」記述例１　"alpha"と同じ `_/alpha/` 記述例２　"富士山"と同じ `_「富士山」` 拡張記法２複数行に渡った文字列を書きやすくするために次の記法をサポートしている。 `__[-]tag ↓ データ↓ ... tag↓` 「`__`」以降行末までをタグとする。以降の行を行末を含めて連結し文字列定数とする。行全体がタグに一致すると繰り込みが終わる。「`__-`」で始めると、行の取り込み時に、行頭の半角スペース、tabを読み飛ばす。タグの検定も読み飛ばし後に行う。記述例 `a:=__eox first line second line eox`
論理値を返す実行文字列	`_'....内容....'` 文字列をコマンドラインとして実行し、その可否を論理値で返却する。コマンドラインの返却値が0ならば、偽、それ以外ならば真を値とする。
文字列を返す実行文字列	_`....内容....` 文字列をコマンドラインとして実行し、その標準出力を文字列で返却する。
注釈	「`/`」と「`/`」で挟んだ部分は空白扱いとなり、注釈として機能する。

`#変数名`	整数変数の値。記述例　 `#uriage`
`#(文字列式)`	間接指定した整数変数の値記述例　 `#('uriage')`
`#変数名 := 値`	整数変数に代入する。記述例　 `#total := 25+42`
`##変数名`	実数変数の値。記述例　 `##phase`
`##(文字列式)`	間接指定した実数変数の値記述例　 `##('pha'+'se')`
`##変数名 := 値`	実数変数に代入する。記述例　 `#$frew := 1.25`
`#$変数名`	小数変数の値。記述例　 `#$phase`
`#$(文字列式)`	間接指定した小数変数の値記述例　 `#$('pha'+'se')`
`#$変数名 := 値`	小数変数に代入する。記述例　 `#$frew := 0c1.25`
`$変数名`	文字列変数の値。記述例　 `$yourname`
`$(文字列式)`	間接指定した文字列変数の値記述例　 `$('yourname')`
`$変数名 := 値`	文字列変数に代入する。記述例　 `$company := "sampodo"`

`@番号`	SYS(番号)	指定番号の情報を`文字列`としての値。番号は負でない整数。記述例　 `@1+"ABC"`
`@( 式 )`	SYS(式)	式で指定した番号の情報を`文字列`としての値。間接指定として使用する。また、負の番号を指定する場合にも使用する。式は整数値。記述例１　 `@(A+4)+"ABC"` 記述例２　 `@(-1)+"ABC"`
`&番号`	SYSINT(番号)	指定番号の情報を`整数`としての値。番号は負でない整数。記述例　 `&1+3`
`&( 式 )`	SYSINT(式)	式で指定した番号の情報を`整数`としての値。間接指定として使用する。また、負の番号を指定する場合にも使用する。式は整数値。記述例１　 `&(A+4)*4` 記述例２　 `&(-3)+7`
`&&番号`	SYSFLOAT(番号)	指定番号の情報を`実数`としての値。番号は負でない整数。記述例　 `sqrt(&&1)`
`&&( 式 )`	SYSFLOAT(式)	式で指定した番号の情報を`実数`としての値。間接指定として使用する。また、負の番号を指定する場合にも使用する。式は整数値。記述例１　 `&&(I+4)/2.0` 記述例２　 `&&(-3)+&&1`
`&@番号`	SYSFIX(番号)	指定番号の情報を`小数`としての値。番号は負でない整数。記述例　 `&@3`
`&@( 式 )`	SYSFIX(式)	式で指定した番号の情報を`小数`としての値。間接指定として使用する。また、負の番号を指定する場合にも使用する。式は整数値。記述例１　 `&@(I+2)/0C2.75` 記述例２　 `&@(-1)+&@2`

`変数名`	変数名を書くことでその値を引用できる。型は最後に代入された値の型。記述例　 `A`
`変数名 := 値変数名(値)`	変数に値を代入する。代入した値を返す。記述例　 `S:='abc'` 変数名の後ろに括弧をつけて代入を表すのは古い記法で、推奨しない。

`LVAR[ 指標 ] LVAR( 指標 )`	指定の変数の値。記述例１　26番目の変数「Z」の値 `LVAR[26]` 記述例２　変数「B」の値 `LVAR["B"]`
`LVAR[ 指標 ] := 値 LVAR( 指標 , 値 )`	指定の変数に値を代入する。この式自体は、代入した値を返す。記述例　変数「B」に文字列「FAST」を代入 `LVAR[2]:="FAST"`

TSEXPR 式記述

1.データ型

2.定数と注釈の記法

3.環境変数

4.アプリケーションとのインタフェース

番号で機能を指定する

名称で機能を指定する

5.汎用変数

単純変数

配列変数

連想配列変数

特殊な変数名

6.名前付き変数

7.固有変数

スイッチ

パターン

スロットファイル

文字列

整数

実数

インデックスファイル

8.演算子

式のまとめ

9.関数

9.関数索引

論理型	真偽の値。
整数型	４バイトの符号付整数。
実数型	倍精度浮動小数。
小数型	十進固定小数点小数。整数部１５桁小数部１５桁。
文字列型	文字の連続。長さの制限はない。内部ではコード0で終端を表しているので、文字列にコード「0」の文字を含むことは出来ない。
バイナリ型	バイトの連続

`配列名{ 指標 }`	連想配列の文字列で指定された要素の値を引用する。型は最後に代入された値の型。キーが存在しないと FALSE を返す。記述例　連想配列 A の「guitar」で指定される要素の値 `A{'guitar'}`
`配列名{ 指標 } :=値`	連想配列の文字列で指定された要素に値を代入する。この式自体は、代入した値を返す。キーが存在しない場合は、キーと値を登録する。記述例　連想配列 S の「name」で指定される要素に文字列「sampodo」を代入 `S{'name'}:='sampodo'`

`SHELF`	単純変数	`[ 式 \| 式 ... ]` の中で式の値の引継ぎのためにシステムが使用している。
	配列変数	ユーザーが使用してよい。引数置換が値を設定、参照できる。TSEXPRとの情報交換に使用する。
	連想配列変数	分配ファイル出力処理のFILESHELF/FILESHELF_STR/FILESHELF_CLOSEのためにシステムが使用している。
`STACK`	単純変数	用途は未定だが使用すべきではない。
	配列変数	スタック・オペレーションの実現のためにシステムが使用している。
	連想配列変数	名前付き変数実現のためにシステムが使用している。
`ARG`	単純変数	用途は未定だが使用すべきではない。
	配列変数	`QSOPTION()` / `CMLARG_STD()` などがファイル名を格納する。ユーザーが使用してよい。
	連想配列変数	`QSOPTION()` / `CMLARG_STD()` などがオプションを格納する。ユーザーが使用してよい。
`VAR`	単純変数	用途は未定だが使用すべきではない。
	配列変数	単純変数を配列として配置しているが、通常は使用すべきではない。
	連想配列変数	用途は未定だが、使用すべきではない。

`?変数名`	変数を直接参照した値記述例　 `?cityname`
`?(文字列式)`	間接指定した変数の値記述例　 `?('cityname')`
`?変数名 := 値`	変数に代入する記述例　 `?total := 25+42`
`?(文字列式) := 値`	間接表記で代入する記述例　 `?('alpha'):=3.14`

`SVAR[ 指標 ]` `SVAR( 指標 )`	指定した SVAR 要素の値を返す。 `SVAR(..)` は古い書き方で推奨しない。 `SVAR[..]` を推奨する。
`SVAR[ 指標 ]:= 値` `SVAR( 指標 , 値 )`	指定したSVAR要素に値を書く。 `SVAR(..,..)` は古い書き方なので推奨しない。`SVAR[..]:=...` を推奨する。

`IVAR[ 指標 ]` `IVAR( 指標 )`	指定した IVAR 要素の値を返す。 `IVAR(..)` は古い書き方で推奨しない。 `IVAR[..]` を推奨する。
`IVAR[ 指標 ]:= 値` `IVAR( 指標 , 値 )`	指定したIVAR要素に値を書く。 `IVAR(..,..)` は古い書き方なので推奨しない。`IVAR[..]:=...` を推奨する。

`FVAR[ 指標 ]` `FVAR( 指標 )`	指定した FVAR 要素の値を返す。 `FVAR(..)` は古い書き方で推奨しない。 `FVAR[..]` を推奨する。
`FVAR[ 指標 ]:= 値` `FVAR( 指標 , 値 )`	指定したFVAR要素に値を書く。 `FVAR(..,..)` は古い書き方なので推奨しない。`FVAR[..]:=...` を推奨する。

ABBREV	ABS	ABSNAME	ACOS
ACOSH	ADD2AR	ADD2ASAR	ADJSTR
AGE	ALTBREAK	ALTF	ALTSKIP
AMP	AND	ANDBIT	AND_DO
AND_LOOP	AQUOTE	AR	AR2ARG
AR2ASAR	AR2BIN	AR2BINAR	AR2FIELD
AR2FILE	AR2LINE	AR2QSARG	AR2STR
AR2STRIX	ARC	ARG2STR	ARG_EVERY
ARG_FOR	ARG_PRIME	ARG_SCAN	ARG_SOME
AR_APPEND	AR_APPENDAR	AR_CLEAR	AR_CONC
AR_COPY	AR_COUNT	AR_EVERY	AR_FILL
AR_FOR	AR_INSAR	AR_LETAR	AR_MAP2
AR_ORDER	AR_PRIME	AR_REDUCE	AR_REP
AR_SCAN	AR_SEL	AR_SET	AR_SETSIZE
AR_SOME	AR_TRANS	ASAR	ASAR2AR
ASAR2FILE	ASAR2LINE	ASAR2STR	ASAR2STRIX
ASARC	ASAR_CLEAR	ASAR_CONC	ASAR_COPY
ASAR_COUNT	ASAR_DEL	ASAR_DIM	ASAR_DIMC
ASAR_FOR	ASAR_HASKEY	ASAR_REF	ASAR_SET
ASAR_WT	ASAR_WTC	ASCII	ASIN
ASINH	ASTER	ASTR	AT
ATAN	ATAN2	ATANH

BANG	BAR	BASENAME	BESSEL_J0
BESSEL_J1	BESSEL_JN	BESSEL_Y0	BESSEL_Y1
BESSEL_YN	BETWEEN	BIN	BIN2AR
BIN2ARAR	BIN2SFLOAT	BIN78	BIN87
BINARY	BINLEN	BINPART	BINSYX
BINVAL	BIN_ADD	BIN_AND	BIN_B2N
BIN_CSUM7	BIN_CSUM8	BIN_DEL	BIN_EVERY
BIN_FOR	BIN_GET	BIN_INS	BIN_KSUM7
BIN_LOAD	BIN_N2B	BIN_NOT	BIN_OR
BIN_PRIME	BIN_PUT	BIN_REP	BIN_REV
BIN_SAVE	BIN_SCAN	BIN_SEL	BIN_SOME
BIN_SUB	BIN_SUM7	BIN_SUM8	BIN_SWAP1
BIN_SWAP4	BIN_XOR	BIT	BIT2STR
BITORDER	BITVAL	BIT_AND	BIT_ASR
BIT_COUNT	BIT_LSR	BIT_NOT	BIT_OPR
BIT_OR	BIT_ROL	BIT_ROR	BIT_SHL
BIT_XOR	BOOL	BOOTDIR	BOTTOM
BP	BQ	BRACKET	BREAK
BREAKIF	BREAKP	BRES	BRESCOUNT
BSLASH	BYTE	BYTEORDER	BYTES
BYTEVAL

CANREAD	CANWRITE	CAP	CARET
CBRT	CD	CEIL	CENTER
CHOPEOL	CHOPLF	CHR	CHRGT
CHRLT	CHRMASK	CHRMASKPAIR	CLIP
CLOSE	CLOSEALL	CLOSENEW	CLOSEOLD
CLRENV	CML	CML2ARG_ALL	CML2ARG_NON
CML2ARG_STD	CMLARG_ALL	CMLARG_NON	CMLARG_STD
CODE	COLON	COMBINATION	COMMA
COMPBIN	COMPDW	COMPFIX	COMPFLOAT
COMPINT	COMPSTR	COMPSTRB	COMPSTRI
COMPSTRIEX	COMPUTER	COND	CONST_C
CONST_E	CONST_F	CONST_G	CONST_H
CONST_K	CONST_ME	CONST_MN	CONST_MP
CONST_MU	CONST_N	CONST_SG	COPY_AR
COS	COSH	CR	CRLF
CUBIC_EQ	CURDIR	CURLINE	CURLINEBIN

DATEFROMNUM	DAYNUM	DAYOFWEEK	DAYSOFMONTH
DEG	DELAR	DEQUOTE	DETAB
DIFF	DIM	DIMC	DIRDELETE
DIRMAKE	DIV1_AR	DIV_AR	DO
DOKA	DOLLAR	DOSDEVICE	DOSDEVNAME
DOT	DOTS	DQ	DR
DROP	DUC	DUCS	DUCSS
DWORD	DWORD78	DWORD87	DWORDS
DWORDVAL

ENTAB	ENV	ENVLIST	ENVPATH
EOF	EOL	EOL2LF	EQL
EQSOLVER	EQUAL	ERROR	ERROUT
ESC	ETAG	ETO10	ETO12
EVAL	EVALQ	EVALSTR	EVERY
EX	EXEC	EXECBIN	EXECQ
EXECUTE	EXEC_AR	EXIST	EXP
EXPAND	EXPANDSTR	EXPAND_AR	EXPNAME

FACTORIAL	FIELD	FIELD2AR	FIELD2STR
FIELD2STRIX	FIELD2SVAR	FIELDS	FIELDS_IX
FIELDS_RANGE	FIELD_ADJ	FIELD_ARG	FIELD_CHOP
FIELD_COUNT	FIELD_EVERY	FIELD_FOR	FIELD_LAST
FIELD_PRIME	FIELD_REM	FIELD_REP	FIELD_ROT
FIELD_SCAN	FIELD_SEL	FIELD_SOME	FILE
FILE2AR	FILE2ARIX	FILE2ASAR	FILE2ASARIX
FILE2FILE	FILE2FILESEL	FILE2FVAR	FILE2IVAR
FILE2LVAR	FILE2STRSEL	FILE2SVAR	FILEBIN
FILEBINOUT	FILECOPY	FILEDATE	FILEDELETE
FILEFREE	FILELINE	FILEMOVE	FILENAME
FILEOUT	FILESHELF	FILESHELF_CLOSE	FILESHELF_STR
FILESIZE	FILETIME	FILE_COUNT	FILE_EVERY
FILE_FOR	FILE_PRIME	FILE_SCAN	FILE_SEL
FILE_SOME	FIND	FINITE	FIRST
FIXNUM	FIX_CUT	FIX_FRAC	FIX_INT
FIX_ROUND	FIX_UP	FLD	FLIPBIT
FLOAT	FLOATSTR	FLOOR	FLT_ALNUM
FLT_ALPHA	FLT_DIGIT	FLT_HALF	FLT_NUM
FMOD	FOLD	FOR	FOREACH
FORMSTR	FRACPART	FROMNIBBLE	FS
FULL	FVAL	FVALSTR	FVAR
FVAR2FILE	FVARINDEX	FVARSET	FXPR
FXPRSTR

HALF	HAS	HASEVERY	HASHEAD
HASIEVERY	HASISOME	HASKEY	HASSOME
HASTAIL	HASXEVERY	HASXSOME	HATENA
HEX2BIN	HEXVAL	HIRAGANA	HITICK
HITICKFREQ	HWORD	HYPOT

IF	IFFALSE	IFNOT	IFNULL
IFP	IFPN	IFTRUE	INDEX
INSAR	INSDAR	INSIXAR	INT
INTEGRAL	INTPART	ISALPHA	ISBIN
ISBLANK	ISBLANKV	ISBOOL	ISCTRL
ISDATE	ISDIR	ISDRIVE	ISENV
ISEVEN	ISFALSE	ISFIXNUM	ISFLOAT
ISFULL	ISFULLALPHA	ISFULLLOWER	ISFULLNUM
ISFULLSIZE	ISFULLUPPER	ISGREEK	ISGREEKLOWER
ISGREEKUPPER	ISHALF	ISHALFKANA	ISHALFSIZE
ISHIRABOU	ISHIRAGANA	ISHIRAGANAX	ISINSTR
ISINT	ISKANJI	ISKATABOU	ISKATAKANA
ISKATAKANAX	ISLEAP	ISLOWER	ISLOWERALL
ISMINUS	ISNULL	ISNUM	ISNUMALPHA
ISODD	ISOUTSTR	ISPLUS	ISQUOTE
ISREADY	ISROMAN	ISROMANLOWER	ISROMANUPPER
ISRUSS	ISRUSSLOWER	ISRUSSUPPER	ISSOSU
ISSPACE	ISSTR	ISTRUE	ISUPDATE
ISUPPER	ISUPPERALL	ISUSED	ISWORD
ISZERO	IVAR	IVAR2FILE	IVARINDEX
IVARSET	IX	IXBIT	IXBITS
IXBYTE	IXB_CLOSE	IXB_COUNT	IXB_FREE
IXB_OPEN	IXB_READ	IXNIBBLE	IXS_CLOSE
IXS_FREE	IXS_OPEN	IXS_SRCH	IXS_SRCHMLT
IXS_SRCHNUM	IXS_SRCHNUMMLT	IXT_CLOSE	IXT_COUNT
IXT_FREE	IXT_OPEN	IXT_READ	IXWORD

LARGE	LAUNCH	LCM	LCMSTR
LEFT	LEN	LF	LF2EOL
LFY	LIMIT	LIMIT_FLOAT	LIMIT_INT
LINE	LINE2AR	LINE2ASAR	LINE2ASARSUM
LINE2STR	LINE2STRIX	LINE2SVAR	LINENUM2POS
LINES	LINESORT	LINES_IX	LINES_RANGE
LINE_CHOP	LINE_COUNT	LINE_EVERY	LINE_FOR
LINE_LAST	LINE_PRIME	LINE_REM	LINE_REP
LINE_ROT	LINE_SCAN	LINE_SEL	LINE_SOME
LN	LOCAL	LOCALTIME	LOG
LOG10	LOGIC_OPR	LOGMSG	LOOP
LR	LVAR	LVAR2FILE	LWORD

MASKBITS	MATCH	MATCHALL	MATCHALL_AR
MATCHEND	MATCHMARK	MATCHPOS	MATCHRESULT
MATCHSTR	MAX_AR	MAX_DW	MAX_FIX
MAX_FLOAT	MAX_INT	MAX_STR	MAX_STRI
MAX_STRX	ME	ME2AR	MEAN_AR
MID	MIDI_BANKL	MIDI_BANKU	MIDI_BEND
MIDI_CAF	MIDI_CC	MIDI_CH	MIDI_NOTE
MIDI_NOTEX	MIDI_NOTEXV	MIDI_PAF	MIDI_PC
MIDI_SYX	MIN_AR	MIN_DW	MIN_FIX
MIN_FLOAT	MIN_INT	MIN_STR	MIN_STRI
MIN_STRX	MISMATCH	MM	MM2AR
MODULE	MONTHNUM	MP	MP2AR
MS	MS2AR	MSG

PASS	PASTE	PAT	PATH
PATHCONC	PATHNAME	PEEP	PERCENT
PERIOD	PERMUTATION	PI	PID
POLYNOMIAL	POP	POPAR	POPFVAR
POPIVAR	POPQSARG	POPSVAR	POS2LINENUM
POW	POW2	PROD	PROD_AR
PROG	PROGLOOP	PTAG	PUSH
PUSHAR	PUSHFVAR	PUSHIVAR	PUSHIX
PUSHQSARG	PUSHSVAR

QS	QSARG	QSARG2AR	QSBIN
QSC	QSCOUNT	QSENV	QSOPT
QSOPTCK	QSOPTION	QSSHIFT	QS_AR
QTAG	QUADRATIC_EQ	QUOTE

RAD	RAND	RANGE	READBIN
READCOUNT	READLN	REG	REP1STR
REP1STRI	REP1STRX	REPARG	REPEAT
REPEAT_COUNT	REPEAT_INDEX	REPLACE	REPLACEALL
REPSTR	REPSTRI	REPSTRIX	REPSTRIXI
REPSTRIXX	REPSTRX	RESULT	REV
REVERSE_AR	REVJ	RIGHT	RIGHTZ
RP

SC	SCAN	SD1_AR	SDQS2AR
SDQS2STR	SD_AR	SEARCH	SEARCHCOUNT
SEARCHI	SEARCHICOUNT	SEARCHX	SEARCHXCOUNT
SEMICOLON	SEP	SEPLINE	SEP_ARG
SEP_CHOP	SEP_COUNT	SEP_EVERY	SEP_FOR
SEP_IX	SEP_LAST	SEP_PRIME	SEP_REM
SEP_REP	SEP_ROT	SEP_SCAN	SEP_SEL
SEP_SOME	SEP_SORT	SEQ_COUNT	SEQ_EVERY
SEQ_FOR	SEQ_PRIME	SEQ_REDUCE	SEQ_SCAN
SEQ_SOME	SETBIT	SETBITS	SETBYTE
SETNIBBLE	SETSTDERR	SETSTDIN	SETSTDOUT
SETWORD	SFLOAT2BIN	SGNBYTE	SGNWORD
SHARP	SHIFT	SHIFTAR	SIN
SINH	SKIP	SKIPIF	SKIPP
SLASH	SMALL	SOINSU	SOME
SORT_AR	SORT_AR_FIX	SORT_AR_FLOAT	SORT_AR_INT
SORT_AR_STR	SP	SPC	SPK
SPLIT	SPLIT2SVAR	SPLITLN	SPOOL
SPS2AR	SPS2STR	SQ	SQRT
SQS2AR	SQS2STR	SQUOTE	SR
SRCHSTR	SRCHSTRI	SRCHSTRX	SS
STACKCOUNT	STACKINIT	STAG	STDOUT
STR	STR0	STRASB	STRASBIF
STRBIN	STRC	STRCONC	STRCONCIX
STRCONCRANGE	STRDW	STRFIXNUM	STRHEX
STRING	STRN2AR	STRN2STR	STRNOTNULL
STRNULL	STRNZ	STRPACK	STRRANGE
STRSP	STR_CHOP	STR_EVERY	STR_FOR
STR_IX	STR_IXSET	STR_LAST	STR_PRIME
STR_REP	STR_ROT	STR_SCAN	STR_SEL
STR_SOME	SUBST	SUBSTBP	SUM
SUM2_AR	SUM_AR	SV	SV1
SV2	SVAR	SVAR2FIELD	SVAR2FILE
SVAR2LINE	SVARCONC	SVARCONCLIST	SVARINDEX
SVARSET	SVARSORT	SVAR_EVERY	SVAR_REP
SVAR_SCAN	SVAR_SOME	SW	SWAPBYTE
SWAPNIBBLE	SWAPWORD	SWOLD	SWSR
SWSRA	SWSRB	SWSRC	SWSRD
SWSRVAL	SWTR	SWTRG	SW_COUNT
SW_DOWNCOUNT	SW_LN	SW_OFFCOUNT	SW_ONCOUNT
SW_PHASE	SW_RESET	SW_RN	SYS
SYSBOOL	SYSFIX	SYSFLOAT	SYSFOLDER
SYSINT	SYSMETRIC	SYSTALK

TAB	TAG	TAN	TANH
TBYTE	TBYTEORDER	TBYTES	TBYTEVAL
TEMPFILE	TESTBIT	TICK	TILDA
TL	TLN	TODAY	TOGE
TONIBBLE	TOP	TR	TRC
TRIM	TRIMLEFT	TRIMRIGHT	TRIMSP
TRS	TYPE	TYPENAME

WAIT	WHEN	WHILE	WHILE_COUNT
WIDTH	WORD	WORDS	WORDVAL
WRITE	WRITECOUNT	WRITELN

XDWORD	XDWORDS	XDWORDVAL	XTBYTE
XTBYTES	XTBYTEVAL	XWORD	XWORDS
XWORDVAL