protected void btnOk_Click(object sender, EventArgs e)
{
ParamFacade facade = PageHelper.GetParamFacade(this.Page);
ParamInfo param = facade.GetParam("AdministratorPassword");
string oldPassword = EncryptTool.MD5(txtOldPassword.Text);
string newPassword = EncryptTool.MD5(txtNewPassword.Text);
string confirmPassword = EncryptTool.MD5(txtConfirmPassword.Text);
if (newPassword != confirmPassword)
{
lblMessage.Text = "两次输入的密码不相同。";
return;
}
if (param == null || string.IsNullOrEmpty(param.Value) || param.Value == oldPassword)
{
param = new ParamInfo();
param.Key = "AdministratorPassword";
param.Value = newPassword;
facade.SaveParam(param);
string url = "Default.aspx";
if (!string.IsNullOrEmpty(Request["ReturnUrl"]))
{
url = Request["ReturnUrl"];
}
string msg = "修改密码成功！";
ScriptManager.RegisterStartupScript(this, this.GetType(), "AlertChangePassword", "AlertAndRedirect('" + msg + "', '" + url + "');", true);
}
else
{
lblMessage.Text = "旧密码输入不正确。";
return;
}
}
protected void lbtnSave_Click(object sender, EventArgs e)
{
try
{
ParamFacade facade = new ParamFacade();
ParamInfo paraInfo = new ParamInfo();
paraInfo.Key = "SiteName";
paraInfo.Value = txtSiteName.Text;
facade.SaveParam(paraInfo);
Application["SiteName"] = null;
paraInfo.Key = "LogoFileName";
paraInfo.Value = txtLogoFileName.Text;
facade.SaveParam(paraInfo);
Application["LogoFileName"] = null;
paraInfo.Key = "Address";
paraInfo.Value = txtAddress.Text;
facade.SaveParam(paraInfo);
Application["Address"] = null;
paraInfo.Key = "PhoneNumber";
paraInfo.Value = txtPhone.Text;
facade.SaveParam(paraInfo);
Application["PhoneNumber"] = null;
paraInfo.Key = "FaxNumber";
paraInfo.Value = txtFax.Text;
facade.SaveParam(paraInfo);
Application["FaxNumber"] = null;
paraInfo.Key = "QQNumber";
paraInfo.Value = txtQQ.Text;
facade.SaveParam(paraInfo);
Application["QQNumber"] = null;
paraInfo.Key = "NoticeDelay";
paraInfo.Value = txtDelay.Text;
facade.SaveParam(paraInfo);
Application["NoticeDelay"] = null;
paraInfo.Key = "AutoPlayMusic";
paraInfo.Value = cbAutoMusic.Checked ? "1" : "0";
facade.SaveParam(paraInfo);
Application["AutoPlayMusic"] = null;
JavascriptAlertAndRedirectAndRefreshParent("保存系统参数成功！", Request.Url.AbsoluteUri);
}
catch (Exception ex)
{
JavascriptAlert(ex.Message);
}
}
private void ParamConfigOperate(byte[] bField, ref int pos, ref int lenth, ParamInfo info)
{
string index = GetString(bField, pos, 2);
pos += 2;
lenth += 2;
switch (index)
{
case "29": //pos终端号
lenth = 8;
info.TerminalNo = GetString(bField, pos, lenth);
break;
case "11":
case "12":
lenth = 2;
break;
case "13":
lenth = 1;
break;
case "14":
lenth = 14;
info.Tel1 = GetString(bField, pos, lenth);
break;
case "15":
lenth = 14;
info.Tel2 = GetString(bField, pos, lenth);
break;
case "16":
lenth = 14;
info.Tel3 = GetString(bField, pos, lenth);
break;
case "17":
lenth = 14;
break;
case "18":
lenth = 1;
break;
case "19":
lenth = 2;
break;
case "20":
case "21":
lenth = 1;
break;
case "22":
lenth = 40;
info.MerchantName = GetString(bField, pos, lenth);
break;
case "23":
case "24":
case "25":
lenth = 1;
break;
case "26":
lenth = 8;
byte[] tempB = new byte[8];
Array.Copy(bField, pos, tempB, 0, 8);
info.SupportType = Utility.bcd2str(tempB, lenth);
break;
case "27":
lenth = 40;
info.MerchantNameE = GetString(bField, pos, lenth);
break;
case "28":
lenth = 15;
info.MerchantNo = GetString(bField, pos, lenth);
break;
case "30":
lenth = 6;
break;
case "31":
lenth = 6;
break;
case "32":
lenth = 19;
info.BankCardNo1 = GetString(bField, pos, lenth).Trim();
break;
case "33":
lenth = 19;
info.BankCardNo2 = GetString(bField, pos, lenth);
break;
case "34":
lenth = 19;
info.BankCardNo3 = GetString(bField, pos, lenth);
break;
case "35":
lenth = 2;
break;
case "36":
lenth = 12;
break;
case "37":
lenth = 12;
info.PayLimit = GetString(bField, pos, lenth);
break;
case "38":
lenth = 12;
break;
case "39":
lenth = 12;
info.TransLimit = GetString(bField, pos, lenth);
break;
case "40":
lenth = 2;
break;
}
}
public static List<ImageInfo> GetBartenderServicePrint(PrintItem currentPrinItem)
{
List<ImageInfo> result = null;
if (!string.IsNullOrEmpty(currentPrinItem.TemplateName) &&
!string.IsNullOrEmpty(currentPrinItem.SpName) &&
currentPrinItem.PrintMode == 4)
{
List<ParamInfo> inputParas = new List<ParamInfo>();
for (int i = 0; i < currentPrinItem.ParameterKeys.Count; i++)
{
ParamInfo newParam = new ParamInfo();
newParam.ParamName = currentPrinItem.ParameterKeys[i];
newParam.Values = currentPrinItem.ParameterValues[i];
inputParas.Add(newParam);
}
inputParas.Add(new ParamInfo
{
ParamName = "@Bartender",
Values = new List<string> { currentPrinItem.TemplateName }
});
string templateName = currentPrinItem.TemplateName + "~" + currentPrinItem.SpName;
if (string.IsNullOrEmpty(currentPrinItem.dpi))
{
result = getbartenderManager().getImageListForPrint(templateName, null, inputParas, false);
}
else
{
result = getbartenderManager().getImageListForPrint(templateName, null, inputParas, false, currentPrinItem.dpi);
}
}
return result;
}
private PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
int countOfCustomModifiers,
ParamInfo<TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder)
{
_containingType = containingType;
var module = moduleSymbol.Module;
PropertyAttributes mdFlags = 0;
BadImageFormatException mrEx = null;
try
{
module.GetPropertyDefPropsOrThrow(handle, out _name, out mdFlags);
}
catch (BadImageFormatException e)
{
mrEx = e;
if ((object)_name == null)
{
_name = string.Empty;
}
}
_getMethod = getMethod;
_setMethod = setMethod;
_handle = handle;
SignatureHeader unusedCallingConvention;
BadImageFormatException getEx = null;
var getMethodParams = (object)getMethod == null ? null : metadataDecoder.GetSignatureForMethod(getMethod.Handle, out unusedCallingConvention, out getEx);
BadImageFormatException setEx = null;
var setMethodParams = (object)setMethod == null ? null : metadataDecoder.GetSignatureForMethod(setMethod.Handle, out unusedCallingConvention, out setEx);
// NOTE: property parameter names are not recorded in metadata, so we have to
// use the parameter names from one of the indexers
// NB: prefer setter names to getter names if both are present.
bool isBad;
_parameters = GetParameters(moduleSymbol, this, propertyParams, setMethodParams ?? getMethodParams, out isBad);
if (getEx != null || setEx != null || mrEx != null || isBad)
{
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
}
var returnInfo = propertyParams[0];
_refKind = returnInfo.IsByRef ? RefKind.Ref : RefKind.None;
// CONSIDER: Can we make parameter type computation lazy?
TypeSymbol originalPropertyType = returnInfo.Type;
_propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, countOfCustomModifiers, handle, moduleSymbol, _refKind);
// Dynamify object type if necessary
_propertyType = _propertyType.AsDynamicIfNoPia(_containingType);
_propertyType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(_propertyType, handle, moduleSymbol);
// A property is bogus and must be accessed by calling its accessors directly if the
// accessor signatures do not agree, both with each other and with the property,
// or if it has parameters and is not an indexer or indexed property.
bool callMethodsDirectly = !DoSignaturesMatch(module, metadataDecoder, propertyParams, _getMethod, getMethodParams, _setMethod, setMethodParams) ||
MustCallMethodsDirectlyCore();
if (!callMethodsDirectly)
{
if ((object)_getMethod != null)
{
_getMethod.SetAssociatedProperty(this, MethodKind.PropertyGet);
}
if ((object)_setMethod != null)
{
_setMethod.SetAssociatedProperty(this, MethodKind.PropertySet);
}
}
if (callMethodsDirectly)
{
_flags |= Flags.CallMethodsDirectly;
}
if ((mdFlags & PropertyAttributes.SpecialName) != 0)
{
_flags |= Flags.IsSpecialName;
}
if ((mdFlags & PropertyAttributes.RTSpecialName) != 0)
{
_flags |= Flags.IsRuntimeSpecialName;
}
}
void ProcessContractDescription()
{
UInt32 dispIndex = 10;
Dictionary<string, ParamInfo> paramDictionary = null;
foreach (OperationDescription opDesc in contract.Operations)
{
dispToName[dispIndex] = opDesc.Name;
nameToDisp[opDesc.Name] = dispIndex;
MethodInfo methodInfo = null;
methodInfo = new MethodInfo(opDesc);
dispToOperationDescription[dispIndex++] = methodInfo;
paramDictionary = new Dictionary<string, ParamInfo>();
bool inVars = true;
inVars = true;
int paramCount = 0;
foreach (MessageDescription msgDesc in opDesc.Messages)
{
paramCount = 0;
if (msgDesc.Body.ReturnValue != null)
{
if (string.IsNullOrEmpty(msgDesc.Body.ReturnValue.BaseType))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.CannotResolveTypeForParamInMessageDescription, "ReturnValue", msgDesc.Body.WrapperName, msgDesc.Body.WrapperNamespace), HR.DISP_E_MEMBERNOTFOUND));
msgDesc.Body.ReturnValue.Type = Type.GetType(msgDesc.Body.ReturnValue.BaseType);
}
foreach (MessagePartDescription param in msgDesc.Body.Parts)
{
UInt32 dispID = 0;
ParamInfo paramInfo = null;
paramInfo = null;
if (!nameToDisp.TryGetValue(param.Name, out dispID))
{
dispToName[dispIndex] = param.Name;
nameToDisp[param.Name] = dispIndex;
dispID = dispIndex;
dispIndex++;
}
if (!paramDictionary.TryGetValue(param.Name, out paramInfo))
{
paramInfo = new ParamInfo();
methodInfo.paramList.Add(paramInfo);
methodInfo.dispIdToParamInfo[dispID] = paramInfo;
if (string.IsNullOrEmpty(param.BaseType))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.CannotResolveTypeForParamInMessageDescription, param.Name, msgDesc.Body.WrapperName, msgDesc.Body.WrapperNamespace), HR.DISP_E_MEMBERNOTFOUND));
paramInfo.type = Type.GetType(param.BaseType, true);
paramInfo.name = param.Name;
paramDictionary[param.Name] = paramInfo;
param.Index = paramCount;
}
param.Type = paramInfo.type;
if (inVars)
{
paramInfo.inIndex = paramCount;
}
else
{
paramInfo.outIndex = paramCount;
}
paramCount++;
}
inVars = false;
}
}
}
internal void CopyFrom(ParamInfo other)
{
Type = other.Type;
Key = other.Key.Clone();
Value = other.Value.Clone();
}
private static ImmutableArray<ParameterSymbol> GetParameters(
PEModuleSymbol moduleSymbol,
PEPropertySymbol property,
ParamInfo<TypeSymbol>[] propertyParams,
ParamInfo<TypeSymbol>[] accessorParams,
out bool anyParameterIsBad)
{
anyParameterIsBad = false;
// First parameter is the property type.
if (propertyParams.Length < 2)
{
return ImmutableArray<ParameterSymbol>.Empty;
}
var numAccessorParams = accessorParams.Length;
var parameters = new ParameterSymbol[propertyParams.Length - 1];
for (int i = 1; i < propertyParams.Length; i++) // from 1 to skip property/return type
{
// NOTE: this is a best guess at the Dev10 behavior. The actual behavior is
// in the unmanaged helper code that Dev10 uses to load the metadata.
var propertyParam = propertyParams[i];
var paramHandle = i < numAccessorParams ? accessorParams[i].Handle : propertyParam.Handle;
var ordinal = i - 1;
bool isBad;
parameters[ordinal] = PEParameterSymbol.Create(moduleSymbol, property, ordinal, paramHandle, propertyParam, out isBad);
if (isBad)
{
anyParameterIsBad = true;
}
}
return parameters.AsImmutableOrNull();
}
public override IStoryCommand Clone()
{
ObjAnimationParamCommand cmd = new ObjAnimationParamCommand();
cmd.m_ObjId = m_ObjId.Clone();
for (int i = 0; i < m_Params.Count; ++i) {
ParamInfo param = new ParamInfo();
param.CopyFrom(m_Params[i]);
cmd.m_Params.Add(param);
}
return cmd;
}
protected override void Load(Dsl.FunctionData funcData)
{
Dsl.CallData callData = funcData.Call;
if (null != callData) {
Load(callData);
for (int i = 0; i < funcData.Statements.Count; ++i) {
Dsl.ISyntaxComponent statement = funcData.Statements[i];
Dsl.CallData stCall = statement as Dsl.CallData;
if (null != stCall && stCall.GetParamNum() >= 2) {
string id = stCall.GetId();
ParamInfo param = new ParamInfo(id, stCall.GetParam(0), stCall.GetParam(1));
m_Params.Add(param);
}
}
}
}
private static bool ReturnTypesMatch(MethodSymbol candidateMethod, TypeMap candidateMethodTypeMap, ref ParamInfo targetReturnParam)
{
TypeSymbol candidateReturnType = candidateMethod.ReturnType;
TypeSymbol targetReturnType = targetReturnParam.Type;
// CONSIDER: Do we want to add special handling for error types? Right now, we expect they'll just fail to match.
if (candidateMethodTypeMap.SubstituteType(candidateReturnType) != targetReturnType)
{
return false;
}
if (!CustomModifiersMatch(candidateMethod.ReturnTypeCustomModifiers, targetReturnParam.CustomModifiers))
{
return false;
}
return true;
}
private void ProcessContractDescription()
{
uint num = 10;
Dictionary<string, ParamInfo> dictionary = null;
foreach (OperationDescription description in this.contract.Operations)
{
this.dispToName[num] = description.Name;
this.nameToDisp[description.Name] = num;
MethodInfo info = null;
info = new MethodInfo(description);
this.dispToOperationDescription[num++] = info;
dictionary = new Dictionary<string, ParamInfo>();
bool flag = true;
flag = true;
int num2 = 0;
foreach (MessageDescription description2 in description.Messages)
{
num2 = 0;
if (description2.Body.ReturnValue != null)
{
if (string.IsNullOrEmpty(description2.Body.ReturnValue.BaseType))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(System.ServiceModel.SR.GetString("CannotResolveTypeForParamInMessageDescription", new object[] { "ReturnValue", description2.Body.WrapperName, description2.Body.WrapperNamespace }), HR.DISP_E_MEMBERNOTFOUND));
}
description2.Body.ReturnValue.Type = Type.GetType(description2.Body.ReturnValue.BaseType);
}
foreach (MessagePartDescription description3 in description2.Body.Parts)
{
uint num3 = 0;
ParamInfo info2 = null;
info2 = null;
if (!this.nameToDisp.TryGetValue(description3.Name, out num3))
{
this.dispToName[num] = description3.Name;
this.nameToDisp[description3.Name] = num;
num3 = num;
num++;
}
if (!dictionary.TryGetValue(description3.Name, out info2))
{
info2 = new ParamInfo();
info.paramList.Add(info2);
info.dispIdToParamInfo[num3] = info2;
if (string.IsNullOrEmpty(description3.BaseType))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(System.ServiceModel.SR.GetString("CannotResolveTypeForParamInMessageDescription", new object[] { description3.Name, description2.Body.WrapperName, description2.Body.WrapperNamespace }), HR.DISP_E_MEMBERNOTFOUND));
}
info2.type = Type.GetType(description3.BaseType, true);
info2.name = description3.Name;
dictionary[description3.Name] = info2;
description3.Index = num2;
}
description3.Type = info2.type;
if (flag)
{
info2.inIndex = num2;
}
else
{
info2.outIndex = num2;
}
num2++;
}
flag = false;
}
}
}
private IEnumerable<ParamInfo> ScrapeParameters(IEnumerable<PSToken> tokens)
{
int groupDepth = 0;
var paramTokens = new List<PSToken>();
var filteredTokens = tokens
.Where(t => t.Type != PSTokenType.Comment && t.Type != PSTokenType.NewLine);
foreach (var token in filteredTokens)
{
paramTokens.Add(token);
if (token.Type == PSTokenType.GroupStart && token.Content == "(")
groupDepth++;
if (token.Type == PSTokenType.GroupEnd && token.Content == ")")
{
groupDepth--;
if (groupDepth <= 0)
break;
}
}
var currentParam = new ParamInfo();
bool expectDefaultValue = false;
foreach (var token in paramTokens)
{
if (token.Type == PSTokenType.Operator && token.Content != "=")
{
expectDefaultValue = false;
if (currentParam.Name != null)
yield return currentParam;
currentParam = new ParamInfo();
continue;
}
if (expectDefaultValue)
{
currentParam.DefaultValue = token.Content;
expectDefaultValue = false;
continue;
}
if (token.Type == PSTokenType.Type)
{
var match = ParameterTypeRegex.Value.Match(token.Content ?? string.Empty);
if (match.Success)
currentParam.Type = match.Groups[1].Value;
}
if (token.Type == PSTokenType.Variable)
currentParam.Name = token.Content;
if (token.Type == PSTokenType.Operator && token.Content == "=")
{
expectDefaultValue = true;
continue;
}
}
if (currentParam.Name != null)
yield return currentParam;
}
internal static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
PEMethodSymbol containingSymbol,
int ordinal,
ParamInfo<TypeSymbol> parameter,
out bool isBad)
{
return Create(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.RefCustomModifiers, parameter.Type, parameter.Handle, parameter.CustomModifiers, out isBad);
}
/// <summary>
/// Construct a parameter symbol for a property loaded from metadata.
/// </summary>
/// <param name="moduleSymbol"></param>
/// <param name="containingSymbol"></param>
/// <param name="ordinal"></param>
/// <param name="handle">The property parameter doesn't have a name in metadata,
/// so this is the handle of a corresponding accessor parameter, if there is one,
/// or of the ParamInfo passed in, otherwise).</param>
/// <param name="isBad" />
/// <param name="parameter"></param>
internal PEParameterSymbol(
PEModuleSymbol moduleSymbol,
PEPropertySymbol containingSymbol,
int ordinal,
ParameterHandle handle,
ParamInfo<TypeSymbol> parameter,
out bool isBad)
: this(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.HasByRefBeforeCustomModifiers, parameter.Type, handle, parameter.CustomModifiers, out isBad)
{
}
private static bool DoSignaturesMatch(
PEModule module,
MetadataDecoder metadataDecoder,
ParamInfo<TypeSymbol>[] propertyParams,
PEMethodSymbol getMethod,
ParamInfo<TypeSymbol>[] getMethodParams,
PEMethodSymbol setMethod,
ParamInfo<TypeSymbol>[] setMethodParams)
{
Debug.Assert((getMethodParams == null) == ((object)getMethod == null));
Debug.Assert((setMethodParams == null) == ((object)setMethod == null));
bool hasGetMethod = getMethodParams != null;
bool hasSetMethod = setMethodParams != null;
if (hasGetMethod && !metadataDecoder.DoPropertySignaturesMatch(propertyParams, getMethodParams, comparingToSetter: false, compareParamByRef: true, compareReturnType: true))
{
return false;
}
if (hasSetMethod && !metadataDecoder.DoPropertySignaturesMatch(propertyParams, setMethodParams, comparingToSetter: true, compareParamByRef: true, compareReturnType: true))
{
return false;
}
if (hasGetMethod && hasSetMethod)
{
var lastPropertyParamIndex = propertyParams.Length - 1;
var getHandle = getMethodParams[lastPropertyParamIndex].Handle;
var setHandle = setMethodParams[lastPropertyParamIndex].Handle;
var getterHasParamArray = !getHandle.IsNil && module.HasParamsAttribute(getHandle);
var setterHasParamArray = !setHandle.IsNil && module.HasParamsAttribute(setHandle);
if (getterHasParamArray != setterHasParamArray)
{
return false;
}
if ((getMethod.IsExtern != setMethod.IsExtern) ||
// (getMethod.IsAbstract != setMethod.IsAbstract) || // NOTE: Dev10 accepts one abstract accessor
(getMethod.IsSealed != setMethod.IsSealed) ||
(getMethod.IsOverride != setMethod.IsOverride) ||
(getMethod.IsStatic != setMethod.IsStatic))
{
return false;
}
}
return true;
}
public ParamInfo AddParam(string name, string typeName)
{
Raise<ArgumentException>.If(_params.Any(p => p.Name == name));
var paramInfo = new ParamInfo(name, typeName);
_params.Add(paramInfo);
return paramInfo;
}
public PEPropertySymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
ParamInfo<TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder)
: base (moduleSymbol, containingType, handle, getMethod, setMethod,
propertyParams[0].CustomModifiers.NullToEmpty().Length + propertyParams[0].RefCustomModifiers.NullToEmpty().Length,
propertyParams, metadataDecoder)
{
var returnInfo = propertyParams[0];
_typeCustomModifiers = CSharpCustomModifier.Convert(returnInfo.CustomModifiers);
_refCustomModifiers = CSharpCustomModifier.Convert(returnInfo.RefCustomModifiers);
}
private static MethodSymbol FindMethodBySignature(TypeSymbol targetTypeSymbol, string targetMemberName, SignatureHeader targetMemberSignatureHeader, int targetMemberTypeParamCount, ParamInfo<TypeSymbol>[] targetParamInfo)
{
foreach (Symbol member in targetTypeSymbol.GetMembers(targetMemberName))
{
var method = member as MethodSymbol;
if ((object)method != null &&
((byte)method.CallingConvention == targetMemberSignatureHeader.RawValue) &&
(targetMemberTypeParamCount == method.Arity) &&
MethodSymbolMatchesParamInfo(method, targetParamInfo))
{
// Behavior in the face of multiple matching signatures is
// implementation defined - we'll just pick the first one.
return method;
}
}
return null;
}
private void InitializeGrid()
{
Grid.Rows.Clear ();
Grid.Columns.Clear ();
_paramInfos = new List<ParamInfo> ();
//
// Image Column
//
_resultImageColIndex = Grid.Columns.Count;
Grid.Columns.Add (new DataGridViewImageColumn {
Width = 20,
MinimumWidth = 20,
ReadOnly = true,
Image = AllImages.Images[NewStatusIcon],
CellTemplate = new DefaultImageCell {
Image = AllImages.Images[NewStatusIcon],
Style = new DataGridViewCellStyle {
Alignment = DataGridViewContentAlignment.TopCenter,
},
},
});
//
// this Column
//
if (_funcElm.IsShared) {
_thisColIndex = -1;
}
else {
_thisColIndex = Grid.Columns.Count;
Grid.Columns.Add ("this", "this");
}
//
// Parameters Column
//
if (_testType == TestType.PropertySetter) {
var pi = new ParamInfo {
Name = "value",
ColIndex = Grid.Columns.Count,
ParameterType = GetTypeName (_funcElm.Type),
};
_paramInfos.Add (pi);
Grid.Columns.Add (pi.Name, pi.Name);
}
else {
foreach (CodeParameter2 p in _funcElm.Parameters) {
var pi = new ParamInfo {
Name = p.Name,
ColIndex = Grid.Columns.Count,
ParameterType = GetTypeName (p.Type),
};
_paramInfos.Add (pi);
Grid.Columns.Add (pi.Name, pi.Name);
}
}
//
// Value and Expected Value Columns
//
if (_testType == TestType.Procedure || _testType == TestType.PropertySetter) {
_resultColIndex = -1;
_expectedColIndex = -1;
}
else {
_resultColIndex = Grid.Columns.Count;
Grid.Columns.Add (_funcElm.Name, _funcElm.Name);
Grid.Columns[_resultColIndex].ReadOnly = true;
_expectedColIndex = Grid.Columns.Count;
Grid.Columns.Add ("E" + _funcElm.Name, "E[" + _funcElm.Name + "]");
}
//
// Assert Column
//
_assertColIndex = Grid.Columns.Count;
Grid.Columns.Add ("Assert", "Assert");
//
// Fail Column
//
_failColIndex = Grid.Columns.Count;
Grid.Columns.Add ("Fail", "Fail");
Grid.Columns[_failColIndex].ReadOnly = true;
Grid.Columns[_failColIndex].Width *= 2;
//
// Format
//
_formattingCells = true;
foreach (var col in Grid.Columns.OfType<DataGridViewColumn> ().Skip (1)) {
col.DefaultCellStyle.WrapMode = DataGridViewTriState.True;
col.Width = _tests.DisplayInfo.GetColumnWidth (col.Name);
}
_formattingCells = false;
}
private static bool MethodSymbolMatchesParamInfo(MethodSymbol candidateMethod, ParamInfo<TypeSymbol>[] targetParamInfo)
{
int numParams = targetParamInfo.Length - 1; //don't count return type
if (candidateMethod.ParameterCount != numParams)
{
return false;
}
// IndexedTypeParameterSymbol is not going to be exposed anywhere,
// so we'll cheat and use it here for comparison purposes.
TypeMap candidateMethodTypeMap = new TypeMap(
candidateMethod.TypeParameters,
IndexedTypeParameterSymbol.Take(candidateMethod.Arity), true);
if (!ReturnTypesMatch(candidateMethod, candidateMethodTypeMap, ref targetParamInfo[0]))
{
return false;
}
for (int i = 0; i < numParams; i++)
{
if (!ParametersMatch(candidateMethod.Parameters[i], candidateMethodTypeMap, ref targetParamInfo[i + 1 /*for return type*/]))
{
return false;
}
}
return true;
}
internal ParamInfo Method_GetParamInfo(long id)
{
var res = SendReceive(CommandSet.METHOD, (int)CmdMethod.GET_PARAM_INFO, new PacketWriter().WriteId(id));
ParamInfo info = new ParamInfo();
info.call_conv = res.ReadInt();
info.param_count = res.ReadInt();
info.generic_param_count = res.ReadInt();
info.ret_type = res.ReadId();
info.param_types = new long[info.param_count];
for (int i = 0; i < info.param_count; ++i)
info.param_types[i] = res.ReadId();
info.param_names = new string[info.param_count];
for (int i = 0; i < info.param_count; ++i)
info.param_names[i] = res.ReadString();
return info;
}
private static bool ParametersMatch(ParameterSymbol candidateParam, TypeMap candidateMethodTypeMap, ref ParamInfo<TypeSymbol> targetParam)
{
Debug.Assert(candidateMethodTypeMap != null);
// This could be combined into a single return statement with a more complicated expression, but that would
// be harder to debug.
if ((candidateParam.RefKind != RefKind.None) != targetParam.IsByRef)
{
return false;
}
// CONSIDER: Do we want to add special handling for error types? Right now, we expect they'll just fail to match.
var substituted = new TypeWithModifiers(candidateParam.Type, candidateParam.CustomModifiers).SubstituteType(candidateMethodTypeMap);
if (substituted.Type != targetParam.Type)
{
return false;
}
if (!CustomModifiersMatch(substituted.CustomModifiers, targetParam.CustomModifiers) ||
!CustomModifiersMatch(candidateMethodTypeMap.SubstituteCustomModifiers(candidateParam.RefCustomModifiers), targetParam.RefCustomModifiers))
{
return false;
}
return true;
}
internal MethodDefSignatureConverter(PEFileToObjectModel peFileToObjectModel, MethodDefinition moduleMethod, MemoryReader signatureMemoryReader)
: base(peFileToObjectModel, signatureMemoryReader, moduleMethod) {
// TODO: Check minimum required size of the signature...
this.FirstByte = this.SignatureMemoryReader.ReadByte();
if (SignatureHeader.IsGeneric(this.FirstByte)) {
this.GenericParamCount = (uint)this.SignatureMemoryReader.ReadCompressedUInt32();
}
this.paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
bool dummyPinned;
this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
byte retByte = this.SignatureMemoryReader.PeekByte(0);
bool isReturnByReference = false;
if (retByte == ElementType.Void) {
this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemVoid;
this.SignatureMemoryReader.SkipBytes(1);
} else if (retByte == ElementType.TypedReference) {
this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemTypedReference;
this.SignatureMemoryReader.SkipBytes(1);
} else {
if (retByte == ElementType.ByReference) {
isReturnByReference = true;
this.SignatureMemoryReader.SkipBytes(1);
}
this.ReturnTypeReference = this.GetTypeReference();
}
PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
uint paramRowCount;
uint paramRowStart = peFileReader.GetParamInformation(moduleMethod.MethodDefRowId, out paramRowCount);
uint paramRowEnd = paramRowStart + paramRowCount;
ParamInfo[] paramInfoArray = new ParamInfo[paramRowCount];
if (peFileReader.UseParamPtrTable) {
for (uint paramRowIter = paramRowStart; paramRowIter < paramRowEnd; ++paramRowIter) {
uint paramRowId = peFileReader.ParamPtrTable.GetParamFor(paramRowIter);
ParamRow paramRow = peFileReader.ParamTable[paramRowId];
// TODO: Error check if seqence is in proper range...
paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags);
}
} else {
for (uint paramRowId = paramRowStart; paramRowId < paramRowEnd; ++paramRowId) {
ParamRow paramRow = peFileReader.ParamTable[paramRowId];
// TODO: Error check if seqence is in proper range...
paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags);
}
}
if (paramRowCount > 0 && paramInfoArray[0].ParamSequence == 0) {
ParamFlags paramFlag = paramInfoArray[0].ParamFlags;
if (isReturnByReference) {
paramFlag |= ParamFlags.ByReference;
}
this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, paramInfoArray[0].ParamName, paramFlag, paramInfoArray[0].ParamRowId);
} else {
this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, Dummy.Name, isReturnByReference ? ParamFlags.ByReference : 0, 0);
}
this.ParamInfoArray = paramInfoArray;
if (this.paramCount > 0) {
IParameterDefinition[] moduleParamArr = this.GetModuleParameters(true, moduleMethod, this.paramCount);
this.paramCount = moduleParamArr.Length;
if (this.paramCount > 0) this.Parameters = moduleParamArr;
}
}
private static bool ReturnTypesMatch(MethodSymbol candidateMethod, TypeMap candidateMethodTypeMap, ref ParamInfo<TypeSymbol> targetReturnParam)
{
Debug.Assert(candidateMethodTypeMap != null);
if (candidateMethod.ReturnsByRef != targetReturnParam.IsByRef)
{
return false;
}
TypeSymbol candidateReturnType = candidateMethod.ReturnType;
TypeSymbol targetReturnType = targetReturnParam.Type;
// CONSIDER: Do we want to add special handling for error types? Right now, we expect they'll just fail to match.
var substituted = new TypeWithModifiers(candidateReturnType, candidateMethod.ReturnTypeCustomModifiers).SubstituteType(candidateMethodTypeMap);
if (substituted.Type != targetReturnType)
{
return false;
}
if (!CustomModifiersMatch(substituted.CustomModifiers, targetReturnParam.CustomModifiers) ||
!CustomModifiersMatch(candidateMethodTypeMap.SubstituteCustomModifiers(candidateMethod.RefCustomModifiers), targetReturnParam.RefCustomModifiers))
{
return false;
}
return true;
}
//public static string GetBartenderPrint(PrintItem currentPrinItem, string pCode)
//{
// string batFilePath = System.Configuration.ConfigurationManager.AppSettings["ClientBatFilePath"];
// string result = null;
// if (!string.IsNullOrEmpty(currentPrinItem.SpName) && currentPrinItem.PrintMode == 3)
// {
// result = getPrintService().GetMainBat(currentPrinItem.SpName, currentPrinItem.ParameterKeys, currentPrinItem.ParameterValues);
// }
// return result;
//}
public static List<ImageInfo> GetTemplatePrint(PrintItem currentPrinItem, Boolean isPrintRoom)
{
List<ImageInfo> result = null;
if (!string.IsNullOrEmpty(currentPrinItem.TemplateName) && currentPrinItem.PrintMode == 1)
{
List<ParamInfo> inputParas = new List<ParamInfo>();
for (int i = 0; i < currentPrinItem.ParameterKeys.Count; i++)
{
ParamInfo newParam = new ParamInfo();
newParam.ParamName = currentPrinItem.ParameterKeys[i];
newParam.Values = currentPrinItem.ParameterValues[i];
inputParas.Add(newParam);
}
if (isPrintRoom)
{
if (string.IsNullOrEmpty(currentPrinItem.dpi))
{
result = getPrintRoomLlbManager().getImageListForPrint(currentPrinItem.TemplateName, null, inputParas, isPrintRoom);
}
else
{
result = getPrintRoomLlbManager().getImageListForPrint(currentPrinItem.TemplateName, null, inputParas, isPrintRoom, currentPrinItem.dpi);
}
}
else
{
if (string.IsNullOrEmpty(currentPrinItem.dpi))
{
result = getCommonLlbManager().getImageListForPrint(currentPrinItem.TemplateName, null, inputParas, isPrintRoom);
}
else
{
result = getCommonLlbManager().getImageListForPrint(currentPrinItem.TemplateName, null, inputParas, isPrintRoom, currentPrinItem.dpi);
}
}
}
return result;
}
public bool readArchivesStructure(ushort paramNumber, ref List<ParamInfo> archStructure)
{
byte FNC = 0x19;
byte[] paramBytes = stringToBytes(paramNumber.ToString());
List<byte> messageBodyList = new List<byte>();
messageBodyList.Add(HT);
messageBodyList.AddRange(stringToBytes("0"));
messageBodyList.Add(HT);
messageBodyList.AddRange(paramBytes);
messageBodyList.Add(FF);
byte[] messageBodyArr = messageBodyList.ToArray();
List<byte> answDataList = new List<byte>();
if (!sendMessage(messageBodyArr, FNC, ref answDataList))
{
WriteToLog("readArchivesStructure: ошибка отправки сообщения");
return false;
}
if (answDataList.Count < 2)
{
WriteToLog("readArchivesStructure: кол-во полученых данных меньше " +
"минимально допустимого числа для данного запроса");
return false;
}
List<byte[]> blocks = new List<byte[]>();
if (!splitInfoBlocks(answDataList.ToArray(), ref blocks))
{
WriteToLog("readArchivesStructure: splitInfoBlocks fail");
return false;
}
List<ParamInfo> pil = new List<ParamInfo>();
bool exceptionFlag = false;
int paramNumb = 4;
for (int i = 0; i < blocks.Count; i++)
{
List<byte>[] values = new List<byte>[paramNumb];
if (!getValueBytesFromInfoBlock(blocks[i], paramNumb, ref values))
{
WriteToLog("readArchivesStructure: getValueBytesFromInfoBlock fail");
return false;
}
ParamInfo pi = new ParamInfo();
try
{
pi.caption = bytesToString(values[0].ToArray());
pi.units = bytesToString(values[1].ToArray());
pi.channelNumber = int.Parse(bytesToString(values[2].ToArray()));
pi.paramNumber = int.Parse(bytesToString(values[3].ToArray()));
}
catch (Exception ex)
{
exceptionFlag = true;
WriteToLog("readArchivesStructure: ошибка преобразование байт в соответствующие единицы");
}
pil.Add(pi);
}
if (!exceptionFlag)
{
archStructure = pil;
return true;
}
else return false;
}
/// <summary>
/// Construct a parameter symbol for a property loaded from metadata.
/// </summary>
/// <param name="moduleSymbol"></param>
/// <param name="containingSymbol"></param>
/// <param name="ordinal"></param>
/// <param name="handle">The property parameter doesn't have a name in metadata,
/// so this is the handle of a corresponding accessor parameter, if there is one,
/// or of the ParamInfo passed in, otherwise).</param>
/// <param name="isBad" />
/// <param name="parameter"></param>
internal static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
PEPropertySymbol containingSymbol,
int ordinal,
ParameterHandle handle,
ParamInfo<TypeSymbol> parameter,
out bool isBad)
{
return Create(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.CountOfCustomModifiersPrecedingByRef, parameter.Type, handle, parameter.CustomModifiers, out isBad);
}
private AstNode ParseMethod(AstNode qyInput)
{
ArrayList argList = new ArrayList();
string name = this.scanner.Name;
string prefix = this.scanner.Prefix;
PassToken(XPathScanner.LexKind.Name);
PassToken(XPathScanner.LexKind.LParens);
if (this.scanner.Kind != XPathScanner.LexKind.RParens)
{
do
{
argList.Add(ParseExpresion(qyInput));
if (this.scanner.Kind == XPathScanner.LexKind.RParens)
{
break;
}
PassToken(XPathScanner.LexKind.Comma);
}while (true);
}
PassToken(XPathScanner.LexKind.RParens);
if (prefix == string.Empty)
{
ParamInfo pi = (ParamInfo)functionTable[name];
if (pi != null)
{
int argCount = argList.Count;
if (argCount < pi.Minargs)
{
throw new XPathException(String.Format("Function '{0}' in '{1}' has invalid number of arguments.", name, this.scanner.SourceText));
}
if (pi.FType == Function.FunctionType.FuncConcat)
{
for (int i = 0; i < argCount; i++)
{
AstNode arg = (AstNode)argList[i];
if (arg.ReturnType != XPathResultType.String)
{
arg = new Function(Function.FunctionType.FuncString, arg);
}
argList[i] = arg;
}
}
else
{
if (pi.Maxargs < argCount)
{
throw new XPathException(String.Format("Function '{0}' in '{1}' has invalid number of arguments.", name, this.scanner.SourceText));
}
if (pi.ArgTypes.Length < argCount)
{
argCount = pi.ArgTypes.Length; // argument we have the type specified (can be < pi.Minargs)
}
for (int i = 0; i < argCount; i++)
{
AstNode arg = (AstNode)argList[i];
if (
pi.ArgTypes[i] != XPathResultType.Any &&
pi.ArgTypes[i] != arg.ReturnType
)
{
switch (pi.ArgTypes[i])
{
case XPathResultType.NodeSet:
if (!(arg is Variable) && !(arg is Function && arg.ReturnType == XPathResultType.Error))
{
throw new XPathException(String.Format("Function '{0}' in '{1}' has invalid number of arguments.", name, this.scanner.SourceText));
}
break;
case XPathResultType.String:
arg = new Function(Function.FunctionType.FuncString, arg);
break;
case XPathResultType.Number:
arg = new Function(Function.FunctionType.FuncNumber, arg);
break;
case XPathResultType.Boolean:
arg = new Function(Function.FunctionType.FuncBoolean, arg);
break;
}
argList[i] = arg;
}
}
}
return(new Function(pi.FType, argList));
}
}
return(new Function(prefix, name, argList));
}
