//------------------------------------------------------------
// FUNCBREC.EnsureNubHasValue
//
/// <summary>
/// Make sure the HasValue property of System.Nullable<T> is appropriate (and return it).
/// </summary>
/// <param name="treeNode"></param>
/// <returns></returns>
//------------------------------------------------------------
private PROPSYM EnsureNubHasValue(BASENODE treeNode)
{
PROPSYM propSym = Compiler.MainSymbolManager.NullableHasValuePropertySym;
if (propSym == null)
{
AGGSYM nubAggSym = Compiler.GetOptPredefAggErr(PREDEFTYPE.G_OPTIONAL, true);
if (nubAggSym == null)
{
return(null);
}
string name = Compiler.NameManager.GetPredefinedName(PREDEFNAME.HASVALUE);
SYM sym = Compiler.MainSymbolManager.LookupAggMember(
name, nubAggSym, SYMBMASK.PROPSYM);
propSym = sym as PROPSYM;
if (propSym == null ||
propSym.IsStatic ||
propSym.Access != ACCESS.PUBLIC ||
propSym.ParameterTypes.Count > 0 ||
!propSym.ReturnTypeSym.IsPredefType(PREDEFTYPE.BOOL) ||
propSym.GetMethodSym == null)
{
Compiler.Error(treeNode, CSCERRID.ERR_MissingPredefinedMember,
new ErrArg(nubAggSym), new ErrArg(name));
return(null);
}
Compiler.MainSymbolManager.NullableHasValuePropertySym = propSym;
}
return(propSym);
}
//------------------------------------------------------------
// SymWithType.CreateCorrespondingInstance (static)
//
/// <summary>
///
/// </summary>
/// <param name="sym"></param>
/// <param name="ats"></param>
/// <returns></returns>
//------------------------------------------------------------
static internal SymWithType CreateCorrespondingInstance(SYM sym, AGGTYPESYM ats)
{
if (sym == null)
{
return(new SymWithType());
}
SymWithType swt = null;
switch (sym.Kind)
{
case SYMKIND.METHSYM:
return(new MethWithType(sym as METHSYM, ats) as SymWithType);
case SYMKIND.PROPSYM:
return(new PropWithType(sym as PROPSYM, ats) as SymWithType);
case SYMKIND.EVENTSYM:
return(new EventWithType(sym as EVENTSYM, ats) as SymWithType);
case SYMKIND.MEMBVARSYM:
return(new FieldWithType(sym as MEMBVARSYM, ats) as SymWithType);
default:
break;
}
return(new SymWithType(sym, ats));
}
//------------------------------------------------------------
// MetaDataHelper.GetFullName (2) static method
//
/// <summary></summary>
/// <param name="sym"></param>
/// <param name="name"></param>
/// <returns></returns>
//------------------------------------------------------------
public static bool GetFullName(SYM sym, out string name)
{
StringBuilder sb = new StringBuilder();
MetaDataHelper help = new MetaDataHelper();
help.GetFullName(sym, sb, null);
name = sb.ToString();
return(true);
}
//------------------------------------------------------------
// MetaDataHelper.GetExplicitImplName (2) static method
//
/// <summary></summary>
/// <param name="sym"></param>
/// <param name="name"></param>
/// <returns></returns>
//------------------------------------------------------------
internal static bool GetExplicitImplName(SYM sym, out string name)
{
StringBuilder sb = new StringBuilder();
MetaDataHelper help = new MetaDataHelper();
help.GetExplicitImplName(sym, sb);
name = sb.ToString();
return(true);
}
//------------------------------------------------------------
// MetaDataHelper.GetTypeVars
//
/// <summary>
/// Add the count of type variables to name, as "name`2".
/// </summary>
/// <param name="sym"></param>
/// <param name="strBuilder"></param>
/// <param name="innerSym"></param>
//------------------------------------------------------------
protected virtual void GetTypeVars(SYM sym, StringBuilder strBuilder, SYM innerSym)
{
if (sym.IsAGGSYM && (sym as AGGSYM).IsArityInName)
{
TypeArray typeVars = (sym as AGGSYM).TypeVariables;
DebugUtil.Assert(typeVars.Count > 0); // isArityInName shouldn't be set otherwise.
strBuilder.Append('`');
strBuilder.AppendFormat("{0}", typeVars.Count);
}
}
//------------------------------------------------------------
// FUNCBREC.BindNubNew
//
/// <summary>
/// Create an expr for new T?(exprSrc) where T is exprSrc->type.
/// </summary>
/// <param name="treeNode"></param>
/// <param name="srcExpr"></param>
/// <returns></returns>
//------------------------------------------------------------
private EXPR BindNubNew(BASENODE treeNode, EXPR srcExpr)
{
DebugUtil.Assert(srcExpr != null);
// Create a NUBSYM instance whose base bype is represented by srcExpr.TypeSym.
NUBSYM nubSym = Compiler.MainSymbolManager.GetNubType(srcExpr.TypeSym);
// Get a TYPESYM instance representing Nullable<> for nubSym.
AGGTYPESYM aggTypeSym = nubSym.GetAggTypeSym();
if (aggTypeSym == null)
{
return(NewError(treeNode, nubSym));
}
Compiler.EnsureState(aggTypeSym, AggStateEnum.Prepared);
METHSYM methSym = Compiler.MainSymbolManager.NullableCtorMethodSym;
if (methSym == null)
{
string name = Compiler.NameManager.GetPredefinedName(PREDEFNAME.CTOR);
for (SYM sym = Compiler.MainSymbolManager.LookupAggMember(name, aggTypeSym.GetAggregate(), SYMBMASK.ALL);
;
sym = sym.NextSameNameSym)
{
if (sym == null)
{
Compiler.Error(treeNode, CSCERRID.ERR_MissingPredefinedMember,
new ErrArg(aggTypeSym), new ErrArg(name));
return(NewError(treeNode, nubSym));
}
if (sym.IsMETHSYM)
{
methSym = sym as METHSYM;
if (methSym.ParameterTypes.Count == 1 && methSym.ParameterTypes[0].IsTYVARSYM &&
methSym.Access == ACCESS.PUBLIC)
{
break;
}
}
}
Compiler.MainSymbolManager.NullableCtorMethodSym = methSym;
}
EXPRCALL resExpr = NewExpr(treeNode, EXPRKIND.CALL, nubSym) as EXPRCALL;
resExpr.MethodWithInst.Set(methSym, aggTypeSym, BSYMMGR.EmptyTypeArray);
resExpr.ArgumentsExpr = srcExpr;
resExpr.ObjectExpr = null;
resExpr.Flags |= EXPRFLAG.NEWOBJCALL | EXPRFLAG.CANTBENULL;
return(resExpr);
}
//------------------------------------------------------------
// MetaDataHelper.GetFullName
//
/// <summary>
/// Returns a fully-qualified name (open type, do not pass TYPESYMs)
/// With inner types denoted with m_chNested (defaults to '+')
/// And everything else separated by dots (.)
/// </summary>
/// <param name="sym"></param>
/// <param name="strBuilder"></param>
/// <param name="innerSym"></param>
//------------------------------------------------------------
public void GetFullName(
SYM sym,
StringBuilder strBuilder,
SYM innerSym) // = null
{
// Special case -- the root namespace.
if (sym.ParentSym == null)
{
// At the root namespace.
return;
}
if (sym.IsTYPESYM)
{
DebugUtil.Assert(false, "MetaDataHelper::GetFullName should not be called on TYPESYMs");
return;
}
PARENTSYM parentSym = sym.ParentSym;
// If Our parent isn't the root, get the parent name and separator and advance beyond it.
if (parentSym.ParentSym != null)
{
GetFullName(parentSym, strBuilder, sym);
strBuilder.Append(parentSym.IsAGGSYM ? this.nested : ".");
}
// Get the current name and add it on
string name;
if (sym.IsPROPSYM)
{
name = (sym as PROPSYM).GetRealName();
}
else
{
name = sym.Name;
}
int ichMin = strBuilder.Length;
if (name == null)
{
GetExplicitImplName(sym, strBuilder);
}
else
{
strBuilder.Append(name);
}
EscapeSpecialChars(strBuilder);
GetTypeVars(sym, strBuilder, innerSym);
}
// Static methods.
//------------------------------------------------------------
// MetaDataHelper.GetTypeAccessFlags
//
/// <summary>
/// <para>Determine the visibility flags for a typedef definition in metadata
/// Accepts TYPEDEFSYMs or AGGSYMs</para>
/// <para>Use System.Reflection.TypeAttribuetes in place of CorTypeAttr of sscli.</para>
/// </summary>
/// <param name="sym"></param>
/// <returns></returns>
//------------------------------------------------------------
internal static TypeAttributes GetTypeAccessFlags(SYM sym)
{
TypeAttributes flags = 0;
DebugUtil.Assert(sym is AGGSYM);
// Set access flags.
if (sym.ParentSym is NSSYM)
{
// "Top-level" aggregate. Can only be public or internal.
DebugUtil.Assert(sym.Access == ACCESS.PUBLIC || sym.Access == ACCESS.INTERNAL);
if (sym.Access == ACCESS.PUBLIC)
{
flags |= TypeAttributes.Public;
}
else
{
flags |= TypeAttributes.NotPublic;
}
}
else
{
// nested aggregate. Can be any access.
switch (sym.Access)
{
case ACCESS.PUBLIC:
flags |= TypeAttributes.NestedPublic;
break;
case ACCESS.INTERNAL:
flags |= TypeAttributes.NestedAssembly;
break;
case ACCESS.PROTECTED:
flags |= TypeAttributes.NestedFamily;
break;
case ACCESS.INTERNALPROTECTED:
flags |= TypeAttributes.NestedFamORAssem;
break;
case ACCESS.PRIVATE:
flags |= TypeAttributes.NestedPrivate;
break;
default:
DebugUtil.Assert(false, "Bad access flag");
break;
}
}
return(flags);
}
static internal void DebugSymsAdd(SYM sym)
{
if (sym == null)
{
return;
}
try
{
SymDictionary.Add(sym.SymID, sym);
}
catch (ArgumentException)
{
}
}
//------------------------------------------------------------
// AggIterator.GetFirstInListAgg
//------------------------------------------------------------
static protected AGGSYM GetFirstInListAgg(SYM sym)
{
// Only use this for child lists in an AGG.
DebugUtil.Assert(sym == null || sym.ParentSym.IsAGGSYM);
for (; sym != null; sym = sym.NextSym)
{
if (sym.IsAGGSYM)
{
return(sym as AGGSYM);
}
}
return(null);
}
//------------------------------------------------------------
// SymWithType.Set (1)
//
/// <summary>
/// <para>If sym is null, ats is set null.</para>
/// <para>If sym is not null, sym and ats should have the same parent.</para>
/// </summary>
/// <param name="sym"></param>
/// <param name="ats"></param>
//------------------------------------------------------------
internal void Set(SYM sym, AGGTYPESYM ats)
{
if (sym == null)
{
ats = null;
}
DebugUtil.Assert(ats == null || sym.ParentSym == ats.GetAggregate());
if (ats != null && sym.ParentSym != ats.GetAggregate())
{
return;
}
this.Sym = sym;
this.AggTypeSym = ats;
}
public GameBoy(string biosFile, string romFile, SpeedupFlags speedupFlags = SpeedupFlags.None)
{
ROM = new ROM(romFile);
Debug.Assert(ROM.HeaderChecksumMatches(), "Cartridge header checksum mismatch!");
Handle = Libgambatte.gambatte_create();
Debug.Assert(Libgambatte.gambatte_loadbios(Handle, biosFile, 0x900, 0x31672598) == 0, "Unable to load BIOS!");
Debug.Assert(Libgambatte.gambatte_load(Handle, romFile, LoadFlags.GbaFlag | LoadFlags.GcbMode | LoadFlags.ReadOnlySav) == 0, "Unable to load ROM!");
VideoBuffer = new byte[160 * 144 * 4];
AudioBuffer = new byte[(SamplesPerFrame + 2064) * 2 * 2]; // Stereo 16-bit samples
InputGetter = () => CurrentJoypad;
Libgambatte.gambatte_setinputgetter(Handle, InputGetter);
string symPath = "symfiles/" + Path.GetFileNameWithoutExtension(romFile) + ".sym";
if (File.Exists(symPath))
{
SYM = new SYM(symPath);
ROM.Symbols = SYM;
}
SetSpeedupFlags(speedupFlags);
StateSize = Libgambatte.gambatte_savestate(Handle, null, 160, null);
SaveStateLabels = new Dictionary <string, int>();
byte[] state = SaveState();
ByteStream data = new ByteStream(state);
data.Seek(3);
data.Seek(data.u24be());
while (data.Position < state.Length)
{
string label = "";
byte character;
while ((character = data.u8()) != 0x00)
{
label += Convert.ToChar(character);
}
int size = data.u24be();
SaveStateLabels[label] = (int)data.Position;
data.Seek(size);
}
}
private void LoadMaps()
{
int numMaps = IsYellow ? 249 : 248;
ReadStream bankStream = ROM.From("MapHeaderBanks");
ReadStream addressStream = ROM.From("MapHeaderPointers");
for (byte i = 0; i < numMaps; i++)
{
int headerAddress = bankStream.u8() << 16 | addressStream.u16le();
if (SYM.Contains(headerAddress))
{
string addressLabel = SYM[headerAddress];
if (addressLabel.EndsWith("_h"))
{
Maps.Add(new RbyMap(this, addressLabel.Substring(0, addressLabel.IndexOf("_h")), i, ROM.From(headerAddress)));
}
}
}
}
//------------------------------------------------------------
// FUNCBREC.EnsureNubGetValOrDef
//
/// <summary>
/// Make sure the HasValue property of System.Nullable<T> is appropriate (and return it).
/// </summary>
/// <param name="treeNode"></param>
/// <returns></returns>
//------------------------------------------------------------
private METHSYM EnsureNubGetValOrDef(BASENODE treeNode)
{
METHSYM methSym = Compiler.MainSymbolManager.NullableGetValOrDefMethodSym;
if (methSym == null)
{
AGGSYM nubAggSym = Compiler.GetOptPredefAggErr(PREDEFTYPE.G_OPTIONAL, true);
if (nubAggSym == null)
{
return(null);
}
string name = Compiler.NameManager.GetPredefinedName(PREDEFNAME.GET_VALUE_OR_DEF);
for (SYM sym = Compiler.MainSymbolManager.LookupAggMember(name, nubAggSym, SYMBMASK.ALL);
;
sym = sym.NextSameNameSym)
{
if (sym == null)
{
Compiler.Error(treeNode, CSCERRID.ERR_MissingPredefinedMember,
new ErrArg(nubAggSym), new ErrArg(name));
return(null);
}
if (sym.IsMETHSYM)
{
methSym = sym as METHSYM;
if (methSym.ParameterTypes.Count == 0 &&
methSym.ParameterTypes.Count == 0 &&
methSym.ReturnTypeSym.IsTYVARSYM &&
!methSym.IsStatic &&
methSym.Access == ACCESS.PUBLIC)
{
break;
}
}
}
Compiler.MainSymbolManager.NullableGetValOrDefMethodSym = methSym;
}
return(methSym);
}
//------------------------------------------------------------
// FUNCBREC.CreateNewLocVarSym
//
/// <summary>Increments the following values:
/// FUNCBREC.localCount,
/// FUNCBREC.unreferencedVarCount and
/// FUNCBREC.uninitedVarCount.
/// And sets LOCVARSYM.LocSlotInfo.
/// </summary>
/// <param name="name"></param>
/// <param name="typeSym"></param>
/// <param name="parentSym"></param>
/// <returns></returns>
//------------------------------------------------------------
internal LOCVARSYM CreateNewLocVarSym(
string name,
TYPESYM typeSym,
PARENTSYM parentSym)
{
SYM sym = Compiler.LocalSymbolManager.LookupLocalSym(
name,
parentSym,
SYMBMASK.LOCVARSYM);
if (sym != null)
{
return(sym as LOCVARSYM);
}
LOCVARSYM locSym = Compiler.LocalSymbolManager.CreateLocalSym(
SYMKIND.LOCVARSYM,
name,
parentSym) as LOCVARSYM;
locSym.TypeSym = typeSym;
StoreInCache(null, name, locSym, null, true);
++this.localCount;
if (this.localCount > 0xffff)
{
Compiler.Error(treeNode, CSCERRID.ERR_TooManyLocals);
}
++this.unreferencedVarCount;
locSym.LocSlotInfo.SetJbitDefAssg(this.uninitedVarCount + 1);
int cbit = FlowChecker.GetCbit(Compiler, locSym.TypeSym);
this.uninitedVarCount += cbit;
return(locSym);
}
public GameBoy(string biosFile, string romFile, string savFile = null, SpeedupFlags speedupFlags = SpeedupFlags.None)
{
ROM = new ROM(romFile);
Debug.Assert(ROM.HeaderChecksumMatches(), "Cartridge header checksum mismatch!");
string romName = Path.GetFileNameWithoutExtension(romFile);
if (savFile == null || savFile == "")
{
File.Delete("roms/" + romName + ".sav");
}
else
{
File.WriteAllBytes("roms/" + romName + ".sav", File.ReadAllBytes(savFile));
}
Handle = Libgambatte.gambatte_create();
Debug.Assert(Libgambatte.gambatte_loadbios(Handle, biosFile, 0x900, 0x31672598) == 0, "Unable to load BIOS!");
Debug.Assert(Libgambatte.gambatte_load(Handle, romFile, LoadFlags.GbaFlag | LoadFlags.GcbMode | LoadFlags.ReadOnlySav) == 0, "Unable to load ROM!");
VideoBuffer = new byte[160 * 144 * 4];
AudioBuffer = new byte[(SamplesPerFrame + 2064) * 2 * 2]; // Stereo 16-bit samples
InputGetter = () => CurrentJoypad;
Libgambatte.gambatte_setinputgetter(Handle, InputGetter);
string symPath = "symfiles/" + romName + ".sym";
if (File.Exists(symPath))
{
SYM = new SYM(symPath);
ROM.Symbols = SYM;
}
SetSpeedupFlags(speedupFlags);
StateSize = Libgambatte.gambatte_savestate(Handle, null, 160, null);
}
//------------------------------------------------------------
// AggIterator.GetFirstInListNsDecl
//------------------------------------------------------------
static protected AGGSYM GetFirstInListNsDecl(SYM sym)
{
// Only use this for child lists in an NSDECL.
DebugUtil.Assert(sym == null || sym.ParentSym.IsNSDECLSYM);
AGGSYM agg;
for (; sym != null; sym = sym.NextSym)
{
switch (sym.Kind)
{
case SYMKIND.AGGDECLSYM:
if ((sym as AGGDECLSYM).IsFirst)
{
return((sym as AGGDECLSYM).AggSym);
}
break;
case SYMKIND.NSDECLSYM:
agg = GetFirstInListNsDecl((sym as NSDECLSYM).FirstChildSym);
if (agg != null)
{
return(agg);
}
break;
case SYMKIND.GLOBALATTRSYM:
break;
default:
DebugUtil.Assert(false, "Bad SK");
break;
}
}
return(null);
}
//------------------------------------------------------------
// SymWithType.Clear
//
/// <summary></summary>
//------------------------------------------------------------
internal void Clear()
{
Sym = null;
AggTypeSym = null;
}
//------------------------------------------------------------
// SymWithType Constructor (2)
//
/// <summary></summary>
/// <param name="sym"></param>
/// <param name="ats"></param>
//------------------------------------------------------------
internal SymWithType(SYM sym, AGGTYPESYM ats)
{
Set(sym, ats);
}
//------------------------------------------------------------
// MetaDataHelper.GetExplicitImplName
//
/// <summary>
/// Get a synthesized name for explicit interface implementations.
/// The name we use is: "InterfaceName.MethodName", where InterfaceName is the fully qualified name
/// of the interface containing the implemented method.
/// This name has a '.' in it, so it can't conflict with any "real" name or be confused with one.
/// </summary>
/// <remarks>
/// Returns true if the buffer had enough space for the name.
/// If not enough space, then adds as much of name as possible to buffer.
/// Always NULL terminates buffer.
/// </remarks>
/// <param name="sym"></param>
/// <param name="strBuilder"></param>
//------------------------------------------------------------
public void GetExplicitImplName(SYM sym, StringBuilder strBuilder)
{
DebugUtil.Assert(sym.IsEVENTSYM || sym.IsMETHPROPSYM);
SymWithType swtImpl = new SymWithType();
ERRORSYM errSym = null;
string implName = null;
string aliasName = null;
switch (sym.Kind)
{
case SYMKIND.EVENTSYM:
EVENTSYM eventSym = sym as EVENTSYM;
DebugUtil.Assert(eventSym.IsExpImpl);
swtImpl = eventSym.SlotEventWithType;
errSym = eventSym.ExpImplErrorSym;
break;
case SYMKIND.METHSYM:
case SYMKIND.PROPSYM:
{
METHPROPSYM mpSym = sym as METHPROPSYM;
DebugUtil.Assert(mpSym.IsExplicitImplementation);
swtImpl = mpSym.SlotSymWithType;
errSym = mpSym.ExpImplErrorSym;
BASENODE nameNode = null;
if (sym.IsMETHSYM &&
(sym as METHSYM).ParseTreeNode != null &&
(sym as METHSYM).ParseTreeNode.Kind == NODEKIND.METHOD)
{
nameNode = ((sym as METHSYM).ParseTreeNode as METHODNODE).NameNode;
}
else if (
sym.IsPROPSYM &&
(sym as PROPSYM).ParseTreeNode != null &&
(sym as PROPSYM).ParseTreeNode.Kind == NODEKIND.PROPERTY)
{
nameNode = ((sym as PROPSYM).ParseTreeNode as PROPERTYNODE).NameNode;
}
while (nameNode != null && nameNode.Kind == NODEKIND.DOT)
{
nameNode = nameNode.AsDOT.Operand1;
}
if (nameNode != null && nameNode.Kind == NODEKIND.ALIASNAME)
{
aliasName = nameNode.AsANYNAME.Name;
}
if (!sym.IsPROPSYM || !(sym as PROPSYM).IsIndexer)
{
break;
}
implName = (swtImpl != null ? (swtImpl.Sym as PROPSYM).GetRealName() : "Item");
// fish out any user specified alias
break;
}
default:
// gcc -Wall (all warnings enabled) complains if all cases
// aren't handled, so we explicitly handle default and assert
DebugUtil.Assert(false);
break;
}
DebugUtil.Assert(swtImpl != null || errSym != null);
if (aliasName != null)
{
strBuilder.Append(aliasName);
strBuilder.Append("::");
}
if (swtImpl != null)
{
GetExplicitImplTypeName(swtImpl.AggTypeSym, strBuilder);
if (implName == null)
{
implName = swtImpl.Sym.Name;
}
}
else
{
GetExplicitImplTypeName(errSym, strBuilder);
}
if (implName != null)
{
// Add dot seperator.
strBuilder.Append('.');
strBuilder.Append(implName);
}
}
//------------------------------------------------------------
// MemberLookup.LookupExtensionMethodInInterfaces
//
/// <summary></summary>
/// <param name="startAggTypeSym"></param>
/// <returns></returns>
//------------------------------------------------------------
private bool LookupExtensionMethodInInterfaces(AGGTYPESYM startAggTypeSym)
{
//DebugUtil.Assert(this.firstSymWithType == null || this.isMulti);
//DebugUtil.Assert(startAggTypeSym != null);
if (startAggTypeSym == null)
{
return(false);
}
if (this.firstSymWithType != null && this.firstSymWithType.IsNotNull)
{
return(false);
}
//DebugUtil.Assert(startAggTypeSym == null || startAggTypeSym.IsInterfaceType());
//DebugUtil.Assert(startAggTypeSym != null || interfaceTypeArray.Count > 0);
//DebugUtil.Assert((this.flags &
// (MemLookFlagsEnum.Ctor | MemLookFlagsEnum.Operator | MemLookFlagsEnum.BaseCall))
// == 0);
TypeArray interfaceTypeArray = startAggTypeSym.GetIfacesAll();
if (interfaceTypeArray == null || interfaceTypeArray.Count == 0)
{
return(false);
}
// Clear all the hidden flags. Anything found in a class hides any other
// kind of member in all the interfaces.
if (startAggTypeSym != null)
{
startAggTypeSym.AllHidden = false;
startAggTypeSym.DiffHidden = (this.firstSymWithType != null);
}
for (int i = 0; i < interfaceTypeArray.Count; ++i)
{
AGGTYPESYM type = interfaceTypeArray[i] as AGGTYPESYM;
DebugUtil.Assert(type.IsInterfaceType());
type.AllHidden = false;
type.DiffHidden = (this.firstSymWithType != null);
}
if (startAggTypeSym != null)
{
Compiler.EnsureState(startAggTypeSym, AggStateEnum.Prepared);
}
if (interfaceTypeArray != null)
{
Compiler.EnsureState(interfaceTypeArray, AggStateEnum.Prepared);
}
//--------------------------------------------------------
// Loop through the interfaces.
//--------------------------------------------------------
bool hideObject = false;
int index = 0;
AGGTYPESYM currentSym = interfaceTypeArray[index++] as AGGTYPESYM;
DebugUtil.Assert(currentSym != null);
for (; ;)
{
DebugUtil.Assert(currentSym != null && currentSym.IsInterfaceType());
bool hideByName = false;
if (!currentSym.AllHidden && SearchSingleType(currentSym, out hideByName))
{
SYM fsym = this.firstSymWithType.Sym;
DebugUtil.Assert(fsym != null);
if (fsym.Kind == SYMKIND.METHSYM &&
(fsym as METHSYM).IsInstanceExtensionMethod)
{
hideByName |= !this.isMulti;
// Mark base interfaces appropriately.
TypeArray interfaceArray = currentSym.GetIfacesAll();
for (int i = 0; i < interfaceArray.Count; ++i)
{
AGGTYPESYM sym = interfaceArray[i] as AGGTYPESYM;
DebugUtil.Assert(sym.IsInterfaceType());
if (hideByName)
{
sym.AllHidden = true;
}
sym.DiffHidden = true;
}
// If we hide all base types, that includes object!
if (hideByName)
{
hideObject = true;
}
}
}
this.flags &= ~MemLookFlagsEnum.TypeVarsAllowed;
if (index >= interfaceTypeArray.Count)
{
return(!hideObject);
}
// Substitution has already been done.
currentSym = interfaceTypeArray[index++] as AGGTYPESYM;
}
}
protected void Button_find_diamonds_Click(object sender, EventArgs e)
{
List <string> list_shapes = new List <string>();
List <string> list_clarity = new List <string>();
List <string> list_color = new List <string>();
List <string> list_cut = new List <string>();
List <string> list_polish = new List <string>();
List <string> list_symmetry = new List <string>();
List <string> list_lab = new List <string>();
double weightMin;
double weightMax;
double priceMin;
double priceMax;
string name;
#region SHAPE
List <string> list_shapes_ = s.readfromyDS("Shape");
foreach (var S in list_shapes_)
{
var chk_SHAPE = (HtmlInputCheckBox)SAHPE.FindControl("ShapeCB_" + S.ToString());
if (chk_SHAPE.Checked == true)
{
list_shapes.Add(S.ToString());
}
}
#endregion
#region Weight
HtmlInputGenericControl weightMin_control = (HtmlInputGenericControl)WEIGHT.FindControl("weightMin");
if (weightMin_control.Value == "".ToString())
{
weightMin_control.Value = "0.1";
}
weightMin = Convert.ToDouble(weightMin_control.Value);
HtmlInputGenericControl weightMax_control = (HtmlInputGenericControl)WEIGHT.FindControl("weightMax");
if (weightMax_control.Value == "".ToString())
{
weightMax_control.Value = "0.1";
}
weightMax = Convert.ToDouble(weightMax_control.Value);
#endregion
#region Price
HtmlInputGenericControl priceMin_control = (HtmlInputGenericControl)WEIGHT.FindControl("priceMin");
if (priceMin_control.Value == "".ToString())
{
priceMin_control.Value = "1";
}
priceMin = Convert.ToDouble(priceMin_control.Value.ToString());
HtmlInputGenericControl priceMax_control = (HtmlInputGenericControl)WEIGHT.FindControl("priceMax");
if (priceMax_control.Value == "".ToString())
{
priceMax_control.Value = "1";
}
priceMax = Convert.ToDouble(priceMax_control.Value.ToString());
#endregion
#region CLARITY
List <string> list_clarity_ = s.readfromyDS("Clarity");
foreach (var C in list_clarity_)
{
CheckBox chk_CLARITY = (CheckBox)CLARITY.FindControl("ClarityCB_" + C.ToString());
if (chk_CLARITY.Checked == true)
{
list_clarity.Add(C.ToString());
}
}
#endregion
#region COLOR
List <string> list_color_ = s.readfromyDS("Color");
foreach (var CR in list_color_)
{
CheckBox chk_COLOR = (CheckBox)COLOR.FindControl("ColorCB_" + CR.ToString());
if (chk_COLOR.Checked == true)
{
list_color.Add(CR.ToString());
}
}
#endregion
#region CUT
List <string> list_cut_ = s.readfromyDS("Cut");
foreach (var CU_ in list_cut_)
{
CheckBox chk_CUT = (CheckBox)CUT.FindControl("CutCB_" + CU_.ToString());
if (chk_CUT.Checked == true)
{
list_cut.Add(CU_.ToString());
}
}
#endregion
#region POLISH
List <string> list_polish_ = s.readfromyDS("Polish");
foreach (var P in list_polish_)
{
CheckBox chk_P = (CheckBox)POLISH.FindControl("PolishCB_" + P.ToString());
if (chk_P.Checked == true)
{
list_polish.Add(P.ToString());
}
}
#endregion
#region SYMMETRY
List <string> list_symmetry_ = s.readfromyDS("Symmetry");
foreach (var SYM in list_symmetry_)
{
CheckBox chk_SYM = (CheckBox)SYMMETRY.FindControl("SymmetryCB_" + SYM.ToString());
if (chk_SYM.Checked == true)
{
list_symmetry.Add(SYM.ToString());
}
}
#endregion
#region LAB
List <string> list_lab_ = s.readfromyDS("Lab");
foreach (var LAB_ in list_lab_)
{
CheckBox chk_LAB = (CheckBox)LAB.FindControl("LabCB_" + LAB_.ToString());
if (chk_LAB.Checked == true)
{
list_lab.Add(LAB_.ToString());
}
}
#endregion
#region Name
HtmlInputText txt_name = (HtmlInputText)NAME.FindControl("Search_By_ID".ToString());
name = txt_name.Value;
#endregion
addproducts_after_filter(list_shapes,
list_clarity,
list_color,
list_cut,
list_polish,
list_symmetry,
list_lab,
weightMin,
weightMax,
priceMin,
priceMax,
name);
}
//------------------------------------------------------------
// MetaDataHelper.GetExplicitImplTypeName
//
/// <summary></summary>
/// <param name="typeSym"></param>
/// <param name="strBuilder"></param>
//------------------------------------------------------------
public void GetExplicitImplTypeName(TYPESYM typeSym, StringBuilder strBuilder)
{
#if DEBUG
if (!(typeSym != null))
{
;
}
#endif
DebugUtil.Assert(typeSym != null);
TYPESYM nakedTypeSym = typeSym.GetNakedType(false);
TypeArray typeArgs = null;
switch (nakedTypeSym.Kind)
{
default:
DebugUtil.Assert(false, "Unhandled type in GetExplicitImplTypeName");
return;
case SYMKIND.TYVARSYM:
strBuilder.Append(nakedTypeSym.Name);
break;
case SYMKIND.NUBSYM:
nakedTypeSym = (nakedTypeSym as NUBSYM).GetAggTypeSym();
if (nakedTypeSym == null)
{
DebugUtil.Assert(false, "Why did GetAts return null?");
return;
}
// Fall through.
goto case SYMKIND.AGGTYPESYM;
case SYMKIND.AGGTYPESYM:
{
AGGTYPESYM outerAggTypeSym = (nakedTypeSym as AGGTYPESYM).OuterTypeSym;
AGGSYM aggSym = nakedTypeSym.GetAggregate();
if (outerAggTypeSym != null)
{
GetExplicitImplTypeName(outerAggTypeSym, strBuilder);
strBuilder.Append('.');
}
else
{
DebugUtil.Assert(aggSym.ParentBagSym != null && !aggSym.ParentBagSym.IsAGGSYM);
int cch = strBuilder.Length;
GetFullName(aggSym.ParentBagSym, strBuilder, aggSym);
if (cch < strBuilder.Length)
{
strBuilder.Append('.');
}
}
strBuilder.Append(aggSym.Name);
typeArgs = (nakedTypeSym as AGGTYPESYM).TypeArguments;
}
break;
case SYMKIND.ERRORSYM:
{
ERRORSYM errSym = nakedTypeSym as ERRORSYM;
SYM parentSym = errSym.ParentSym;
if (parentSym != null && parentSym.IsTYPESYM)
{
GetExplicitImplTypeName(parentSym as TYPESYM, strBuilder);
strBuilder.Append('.');
}
else if (parentSym != null && parentSym.IsNSAIDSYM)
{
parentSym = (parentSym as NSAIDSYM).NamespaceSym;
int cch = strBuilder.Length;
GetFullName(parentSym, strBuilder, errSym);
if (cch < strBuilder.Length)
{
strBuilder.Append('.');
}
}
strBuilder.Append(errSym.ErrorName);
typeArgs = errSym.TypeArguments;
}
break;
}
if (typeArgs != null && typeArgs.Count > 0)
{
strBuilder.Append('<');
for (int i = 0; i < typeArgs.Count; ++i)
{
if (i > 0)
{
strBuilder.Append(',');
}
GetExplicitImplTypeName(typeArgs[i], strBuilder);
}
strBuilder.Append('>');
}
// Add ptr and array modifiers
AddTypeModifiers(typeSym, strBuilder);
}
