/// <summary>
/// System.Type を type_dic で利用できるように登録します。
/// </summary>
/// <param name="type">登録する型を指定します。</param>
/// <returns>新しく登録した TypeCodes を返します。
/// 既に登録されていた場合には、登録されていた TypeCodes を返します。</returns>
public static TypeCodes RegisterTypeCode(System.Type type)
{
TypeCodes code;
if (type_dic.TryGetValue(type, out code))
{
return(code);
}
else
{
code = (TypeCodes)type_dic.Count;
type_dic.Add(type, code);
return(code);
}
}
private static ICustomReader GetCustomReader(System.Type type)
{
// 既に登録されている場合
ICustomReader ret;
if (creaders.TryGetValue(type, out ret))
{
return(ret);
}
ReadTypeAttribute[] attrs;
//-- 直接の属性適用
attrs = (ReadTypeAttribute[])type.GetCustomAttributes(typeof(ReadTypeAttribute), false);
if (attrs.Length != 0)
{
return(creaders[type] = attrs[0].GetCustomReader(type));
}
//--派生元での属性適用
attrs = (ReadTypeAttribute[])type.GetCustomAttributes(typeof(ReadTypeAttribute), true);
foreach (ReadTypeAttribute attr in attrs)
{
if (attr.Inheritable)
{
return(creaders[type] = attr.GetCustomReader(type));
}
}
// 見つからなかった場合
return(creaders[type] = null);
}
private readlink_cache_entry LinkGetEntry(FileInfo link)
{
string rpath = link.InternalPath;
readlink_cache_entry entry;
if (readlink_cache.TryGetValue(rpath, out entry))
{
if (link.LastWriteTime <= entry.informationTime)
{
return(entry);
}
}
else
{
entry = new readlink_cache_entry();
entry.informationTime = System.DateTime.MinValue;
readlink_cache[rpath] = entry;
}
session.Message.Write(1, "$ readlink {0}", rpath);
entry.targetPath = session.Sftp.noglob_readlink(rpath);
entry.informationTime = System.DateTime.Now;
entry.cyglink_data = null;
return(entry);
}
public MethodSignature(IMethodDeclaration methDecl)
{
this.meth_decl = methDecl;
this.name = meth_decl.Name;
if (meth_decl.SpecialName)
{
this.m_type = MethodType.SpecialName;
switch (this.name)
{
case "op_Implicit": this.m_type = MethodType.ImplicitCast; break;
case "op_Explicit": this.m_type = MethodType.ExplicitCast; break;
case ".cctor": this.m_type = MethodType.Constructor; break;
case ".ctor": this.m_type = MethodType.StaticConstructor; break;
default:
string op;
if (operators.TryGetValue(name, out op))
{
this.name = op;
this.m_type = MethodType.Operator;
}
break;
}
}
else
{
this.m_type = MethodType.Ordinary;
}
type_decl = ((ITypeReference)methDecl.DeclaringType).Resolve();
}
public override int ReadData(byte[] buff, int buffOffset, string name, long offset, ref int length)
{
cache_t cache;
if (!dic_cache.TryGetValue(name, out cache))
{
return(base.ReadData(buff, buffOffset, name, offset, ref length));
}
System.DateTime mtime = operation.FileGetMTime(name);
if (cache.mtime == mtime)
{
lock (cache){
int offsetInCache = (int)(offset - cache.offset);
if (offsetInCache >= 0 && offset + length <= cache.offset + cache.buff.Length)
{
if (length > cache.length - offsetInCache)
{
length = cache.length - offsetInCache;
}
System.Array.Copy(cache.buff, offsetInCache, buff, buffOffset, length);
return(0);
}
}
}
long coff = offset & ~0x0FFF;
long cend = offset + length + 0xFFF & ~0xFFF;
int len = (int)(cend - coff);
byte[] nbuff = new byte[len];
int ret = base.ReadData(nbuff, 0, name, coff, ref len);
if (ret != 0)
{
return(ret);
}
{
int offsetInCache = (int)(offset - coff);
if (len - offsetInCache < length)
{
length = len - offsetInCache;
}
System.Array.Copy(nbuff, offset - coff, buff, buffOffset, length);
}
lock (cache){
cache.buff = nbuff;
cache.offset = coff;
cache.length = len;
cache.mtime = mtime;
}
return(0);
}
/// <summary>
/// 指定した名前を以て登録されたインスタンスを取得します。
/// </summary>
/// <param name="name">取得したいインスタンスの登録名を指定します。</param>
/// <returns>指定した名前に対応するインスタンスが登録されていない場合には null を返します。</returns>
internal static ITreeNodeCheckBox GetInstance(string name)
{
ITreeNodeCheckBox ret;
if (str2ins.TryGetValue(name, out ret))
{
return(ret);
}
return(null);
}
/// <summary>
/// 指定したインスタンスの名前を取得します。
/// </summary>
/// <param name="chkbox">登録名を知りたいインスタンスを指定します。</param>
/// <returns>指定したインスタンスが登録されていない場合には null を返します。</returns>
internal static string GetName(ITreeNodeCheckBox chkbox)
{
string ret;
if (ins2str.TryGetValue(chkbox, out ret))
{
return(ret);
}
return(null);
}
/// <summary>
/// 指定したファイルについてのファイル情報を取得します。
/// </summary>
/// <param name="referenceTime">情報の期限と比較する参照時刻を指定します。</param>
/// <param name="path">ファイルの内部名を指定します。</param>
/// <param name="info">
/// キャッシュされたファイル情報が見付かった時、
/// ファイルが存在していればファイル情報を返します。
/// ファイルが存在していないという情報があった null を返します。
/// ファイル情報が見付からなかった時は null を返します。
/// </param>
/// <returns>
/// キャッシュされたファイル情報が見付かった時に true を返します。
/// true が返った場合でも、ファイルが存在しないという情報が見付かった時には info は null になります。
/// それ以外の場合に false を返します。
/// </returns>
public bool TryGetFile(System.DateTime referenceTime, string path, out FileInfo info)
{
this.DiscardOld(referenceTime);
bool ret = dicattr.TryGetValue(path, out info);
if (ret && info.IsNotExist)
{
info = null;
}
return(ret);
}
/// <summary>
/// 指定した名前の一致グループを取得します。
/// </summary>
/// <param name="name">取得する一致グループの名前を指定します。</param>
/// <returns>指定した名前の一致グループを返します。</returns>
public Group <TCapture> this[string name] {
get{
Gen::Dictionary <string, Group <TCapture> > c = CacheN;
Group <TCapture> ret;
if (!c.TryGetValue(name, out ret))
{
c[name] = new Group <TCapture>(parent, name);
}
return(c[name]);
}
}
/// <summary>
/// 指定した番号の一致グループを取得します。
/// </summary>
/// <param name="index">取得するグループの番号を指定します。
/// 番号は、現在のノードを基準にして付けられます。
/// 則ち、現在のノードの子ノードの</param>
/// <returns>指定した番号の一致グループを返します。</returns>
public Group <TCapture> this[int index] {
get{
Gen::Dictionary <int, Group <TCapture> > c = CacheI;
Group <TCapture> ret;
if (!c.TryGetValue(index, out ret))
{
c[index] = new Group <TCapture>(parent, index);
}
return(c[index]);
}
}
//**************************************************************************
static DecsetBitIndex Code2DecsetBitIndex(int code)
{
int s;
if (decbits.TryGetValue(code, out s))
{
return((DecsetBitIndex)s);
}
else
{
return((DecsetBitIndex)0);
}
}
internal static ExpressionType GetExpressionType(IExpression expression)
{
System.Type t = expression.GetType();
ExpressionType ret;
if (exp_types.TryGetValue(expression.GetType(), out ret))
{
return(ret);
}
System.Type[] interfaces = t.GetInterfaces();
for (int i = 0, iM = interfaces.Length; i < iM; i++)
{
if (exp_types.TryGetValue(interfaces[i], out ret))
{
exp_types[t] = ret; // 覚えて置く
return(ret);
}
}
return(ExpressionType.Unknown);
}
private static StatementType GetExpressionType(IStatement statement)
{
System.Type t = statement.GetType();
StatementType ret;
if (state_types.TryGetValue(statement.GetType(), out ret))
{
return(ret);
}
System.Type[] interfaces = t.GetInterfaces();
for (int i = 0, iM = interfaces.Length; i < iM; i++)
{
if (state_types.TryGetValue(interfaces[i], out ret))
{
state_types[t] = ret; // 覚えて置く
return(ret);
}
}
return(StatementType.Unknown);
}
/// <summary>
/// 実際の COM のインスタンスから Window クラスを生成します。
/// </summary>
/// <param name="obj">COM の HTMLWindow インスタンスを指定します。</param>
/// <returns>引数に渡した obj に対応して作成した Window インスタンスを作成します。</returns>
internal static Window FromObj(object obj)
{
if (obj == null)
{
return(null);
}
Window ret;
if (!instances.TryGetValue(obj, out ret))
{
ret = new Window(obj);
ret.onunload += delegate(){ instances.Remove(obj); };
instances.Add(obj, ret);
}
return(ret);
}
//--------------------------------------------------------------------------
public bool TryGetList(string path, out Gen::List <SftpFileInfo> result)
{
this.DiscardOld();
lsres_t value;
if (diclist.TryGetValue(path, out value))
{
result = value.result;
return(true);
}
else
{
result = null;
return(false);
}
}
public bool TryGetList(System.DateTime referenceTime, string path, out Gen::IEnumerable <FileInfo> list)
{
this.DiscardOld(referenceTime);
DirEntries value;
if (diclist.TryGetValue(path, out value))
{
list = value.list;
return(true);
}
else
{
list = null;
return(false);
}
}
//--------------------------------------------------------------------------
public bool TryGetAttr(string path, out jsch::SftpATTRS attr)
{
this.DiscardOld();
SftpFileInfo value;
if (dicattr.TryGetValue(path, out value))
{
attr = value.Attribute;
return(true);
}
else
{
attr = null;
return(false);
}
}
public static int type分岐4()
{
int c = 0;
System.Type t = types[random.Next(types.Length)];
int typecode;
if (Type分岐4_dic.TryGetValue(t, out typecode))
{
switch (typecode)
{
case 0: c = 1; break;
case 1: c = 4; break;
case 2: c = 2; break;
case 3: c = 8; break;
case 4: c = 3; break;
case 5: c = 11; break;
case 6: c = 12; break;
case 7: c = 6; break;
case 8: c = 1; break;
case 9: c = 5; break;
case 10: c = 13; break;
case 11: c = 7; break;
case 12: c = 10; break;
case 13: c = 9; break;
}
}
return(c);
}
private static int GetExpressionPrecedence(IExpression exp)
{
ExpressionType xtype = GetExpressionType(exp);
int ret;
if (prec_exp.TryGetValue(xtype, out ret))
{
return(ret);
}
if (xtype == ExpressionType.Binary && prec_binop.TryGetValue(((IBinaryExpression)exp).Operator, out ret))
{
return(ret);
}
else if (xtype == ExpressionType.Unary && prec_unary.TryGetValue(((IUnaryExpression)exp).Operator, out ret))
{
return(ret);
}
return(-2);
}
//============================================================
// コマンド \* の読み取り
//============================================================
private void readCommand(Gen::Dictionary <string, CommandData> commands)
{
__debug__.RegexParserToDo("複数文字名のコマンド");
if (!this.lreader.MoveNext())
{
this.lreader.SetError((@"\ の後にコマンド名が続いていません。"), 0, null);
wtype = WordType.Text;
return;
}
this.cword += this.lreader.CurrentLetter; if (!this.lreader.MoveNext())
{
return;
}
CommandData dat;
if (!commands.TryGetValue(cword, out dat))
{
this.lreader.SetError((@"指定した名前のコマンドは登録されていません。"), 0, null);
wtype = WordType.Text;
return;
}
if (dat.ArgumentType == CommandArgumentType.Brace)
{
if (!(this.lreader.CurrentLetter == '{'))
{
value = null;
}
else
{
string cmd = cword;
cword = "";
if (!this.lreader.MoveNext())
{
goto ERR_ARG;
}
int iP = 1;
bool escape = false;
while (true)
{
if (escape)
{
escape = false;
}
else
{
if ((this.lreader.CurrentLetter == '{'))
{
iP++;
}
else if ((this.lreader.CurrentLetter == '}'))
{
if (--iP == 0)
{
lreader.MoveNext(); break;
}
}
else if ((this.lreader.CurrentLetter == '\\'))
{
escape = true;
}
}
this.cword += this.lreader.CurrentLetter; if (!this.lreader.MoveNext())
{
goto ERR_ARG;
}
}
value = cword;
cword = cmd;
return;
ERR_ARG:
value = cword;
cword = cmd;
this.lreader.SetError(("引数の終端が来ない内に、正規表現の末端に達しました。"), 0, null);
}
}
}
public int Read(byte[] buff, int buffOffset, long offset, ref int rlength)
{
// ファイルサイズ制限
if (offset + rlength > filesize)
{
rlength = (int)(filesize - offset);
}
int data_off_buff = buffOffset;
long data_off_file = offset;
int data_len = rlength;
int boff = (int)(data_off_file / BLKSIZE);
int bend = (int)((data_off_file + rlength + BLKMASK) / BLKSIZE);
rlength = 0;
int rlength_tail = 0;
lock (map){
// 既にデータを持っている部分は処理
block_t b;
while (boff < bend && map.TryGetValue(boff, out b))
{
int copy_off_block = (int)(data_off_file - boff * (long)BLKSIZE);
int copy_len = BLKSIZE - copy_off_block;
if (copy_len > data_len)
{
copy_len = data_len;
}
b.ReadCache(parent, buff, data_off_buff, copy_off_block, copy_len);
// 更新
data_off_buff += copy_len;
data_off_file += copy_len;
data_len -= copy_len;
rlength += copy_len;
boff++;
}
// 末端からも処理
while (boff < bend - 1 && map.TryGetValue(bend - 1, out b))
{
int copy_off_data = (int)((bend - 1) * BLKSIZE - data_off_file);
int copy_off_buff = data_off_buff + copy_off_data;
int copy_len = (int)(data_len - copy_off_data);
b.ReadCache(parent, buff, copy_off_buff, 0, copy_len);
data_len -= copy_len;
rlength_tail += copy_len;
bend--;
}
if (boff == bend)
{
return(0);
}
// データ取得
{
long load_off_file = boff * BLKSIZE;
long load_end_file = bend * BLKSIZE;
int load_len = (int)(load_end_file - load_off_file);
byte[] nbuff = new byte[load_len];
int ret = parent.operation.ReadData(nbuff, 0, this.name, load_off_file, ref load_len);
this.update_cache(nbuff, boff, load_len);
// 結果書込
int data_off_nbuff = (int)(data_off_file - load_off_file);
if (load_len - data_off_nbuff < data_len)
{
data_len = load_len - data_off_nbuff;
}
else
{
rlength += rlength_tail;
}
rlength += data_len;
System.Array.Copy(nbuff, data_off_nbuff, buff, data_off_buff, data_len);
return(0);
}
}
/*
* lock(cache){
* cache.buff=nbuff;
* cache.offset=coff;
* cache.length=length;
* }
* //*/
}
public string WriteName(LanguageWriter w)
{
if (tref != null)
{
string name = tref.Name.Replace(".", "::").Replace("+", "::");
string special;
if (tref.Namespace == "System" && specialTypeNames.TryGetValue(name, out special))
{
name = special;
}
name = NameMangling.UnDecorateName(name);
w.WriteReference(name, this.FullName, tref);
ITypeCollection genericArguments = tref.GenericArguments;
if (genericArguments.Count > 0)
{
w.Write("<");
bool first = true;
foreach (IType type1 in genericArguments)
{
if (first)
{
first = false;
}
else
{
w.Write(", ");
}
new TypeRef(type1).WriteNameWithRef(w);
}
w.Write(">");
}
return(name);
}
IArrayType type2 = type as IArrayType;
if (type2 != null)
{
w.WriteKeyword("array");
w.Write("<");
new TypeRef(type2.ElementType).WriteNameWithRef(w);
if (type2.Dimensions.Count > 1)
{
w.Write(", ");
w.WriteAsLiteral(type2.Dimensions.Count);
}
w.Write(">");
}
IPointerType type4 = type as IPointerType;
if (type4 != null)
{
new TypeRef(type4.ElementType).WriteNameWithRef(w);
w.Write("*");
}
IReferenceType type3 = type as IReferenceType;
if (type3 != null)
{
new TypeRef(type3.ElementType).WriteNameWithRef(w);
w.Write("%");
}
IOptionalModifier modifier2 = type as IOptionalModifier;
if (modifier2 != null)
{
WriteModify(w, new TypeRef(modifier2.Modifier), new TypeRef(modifier2.ElementType), false);
}
IRequiredModifier modifier = type as IRequiredModifier;
if (modifier != null)
{
WriteModify(w, new TypeRef(modifier.Modifier), new TypeRef(modifier.ElementType), true);
}
IFunctionPointer fptr = type as IFunctionPointer;
if (fptr != null)
{
w.Write("(");
new TypeRef(fptr.ReturnType.Type).WriteNameWithRef(w);
w.Write(" (*)(");
bool first = true;
foreach (IParameterDeclaration declaration in fptr.Parameters)
{
if (first)
{
first = false;
}
else
{
w.Write(", ");
}
new TypeRef(declaration.ParameterType).WriteNameWithRef(w);
}
w.Write("))");
}
IGenericParameter parameter = type as IGenericParameter;
if (parameter != null)
{
w.WriteReference(parameter.Name, "/* ジェネリックパラメータ */ " + parameter.Name, null);
}
IGenericArgument argument = type as IGenericArgument;
if (argument != null)
{
new TypeRef(argument.Resolve()).WriteNameWithRef(w);
}
if (type is IValueTypeConstraint)
{
w.WriteKeyword("value class");
}
else if (type is IDefaultConstructorConstraint)
{
w.Write("<DefaultConstructorConstraint>");
}
return("<不明な型>");
}
public void dbg_NearImage()
{
ImageDirectory overlap = new ImageDirectory("<重複検索>", root);
Gen::Dictionary <Image, ImageDirectory> groups = new Gen::Dictionary <Image, ImageDirectory>();
afh.ImageArrange.ProgressDialog progress = new ProgressDialog();
progress.Title = "重複比較中 ...";
progress.ProgressMax = this.sorted.Count;
progress.Show();
for (int i = 0; i < this.sorted.Count; i++)
{
Image img1 = new Image(this.root, this.sorted[i]);
if (i % 50 == 0)
{
progress.Description = "画像 '" + img1.thm.filepath + "' の類似画像を探索中 ...";
if (progress.IsCanceled)
{
return;
}
}
for (int j = i + 1; j < this.sorted.Count; j++)
{
Image img2 = new Image(this.root, this.sorted[j]);
if (!Image.EqualAspect(img1, img2))
{
break;
}
if (Image.Resembles(img1, img2))
{
ImageDirectory group1 = null;
ImageDirectory group2 = null;
bool b1 = groups.TryGetValue(img1, out group1);
bool b2 = groups.TryGetValue(img2, out group2);
switch ((b1?1:0) | (b2?2:0))
{
case 3: // 両方
if (group1 == group2)
{
break;
}
// 両グループの併合
overlap.dirs.Remove(group2);
foreach (Image img in group2.EnumImages())
{
group1.Add(img);
groups[img] = group1;
}
break;
case 1: // group1 だけ
group1.Add(img2);
groups.Add(img2, group1);
break;
case 2: // group2 だけ
group2.Add(img1);
groups.Add(img1, group2);
break;
case 0: // 両者未登録
ImageDirectory group = new ImageDirectory("Group " + overlap.dirs.Count.ToString(), root);
group.Add(img1);
group.Add(img2);
groups.Add(img1, group);
groups.Add(img2, group);
overlap.Add(group);
break;
default:
throw new System.InvalidProgramException();
}
//System.Console.WriteLine("次の画像は似ています\r\n {0}\r\n {1}",thm1.filepath,thm2.filepath);
}
}
if (i % 10 == 0)
{
progress.Progress = i;
}
}
progress.Close();
this.root.dirs.Add(overlap);
}
//============================================================
// コマンド \* の読み取り
//============================================================
private void readCommand(Gen::Dictionary <string, CommandData> commands)
{
__debug__.RegexParserToDo("複数文字名のコマンド");
if (!next)
{
error(@"\ の後にコマンド名が続いていません。");
wtype = WordType.Text;
return;
}
add; next;
CommandData dat;
if (!commands.TryGetValue(cword, out dat))
{
error(@"指定した名前のコマンドは登録されていません。");
wtype = WordType.Text;
return;
}
if (dat.ArgumentType == CommandArgumentType.Brace)
{
if ("not:{")
{
value = null;
}
else
{
string cmd = cword;
cword = "";
if (!next)
{
goto ERR_ARG;
}
int iP = 1;
bool escape = false;
while (true)
{
if (escape)
{
escape = false;
}
else
{
if ("is:{")
{
iP++;
}
else if ("is:}")
{
if (--iP == 0)
{
lreader.MoveNext(); break;
}
}
else if ("is:\\")
{
escape = true;
}
}
add; if (!next)
{
goto ERR_ARG;
}
}
value = cword;
cword = cmd;
return;
ERR_ARG:
value = cword;
cword = cmd;
error("引数の終端が来ない内に、正規表現の末端に達しました。");
}
}
}