Last active
October 8, 2021 05:05
-
-
Save nikolat/1007538 to your computer and use it in GitHub Desktop.
YAYA as SAORI
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// https://gist.github.com/nikolat/1007538 | |
// yaya.dll設定 | |
#globaldefine AYAINFO_VERSION 0 | |
#globaldefine AYAINFO_CHARSET 1 | |
#globaldefine AYAINFO_PATH 2 | |
#define PROTOCOL_VERSION "1.0" /* SAORIプロトコルバージョン */ | |
#define PROTOCOL_SENDER "AYASAORI" /* Sender */ | |
#define CRLF CHR(0xd)+CHR(0xa) /* 改行コード */ | |
#define FUNC_UNDEFIND 0 | |
#define FUNC_USER 1 | |
#define FUNC_BUILTIN 2 | |
#globaldefine STATUS_OK "200 OK" | |
#globaldefine STATUS_NO_CONTENT "204 No Content" | |
#globaldefine STATUS_BAD_REQUEST "400 Bad Request" | |
#globaldefine STATUS_INTERNAL_SERVER_ERROR "500 Internal Server Error" | |
/** AYA API load | |
* 初期化 | |
* | |
* @param string _argv[0] ライブラリのディレクトリパス | |
*/ | |
load | |
{ | |
AYASAORI.PATH = _argv[0] | |
AYASAORI.LOADEDCLS = IARRAY() | |
AYASAORI.VERSION = PROTOCOL_VERSION | |
AYASAORI.SENDER = PROTOCOL_SENDER | |
} | |
/** AYA API unload | |
* 後始末 | |
*/ | |
unload | |
{ | |
ERASEVAR("REQ.HEADER") | |
ERASEVAR("REQ.COMMAND") | |
ERASEVAR("REQ.VERSION") | |
ERASEVAR("REQ.PROTOCOL") | |
// デストラクタコール | |
foreach AYASAORI.LOADEDCLS; _cls { | |
_func = "%(_cls).Unload" | |
if ISFUNC(_func) { | |
EVAL(_func) | |
} | |
} | |
ERASEVAR("AYASAORI.PATH") | |
ERASEVAR("AYASAORI.SENDER") | |
ERASEVAR("AYASAORI.VERSION") | |
ERASEVAR("AYASAORI.LOADEDCLS") | |
} | |
/** AYA API request | |
* リクエストヘッダを解析し、指定の関数を呼び出して結果をレスポンスヘッダとして返す | |
* | |
* @param string _argv[0] リクエストヘッダ文字列 | |
* @return string レスポンスヘッダ文字列 | |
*/ | |
request | |
{ | |
REQ.HEADER = _argv[0] | |
_header = SPLIT(_argv[0], CRLF) | |
// 不正なヘッダ | |
if ARRAYSIZE(_header) <= 1 { | |
AYASAORI.Response("400 Bad Request") | |
return | |
} | |
// リクエストラインの分析 | |
_requestLine = _header[0] | |
_header[0] = IARRAY | |
_requestLine = CUTSPACE(_requestLine) | |
REQ.COMMAND = _requestLine[0, " SAORI"] | |
REQ.VERSION = _requestLine[1, "/"] | |
REQ.PROTOCOL = "SAORI/" + REQ.VERSION | |
case REQ.COMMAND { | |
when "GET Version" { | |
RES.RESULT = GETSETTING('coreinfo.name') + '/' + GETSETTING('coreinfo.version') | |
AYASAORI.Response("200 OK") | |
return | |
} | |
when "EXECUTE" { | |
foreach _header; _line { | |
if _line == "" | |
break | |
_field = SPLIT(_line, ":", 2) | |
_key = CUTSPACE(_field[0]) | |
_value = CUTSPACE(_field[1]) | |
// 変数をセットする。大文字で統一 | |
// Charset, SecurityLevel, Sender, Argument[0..n] 以外は無いはず | |
_key = TOUPPER(_key) | |
if _key == "CHARSET" || _key == "SECURITYLEVEL" / | |
|| _key == "SENDER" || RE_MATCH(_key, "ARGUMENT[0-9]+") | |
LETTONAME("REQ.%(_key)", _value) | |
} | |
// ユーザ関数のみ処理対象とする | |
_result = 0 | |
if ISFUNC(REQ.ARGUMENT0) == FUNC_USER || ISFUNC(REQ.ARGUMENT0) == FUNC_BUILTIN { | |
REQ.ARGS = IARRAY() | |
_i = 0 | |
while 1 { | |
// ループ操作の簡易化のために、REQ.ARGS配列を作る | |
if ISVAR("REQ.ARGUMENT%(_i)") { | |
// Argument0 はメソッド(または関数名)なので飛ばす | |
if _i == 0 { | |
_i++ | |
continue | |
} | |
REQ.ARGS ,= EVAL("REQ.ARGUMENT%(_i)") | |
_i++ | |
} else { | |
break | |
} | |
} | |
// コンストラクタコール | |
if STRSTR(REQ.ARGUMENT0, ".", 0) != -1 { | |
_tmp = SPLIT(REQ.ARGUMENT0, ".", 2) | |
_cls = _tmp[0] | |
_mth = _tmp[1] | |
if _mth == "Load" { | |
AYASAORI.LOADEDCLS ,= _cls | |
} else { | |
if ASEARCH(_cls, AYASAORI.LOADEDCLS) < 0 { | |
_func = "%(_cls).Load" | |
// モジュールロードの実行 | |
if ISFUNC(_func) { | |
_dummy = EVAL(_func) | |
} | |
AYASAORI.LOADEDCLS ,= _cls | |
} | |
} | |
} | |
// 関数実行 | |
if ISFUNC(REQ.ARGUMENT0) == FUNC_BUILTIN | |
_result = EVAL(TOLOWER(REQ.ARGUMENT0)) | |
else | |
_result = EVAL(REQ.ARGUMENT0) | |
} else { | |
AYASAORI.Response(STATUS_NO_CONTENT) | |
return | |
} | |
if _result == -1 { | |
AYASAORI.Response(STATUS_BAD_REQUEST) | |
} else { | |
// レスポンスの作成 | |
AYASAORI.Response(STATUS_OK) | |
} | |
// 変数の後始末 | |
ERASEVAR("REQ.SECURITYLEVEL") | |
ERASEVAR("REQ.CHARSET") | |
ERASEVAR("REQ.SENDER") | |
ERASEVAR("REQ.ARGS") | |
_i = 0 | |
while 1 { | |
if ISVAR("REQ.ARGUMENT%(_i)") { | |
ERASEVAR("REQ.ARGUMENT%(_i)") | |
} else { | |
break | |
} | |
_i++ | |
} | |
} | |
// 未知のリクエスト | |
others | |
AYASAORI.Response(STATUS_BAD_REQUEST) | |
return | |
} | |
} | |
/** レスポンスヘッダを構築する | |
* | |
* @param string _argv[0] ステータス | |
* @param string[] _argv[1] Value[0..n] | |
* @return string レスポンスヘッダ文字列 | |
*/ | |
AYASAORI.Response | |
{ | |
_version = "" | |
_charset = "" | |
_sender = "" | |
_status = "" | |
if ISVAR("RES.VERSION") { | |
_version = RES.VERSION | |
ERASEVAR("RES.VERSION") | |
} else { | |
_version = AYASAORI.VERSION | |
} | |
if ISVAR("RES.CHARSET") { | |
_charset = RES.CHARSET | |
ERASEVAR("RES.CHARSET") | |
} else { | |
_charset = REQ.CHARSET | |
} | |
void SETSETTING('charset.output',_charset) | |
if ISVAR("RES.SENDER") { | |
_sender = RES.SENDER | |
ERASEVAR("RES.SENDER") | |
} else { | |
_sender = AYASAORI.SENDER | |
} | |
if ISVAR("RES.STATUS") { | |
_status = RES.STATUS | |
ERASEVAR("RES.STATUS") | |
} else { | |
_status = _argv[0] | |
} | |
_response = "" | |
_response += "SAORI/%(_version) %(_status)" + CRLF | |
_response += "Charset: %(_charset)" + CRLF | |
_response += "Sender: %(_sender)" + CRLF | |
if ISVAR("RES.RESULT") { | |
_response += "Result: %(RES.RESULT)" + CRLF | |
ERASEVAR("RES.RESULT") | |
} | |
_i = 0 | |
while 1 { | |
if ISVAR("RES.VALUE%(_i)") { | |
_response += "Value%(_i): " + EVAL("RES.VALUE%(_i)") + CRLF | |
ERASEVAR("RES.VALUE%(_i)") | |
} else { | |
break | |
} | |
_i++ | |
} | |
_response + CRLF | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// ※修正しました | |
acos | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("acos: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = ACOS(_req0) | |
} | |
// 位置情報はValue0で返る | |
any | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("any: 引数が不足しています") | |
-1 | |
return | |
} | |
if ARRAYSIZE(REQ.ARGS) == 1 | |
RES.RESULT = ANY(REQ.ARGS[0]) | |
else | |
RES.RESULT = ANY(REQ.ARGS) | |
RES.VALUE0 = LSO | |
} | |
arraysize | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("arraysize: 引数が不足しています") | |
-1 | |
return | |
} | |
if ARRAYSIZE(REQ.ARGS) == 1 | |
RES.RESULT = ARRAYSIZE(REQ.ARGS[0]) | |
else | |
RES.RESULT = ARRAYSIZE(REQ.ARGS) | |
} | |
asearch | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("asearch: 引数が不足しています") | |
-1 | |
return | |
} | |
_key = REQ.ARGS[0] | |
REQ.ARGS[0] = IARRAY | |
RES.RESULT = ASEARCH(_key, REQ.ARGS) | |
} | |
// ※修正しました | |
// Resultは発見した個数 | |
// Value[0..n]に個々の発見位置 | |
asearchex | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("asearchex: 引数が不足しています") | |
-1 | |
return | |
} | |
_key = REQ.ARGS[0] | |
REQ.ARGS[0] = IARRAY | |
_result = ASEARCHEX(_key, REQ.ARGS) | |
RES.RESULT = _result | |
RES.RESULT = ARRAYSIZE(RES.RESULT) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// ※修正しました | |
asin | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("asin: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = ASIN(_req0) | |
} | |
// ※修正しました | |
atan | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("atan: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = ATAN(_req0) | |
} | |
binstrtoi | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("binstrtoi: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = BINSTRTOI(REQ.ARGS[0]) | |
} | |
// ※修正しました | |
ceil | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("ceil: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = CEIL(_req0) | |
} | |
charsetlib | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("charsetlib: 引数が不足しています") | |
-1 | |
return | |
} | |
CHARSETLIB(REQ.ARGS[0]) | |
} | |
chr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("chr: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = CHR(REQ.ARGS[0]) | |
} | |
chrcode | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("chrcode: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = CHRCODE(REQ.ARGS[0]) | |
} | |
// ※修正しました | |
cos | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("cos: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = COS(_req0) | |
} | |
cutspace | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("cutspace: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = CUTSPACE(REQ.ARGS[0]) | |
} | |
// レスポンスヘッダでまた文字列に戻るので意味がない | |
cvint | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("cvint: 引数が不足しています") | |
-1 | |
return | |
} | |
CVINT(REQ.ARGS[0]) | |
RES.RESULT = REQ.ARGS[0] | |
} | |
// レスポンスヘッダでまた文字列に戻るので意味がない | |
cvreal | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("cvreal: 引数が不足しています") | |
-1 | |
return | |
} | |
CVREAL(REQ.ARGS[0]) | |
RES.RESULT = REQ.ARGS[0] | |
} | |
// 元々文字列なので意味がない | |
cvstr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("cvstr: 引数が不足しています") | |
-1 | |
return | |
} | |
CVSTR(REQ.ARGS[0]) | |
RES.RESULT = REQ.ARGS[0] | |
} | |
erase | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("erase: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = ERASE(REQ.ARGS[0], REQ.ARGS[1], REQ.ARGS[2]) | |
} | |
erasevar | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("erasevar: 引数が不足しています") | |
-1 | |
return | |
} | |
ERASEVAR(REQ.ARGS[0]) | |
} | |
eval | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("eval: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = EVAL(REQ.ARGS[0]) | |
} | |
fcharset | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("fcharset: 引数が不足しています") | |
-1 | |
return | |
} | |
FCHARSET(REQ.ARGS[0]) | |
} | |
fclose | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("fclose: 引数が不足しています") | |
-1 | |
return | |
} | |
FCLOSE(REQ.ARGS[0]) | |
} | |
fcopy | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fcopy: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FCOPY(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
fdel | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("fdel: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FDEL(REQ.ARGS[0]) | |
} | |
fenum | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("fenum: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FENUM(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
// ※修正しました | |
floor | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("floor: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0=TOREAL(REQ.ARGS[0]) | |
RES.RESULT = FLOOR(_req0) | |
} | |
fmove | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fmove: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FMOVE(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
fopen | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fopen: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FOPEN(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
// ファイル終端まで読むと、Resultが無くなりValue0が"EOF"になる | |
fread | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("fread: 引数が不足しています") | |
-1 | |
return | |
} | |
_result = FREAD(REQ.ARGS[0]) | |
if GETTYPE(_result) == 1 | |
RES.VALUE0 = "EOF" | |
else | |
RES.RESULT = _result | |
} | |
frename | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("frename: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FRENAME(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
fsize | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("fsize: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FSIZE(REQ.ARGS[0]) | |
} | |
// ※修正しました | |
fwrite | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fwrite: 引数が不足しています") | |
-1 | |
return | |
} | |
FWRITE(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
// ※修正しました | |
fwrite2 | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fwrite2: 引数が不足しています") | |
-1 | |
return | |
} | |
FWRITE2(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
// 恐らく意味なし | |
getdelim | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("getdelim: 引数が不足しています") | |
-1 | |
return | |
} | |
if ARRAYSIZE(REQ.ARGS) == 1 | |
RES.RESULT = GETDELIM(REQ.ARGS[0]) | |
else | |
RES.RESULT = GETDELIM(TOSTR(REQ.ARGS)) | |
} | |
// ※修正しました | |
getlasterror | |
{ | |
RES.RESULT = GETLASTERROR() | |
} | |
// ※修正しました | |
/** | |
* Value0: 物理メモリの使用率 | |
* Value1: 物理メモリ量 | |
* Value2: 空き物理メモリ量 | |
* Value3: 仮想+物理メモリ量 | |
* Value4: 仮想+物理空きメモリ量 | |
*/ | |
getmeminfo | |
{ | |
_result = GETMEMINFO() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// ※修正しました。 | |
getsetting | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("getsetting: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = GETSETTING(TOAUTO(REQ.ARGS[0])) | |
} | |
// ※修正しました | |
getstrbytes | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("getstrbytes: 引数が不足しています") | |
-1 | |
return | |
} | |
if ARRAYSIZE(REQ.ARGS) == 1 { | |
RES.RESULT = GETSTRBYTES(REQ.ARGS[0]) | |
} | |
else { | |
_req1 = TOINT(REQ.ARGS[1]) | |
RES.RESULT = GETSTRBYTES(REQ.ARGS[0], _req1) | |
} | |
} | |
gettickcount | |
{ | |
RES.RESULT = GETTICKCOUNT() | |
} | |
/** | |
* Value0: 西暦年 | |
* Value1: 月 | |
* Value2: 日 | |
* Value3: 曜日(0-6)で0が日曜日 | |
* Value4: 時 | |
* Value5: 分 | |
* Value6: 秒 | |
*/ | |
gettime | |
{ | |
_result = GETTIME(REQ.ARGS[0]) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// ※修正しました | |
gettype | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("gettype: 引数が不足しています") | |
-1 | |
return | |
} | |
tes=ISREALSTR(REQ.ARGS[0]) | |
tes2=ISINTSTR(REQ.ARGS[0]) | |
RES.RESULT = GETTYPE(_req0) | |
if ISINTSTR(REQ.ARGS[0]) == 1 { | |
_req0=TOINT(REQ.ARGS[0]) | |
RES.RESULT = GETTYPE(_req0) | |
} | |
elseif ISREALSTR(REQ.ARGS[0]) == 1 { | |
_req0=TOREAL(REQ.ARGS[0]) | |
RES.RESULT = GETTYPE(_req0) | |
} | |
} | |
hexstrtoi | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("hexstrtoi: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = HEXSTRTOI(REQ.ARGS[0]) | |
} | |
// 空の汎用配列を返しても意味がない | |
iarray | |
{ | |
RES.RESULT = IARRAY() | |
} | |
// ※修正しました | |
insert | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("insert: 引数が不足しています") | |
-1 | |
return | |
} | |
_req1 = TOINT(REQ.ARGS[1]) | |
RES.RESULT = INSERT(REQ.ARGS[0], _req1, REQ.ARGS[2]) | |
} | |
isfunc | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("isfunc: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = ISFUNC(REQ.ARGS[0]) | |
} | |
isintstr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("isintstr: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = ISINTSTR(REQ.ARGS[0]) | |
} | |
isrealstr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("isrealstr: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = ISREALSTR(REQ.ARGS[0]) | |
} | |
isvar | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("isvar: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = ISVAR(REQ.ARGS[0]) | |
} | |
lettoname | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("lettoname: 引数が不足しています") | |
-1 | |
return | |
} | |
LETTONAME(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
loadlib | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("loadlib: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = LOADLIB(REQ.ARGS[0]) | |
} | |
log | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("log: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = LOG(REQ.ARGS[0]) | |
} | |
log10 | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("log10: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = LOG10(REQ.ARGS[0]) | |
} | |
logging | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("logging: 引数が不足しています") | |
-1 | |
return | |
} | |
LOGGING(REQ.ARGS[0]) | |
} | |
// ほぼ意味なし | |
// ※修正しました | |
lso | |
{ | |
RES.RESULT = LSO() | |
} | |
mkdir | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("mkdir: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = MKDIR(REQ.ARGS[0]) | |
} | |
// ※修正しました | |
pow | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("pow: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
_req1 = TOREAL(REQ.ARGS[1]) | |
RES.RESULT = POW(_req0, _req1) | |
} | |
// ※修正しました | |
rand | |
{ | |
RES.RESULT = RAND(REQ.ARGS[0]) | |
} | |
srand | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("srand: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = SRAND(REQ.ARGS[0]) | |
} | |
// Result: 列挙された数 | |
// Value[0..n]: 文字列の長さ | |
re_getlen | |
{ | |
_result = RE_GETLEN() | |
RES.RESULT = ARRAYSIZE(_result) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// Result: 列挙された数 | |
// Value[0..n]: 列挙された部分文字列の位置 | |
re_getpos | |
{ | |
_result = RE_GETPOS() | |
RES.RESULT = ARRAYSIZE(_result) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// Result: 列挙された数 | |
// Value[0..n]: 列挙された部分文字列(※正常に値が返らない) | |
re_getstr | |
{ | |
_result = RE_GETSTR() | |
RES.RESULT = ARRAYSIZE(_result) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// Result: 見つかった数 | |
// Value[0..n]: 見つかった部分文字列 | |
re_grep | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("re_grep: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = RE_GREP(REQ.ARGS[0], REQ.ARGS[1]) | |
if RES.RESULT >= 1 { | |
_result = RE_GETSTR() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
} | |
// Result: マッチしたら1、しなかったら0 | |
// Value[0..n]: 見つかった場合部分文字列 | |
re_match | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("re_match: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = RE_MATCH(REQ.ARGS[0], REQ.ARGS[1]) | |
if RES.RESULT == 1 { | |
_result = RE_GETSTR() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
} | |
// Result: 置換結果文字列 | |
// Value[0..n]: 対象文字列の正規表現全体にマッチした部分 | |
re_replace | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("re_replace: 引数が不足しています") | |
-1 | |
return | |
} | |
_count = TOINT(REQ.ARGS[3]) | |
RES.RESULT = RE_REPLACE(REQ.ARGS[0], REQ.ARGS[1], REQ.ARGS[2], _count) | |
_result = RE_GETSTR() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// Result: マッチする個所があれば1、なかったら0 | |
// Value[0..n]: 見つかった場合部分文字列 | |
re_search | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("re_search: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = RE_SEARCH(REQ.ARGS[0], REQ.ARGS[1]) | |
if RES.RESULT == 1 { | |
_result = RE_GETSTR() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
} | |
// Result: 分割数 | |
// Value[0..n]: 分割された文字列 | |
re_split | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("re_split: 引数が不足しています") | |
-1 | |
return | |
} | |
_result = "" | |
if REQ.ARGS[2]=="" { | |
_result = RE_SPLIT(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
else { | |
_result = RE_SPLIT(REQ.ARGS[0],REQ.ARGS[1],REQ.ARGS[2]) | |
} | |
RES.RESULT = ARRAYSIZE(_result) | |
_result = RE_GETSTR() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
replace | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("replace: 引数が不足しています") | |
-1 | |
return | |
} | |
_count = TOINT(REQ.ARGS[3]) | |
RES.RESULT = REPLACE(REQ.ARGS[0], REQ.ARGS[1], REQ.ARGS[2], _count) | |
} | |
// 第2引数の文字列の改行は\\r\\nとしてエスケープされていること | |
requestlib | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("requestlib: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = REQUESTLIB(REQ.ARGS[0], REPLACE(REQ.ARGS[1], "\r\n", CRLF)) | |
} | |
rmdir | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("rmdir: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = RMDIR(REQ.ARGS[0]) | |
} | |
// ※修正しました | |
round | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("round: 引数が不足しています") | |
-1 | |
return | |
} | |
_res = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = ROUND(_res) | |
} | |
savevar | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("savevar: 引数が不足しています") | |
-1 | |
return | |
} | |
SAVEVAR(REQ.ARGS[0]) | |
} | |
setdelim | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("setdelim: 引数が不足しています") | |
-1 | |
return | |
} | |
SETDELIM(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
// ※修正しました | |
setlasterror | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("setlasterror: 引数が不足しています") | |
-1 | |
return | |
} | |
_req1 = TOINT(REQ.ARGS[0]) | |
SETLASTERROR(_req1) | |
} | |
sin | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("sin: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = SIN(_req0) | |
} | |
// Result: 分割数 | |
// Value[0..n]: 分割された文字列 | |
split | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("split: 引数が不足しています") | |
-1 | |
return | |
} | |
_result = SPLIT(REQ.ARGS) | |
RES.RESULT = ARRAYSIZE(_result) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
LOGGING(EVAL("RES.VALUE%(_i)")) | |
} | |
} | |
// Result: 分割数 | |
// Value0: ドライブ部分 | |
// Value1: ディレクトリ部分 | |
// Value2: ファイルベース名部分 | |
// Value3: 拡張子部分 | |
splitpath | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("splitpath: 引数が不足しています") | |
-1 | |
return | |
} | |
_result = SPLITPATH(REQ.ARGS[0]) | |
RES.RESULT = ARRAYSIZE(_result) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
sqrt | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("sqrt: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = SQRT(REQ.ARGS[0]) | |
} | |
// 関数の引数は汎用配列 | |
strform | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("strform: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = STRFORM(REQ.ARGS) | |
} | |
strlen | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("strlen: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = STRLEN(REQ.ARGS[0]) | |
} | |
// ※修正しました | |
strstr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("strstr: 引数が不足しています") | |
-1 | |
return | |
} | |
_req2 = TOINT(REQ.ARGS[2]) | |
RES.RESULT = STRSTR(REQ.ARGS[0], REQ.ARGS[1], _req2) | |
} | |
// ※修正しました | |
substr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("substr: 引数が不足しています") | |
-1 | |
return | |
} | |
_req1=TOINT(REQ.ARGS[1]) | |
_req2=TOINT(REQ.ARGS[2]) | |
RES.RESULT = SUBSTR(REQ.ARGS[0], _req1, _req2) | |
} | |
// ※修正しました | |
tan | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("tan: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = TAN(_req0) | |
} | |
tobinstr | |
{ | |
RES.RESULT = TOBINSTR(TOINT(REQ.ARGS[0])) | |
} | |
tohexstr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("tohexstr: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = TOHEXSTR(TOINT(REQ.ARGS[0])) | |
} | |
// 再び文字列で戻るので意味なし | |
toint | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("toint: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = TOINT(REQ.ARGS[0]) | |
} | |
tolower | |
{ | |
RES.RESULT = TOLOWER(REQ.ARGS[0]) | |
} | |
// 再び文字列で戻るので意味なし | |
toreal | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("toreal: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = TOREAL(REQ.ARGS[0]) | |
} | |
// 元々文字列なので意味なし | |
tostr | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("tostr: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = TOSTR(REQ.ARGS[0]) | |
} | |
toupper | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("toupper: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = TOUPPER(REQ.ARGS[0]) | |
} | |
unloadlib | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("unloadlib: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = UNLOADLIB(REQ.ARGS[0]) | |
} | |
// ------ ※以下新規追加分 ----------- | |
/** | |
* Value0: ARCHIV アーカイブファイル、またはアーカイブディレクトリ。 | |
* Value1: COMPRESSED 圧縮ファイル、または圧縮ディレクトリ。 | |
* Value2: DIRECTORY ディレクトリ。 | |
* Value3: HIDDEN 隠しファイルまたは隠しディレクトリ。 | |
* Value4: NORMAL 属性なし。 | |
* Value5: OFFLINE このファイルのデータは、今すぐは利用不能。 | |
* Value6: READONLY 読み取り専用ファイル。 | |
* Value7: SYSTEM Windowsが使用するファイル。 | |
* Value8: TEMP 一時ファイル。 | |
*/ | |
fattrib | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("fattrib: 引数が不足しています") | |
-1 | |
return | |
} | |
_result = FATTRIB(REQ.ARGS[0]) | |
RES.RESULT = _result | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
// ------ ※以下YAYA新規追加分 ----------- | |
bitwise_or | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("bitwise_or: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOINT(REQ.ARGS[0]) | |
_req1 = TOINT(REQ.ARGS[1]) | |
RES.RESULT = BITWISE_OR(_req0,_req1) | |
} | |
bitwise_and | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("bitwise_and: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOINT(REQ.ARGS[0]) | |
_req1 = TOINT(REQ.ARGS[1]) | |
RES.RESULT = BITWISE_AND(_req0,_req1) | |
} | |
bitwise_xor | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("bitwise_xor: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOINT(REQ.ARGS[0]) | |
_req1 = TOINT(REQ.ARGS[1]) | |
RES.RESULT = BITWISE_XOR(_req0,_req1) | |
} | |
bitwise_not | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("bitwise_not: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOINT(REQ.ARGS[0]) | |
RES.RESULT = BITWISE_NOT(_req0) | |
} | |
bitwise_shift | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("bitwise_shift: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOINT(REQ.ARGS[0]) | |
_req1 = TOINT(REQ.ARGS[1]) | |
RES.RESULT = BITWISE_SHIFT(_req0,_req1) | |
} | |
charsetlibex | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("charsetlibex: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = CHARSETLIBEX(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
cosh | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("cosh: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = COSH(REQ.ARGS[0]) | |
} | |
// 動作しない | |
cvauto | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("cvauto: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = CVAUTO(REQ.ARGS[0]) | |
} | |
execute | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("execute: 引数が不足しています") | |
-1 | |
return | |
} | |
elseif REQ.ARGS[1]!="" { | |
RES.RESULT = EXECUTE(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
else { | |
RES.RESULT = EXECUTE(REQ.ARGS[0]) | |
} | |
} | |
fdigest | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fdigest: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FDIGEST(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
freadbin | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("freadbin: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[2]=="" { | |
_req1=TOINT(REQ.ARGS[1]) | |
RES.RESULT = FREADBIN(REQ.ARGS[0],_req1) | |
} | |
else { | |
_req1=TOINT(REQ.ARGS[1]) | |
RES.RESULT = FREADBIN(REQ.ARGS[0],_req1,REQ.ARGS[2]) | |
} | |
} | |
fwritebin | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fwritebin: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[2]=="" { | |
_req1=TOINT(REQ.ARGS[1]) | |
RES.RESULT = FWRITEBIN(REQ.ARGS[0],_req1) | |
} | |
else { | |
_req1=TOINT(REQ.ARGS[1]) | |
RES.RESULT = FWRITEBIN(REQ.ARGS[0],_req1,REQ.ARGS[2]) | |
} | |
} | |
// 多分使う意味無し。 | |
getcallstack | |
{ | |
_result = GETCALLSTACK | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
getenv | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("getenv: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = GETENV(REQ.ARGS[0]) | |
} | |
getfunclist | |
{ | |
if REQ.ARGS[0]="" { | |
_result = GETFUNCLIST() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
else { | |
_result = GETFUNCLIST(REQ.ARGS[0]) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
} | |
getsystemfunclist | |
{ | |
if REQ.ARGS[0]="" { | |
_result = GETSYSTEMFUNCLIST() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
else { | |
_result = GETSYSTEMFUNCLIST(REQ.ARGS[0]) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
} | |
getfuncinfo | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("getfuncinfo: 引数が不足しています") | |
-1 | |
return | |
} | |
_result = GETFUNCINFO(REQ.ARGS[0]) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
getseccount | |
{ | |
_req0 = TOAUTO(REQ.ARGS[0]) | |
_req1 = TOAUTO(REQ.ARGS[1]) | |
_req2 = TOAUTO(REQ.ARGS[2]) | |
_req3 = 0 | |
_req4 = TOAUTO(REQ.ARGS[4]) | |
_req5 = TOAUTO(REQ.ARGS[5]) | |
_req6 = TOAUTO(REQ.ARGS[6]) | |
RES.RESULT = GETSECCOUNT(_req0,_req1,_req2,_req3,_req4,_req5,_req6) | |
} | |
getstrurldecode | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("getseccount: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[1]=="" { | |
RES.RESULT = GETSTRURLDECODE(REQ.ARGS[0]) | |
} | |
else { | |
RES.RESULT = GETSTRURLDECODE(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
} | |
getstrurlencode | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("getstrurlencode: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[1]=="" { | |
RES.RESULT = GETSTRURLENCODE(REQ.ARGS[0]) | |
} | |
else { | |
RES.RESULT = GETSTRURLENCODE(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
} | |
han2zen | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("han2zen: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[1]=="" { | |
RES.RESULT = HAN2ZEN(REQ.ARGS[0]) | |
} | |
else { | |
RES.RESULT = HAN2ZEN(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
} | |
processglobaldefine | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("processglobaldefine: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = PROCESSGLOBALDEFINE(REQ.ARGS[0]) | |
} | |
readfmo | |
{ | |
if REQ.ARGS[0]=="" { | |
RES.RESULT = READFMO | |
} | |
else { | |
RES.RESULT = READFMO(REQ.ARGS[0]) | |
} | |
} | |
restorevar | |
{ | |
if REQ.ARGS[0]=="" { | |
RES.RESULT = RESTOREVAR | |
} | |
else { | |
RES.RESULT = RESTOREVAR(REQ.ARGS[0]) | |
} | |
} | |
sinh | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("sinh: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = SINH(_req0) | |
} | |
tanh | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("tanh: 引数が不足しています") | |
-1 | |
return | |
} | |
_req0 = TOREAL(REQ.ARGS[0]) | |
RES.RESULT = TANH(_req0) | |
} | |
// 多分ほぼ使う意味なし | |
toauto | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("toauto: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = TOAUTO(REQ.ARGS[0]) | |
} | |
zen2han | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("zen2han: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[1]=="" { | |
RES.RESULT = ZEN2HAN(REQ.ARGS[0]) | |
} | |
else { | |
RES.RESULT = ZEN2HAN(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
} | |
setsetting | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("setsetting: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = SETSETTING(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
dumpvar { | |
DUMPVAR() | |
} | |
geterrorlog | |
{ | |
_result = GETERRORLOG() | |
RES.RESULT = ARRAYSIZE(_result)//とりあえずエラーログの個数を返すことにする | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
LOGGING(EVAL("RES.VALUE%(_i)")) | |
} | |
} | |
dicload | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("dicload: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[1]=="" { | |
RES.RESULT = DICLOAD(REQ.ARGS[0]) | |
} | |
else { | |
RES.RESULT = DICLOAD(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
} | |
dicunload | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("dicunload: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = DICUNLOAD(REQ.ARGS[0]) | |
} | |
undefglobaldefine | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("undefglobaldefine: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = UNDEFGLOBALDEFINE(REQ.ARGS[0]) | |
} | |
undeffunc | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("undeffunc: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = UNDEFFUNC(REQ.ARGS[0]) | |
} | |
license { | |
_result = LICENSE() | |
RES.RESULT = TOSTR(_result) | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
LOGGING(EVAL("RES.VALUE%(_i)")) | |
} | |
} | |
// Result: 置換結果文字列 | |
// Value[0..n]: 対象文字列の正規表現全体にマッチした部分 | |
re_replaceex | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("re_replaceex: 引数が不足しています") | |
-1 | |
return | |
} | |
_count = TOINT(REQ.ARGS[3]) | |
RES.RESULT = RE_REPLACEEX(REQ.ARGS[0], REQ.ARGS[1], REQ.ARGS[2], _count) | |
_result = RE_GETSTR() | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
fseek | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("fseek: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FSEEK(REQ.ARGS[0],(TOINT(REQ.ARGS[1])),REQ.ARGS[2]) | |
} | |
ftell | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("ftell: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = FTELL(REQ.ARGS[0]) | |
} | |
charsetidtotext | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("charsetidtotext: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = CHARSETIDTOTEXT(REQ.ARGS[0]) | |
} | |
charsettexttoid | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("charsettexttoid: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = CHARSETTEXTTOID(REQ.ARGS[0]) | |
} | |
getvarlist | |
{ | |
if REQ.ARGS[0]=="" { | |
RES.RESULT = TOSTR(GETVARLIST()) | |
} | |
else { | |
RES.RESULT = TOSTR(GETVARLIST(REQ.ARGS[0])) | |
} | |
_result = RES.RESULT | |
for _i = 0; _i < ARRAYSIZE(_result); _i++ { | |
LETTONAME("RES.VALUE%(_i)", _result[_i]) | |
} | |
} | |
execute_wait | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("execute_wait: 引数が不足しています") | |
-1 | |
return | |
} | |
elseif REQ.ARGS[1]!="" { | |
RES.RESULT = EXECUTE_WAIT(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
else { | |
RES.RESULT = EXECUTE_WAIT(REQ.ARGS[0]) | |
} | |
} | |
strdecode | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("strdecode: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[1]=="" { | |
RES.RESULT = STRDECODE(REQ.ARGS[0]) | |
} | |
elseif REQ.ARGS[2]=="" { | |
RES.RESULT = STRENCODE(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
else { | |
RES.RESULT = STRDECODE(REQ.ARGS[0],REQ.ARGS[1],REQ.ARGS[2]) | |
} | |
} | |
strencode | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("strencode: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[1]=="" { | |
RES.RESULT = STRENCODE(REQ.ARGS[0]) | |
} | |
elseif REQ.ARGS[2]=="" { | |
RES.RESULT = STRENCODE(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
else { | |
RES.RESULT = STRENCODE(REQ.ARGS[0],REQ.ARGS[1],REQ.ARGS[2]) | |
} | |
} | |
re_option | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("re_option: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = RE_OPTION(REQ.ARGS[0]) | |
} | |
freadencode | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("freadencode: 引数が不足しています") | |
-1 | |
return | |
} | |
_req1=TOINT(REQ.ARGS[1]) | |
if REQ.ARGS[2]=="" { | |
RES.RESULT = FREADENCODE(REQ.ARGS[0],_req1) | |
} | |
else { | |
RES.RESULT = FREADENCODE(REQ.ARGS[0],_req1,REQ.ARGS[2]) | |
} | |
} | |
fwritedecode | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("fwritedecode: 引数が不足しています") | |
-1 | |
return | |
} | |
if REQ.ARGS[2]=="" { | |
RES.RESULT = FWRITEDECODE(REQ.ARGS[0],REQ.ARGS[1]) | |
} | |
else { | |
RES.RESULT = FWRITEDECODE(REQ.ARGS[0],REQ.ARGS[1],REQ.ARGS[2]) | |
} | |
} | |
// 修正(2014.01.03) | |
asort | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("asort: 引数が不足しています") | |
-1 | |
return | |
} | |
_option = REQ.ARGS[0] | |
REQ.ARGS[0] = IARRAY() | |
_array0 = REQ.ARGS | |
_array1 = ASORT(_option, _array0) | |
_i = 0 | |
foreach _array1 ; _v { | |
LETTONAME("RES.VALUE%(_i)", _v) | |
_i ++ | |
} | |
RES.RESULT = '' | |
} | |
// 追加(2014.01.04) | |
translate | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 3 { | |
LOGGING("translate: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = TRANSLATE(REQ.ARGS[0], REQ.ARGS[1], REQ.ARGS[2]) | |
} | |
//Tc562-1 | |
isevaluable | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("isevaluable: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = ISEVALUABLE(REQ.ARGS[0]) | |
} | |
settamahwnd | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("settamahwnd: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = SETTAMAHWND(REQ.ARGS[0]) | |
} | |
isglobaldefine | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("isglobaldefine: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = ISGLOBALDEFINE(REQ.ARGS[0]) | |
} | |
setglobaldefine | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 2 { | |
LOGGING("setglobaldefine: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = SETGLOBALDEFINE(REQ.ARGS[0], REQ.ARGS[1]) | |
} | |
append_runtime_dic | |
{ | |
if ARRAYSIZE(REQ.ARGS) < 1 { | |
LOGGING("append_runtime_dic: 引数が不足しています") | |
-1 | |
return | |
} | |
RES.RESULT = APPEND_RUNTIME_DIC(REQ.ARGS[0]) | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//****************************************************************************** | |
// YAYA as SAORI テンプレート | |
// yaya.txt (設定ファイル) | |
// original written by umeici. | |
// changed by 摂理, yaya develop team, and many UKAGAKA developers. | |
// Special thanks to postic管理人 and もっしょくし. | |
// Last Editor: Don | |
// Last Update: 2021-07-10 | |
//****************************************************************************** | |
//---- 文字コード ----------------------------------------------------------------------- | |
charset.dic, Shift_JIS // 辞書ファイル | |
charset.output, Shift_JIS // 出力 | |
//---- 言語 ----------------------------------------------------------------------------- | |
messagetxt, messagetxt/japanese.txt // ログに記録されるエラーメッセージ類の言語ファイル | |
//---- 読み込む辞書 --------------------------------------------------------------------- | |
dic, ayasaori.aym // 文SAORIインターフェイスモジュール | |
dic, builtins.aym // ビルトイン関数モジュール | |
//dic, sample.aym // このように、モジュールを追記するだけですぐに使えます | |
//---- 実行ログ ------------------------------------------------------------------------- | |
//log, ayasaori.log // 実行ログをayasaori.logに記録します。開発時には記録しておいたほうが良いです。 | |
iolog, off // load, unload, request 実行時の記録 on で記録する。 | |
//---- セーブファイル ------------------------------------------------------------------- | |
save.auto, off // 自動保存機能 |
builtins.aymのfwritedecodeで第3引数(type)を省略できるよう変更
builtins.aymにgeterrorlogを追加(戻り値が配列なのでSPLITとかと同様Value*に格納しました)
builtins.aymにdicloadを追加
builtins.aymのgetsettingで引数の数値指定が一部動作していなかった問題を修正
builtins.aymにgetsystemfunclistを追加
ログに記録されるエラーメッセージ類の言語ファイルを同梱(yaya.txtの編集)
builtins.aymにgetfuncinfoを追加
builtins.aymにprocessglobaldefineを追加
builtins.aymにundeffuncとundefglobaldefineとdicunloadを追加
builtins.aymにisevaluableとsettamahwndとisglobaldefineとsetglobaldefineとappend_runtime_dicを追加
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
↑FWRITEDECODEは第3引数省略不可だったらしいので修正