///////////////////////////////////////////////////////////////////////
internal ArgumentList( /* NOTE: For [apply] and [proc] use only. */
StringPairList list,
ArgumentFlags flags
)
: this()
{
if (list != null)
{
int count = list.Count;
for (int index = 0; index < count; index++)
{
IPair <string> element = list[index];
//
// HACK: Skip over any null entries, thus ignoring
// them.
//
if (element == null)
{
continue;
}
//
// NOTE: Does this argument list accept a variable
// numbers of arguments (COMPAT: Tcl)? If so,
// add a flag to the final argument to mark it
// as an "argument list".
//
ArgumentFlags nameFlags = ArgumentFlags.None;
if ((index == (count - 1)) && String.Compare(
element.X, TclVars.Arguments,
StringOps.SystemStringComparisonType) == 0)
{
nameFlags |= ArgumentFlags.ArgumentList;
}
ArgumentFlags valueFlags = (element.Y != null) ?
ArgumentFlags.HasDefault : ArgumentFlags.None;
Argument argument;
if (FlagOps.HasFlags(flags, ArgumentFlags.NameOnly, true))
{
argument = Argument.InternalCreate(
flags | nameFlags | valueFlags, element.X,
Argument.NoValue, element.Y);
}
else
{
argument = Argument.InternalCreate(
flags | nameFlags | valueFlags, Argument.NoName,
element.X, element.Y);
}
this.Add(argument);
}
}
}
///////////////////////////////////////////////////////////////////////
public IStringList ToList(
string pattern,
bool empty,
bool noCase
)
{
StringPairList inputList;
StringPairList outputList = new StringPairList();
if (empty)
{
inputList = this;
}
else
{
inputList = new StringPairList();
foreach (IPair <string> element in this)
{
if (element == null)
{
continue;
}
if (String.IsNullOrEmpty(element.X) &&
String.IsNullOrEmpty(element.Y))
{
continue;
}
inputList.Add(element);
}
}
ReturnCode code;
Result error = null;
code = GenericOps <IPair <string> > .FilterList(
inputList, outputList, Index.Invalid, Index.Invalid,
ToStringFlags.None, pattern, noCase, ref error);
if (code != ReturnCode.Ok)
{
DebugOps.Complain(code, error);
//
// TODO: Return null in the error case here?
//
outputList = null;
}
return(outputList);
}
///////////////////////////////////////////////////////////////////////
public StringPairList ToPairs(
string pattern,
bool noCase
)
{
StringPairList list = new StringPairList();
foreach (KeyValuePair <string, string> pair in this)
{
if ((pattern == null) ||
Parser.StringMatch(null, pair.Key, 0, pattern, 0, noCase))
{
list.Add(pair.Key, pair.Value);
}
}
return(list);
}
///////////////////////////////////////////////////////////////////////
public string ToString(
string separator,
string pattern,
bool empty,
bool noCase
)
{
if (empty)
{
return(GenericOps <IPair <string> > .ListToString(
this, Index.Invalid, Index.Invalid, ToStringFlags.None,
separator, pattern, noCase));
}
else
{
StringPairList result = new StringPairList();
foreach (IPair <string> element in this)
{
if (element == null)
{
continue;
}
if (String.IsNullOrEmpty(element.X) &&
String.IsNullOrEmpty(element.Y))
{
continue;
}
result.Add(element);
}
return(GenericOps <IPair <string> > .ListToString(
result, Index.Invalid, Index.Invalid, ToStringFlags.None,
separator, pattern, noCase));
}
}
