/// <summary>
/// 配列に変数を代入する
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
public void SetValue(int index, object value)
{
NakoVariable v = new NakoVariable();
v.SetBodyAutoType(value);
this.SetVar(index, v);
}
private object _append(INakoFuncCallInfo info)
{
object ary = info.StackPop(); // 参照渡しなので変数への参照が得られる
object s = info.StackPop();
if (!(ary is NakoVariable))
{
throw new NakoPluginRuntimeException("『追加』の引数がvariableではありません");
}
NakoVariable ary_link = (NakoVariable)ary;
if (ary_link.Body is NakoVarArray)
{
NakoVarArray arr = (NakoVarArray)ary_link.Body;
NakoVariable new_item = new NakoVariable();
new_item.SetBodyAutoType(s);
arr.Add(new_item);
}else if(ary_link.Body is string && (string)ary_link.Body==""){
NakoVarArray arr = new NakoVarArray();
NakoVariable new_item = new NakoVariable();
new_item.SetBodyAutoType(s);
arr.Add(new_item);
ary_link.SetBody(arr,NakoVarType.Array);
}
// 結果をセット
return null;
}
/// <summary>
/// 配列変数(ハッシュ)の要素を設定する
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SetValueFromKey(string key, object value)
{
NakoVariable v = new NakoVariable();
v.key = key;
v.SetBodyAutoType(value);
this.SetVarFromKey(key, v);
}
/// <summary>
/// 配列に値を代入する
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
public void SetVar(int index, NakoVariable value)
{
while (index >= list.Count)
{
list.Add(null);
}
list[index] = value;
}
/// <summary>
/// ハッシュのキーを得る
/// </summary>
/// <returns></returns>
public string[] GetKeys()
{
string[] r = new string[list.Count];
for (int i = 0; i < list.Count; i++)
{
NakoVariable v = list[i];
r[i] = v.key;
}
return(r);
}
/// <summary>
/// 配列要素を得る
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public object GetValueFromObj(object key)
{
NakoVariable v = GetVarFromObj(key);
if (v != null)
{
return(v.Body);
}
return(null);
}
/// <summary>
/// 配列に値を代入する
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public object GetValueFromKey(string key)
{
NakoVariable v = GetVarFromKey(key);
if (v != null)
{
return(v.Body);
}
return(null);
}
/// <summary>
/// 配列要素を得る
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public object GetValue(int index)
{
NakoVariable v = GetVar(index);
if (v == null)
{
return(null);
}
return(v.Body);
}
/// <summary>
/// ハッシュに変数を代入する
/// </summary>
/// <param name="key">文字列でキーを指定</param>
/// <param name="var"></param>
public void SetVarFromKey(string key, NakoVariable var)
{
int i = GetIndexFromKey(key);
if (i >= 0)
{
list.RemoveAt(i);
}
var.key = key;
list.Add(var);
}
/// <summary>
/// 末尾の要素を切り取って返す
/// </summary>
/// <returns></returns>
public NakoVariable Pop()
{
if (list.Count == 0)
{
return(null);
}
int last = list.Count - 1;
NakoVariable last_o = list[last];
list.RemoveAt(last);
return(last_o);
}
/// <summary>
/// 配列(インデックス/ハッシュ)に変数を代入する
/// </summary>
/// <param name="key">整数 or 文字列でキーを指定</param>
/// <param name="value"></param>
public void SetVarFromObj(object key, NakoVariable value)
{
if (key is string)
{
SetVarFromKey((string)key, value);
}
else
{
int index = Convert.ToInt32(key);
SetVar(index, value);
}
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="scope"></param>
public NakoVariableManager(NakoVariableScope scope)
{
list = new List<NakoVariable>();
names = new Dictionary<string, int>();
if (scope == NakoVariableScope.Global)
{
// 変数「それ」を登録
NakoVariable sore = new NakoVariable();
sore.SetBody(0, NakoVarType.Int);
list.Add(sore);
names[NakoReservedWord.SORE] = 0;
}
}
/// <summary>
/// ハッシュのキーを得る
/// </summary>
/// <returns></returns>
public string[] GetKeys()
{
//string[] r = new string[list.Count];
System.Collections.Generic.List <string> r = new System.Collections.Generic.List <string>();
for (int i = 0; i < list.Count; i++)
{
NakoVariable v = list[i];
if (v != null)
{
//r [i] = v.key;
r.Add((v.key == null)? i.ToString() : v.key);
}
}
return(r.ToArray());
}
/// <summary>
/// 値を検索してキー番号を返す
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public int FindValue(object v)
{
for (int i = 0; i < list.Count; i++)
{
NakoVariable item = list[i];
if (v == null)
{
continue;
}
if (v.Equals(item.Body))
{
return(i);
}
}
return(-1);
}
/// <summary>
/// ハッシュ名からハッシュ番号を得る
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public int GetIndexFromKey(string key)
{
// TODO: ここにキャッシュ検索を入れると早くなる!!
for (int i = 0; i < list.Count; i++)
{
NakoVariable v = list[i];
if (v == null)
{
continue;
}
if (key == v.key)
{
return(i);
}
}
return(-1);
}
/// <summary>
/// 配列要素を得る
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public NakoVariable GetVarFromObj(object key)
{
if (key is string)
{
return(GetVarFromKey((string)key));
}
else if (key is NakoVariable)
{
NakoVariable v = (NakoVariable)key;
if (v.key != null)
{
return(GetVarFromObj(v.key));
}
else
{
return(GetVarFromObj(v.Body));
}
}
else
{
int index = Convert.ToInt32(key);
return(GetVar(index));
}
}
/// <summary>
/// 配列要素を追加する
/// </summary>
/// <param name="item"></param>
public void Add(NakoVariable item)
{
list.Add(item);
}
private object _getPlugins(INakoFuncCallInfo info)
{
NakoVarArray a = info.CreateArray();
foreach (KeyValuePair<string, INakoPlugin> pair in NakoAPIFuncBank.Instance.PluginList)
{
NakoVariable v = new NakoVariable();
v.SetBodyAutoType(pair.Key);
a.Add(v);
}
return a;
}
/// <summary>
/// 変数をセット
/// </summary>
/// <param name="index"></param>
/// <param name="v"></param>
public void SetVar(int index, NakoVariable v)
{
// Create Var
while (index >= list.Count)
{
list.Add(null);
}
list[index] = v;
}
/// <summary>
/// 名前のない変数を作成
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public int CreateVarNameless(NakoVariable v)
{
string name = ";nameless_" + list.Count; // あり得ない変数名を作る
return CreateVar(name, v);
}
/// <summary>
/// 配列に変数を代入する
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
public void SetValue(int index, object value)
{
NakoVariable v = new NakoVariable();
v.SetBodyAutoType(value);
this.SetVar(index, v);
}
/// <summary>
/// 配列に要素を挿入する
/// </summary>
/// <param name="index"></param>
/// <param name="item"></param>
public void Insert(int index, NakoVariable item)
{
list.Insert(index, item);
}
//> _def_function : DEF_FUNCTION _def_function_args _scope
//> ;
private bool _def_function()
{
if (!Accept(NakoTokenType.DEF_FUNCTION)) return false;
NakoToken t = tok.CurrentToken;
tok.MoveNext(); // '*'
NakoFunc userFunc = new NakoFunc();
userFunc.funcType = NakoFuncType.UserCall;
// 引数 + 関数名の取得
_def_function_args(userFunc);
// ブロックの取得
PushFrame();
NakoNodeDefFunction funcNode = new NakoNodeDefFunction();
funcNode.func = userFunc;
parentNode = funcNode.funcBody = new NakoNode();
funcNode.RegistArgsToLocalVar();
localVar = funcNode.localVar;
if (!_scope())
{
throw new NakoParserException("関数定義中のエラー。", t);
}
PopFrame();
// グローバル変数に登録
NakoVariable v = new NakoVariable();
v.SetBody(funcNode, NakoVarType.UserFunc);
globalVar.CreateVar(userFunc.name, v);
// 関数の宣言は、ノードのトップ直下に追加する
if (!this.topNode.hasChildren())
{
this.topNode.AddChild(new NakoNode());
}
this.topNode.Children.Insert(0, funcNode);
return true;
}
/// <summary>
/// 変数を作成
/// </summary>
/// <param name="name"></param>
/// <param name="v"></param>
/// <returns></returns>
public int CreateVar(string name, NakoVariable v)
{
if (v == null)
{
v = new NakoVariable();
}
list.Add(v);
int i = list.Count - 1;
names[name] = i;
return i;
}
/// <summary>
/// 変数をセット
/// </summary>
/// <param name="name"></param>
/// <param name="v"></param>
public void SetVar(string name, NakoVariable v)
{
int i = GetIndex(name);
if (i < 0)
{
i = CreateVar(name, v);
}
list[i] = v;
}
/// <summary>
/// 変数の値を取得
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public object GetValue(int index)
{
NakoVariable v = GetVar(index);
if (v == null)
{
v = new NakoVariable();
while (index >= list.Count)
{
list.Add(new NakoVariable());
}
SetVar(index, v);
}
return v.Body;
}
private void ld_global_ref(int no)
{
NakoVariable v = globalVar.GetVar(no);
if (v == null)
{
v = new NakoVariable();
v.varNo = no;
globalVar.SetVar(no, v);
}
StackPush(v);
}
private void ld_local_ref(int no)
{
NakoVariable v = localVar.GetVar(no);
if (v == null)
{
v = new NakoVariable();
localVar.SetVar(no, v);
}
StackPush(v);
}
/// <summary>
/// 配列要素を追加する
/// </summary>
/// <param name="item"></param>
public void Add(NakoVariable item)
{
list.Add(item);
}
/// <summary>
/// 配列に要素を挿入する
/// </summary>
/// <param name="index"></param>
/// <param name="item"></param>
public void Insert(int index, NakoVariable item)
{
list.Insert(index, item);
}
/// <summary>
/// 変数に値を設定
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
public void SetValue(int index, object value)
{
NakoVariable v = GetVar(index);
if (v == null)
{
v = new NakoVariable();
SetVar(index, v);
}
v.SetBodyAutoType(value);
}
/// <summary>
/// 配列要素をスタックに乗せるが、その時、配列オブジェクトへのリンクを乗せる
/// </summary>
private void ld_elem_ref()
{
object idx = StackPop();
object var = StackPop();
NakoVarArray var_ary;
// var が不正なら null を乗せて帰る
if (!(var is NakoVariable))
{
StackPush(null);
return;
}
if (var is NakoVarArray)
{
NakoVarArray a = (NakoVarArray)var;
NakoVariable elem = a.GetVarFromObj(idx);
StackPush(elem);
return;
}
if (((NakoVariable)var).Body is NakoVarArray)
{
var_ary = (NakoVarArray)((NakoVariable)var).Body;
NakoVariable elem = var_ary.GetVarFromObj(idx);
if (elem == null)
{
elem = new NakoVariable();
var_ary.SetVarFromObj(idx, elem);
}
StackPush(elem);
}
if (((NakoVariable)var).Body == null)
{
((NakoVariable)var).SetBody(new NakoVarArray(), NakoVarType.Array);
}
if (((NakoVariable)var).Body is NakoVarArray)
{
var_ary = (NakoVarArray)((NakoVariable)var).Body;
NakoVariable elem = var_ary.GetVarFromObj(idx);
if (elem == null)
{
elem = new NakoVariable();
var_ary.SetVarFromObj(idx, elem);
}
StackPush(elem);
}
else
{
StackPush(null);
}
}
/// <summary>
/// システムに登録する
/// </summary>
/// <param name="dic"></param>
/// <param name="globalVar"></param>
public void RegisterToSystem(NakoTokenDic dic, NakoVariableManager globalVar)
{
// --- 関数
// Tokenizer に登録
for (int i = 0; i < FuncList.Count; i++)
{
NakoAPIFunc call = FuncList[i];
if (!dic.ContainsKey(call.name))
{
dic.Add(call.name, NakoTokenType.FUNCTION_NAME);
}
else
{
dic[call.name] = NakoTokenType.FUNCTION_NAME;
}
}
// NakoVariables に登録
for (int i = 0; i < FuncList.Count; i++)
{
NakoVariable var = new NakoVariable();
var.SetBody(i, NakoVarType.SystemFunc);
NakoAPIFunc call = FuncList[i];
globalVar.SetVar(call.name, var);
}
// --- 変数
foreach (string name in VarList.Keys)
{
NakoVariable var = new NakoVariable();
var.SetBodyAutoType(VarList[name]);
globalVar.SetVar(name, var);
}
}
/// <summary>
/// ハッシュに変数を代入する
/// </summary>
/// <param name="key">文字列でキーを指定</param>
/// <param name="var"></param>
public void SetVarFromKey(string key, NakoVariable var)
{
int i = GetIndexFromKey(key);
if (i >= 0)
{
list.RemoveAt(i);
}
var.key = key;
list.Add(var);
}
/// <summary>
/// 配列(インデックス/ハッシュ)に変数を代入する
/// </summary>
/// <param name="key">整数 or 文字列でキーを指定</param>
/// <param name="value"></param>
public void SetVarFromObj(object key, NakoVariable value)
{
if (key is string)
{
SetVarFromKey((string)key, value);
}
else
{
int index = Convert.ToInt32(key);
SetVar(index, value);
}
}
/// <summary>
/// 配列変数(ハッシュ)の要素を設定する
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void SetValueFromKey(string key, object value)
{
NakoVariable v = new NakoVariable();
v.key = key;
v.SetBodyAutoType(value);
this.SetVarFromKey(key, v);
}
private void st_elem()
{
object value = StackPop();
object index = StackPop();
object var = StackPop();
if (var is NakoVariable)
{
NakoVariable var2 = (NakoVariable)var;
// null か空の文字列なら NakoArray として生成
if (var2.Body == null || (var2.Type==NakoVarType.String && (string)var2.Body==""))
{
var2.SetBody(new NakoVarArray(), NakoVarType.Array);
}
if (!(var2.Body is NakoVarArray))
{
string s = "";
if (var2.Body != null) s = var2.Body.ToString();
var2.SetBody(new NakoVarArray(), NakoVarType.Array);
((NakoVarArray)var2.Body).SetValuesFromString(s);
}
// NakoArray なら 要素にセット
if (var2.Body is NakoVarArray)
{
NakoVarArray var3 = (NakoVarArray)(var2.Body);
NakoVariable elem = var3.GetVarFromObj(index);
if (elem == null)
{
elem = new NakoVariable();
elem.SetBodyAutoType(value);
if (index is long)
{
elem.varNo = Convert.ToInt32(index);
}
var3.SetVarFromObj(index, elem);
}
else
{
elem.SetBodyAutoType(value);
}
}
}
}
/// <summary>
/// 配列に値を代入する
/// </summary>
/// <param name="index"></param>
/// <param name="value"></param>
public void SetVar(int index, NakoVariable value)
{
while (index >= list.Count) { list.Add(null); }
list[index] = value;
}
/// <summary>
/// 変数をセット
/// </summary>
/// <param name="varname"></param>
/// <param name="value"></param>
public void SetVariable(string varname, NakoVariable value)
{
_runner.globalVar.SetVar(varname, (NakoVariable)value);
}
