public override void Visit(INamedArgument namedArgument)
{
if (Process(namedArgument))
{
visitor.Visit(namedArgument);
}
base.Visit(namedArgument);
}
private void HandleNamed(INamedArgument namedArgument, string identifier)
{
this.CheckThatThereIsAValue(identifier);
var value = this.arguments.Dequeue();
namedArgument.Handle(value);
this.required.Remove(namedArgument);
}
private static List <string> GetArgumentNames(INamedArgument attr)
{
var ret = new List <string>();
if (attr.ShortName != null)
{
ret.Add("-" + attr.ShortName);
}
if (attr.LongName != null)
{
ret.Add("--" + attr.LongName);
}
return(ret);
}
private static List <string> GetArgumentNames(INamedArgument attr, IParserConfig config)
{
var ret = new List <string>();
if (attr.ShortName != null)
{
ret.Add("" + config.ArgumentPrefix + attr.ShortName);
}
if (attr.LongName != null)
{
ret.Add("" + config.ArgumentPrefix + config.ArgumentPrefix + attr.LongName);
}
return(ret);
}
private void HandleArgumentWithName(IArgument argument, string name)
{
ISwitch switchArgument = argument as ISwitch;
if (switchArgument != null)
{
HandleSwitch(switchArgument);
}
INamedArgument namedArgument = argument as INamedArgument;
if (namedArgument != null)
{
this.HandleNamed(namedArgument, name);
}
}
public static void HaveNamed(this ObjectAssertions assertions, string name, string input, Func <bool> validation)
{
var subject = assertions.Subject as CommandLineConfiguration;
Execute.Assertion
.ForCondition(subject != null)
.FailWith("object must be a non-null CommandLineConfiguration");
int count = subject.Arguments.OfType <INamedArgument>().Count(n => n.Name == name);
Execute.Assertion
.ForCondition(count == 1)
.FailWith("named argument `{0}` does exist `{1}` times, but was expected to exist exactly once.", name, count);
INamedArgument namedArgument = subject.Arguments.OfType <INamedArgument>().Single(n => n.Name == name);
namedArgument.Handle(input);
Execute.Assertion
.ForCondition(validation())
.FailWith("callback did not execute successfully");
}
public virtual void onASTElement(INamedArgument namedArgument) { }
public void Visit(INamedArgument namedArgument)
{
Contract.Requires(namedArgument != null);
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="namedArgument"></param>
public NamedArgument(INamedArgument namedArgument)
: base(namedArgument)
{
this.argumentName = namedArgument.ArgumentName;
this.argumentValue = namedArgument.ArgumentValue;
this.resolvedDefinition = namedArgument.ResolvedDefinition;
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public virtual void Visit(INamedArgument namedArgument)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(namedArgument);
this.Visit(namedArgument.ArgumentValue);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not to decrease this.path.Count.
this.path.Pop();
}
private static ArgumentDisplay GetArgumentsForDisplay(INamedArgument attr, IParserConfig config)
{
var names = GetArgumentNames(attr, config);
return(GetArgumentsForDisplay(names, attr));
}
/// <summary>
/// Returns a shallow copy of the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public NamedArgument Copy(INamedArgument namedArgument)
{
return new NamedArgument(namedArgument);
}
public virtual void onASTElement(INamedArgument namedArgument)
{
}
/// <summary>
/// Visits the specified named argument.
/// </summary>
/// <param name="namedArgument">The named argument.</param>
public override void Visit(INamedArgument namedArgument)
{
NamedArgument mutableNamedArgument = namedArgument as NamedArgument;
if (alwaysMakeACopy || mutableNamedArgument == null) mutableNamedArgument = new NamedArgument(namedArgument);
this.resultExpression = this.myCodeMutator.Visit(mutableNamedArgument);
}
/// <summary>
/// Visits the specified named argument.
/// </summary>
/// <param name="namedArgument">The named argument.</param>
public override void Visit(INamedArgument namedArgument)
{
NamedArgument mutableNamedArgument = new NamedArgument(namedArgument);
this.resultExpression = this.myCodeCopier.DeepCopy(mutableNamedArgument);
}
/// <summary>
/// Rewrites the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public virtual IExpression Rewrite(INamedArgument namedArgument)
{
return namedArgument;
}
/// <summary>
///
/// </summary>
/// <param name="namedArgument"></param>
public NamedArgument(INamedArgument namedArgument)
: base(namedArgument)
{
this.argumentName = namedArgument.ArgumentName;
this.argumentValue = namedArgument.ArgumentValue;
this.resolvedDefinition = namedArgument.ResolvedDefinition;
this.getterIsVirtual = namedArgument.GetterIsVirtual;
this.setterIsVirtual = namedArgument.SetterIsVirtual;
}
public override void Visit(INamedArgument namedArgument)
{
allElements.Add(new InvokInfo(Traverser, "INamedArgument", namedArgument));
}
public override void TraverseChildren(INamedArgument namedArgument)
{
//TODO: get rid of INamedArgument
}
public override void Visit(INamedArgument namedArgument)
{
if(Process(namedArgument)){visitor.Visit(namedArgument);}
base.Visit(namedArgument);
}
/// <summary>
/// Rewrites the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public virtual IExpression Rewrite(INamedArgument namedArgument)
{
var mutableNamedArgument = namedArgument as NamedArgument;
if (mutableNamedArgument == null) return namedArgument;
this.RewriteChildren(mutableNamedArgument);
return mutableNamedArgument;
}
public override void TraverseChildren(INamedArgument namedArgument) {
//TODO: get rid of INamedArgument
}
/// <summary>
/// Returns a deep copy of the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public NamedArgument Copy(INamedArgument namedArgument)
{
var mutableCopy = this.shallowCopier.Copy(namedArgument);
this.CopyChildren((Expression)mutableCopy);
mutableCopy.ArgumentValue = this.Copy(mutableCopy.ArgumentValue);
return mutableCopy;
}
/// <summary>
/// Obtains the values of AllowMultiple, Inherited and ValidOn by looking at the arguments of the AttributeUsage custom attribute that is supposed to be
/// attached to the type of this custom attribute.
/// </summary>
private void GetUsageInformation()
{
this.flags = 0x40000000; //Records that the attribute usage has already been determined.
INameTable nameTable = this.ContainingBlock.Compilation.NameTable;
ITypeDefinition attributeUsageAttribute = this.ContainingBlock.Compilation.PlatformType.SystemAttributeUsageAttribute.ResolvedType;
foreach (ICustomAttribute attribute in this.Type.ResolvedType.Attributes)
{
if (attribute.Type.ResolvedType != attributeUsageAttribute)
{
continue;
}
bool firstArgument = true;
foreach (IExpression expression in attribute.Arguments)
{
ICompileTimeConstant /*?*/ cc = expression as ICompileTimeConstant;
if (firstArgument)
{
if (cc != null)
{
if (cc.Value is int)
{
//^ assume false; //not really, but we need to shut up a bogus message: Unboxing cast might fail
this.flags |= (int)cc.Value;
} //else TODO: error?
} //else TODO: error?
}
else
{
INamedArgument /*?*/ namedArgument = expression as INamedArgument;
if (namedArgument != null)
{
if (namedArgument.ArgumentName.UniqueKey == nameTable.AllowMultiple.UniqueKey)
{
cc = namedArgument.ArgumentValue as ICompileTimeConstant;
if (cc != null && cc.Value is bool)
{
if (((bool)cc.Value))
{
this.flags |= 0x20000000;
}
}//else TODO: error?
}
else if (namedArgument.ArgumentName.UniqueKey == nameTable.Inherited.UniqueKey)
{
cc = namedArgument.ArgumentValue as ICompileTimeConstant;
if (cc != null && cc.Value is bool)
{
if (((bool)cc.Value))
{
this.flags |= 0x10000000;
}
} //else TODO: error?
}
} //else TODO: error?
}
}
break;
}
//TODO: what if attribute does not have usage attribute? Error?
}
public void Visit(INamedArgument namedArgument)
{
this.result = this.copier.Copy(namedArgument);
}
/// <summary>
/// Traverses the named argument expression.
/// </summary>
public void Traverse(INamedArgument namedArgument)
{
Contract.Requires(namedArgument != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(namedArgument);
if (this.StopTraversal) return;
this.TraverseChildren(namedArgument);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(namedArgument);
}
public override void TraverseChildren(INamedArgument namedArgument)
{ MethodEnter(namedArgument);
base.TraverseChildren(namedArgument);
MethodExit(); }
public void Visit(INamedArgument namedArgument)
{
this.traverser.Traverse(namedArgument);
}
/// <summary>
/// Performs some computation with the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public virtual void Visit(INamedArgument namedArgument)
{
}
public void Visit(INamedArgument namedArgument)
{
this.result = this.rewriter.Rewrite(namedArgument);
}
/// <summary>
/// Traverses the children of the named argument expression.
/// </summary>
public virtual void TraverseChildren(INamedArgument namedArgument)
{
Contract.Requires(namedArgument != null);
this.TraverseChildren((IExpression)namedArgument);
if (this.StopTraversal) return;
this.Traverse(namedArgument.ArgumentValue);
}
/// <summary>
/// Returns a shallow copy of the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public NamedArgument Copy(INamedArgument namedArgument) {
Contract.Requires(namedArgument != null);
Contract.Ensures(Contract.Result<NamedArgument>() != null);
return new NamedArgument(namedArgument);
}
/// <summary>
/// Performs some computation with the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public virtual void Visit(INamedArgument namedArgument)
{
this.Visit((IExpression)namedArgument);
}
/// <summary>
/// Returns a deep copy of the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public NamedArgument Copy(INamedArgument namedArgument) {
Contract.Requires(namedArgument != null);
Contract.Ensures(Contract.Result<NamedArgument>() != null);
var mutableCopy = this.shallowCopier.Copy(namedArgument);
this.CopyChildren((Expression)mutableCopy);
mutableCopy.ArgumentValue = this.Copy(mutableCopy.ArgumentValue);
return mutableCopy;
}
public void Visit(INamedArgument namedArgument)
{
throw new NotImplementedException();
}
/// <summary>
/// Performs some computation with the given named argument expression.
/// </summary>
/// <param name="namedArgument"></param>
public virtual void Visit(INamedArgument namedArgument)
{
}
public override void TraverseChildren(INamedArgument namedArgument) {
base.TraverseChildren(namedArgument);
}
private static ArgumentDisplay GetArgumentsForDisplay(INamedArgument attr)
{
var names = GetArgumentNames(attr);
return(GetArgumentsForDisplay(names, attr));
}
public override void TraverseChildren(INamedArgument namedArgument)
{
MethodEnter(namedArgument);
base.TraverseChildren(namedArgument);
MethodExit();
}
/// <summary>
/// Visits the specified named argument.
/// </summary>
/// <param name="namedArgument">The named argument.</param>
public override void Visit(INamedArgument namedArgument)
{
NamedArgument mutableNamedArgument = namedArgument as NamedArgument;
if (mutableNamedArgument == null) {
this.resultExpression = namedArgument;
return;
}
this.resultExpression = this.myCodeMutator.Visit(mutableNamedArgument);
}
