private void PopulateControls()
{
if (ddlTemplates.Items.Count > 0)
{
return;
}
ddlTemplates.DataValueField = "Value";
ddlTemplates.DataTextField = "Name";
ddlTemplates.DataSource = EnumDefined.LoadFromConfigurationXml("product", "templatedetail", "xsltname");
ddlTemplates.DataBind();
}
private void PopulateControls()
{
if (ddlNewsType.Items.Count > 0)
{
return;
}
ddlNewsType.DataValueField = "Value";
ddlNewsType.DataTextField = "Name";
ddlNewsType.DataSource = EnumDefined.LoadFromConfigurationXml("news", "newstype", "value");
ddlNewsType.DataBind();
}
public static string GetNameByNewsType(int newsType, string newsTypeNameFormat, string defaultName)
{
if (newsType > 0)
{
List <EnumDefined> lstEnum = EnumDefined.LoadFromConfigurationXml("news", "newstype", "value");
foreach (EnumDefined item in lstEnum)
{
if (item.Value == newsType.ToString())
{
return(string.Format(newsTypeNameFormat, item.Name));
}
}
}
return(defaultName);
}
private void PopulateControls()
{
List <EnumDefined> list = EnumDefined.LoadFromConfigurationXml("product", "showoption", "value", "name");
ddlShowOption.DataSource = list;
ddlShowOption.DataBind();
ListItem li = ddlShowOption.Items.FindByValue(option.ToString());
if (li != null)
{
ddlShowOption.ClearSelection();
li.Selected = true;
}
PopulateZoneList();
}
private void PopulateControls()
{
List <EnumDefined> list = EnumDefined.LoadFromConfigurationXml("news");
ddlPosition.DataSource = list;
ddlPosition.DataBind();
ListItem li = ddlPosition.Items.FindByValue(pos.ToString());
if (li != null)
{
ddlPosition.ClearSelection();
li.Selected = true;
}
PopulateZoneList();
}
Assume(APC pc, string tag, Variable source, object provenance, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
if (tag != "false")
{
return(data.AssumeCondition(ToBoxedVariable(source)));
}
else
{
// try to see if it is sv == 0
var bExp = ToBoxedExpression(pc, source);
BoxedExpression left;
int k;
Variable underlying;
if (bExp.IsCheckExp1EqConst(out left, out k) && k == 0 && left.TryGetFrameworkVariable(out underlying))
{
return(data.AssumeCondition(ToBoxedVariable(underlying)));
}
return(data);
}
}
private void PopulateControls()
{
try
{
List <EnumDefined> list = EnumDefined.LoadFromConfigurationXml("product");
list.RemoveAll(s => Convert.ToInt32(s.Value) <= 0);
ddlPosition.DataSource = list;
ddlPosition.DataBind();
ListItem li = ddlPosition.Items.FindByValue(pos.ToString());
if (li != null)
{
ddlPosition.ClearSelection();
li.Selected = true;
}
PopulateZoneList();
}
catch (Exception ex)
{
log.Error(ex.Message);
}
}
private void EnsureItems()
{
if (ddPosition == null)
{
ddPosition = new DropDownList();
ddPosition.DataValueField = "Value";
ddPosition.DataTextField = "Name";
if (this.Controls.Count == 0)
{
this.Controls.Add(ddPosition);
}
}
if (ddPosition.Items.Count > 0)
{
return;
}
ddPosition.DataSource = EnumDefined.LoadFromConfigurationXml("news");
ddPosition.DataBind();
ddPosition.Items.Insert(0, new ListItem("", "-1"));
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Ldelem(APC pc, Type type, Variable dest, Variable array, Variable index, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
var arrayType = this.Context.ValueContext.GetType(pc, array);
if (arrayType.IsNormal && this.DecoderForMetaData.IsArray(arrayType.Value))
{
return(AssumeIfEnumType(this.DecoderForMetaData.ElementType(arrayType.Value), dest, data));
}
return(data);
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Call <TypeList, ArgList>(APC pc, Method method,
bool tail, bool virt, TypeList extraVarargs, Variable dest, ArgList args, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
var methodname = this.DecoderForMetaData.Name(method);
var nsName = this.DecoderForMetaData.Namespace(this.DecoderForMetaData.DeclaringType(method));
Type type;
if (nsName != null && methodname != null &&
nsName.Equals("System") && methodname.Equals("GetTypeFromHandle"))
{
Type runtimeType;
if (Context.ValueContext.IsRuntimeType(this.Context.MethodContext.CFG.Post(pc), dest, out runtimeType)) // Get the type
{
this.lastTypeForGetTypeFromHandle[dest] = runtimeType;
}
return(data);
}
if (args.Count == 2 && methodname == "IsDefined" && this.lastTypeForGetTypeFromHandle.TryGetValue(args[0], out type))
{
data = data.AssumeTypeIff(ToBoxedVariable(dest), type, ToBoxedVariable(args[1]));
Variable unboxed;
if (this.Context.ValueContext.TryUnbox(pc, args[1], out unboxed))
{
data = data.AssumeTypeIff(ToBoxedVariable(dest), type, ToBoxedVariable(unboxed));
}
return(data);
}
var destType = this.Context.ValueContext.GetType(this.MethodDriver.CFG.Post(pc), dest);
if (destType.IsNormal && this.DecoderForMetaData.IsEnumWithoutFlagAttribute(destType.Value))
{
data = data.AssumeCondition(destType.Value, ToBoxedVariable(dest));
}
return(data);
}
Assert(APC pc, string tag, Variable condition, object provenance, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
return(data.AssumeCondition(ToBoxedVariable(condition)));
}
private EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> AssumeIfEnumType(APC pc, Variable dest, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
var type = this.Context.ValueContext.GetType(pc.Post(), dest);
if (type.IsNormal)
{
return(this.AssumeIfEnumType(type.Value, dest, data));
}
return(data);
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Ldloc(APC pc, Local local, Variable dest, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
return(AssumeIfEnumType(pc, dest, data));
}
public ArrayState MakeState(EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> newSubState, ArrayState oldState)
{
return(oldState.UpdatePluginAt(this.Id, newSubState));
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Ldarg(APC pc, Parameter argument, bool isOld, Variable dest, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
return(AssumeIfEnumType(pc, dest, data));
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Ldind(APC pc, Type type, bool @volatile, Variable dest, Variable ptr, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
return(AssumeIfEnumType(pc, dest, data));
}
public EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Rename(EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> state, Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap)
{
RenameTypes(refinedMap);
return(state.Rename(refinedMap));
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Ldfld(APC pc, Field field, bool @volatile, Variable dest, Variable obj, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
return(AssumeIfEnumType(pc, dest, data));
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> HelperForAssignInParallel(
EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> state, Pair <APC, APC> edge,
Dictionary <BoxedVariable <Variable>, FList <BoxedVariable <Variable> > > refinedMap, Converter <BoxedVariable <Variable>, BoxedExpression> convert)
{
return(Rename(state, refinedMap));
}
private EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> AssumeIfEnumType(Type type, Variable v, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
if (this.DecoderForMetaData.IsEnumWithoutFlagAttribute(type))
{
return(data.AssumeCondition(type, ToBoxedVariable(v)));
}
return(data);
}
public override EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> Entry(APC pc, Method method, EnumDefined <BoxedVariable <Variable>, Type, BoxedExpression> data)
{
foreach (var param in this.DecoderForMetaData.Parameters(method).Enumerate())
{
Variable symb;
if (this.Context.ValueContext.TryParameterValue(Context.MethodContext.CFG.Post(pc), param, out symb))
{
var typeForParam = this.Context.ValueContext.GetType(Context.MethodContext.CFG.Post(pc), symb);
if (typeForParam.IsNormal && this.DecoderForMetaData.IsEnumWithoutFlagAttribute(typeForParam.Value))
{
data = data.AssumeCondition(typeForParam.Value, ToBoxedVariable(symb));
}
}
}
return(data);
}
