public static void AddNamespace(INamespace ns)
{
if (ns == null)
throw new ArgumentNullException("ns");
namespaces[ns.Identifier] = ns;
}
public static IEntity ResolveSingle(INamespace root, string name)
{
var resolved = new List<IEntity>();
Assert.IsTrue(root.Resolve(resolved, name, EntityType.Any), "Failed to resolve '{0}' against '{1}'", name, root);
Assert.AreEqual(1, resolved.Count);
return resolved[0];
}
public static bool ResolveCoalescingNamespaces(INamespace parent, INamespace namespaceToResolveAgainst, string name, EntityType typesToConsider, ICollection<IEntity> resultingSet)
{
var resolved = new Set<IEntity>();
if (!namespaceToResolveAgainst.Resolve(resolved, name, typesToConsider))
return false;
return CoalesceResolved(resolved, parent, name, resultingSet);
}
public void AddNamespace (INamespace ns)
{
if (usedNamespaces.Contains (ns.Name))
return;
usedNamespaces.Add (ns.Name);
result.Add (Factory.CreateNamespaceCompletionData (ns));
}
public CodeNamespace(CodeModelContext context, INamespace ns)
: base(context)
{
this.ns = ns;
this.InfoLocation = global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationExternal;
this.Language = context.CurrentProject.GetCodeModelLanguage();
}
public static IEntity ResolveQualifiedNameToSingle(INamespace root, string qualifiedName)
{
IEntity current = root;
foreach (string part in qualifiedName.Split('.'))
current = ResolveSingle((INamespace) current, part);
return current;
}
public void SetChild(string name, INamespace entity)
{
_children[name] = entity;
if (name == "")
{
_empty = entity;
}
}
AstNode[] FindReferences(INamespace ns)
{
var result = new List<AstNode>();
var searchScopes = findReferences.GetSearchScopes(ns);
findReferences.FindReferencesInFile(searchScopes, unresolvedFile, syntaxTree, compilation,
(node, rr) => result.Add(node), CancellationToken.None);
return result.OrderBy(n => n.StartLocation).ToArray();
}
public NamespaceEntity(INamespace parent, TypeSystemServices tagManager, string name)
{
_parent = parent;
_typeSystemServices = tagManager;
_name = name;
_assemblies = new Dictionary<Assembly, Dictionary<string, List<Type>>>(AssemblyEqualityComparer.Default);
_childrenNamespaces = new Dictionary<string, NamespaceEntity>();
_internalModules = new List<ModuleEntity>();
_externalModules = new List<ExternalType>();
public GlobalNamespace(IDictionary children)
: base(null, children)
{
_empty = (INamespace)children[""];
if (null == _empty)
{
_empty = NullNamespace.Default;
}
}
public Hypertable(String host, String ns)
{
this.host = host;
this.ns = ns;
String conn = "Provider=Hyper;Uri=net.tcp://" + host;
htContext = Context.Create(conn);
htClient = htContext.CreateClient();
htNs = htClient.OpenNamespace(ns, OpenDispositions.OpenAlways | OpenDispositions.CreateIntermediate);
}
public SimpleNamespace(INamespace parent, IDictionary children)
{
if (null == children)
{
throw new ArgumentNullException("children");
}
_parent = parent;
_children = children;
}
public NamespaceDelegator(INamespace parent, params INamespace[] namespaces)
{
if (null == namespaces)
{
throw new ArgumentNullException("namespaces");
}
_parent = parent;
_namespaces = namespaces;
}
bool IsAccessible(MemberLookup lookup, INamespace ns)
{
if (ns.Types.Any (t => lookup.IsAccessible (t, false)))
return true;
foreach (var child in ns.ChildNamespaces)
if (IsAccessible (lookup, child))
return true;
return false;
}
public void LoadNMeta()
{
EPackage package;
package = EcoreInterop.LoadPackageFromFile("NMeta.ecore");
Assert.IsNotNull(package);
metaNamespace = EcoreInterop.Transform2Meta(package);
var boolean = metaNamespace.Resolve(new Uri("Boolean", UriKind.Relative));
var isInterface = metaNamespace.Resolve(new Uri("Class/IsInterface", UriKind.Relative)) as IAttribute;
//var serializer = new ModelSerializer();
//serializer.RootPrefix = "nmeta";
//using (var sw = new FileStream(@"C:\Projekte\NMF\NMeta.nmf", FileMode.OpenOrCreate))
//{
// serializer.Serialize(metaNamespace.Model, sw);
//}
Assert.IsNotNull(metaNamespace);
Assert.AreEqual(20, metaNamespace.Types.OfType<IClass>().Count());
type = GetClass("Type");
@class = GetClass("Class");
structuredType = GetClass("StructuredType");
typedElement = GetClass("ITypedElement");
metaElement = GetClass("MetaElement");
attribute = GetClass("Attribute");
reference = GetClass("Reference");
referenceType = GetClass("ReferenceType");
dataType = GetClass("DataType");
primitiveType = GetClass("PrimitiveType");
@namespace = GetClass("Namespace");
extension = GetClass("Extension");
@event = GetClass("Event");
operation = GetClass("Operation");
parameter = GetClass("Parameter");
enumeration = GetClass("Enumeration");
literal = GetClass("Literal");
modelElement = GetClass("ModelElement");
direction = metaNamespace.Types.OfType<IEnumeration>().FirstOrDefault(en => en.Name == "Direction");
Assert.IsNotNull(direction);
direction.Literals.Select(l => l.Name).AssertSequence("In", "Out", "InOut");
AssertBaseTypes();
AssertProperties();
var model = metaNamespace.Model;
Assert.IsNotNull(model);
Assert.AreSame(type, model.Resolve("#//Type"));
Assert.AreSame(@class, model.Resolve("#//Class"));
Assert.AreSame(structuredType, model.Resolve("#//StructuredType"));
}
public static Set<IEntity> ResolveQualifiedName(INamespace root, string qualifiedName)
{
INamespace current = root;
string[] parts = qualifiedName.Split('.');
for (int i=0; i < parts.Length - 1; ++i)
current = (INamespace) ResolveSingle(current, parts[i]);
var result = new Set<IEntity>();
current.Resolve(result, parts[parts.Length - 1], EntityType.Any);
return result;
}
/// <summary>
/// Creates a new merged root namespace.
/// </summary>
/// <param name="compilation">The main compilation.</param>
/// <param name="namespaces">The individual namespaces being merged.</param>
/// <param name="externAlias">The extern alias for this namespace.</param>
public MergedNamespace(ICompilation compilation, INamespace[] namespaces, string externAlias = null)
{
if (compilation == null)
throw new ArgumentNullException("compilation");
if (namespaces == null)
throw new ArgumentNullException("namespaces");
this.compilation = compilation;
this.namespaces = namespaces;
this.externAlias = externAlias;
}
public void AddNamespace (MemberLookup lookup, INamespace ns)
{
if (usedNamespaces.Contains (ns.Name))
return;
if (!IsAccessible (lookup, ns)) {
usedNamespaces.Add (ns.Name);
return;
}
usedNamespaces.Add (ns.Name);
result.Add (Factory.CreateNamespaceCompletionData (ns));
}
/// <summary>
/// Creates a new merged child namespace.
/// </summary>
/// <param name="parentNamespace">The parent merged namespace.</param>
/// <param name="namespaces">The individual namespaces being merged.</param>
public MergedNamespace(INamespace parentNamespace, INamespace[] namespaces)
{
if (parentNamespace == null)
throw new ArgumentNullException("parentNamespace");
if (namespaces == null)
throw new ArgumentNullException("namespaces");
this.parentNamespace = parentNamespace;
this.namespaces = namespaces;
this.compilation = parentNamespace.Compilation;
this.externAlias = parentNamespace.ExternAlias;
}
public static bool ResolveCoalescingNamespaces(INamespace parent, INamespace namespaceToResolveAgainst, string name, EntityType typesToConsider, ICollection<IEntity> resultingSet)
{
var resolved = AcquireSet();
try {
if (!namespaceToResolveAgainst.Resolve(resolved, name, typesToConsider))
return false;
return CoalesceResolved(resolved, parent, name, resultingSet);
}
finally {
ReleaseSet(resolved);
}
}
public static INamespace CoalescedNamespaceFor(INamespace parent, string name, List<INamespace> namespaces)
{
switch (namespaces.Count)
{
case 0:
return null;
case 1:
return namespaces.First();
default:
return new ResolvedNamespaces(name, parent, namespaces.ToArray());
}
}
private static void CollectAllMembers(List<IEntity> members, INamespace entity)
{
var type = entity as IType;
if (null != type)
{
members.ExtendUnique(type.GetMembers());
CollectBaseTypeMembers(members, type.BaseType);
}
else
{
members.Extend(entity.GetMembers());
}
}
public static bool ResolveCoalescingNamespaces(INamespace parent, IEnumerable<INamespace> namespacesToResolveAgainst, string name, EntityType typesToConsider, ICollection<IEntity> resultingSet)
{
bool success = false;
var resolved = new Set<IEntity>();
foreach (var root in namespacesToResolveAgainst)
if (root.Resolve(resolved, name, typesToConsider))
success = true;
if (!success)
return false;
return CoalesceResolved(resolved, parent, name, resultingSet);
}
public void WriteNamespace(INamespace namespaceDeclaration)
{
if (_injectXmlDoc)
{
// inject XML documentation into generated namespace
string nsStr = GetNamespaceAsString(namespaceDeclaration);
_formatter.Write(nsStr);
}
else
{
// write it as the original implementor does it
_writer.WriteNamespace(namespaceDeclaration);
}
}
private static bool CoalesceResolved(IEnumerable<IEntity> resolved, INamespace parent, string name, ICollection<IEntity> resultingSet)
{
var namespaces = new List<INamespace>();
foreach (IEntity entity in resolved)
{
if (entity.EntityType == EntityType.Namespace)
namespaces.Add((INamespace) entity);
else
resultingSet.Add(entity);
}
INamespace resolvedNamespace = CoalescedNamespaceFor(parent, name, namespaces);
if (resolvedNamespace != null)
resultingSet.Add(resolvedNamespace);
return true;
}
public bool Compile(List<Input> inputs)
{
this.inputs = inputs;
var parser = new CSharpParser();
var project = (IProjectContent)new CSharpProjectContent();
// Parse each input
var parsing = Stopwatch.StartNew();
foreach (var input in inputs) {
input.tree = parser.Parse(input.contents, input.name);
input.file = input.tree.ToTypeSystem();
project = project.AddOrUpdateFiles(input.file);
}
timingInMilliseconds["Parsing"] = parsing.ElapsedMilliseconds;
// Add errors and warnings
foreach (var diagnostic in parser.ErrorsAndWarnings) {
diagnostics.Add(diagnostic);
}
// Compilation fails for parse errors
if (parser.HasErrors) {
return false;
}
// Scan the type system
var compiling = Stopwatch.StartNew();
compilation = project.CreateCompilation();
root = compilation.RootNamespace;
ScanTypes(root);
timingInMilliseconds["Compiling"] = compiling.ElapsedMilliseconds;
// Scan the syntax tree, linking it to the type system
var visitor = new Visitor(this);
foreach (var input in inputs) {
visitor.resolver = input.resolver = new CSharpAstResolver(compilation, input.tree, input.file);
input.tree.AcceptVisitor(visitor);
}
// Transform the syntax tree into valid JavaScript
var lowering = Stopwatch.StartNew();
var success = LoweringContext.Lower(this);
timingInMilliseconds["Lowering"] = lowering.ElapsedMilliseconds;
return success;
}
public static bool ResolveCoalescingNamespaces(INamespace parent, IList<INamespace> namespacesToResolveAgainst, string name, EntityType typesToConsider, ICollection<IEntity> resultingSet)
{
bool success = false;
var resolved = AcquireSet();
try {
//foreach (var root in namespacesToResolveAgainst)
for (int i = 0; i < namespacesToResolveAgainst.Count; ++i)
if (namespacesToResolveAgainst[i].Resolve(resolved, name, typesToConsider))
success = true;
if (!success)
return false;
return CoalesceResolved(resolved, parent, name, resultingSet);
}
finally {
ReleaseSet(resolved);
}
}
protected INamespace SafeGetNamespace(string qname)
{
INamespace ns = (INamespace)NameResolutionService.ResolveQualifiedName(qname);
return(null == ns ? NullNamespace.Default : ns);
}
public ClassOutputModel(string type, INamespace ns, IDesignModel designModel, IProjectFile file = null) : base(type, ns, designModel, file)
{
}
public void LeaveNamespace()
{
CurrentNamespace = CurrentNamespace.ParentNamespace;
}
internal void AddChild(INamespace ns)
{
_children.Add(ns);
}
public string GetOutputFolderPath(INamespace classNamespace)
{
return(this.GetNamespaceName(classNamespace).Replace(".", "/"));
}
public NamespaceImpl(string name, INamespace nsp = null)
{
Namespace = nsp;
nsp?.Members.Add(this);
Name = name;
}
private void SearchInTheCode(string sQuery)
{
lstResults.Items.Clear();
object value = this.assemblyBrowser.ActiveItem;
TextFormatter formatter = new TextFormatter();
ILanguage language = this.languageManager.ActiveLanguage;
if ((language == null) || (formatter == null))
{
return;
}
// is selected item an assembly
IAssembly assembly = value as IAssembly;
if (assembly != null)
{
try
{
bCountAtModuleLevel = true;
pgBar.Maximum = 0;
foreach (IModule m in assembly.Modules)
{
pgBar.Maximum = pgBar.Maximum + m.Types.Count;
}
SearchInAssembly(value);
}
finally
{
pgBar.Value = 0;
bCountAtModuleLevel = false;
}
return;
}
if (this.bIsCanceledRequired)
{
return;
}
// is selected item a module
IModule module = value as IModule;
if (module != null)
{
try
{
bCountAtModuleLevel = true;
pgBar.Maximum = module.Types.Count;
SearchInModule(value);
}
finally
{
pgBar.Value = 0;
bCountAtModuleLevel = false;
}
return;
}
if (this.bIsCanceledRequired)
{
return;
}
// is selected item a namespace
INamespace namespaceDeclaration = value as INamespace;
if (namespaceDeclaration != null)
{
try
{
bCountAtNSLevel = true;
pgBar.Maximum = namespaceDeclaration.Types.Count;
SearchInNameSpace(value);
}
finally
{
pgBar.Value = 0;
bCountAtNSLevel = false;
}
return;
}
if (this.bIsCanceledRequired)
{
return;
}
// is selected item a type
ITypeDeclaration typeDeclaration = value as ITypeDeclaration;
if (typeDeclaration != null)
{
try
{
bCountAtTypeLevel = true;
pgBar.Maximum = typeDeclaration.Methods.Count;
SearchInType(value);
}
finally
{
pgBar.Value = 0;
bCountAtTypeLevel = false;
}
return;
}
if (this.bIsCanceledRequired)
{
return;
}
// is selected item a method
IMethodDeclaration methodDeclaration = value as IMethodDeclaration;
if (methodDeclaration != null)
{
SearchInMethod(value);
return;
}
}
public NamespaceResolveResult(INamespace ns) : base(SpecialType.UnknownType)
{
this.ns = ns;
}
private void PopulateAssemblyTypes(List<StaticDeclaredTypeWrapper> types, INamespace namespaceHandle,
IDeclarationsCache cache, bool includeNonPublicTypes)
{
if (namespaceHandle == null || ! namespaceHandle.IsValid())
return;
foreach (IDeclaredElement elementHandle in namespaceHandle.GetNestedElements(cache))
{
ITypeElement typeHandle = elementHandle as ITypeElement;
if (typeHandle != null)
{
PopulateAssemblyTypes(types, typeHandle, includeNonPublicTypes);
}
else
{
INamespace nestedNamespace = elementHandle as INamespace;
if (nestedNamespace != null)
PopulateAssemblyTypes(types, nestedNamespace, cache, includeNonPublicTypes);
}
}
}
public ClassModel(string name, string type, INamespace ns, IXmlElement element = null, IParseLocationInfo parseLocation = null)
: base(name, type, ns, element, parseLocation)
{
}
internal static UsedNamespaceOrType CreateNamespace(INamespace @namespace, IAssemblyReference assemblyOpt = null, string aliasOpt = null)
{
Debug.Assert(@namespace != null);
return(new UsedNamespaceOrType(alias: aliasOpt, targetAssembly: assemblyOpt, targetNamespace: @namespace));
}
public DocumentElement(IEnumerable <IUsing> usings, INamespace @namespace, IClass @class)
: this(usings, @namespace, new List <IClass> {
@class
})
{
}
public string GetNamespaceName(INamespace classNamespace)
{
return(classNamespace.Name);
}
public DocumentElement(IEnumerable <IUsing> usings, INamespace @namespace, IEnumerable <IClass> classes)
{
this.Usings = usings;
this.Namespace = @namespace;
this.Classes = classes;
}
public ClassOutputModelBuilder CreateInterface(string className, INamespace classNamespace = null)
{
CreateClassInternal(className, classNamespace, true);
return(this);
}
/// <inheritdoc/>
public virtual void VisitNamespace(INamespace @namespace)
{
}
private static void FlattenChildNamespaces(ICollection <INamespace> resultingList, INamespace ns)
{
foreach (IEntity ent in ns.GetMembers())
{
if (EntityType.Namespace != ent.EntityType)
{
continue;
}
INamespace nsEnt = (INamespace)ent;
resultingList.Add(nsEnt);
FlattenChildNamespaces(resultingList, nsEnt);
}
}
public IEntity Resolve(INamespace ns, string name)
{
return(Resolve(ns, name, EntityType.Any));
}
ICompletionData ICompletionDataFactory.CreateNamespaceCompletionData(INamespace name)
{
return(new CompletionData(name.Name, AstStockIcons.Namespace));
}
private bool ResolveCoalescingNamespaces(INamespace ns, string name, EntityType elementType, ICollection <IEntity> resultingSet)
{
return(Namespaces.ResolveCoalescingNamespaces(ns.ParentNamespace, ns, name, elementType, resultingSet));
}
public static bool NeedsQualificationFor(this Node node, INamespace ns)
{
return(node.GetAncestors <Import>().Any(imp => imp.Namespace == ns.FullName));
}
protected void EnterNamespace(INamespace ns)
{
NameResolutionService.EnterNamespace(ns);
}
///////////////////////////////////////////////////////////////////////
#region IExecute Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
ReturnCode code;
//
// NOTE: *WARNING* We do NOT actually support namespaces. This
// command exists for the sole purpose of improving source
// code compatibility with simple stand alone scripts that
// may simply wrap themselves in a "namespace eval" block,
// etc. Any other (more involved) use may not work at all
// or may cause undesired and/or unpredictable results.
//
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 2)
{
string subCommand = arguments[1];
bool tried = false;
code = ScriptOps.TryExecuteSubCommandFromEnsemble(
interpreter, this, clientData, arguments, true,
false, ref subCommand, ref tried, ref result);
if ((code == ReturnCode.Ok) && !tried)
{
switch (subCommand)
{
case "children":
{
if ((arguments.Count >= 2) && (arguments.Count <= 4))
{
string name = null;
if (arguments.Count >= 3)
{
name = arguments[2];
}
string pattern = null;
if (arguments.Count >= 4)
{
pattern = arguments[3];
}
IEnumerable <INamespace> children = NamespaceOps.Children(
interpreter, name, pattern, false, ref result);
if (children != null)
{
StringList list = new StringList();
foreach (INamespace child in children)
{
list.Add(child.QualifiedName);
}
result = list;
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"namespace children ?name? ?pattern?\"";
code = ReturnCode.Error;
}
break;
}
case "code":
{
if (arguments.Count == 3)
{
string text = arguments[2];
if (!NamespaceOps.IsSubCommand(interpreter, text, "inscope"))
{
INamespace currentNamespace = null;
code = interpreter.GetCurrentNamespaceViaResolvers(
null, LookupFlags.Default, ref currentNamespace,
ref result);
if (code == ReturnCode.Ok)
{
StringList list = new StringList();
list.Add(NamespaceOps.MakeAbsoluteName(
this.Name));
list.Add("inscope");
list.Add(NamespaceOps.MakeAbsoluteName(
currentNamespace.QualifiedName));
list.Add(text);
result = list;
}
}
else
{
result = text; /* COMPAT: Tcl. */
}
}
else
{
result = "wrong # args: should be \"namespace code script\"";
code = ReturnCode.Error;
}
break;
}
case "current":
{
if (arguments.Count == 2)
{
INamespace currentNamespace = null;
code = interpreter.GetCurrentNamespaceViaResolvers(
null, LookupFlags.Default, ref currentNamespace,
ref result);
if (code == ReturnCode.Ok)
{
if (currentNamespace != null)
{
result = currentNamespace.QualifiedName;
}
else
{
result = "current namespace is invalid";
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"namespace current\"";
code = ReturnCode.Error;
}
break;
}
case "delete":
{
if (arguments.Count >= 2)
{
for (int index = 2; index < arguments.Count; index++)
{
code = interpreter.DeleteNamespace(
VariableFlags.None, arguments[index], false,
ref result);
if (code != ReturnCode.Ok)
{
break;
}
}
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
else
{
result = "wrong # args: should be \"namespace delete ?name name ...?\"";
code = ReturnCode.Error;
}
break;
}
case "enable":
{
if ((arguments.Count >= 2) && (arguments.Count <= 4))
{
if (arguments.Count >= 3)
{
bool enabled = false;
code = Value.GetBoolean2(
arguments[2], ValueFlags.AnyBoolean,
interpreter.CultureInfo, ref enabled, ref result);
bool force = false;
if ((code == ReturnCode.Ok) && (arguments.Count >= 4))
{
code = Value.GetBoolean2(
arguments[3], ValueFlags.AnyBoolean,
interpreter.CultureInfo, ref force, ref result);
}
if (code == ReturnCode.Ok)
{
code = NamespaceOps.Enable(
interpreter, enabled, force, ref result);
}
}
if (code == ReturnCode.Ok)
{
result = interpreter.AreNamespacesEnabled();
}
}
else
{
result = "wrong # args: should be \"namespace enable ?enabled? ?force?\"";
code = ReturnCode.Error;
}
break;
}
case "eval":
{
if (arguments.Count >= 4)
{
string namespaceName = NamespaceOps.MapName(
interpreter, arguments[2]);
INamespace @namespace = NamespaceOps.Lookup(
interpreter, namespaceName, false, true,
ref result);
if (@namespace != null)
{
string name = StringList.MakeList("namespace eval", @namespace.QualifiedName);
ICallFrame frame = interpreter.NewNamespaceCallFrame(
name, CallFrameFlags.Evaluate | CallFrameFlags.UseNamespace,
arguments, @namespace, false);
interpreter.PushNamespaceCallFrame(frame);
if (arguments.Count == 4)
{
code = interpreter.EvaluateScript(arguments[3], ref result);
}
else
{
code = interpreter.EvaluateScript(arguments, 3, ref result);
}
if (code == ReturnCode.Error)
{
Engine.AddErrorInformation(interpreter, result,
String.Format("{0} (in namespace eval \"{1}\" script line {2})",
Environment.NewLine, NamespaceOps.MaybeQualifiedName(@namespace,
true), Interpreter.GetErrorLine(interpreter)));
}
/* IGNORED */
interpreter.PopNamespaceCallFrame(frame);
/* NO RESULT */
Engine.CleanupNamespacesOrComplain(interpreter);
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"namespace eval name arg ?arg ...?\"";
code = ReturnCode.Error;
}
break;
}
case "exists":
{
if (arguments.Count == 3)
{
result = ConversionOps.ToInt(NamespaceOps.Lookup(
interpreter, arguments[2], false, false) != null);
}
else
{
result = "wrong # args: should be \"namespace exists name\"";
code = ReturnCode.Error;
}
break;
}
case "export":
{
if (arguments.Count >= 2)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-clear", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
if (arguments.Count > 2)
{
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
bool clear = false;
if (options.IsPresent("-clear"))
{
clear = true;
}
StringList patterns = new StringList();
if (argumentIndex != Index.Invalid)
{
patterns.AddObjects(ArgumentList.GetRange(arguments, argumentIndex));
}
code = NamespaceOps.Export(interpreter, null, patterns, clear, ref result);
}
}
else
{
result = "wrong # args: should be \"namespace export ?-clear? ?pattern pattern ...?\"";
code = ReturnCode.Error;
}
break;
}
case "forget":
{
if (arguments.Count >= 2)
{
if (arguments.Count >= 3)
{
code = NamespaceOps.Forget(interpreter,
new StringList(ArgumentList.GetRange(arguments, 2)),
ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
else
{
result = String.Empty;
code = ReturnCode.Ok;
}
}
else
{
result = "wrong # args: should be \"namespace forget ?pattern pattern ...?\"";
code = ReturnCode.Error;
}
break;
}
case "import":
{
if (arguments.Count >= 2)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-force", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
if (arguments.Count > 2)
{
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
bool force = false;
if (options.IsPresent("-force"))
{
force = true;
}
StringList patterns = new StringList();
if (argumentIndex != Index.Invalid)
{
patterns.AddObjects(ArgumentList.GetRange(arguments, argumentIndex));
}
code = NamespaceOps.Import(interpreter, patterns, force, ref result);
}
}
else
{
result = "wrong # args: should be \"namespace import ?-force? ?pattern pattern ...?\"";
code = ReturnCode.Error;
}
break;
}
case "info":
{
if (arguments.Count == 3)
{
code = NamespaceOps.InfoSubCommand(
interpreter, arguments[2], ref result);
}
else
{
result = "wrong # args: should be \"namespace info name\"";
code = ReturnCode.Error;
}
break;
}
case "inscope":
{
if (arguments.Count >= 4)
{
string namespaceName = NamespaceOps.MapName(
interpreter, arguments[2]);
INamespace @namespace = NamespaceOps.Lookup(
interpreter, namespaceName, false, false,
ref result);
if (@namespace != null)
{
if (arguments.Count > 4)
{
IScriptLocation location = null;
#if DEBUGGER && BREAKPOINTS
code = ScriptOps.GetLocation(
interpreter, arguments, 3, ref location,
ref result);
if (code == ReturnCode.Ok)
#endif
{
string name = StringList.MakeList("namespace inscope", @namespace.QualifiedName);
ICallFrame frame = interpreter.NewNamespaceCallFrame(
name, CallFrameFlags.InScope | CallFrameFlags.UseNamespace,
arguments, @namespace, false);
interpreter.PushNamespaceCallFrame(frame);
StringList list = new StringList(arguments, 4);
code = interpreter.EvaluateScript(
ListOps.Concat(arguments[3], list.ToString()),
location, ref result);
if (code == ReturnCode.Error)
{
Engine.AddErrorInformation(interpreter, result,
String.Format("{0} (in namespace inscope \"{1}\" script line {2})",
Environment.NewLine, NamespaceOps.MaybeQualifiedName(@namespace,
true), Interpreter.GetErrorLine(interpreter)));
}
/* IGNORED */
interpreter.PopNamespaceCallFrame(frame);
/* NO RESULT */
Engine.CleanupNamespacesOrComplain(interpreter);
}
}
else
{
string name = StringList.MakeList("namespace inscope", @namespace.QualifiedName);
ICallFrame frame = interpreter.NewNamespaceCallFrame(
name, CallFrameFlags.InScope | CallFrameFlags.UseNamespace,
arguments, @namespace, false);
interpreter.PushNamespaceCallFrame(frame);
code = interpreter.EvaluateScript(arguments[3], ref result);
if (code == ReturnCode.Error)
{
Engine.AddErrorInformation(interpreter, result,
String.Format("{0} (in namespace inscope \"{1}\" script line {2})",
Environment.NewLine, NamespaceOps.MaybeQualifiedName(@namespace,
true), Interpreter.GetErrorLine(interpreter)));
}
/* IGNORED */
interpreter.PopNamespaceCallFrame(frame);
/* NO RESULT */
Engine.CleanupNamespacesOrComplain(interpreter);
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"namespace inscope name arg ?arg...?\"";
code = ReturnCode.Error;
}
break;
}
case "mappings":
{
if (arguments.Count == 2)
{
lock (interpreter.SyncRoot) /* TRANSACTIONAL */
{
StringDictionary namespaceMappings = interpreter.NamespaceMappings;
if (namespaceMappings != null)
{
result = namespaceMappings.KeysAndValuesToString(null, false);
code = ReturnCode.Ok;
}
else
{
result = "namespace mappings not available";
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"namespace mappings\"";
code = ReturnCode.Error;
}
break;
}
case "name":
{
if (arguments.Count == 3)
{
string name = arguments[2];
if (!NamespaceOps.IsQualifiedName(name))
{
result = NamespaceOps.MakeQualifiedName(interpreter, name, true);
code = ReturnCode.Ok;
}
else
{
result = "only non-qualified names are allowed";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"namespace name name\"";
code = ReturnCode.Error;
}
break;
}
case "origin":
{
if (arguments.Count == 3)
{
code = NamespaceOps.Origin(interpreter, null, arguments[2], ref result);
}
else
{
result = "wrong # args: should be \"namespace origin name\"";
code = ReturnCode.Error;
}
break;
}
case "parent":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
code = NamespaceOps.Parent(
interpreter, (arguments.Count == 3) ? arguments[2] : null,
ref result);
}
else
{
result = "wrong # args: should be \"namespace parent ?name?\"";
code = ReturnCode.Error;
}
break;
}
case "qualifiers":
{
if (arguments.Count == 3)
{
string qualifiers = null;
string tail = null;
code = NamespaceOps.SplitName(
arguments[2], ref qualifiers, ref tail, ref result);
if (code == ReturnCode.Ok)
{
result = qualifiers;
}
}
else
{
result = "wrong # args: should be \"namespace qualifiers string\"";
code = ReturnCode.Error;
}
break;
}
case "rename":
{
if (arguments.Count == 4)
{
code = interpreter.RenameNamespace(
arguments[2], arguments[3], RenameGlobalOk,
RenameInUseOk, ref result);
}
else
{
result = "wrong # args: should be \"namespace rename oldName newName\"";
code = ReturnCode.Error;
}
break;
}
case "tail":
{
if (arguments.Count == 3)
{
string qualifiers = null;
string tail = null;
code = NamespaceOps.SplitName(
arguments[2], ref qualifiers, ref tail, ref result);
if (code == ReturnCode.Ok)
{
result = tail;
}
}
else
{
result = "wrong # args: should be \"namespace tail string\"";
code = ReturnCode.Error;
}
break;
}
case "unknown":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
INamespace currentNamespace = null;
code = interpreter.GetCurrentNamespaceViaResolvers(
null, LookupFlags.Default, ref currentNamespace,
ref result);
if (code == ReturnCode.Ok)
{
if (currentNamespace != null)
{
if (arguments.Count == 3)
{
string unknown = StringOps.NullIfEmpty(arguments[2]);
if (String.IsNullOrEmpty(unknown) &&
NamespaceOps.IsGlobal(interpreter, currentNamespace))
{
currentNamespace.Unknown = interpreter.GlobalUnknown;
}
else
{
currentNamespace.Unknown = unknown;
}
result = unknown;
}
else
{
result = currentNamespace.Unknown;
}
}
else
{
if (arguments.Count == 3)
{
string unknown = StringOps.NullIfEmpty(arguments[2]);
if (String.IsNullOrEmpty(unknown))
{
interpreter.GlobalUnknown = TclVars.Unknown;
}
else
{
interpreter.GlobalUnknown = unknown;
}
result = unknown;
}
else
{
result = interpreter.GlobalUnknown;
}
}
}
}
else
{
result = "wrong # args: should be \"namespace unknown ?script?\"";
code = ReturnCode.Error;
}
break;
}
case "which":
{
if (arguments.Count >= 2)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-command", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-variable", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
if (arguments.Count > 2)
{
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, OptionBehaviorFlags.LastIsNonOption, false, ref argumentIndex, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
if ((argumentIndex != Index.Invalid) &&
((argumentIndex + 1) == arguments.Count))
{
string name = arguments[argumentIndex];
bool isCommand = false;
if (options.IsPresent("-command"))
{
isCommand = true;
}
bool isVariable = false;
if (options.IsPresent("-variable"))
{
isVariable = true;
}
if (!isCommand || !isVariable)
{
NamespaceFlags flags = NamespaceFlags.None;
if (isCommand)
{
flags |= NamespaceFlags.Command;
}
else if (isVariable)
{
flags |= NamespaceFlags.Variable;
}
else
{
flags |= NamespaceFlags.Command;
}
code = NamespaceOps.Which(interpreter, null, name, flags, ref result);
}
else
{
result = "wrong # args: should be \"namespace which ?-command? ?-variable? name\"";
code = ReturnCode.Error;
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"namespace which ?-command? ?-variable? name\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"namespace which ?-command? ?-variable? name\"";
code = ReturnCode.Error;
}
break;
}
default:
{
result = ScriptOps.BadSubCommand(
interpreter, null, null, subCommand, this, null, null);
code = ReturnCode.Error;
break;
}
}
}
}
else
{
result = "wrong # args: should be \"namespace subcommand ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
public string GetOutputFolderPath(INamespace classNamespace)
{
return(classNamespace.Name.Replace(".", "/"));
}
public GenericParametersNamespaceExtender(IType type, INamespace currentNamespace)
{
_type = type;
_parent = currentNamespace;
}
public static CompilerError MemberNotFound(MemberReferenceExpression node, INamespace @namespace, string suggestion)
{
return(MemberNotFound(node, node.Name, @namespace, suggestion));
}
public static CompilerError MemberNotFound(Node node, string memberName, INamespace @namespace, string suggestion)
{
return(Instantiate("BCE0019", node, memberName, @namespace, DidYouMeanOrNull(suggestion)));
}
public DummyNamespace(INamespace parentNamespace, string name)
{
this.parentNamespace = parentNamespace;
this.name = name;
}
public ProjectConfiguration(string type, INamespace ns, IXmlElement designModelElement, IProjectCollection projects)
: base(null, type, ns, designModelElement)
{
Projects = projects;
}
void ProcessNodeInMethodContext(InternalMethod entity, INamespace ns, Node node)
{
PushMethodInfo(entity);
EnterNamespace(ns);
try
{
Visit(node);
}
finally
{
LeaveNamespace();
PopMethodInfo();
}
}
public override void Rename(INamespace ns, string name)
{
RenameRefactoring.RenameNamespace(ns, name);
}
IEnumerable<IMethod> GetExtensionMethods(INamespace ns)
{
// TODO: maybe make this a property on INamespace?
return
from c in ns.Types
where c.IsStatic && c.HasExtensionMethods && c.TypeParameters.Count == 0
from m in c.Methods
where m.IsExtensionMethod
select m;
}
NamespaceDeclaration ConvertNamespaceDeclaration(INamespace ns)
{
return(new NamespaceDeclaration(ns.FullName));
}
