public void Remove (IAssemblyContext ctx)
{
if (sources.Remove (ctx)) {
ctx.Changed -= CtxChanged;
CtxChanged (null, null);
}
}
public bool Check(IAssemblyContext assemblyContext, IEnumerable<Dependency> dependencies)
{
bool result = true;
int reorgCount = 0;
int nextReorg = 200;
foreach (Dependency d in dependencies) {
// The group is the globale one (""); or the dependency's left side
// matches the group's pattern:
Dependency d1 = d;
if (_groupRegexes == null || _groupRegexes.Any(r => Regex.IsMatch(d1.UsingItem, r))) {
//if (_groupRegexes != null) {
// _groupRegexes.ToString();
//}
result &= Check(assemblyContext, d);
if (++reorgCount > nextReorg) {
_forbidden.Sort(_sortOnDescendingHitCount);
_allowed.Sort(_sortOnDescendingHitCount);
_questionable.Sort(_sortOnDescendingHitCount);
nextReorg = 6 * nextReorg / 5 + 200;
}
}
}
return result;
}
public void Replace (IAssemblyContext oldCtx, IAssemblyContext newCtx)
{
int i = sources.IndexOf (oldCtx);
if (i != -1) {
sources [i] = newCtx;
CtxChanged (null, null);
}
}
public void Remove (IAssemblyContext ctx)
{
var prev = sources;
sources = sources.Remove (ctx);
if (sources != prev) {
ctx.Changed -= CtxChanged;
CtxChanged (null, null);
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.AssemblyContext_ComponentSpecifiedExecutionTime == null))
{
IAssemblyContext assemblyContext_ComponentSpecifiedExecutionTimeCasted = item.As <IAssemblyContext>();
if ((assemblyContext_ComponentSpecifiedExecutionTimeCasted != null))
{
this._parent.AssemblyContext_ComponentSpecifiedExecutionTime = assemblyContext_ComponentSpecifiedExecutionTimeCasted;
return;
}
}
}
public MakefileData ()
{
relativeMakefileName = String.Empty;
buildTargetName = "all";
cleanTargetName = "clean";
executeTargetName = String.Empty;
ParallelProcesses = 1;
assemblyContext = GetMonoRuntimeContext ();
if (assemblyContext == null)
integrationEnabled = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildTarget"/> class.
/// </summary>
/// <param name="targetAssemblyPath">Path of the target assembly being built.</param>
/// <param name="outputAssemblyPath">Path for the output assembly.</param>
/// <param name="assembly"><see cref="Assembly"/> being built.</param>
/// <param name="assemblyContext"><see cref="AssemblyContext"/> for the <see cref="Assembly"/> being built.</param>
public BuildTarget(
string targetAssemblyPath,
string outputAssemblyPath,
Assembly assembly,
IAssemblyContext assemblyContext)
{
TargetAssemblyPath = targetAssemblyPath;
OutputAssemblyPath = outputAssemblyPath;
Assembly = assembly;
AssemblyContext = assemblyContext;
AssemblyName = assembly.GetName();
}
/// <summary>
/// Retrieve the matching type in the Cecil object model
/// </summary>
/// <param name="tdec">Reflector type declaration</param>
/// <returns>Cecil type definition (null if not found)</returns>
public static TypeDefinition ReflectorTypeToCecilType(ITypeDeclaration tdec)
{
IModule moddec = GetModule(tdec);
IAssemblyContext context = PluginFactory.GetInstance().GetAssemblyContext(moddec.Location);
if (context != null)
{
return(FindMatchingType(context.AssemblyDefinition, tdec));
}
return(null);
}
public void SetProject(DotNetProject netProject)
{
selection.Clear();
configureProject = netProject;
if (netProject != null)
{
SetTargetFramework(netProject.AssemblyContext, netProject.TargetFramework);
Reset();
}
else
{
targetContext = null;
targetVersion = null;
store.Clear();
}
}
public void HandleItem(object item)
{
string location = PluginFactory.GetInstance().GetModuleLocation(item);
IAssemblyContext context = PluginFactory.GetInstance().GetAssemblyContext(location);
if (context != null)
{
m_mdef = context.AssemblyDefinition.MainModule;
}
else
{
m_mdef = null;
}
Definition.Bind(m_mdef);
CustomAttributes.Bind(m_mdef);
}
/// <summary>
/// Check all dependencies against dependency rules created
/// with <c>AddDependencyRules</c>.
/// </summary>
/// <returns>true if no dependencies is illegal according to our rules</returns>
public bool Check(IAssemblyContext assemblyContext, IEnumerable<DependencyRuleGroup> groups, IEnumerable<Dependency> dependencies, bool showUnusedQuestionableRules)
{
bool result = true;
foreach (var g in groups) {
result &= g.Check(assemblyContext, dependencies);
}
foreach (DependencyRuleRepresentation r in _representations) {
if (showUnusedQuestionableRules && r.IsQuestionableRule && !r.WasHit) {
Log.WriteInfo("Questionable rule " + r + " was never matched - maybe you can remove it!");
} else {
if (Log.IsVerboseEnabled) {
Log.WriteInfo("Rule " + r + " was hit " + r.HitCount + " times.");
}
}
}
return result;
}
private void LoadNodeOnDemand(TreeNode node)
{
if (node.Nodes.ContainsKey(EXPANDER_NODE_KEY))
{
node.Nodes.RemoveAt(node.Nodes.IndexOfKey(EXPANDER_NODE_KEY));
}
if ((node.Tag) is IReflectionVisitable)
{
IReflectionVisitable visitable = (IReflectionVisitable)node.Tag;
if (!m_visiteditems.ContainsKey(visitable))
{
visitable.Accept(this);
m_visiteditems.Add(visitable, visitable);
}
}
else if ((node.Tag) is IAssemblyWrapper)
{
IAssemblyWrapper iasm = (IAssemblyWrapper)node.Tag;
IAssemblyContext context = PluginFactory.GetInstance().GetAssemblyContext(iasm.Location);
if (context != null)
{
AssemblyDefinition asmdef = context.AssemblyDefinition;
if ((AssemblyRestriction == null) || (asmdef == AssemblyRestriction))
{
m_nodes.Remove(node.Tag);
m_nodes.Add(asmdef, node);
node.Tag = asmdef;
foreach (ModuleDefinition moddef in asmdef.Modules)
{
AppendNode(asmdef, moddef, moddef.Types.Count > 0);
}
}
else
{
node.Tag = "restricted";
node.Text += String.Format(" (You can't use this assembly for selection -> restricted to {0})", AssemblyRestriction.Name.Name);
}
}
}
}
public override void Compile(IAssemblyContext context)
{
var cmd = new StringBuilder("gcc -Wall -shared -o ");
cmd.Append(context.OutputFile);
foreach (var code in context.Types.SelectMany(t => t.MethodContexts))
cmd.AppendFormat(" {0}", code.OutputFile);
string output;
string error;
if (Helper.Execute(cmd.ToString(), out error, out output) == 0)
{
if (!string.IsNullOrEmpty(error))
Helper.Break();
return;
}
Helper.Stop(new ApplicationException(error + output));
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Interface == null))
{
IInterface interfaceCasted = item.As <IInterface>();
if ((interfaceCasted != null))
{
this._parent.Interface = interfaceCasted;
return;
}
}
if ((this._parent.ConnectedAssemblyContext == null))
{
IAssemblyContext connectedAssemblyContextCasted = item.As <IAssemblyContext>();
if ((connectedAssemblyContextCasted != null))
{
this._parent.ConnectedAssemblyContext = connectedAssemblyContextCasted;
return;
}
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Assembly == null))
{
IAssemblyContext assemblyCasted = item.As <IAssemblyContext>();
if ((assemblyCasted != null))
{
this._parent.Assembly = assemblyCasted;
return;
}
}
if ((this._parent.Container == null))
{
FZI.SoftwareEngineering.DeepModeling.TwoLevelADL.Deployment.IContainer containerCasted = item.As <FZI.SoftwareEngineering.DeepModeling.TwoLevelADL.Deployment.IContainer>();
if ((containerCasted != null))
{
this._parent.Container = containerCasted;
return;
}
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
IAssemblyContext encapsulatedContextsCasted = item.As <IAssemblyContext>();
if ((encapsulatedContextsCasted != null))
{
this._parent.EncapsulatedContexts.Add(encapsulatedContextsCasted);
}
IDelegateConnector delegateConnectorsCasted = item.As <IDelegateConnector>();
if ((delegateConnectorsCasted != null))
{
this._parent.DelegateConnectors.Add(delegateConnectorsCasted);
}
IAssemblyConnector connectorsCasted = item.As <IAssemblyConnector>();
if ((connectorsCasted != null))
{
this._parent.Connectors.Add(connectorsCasted);
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Assembly == null))
{
IAssemblyContext assemblyCasted = item.As <IAssemblyContext>();
if ((assemblyCasted != null))
{
this._parent.Assembly = assemblyCasted;
return;
}
}
if ((this._parent.Container == null))
{
IContainer_MM06 containerCasted = item.As <IContainer_MM06>();
if ((containerCasted != null))
{
this._parent.Container = containerCasted;
return;
}
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.SinkRole__EventChannelSinkConnector == null))
{
ISinkRole sinkRole__EventChannelSinkConnectorCasted = item.As <ISinkRole>();
if ((sinkRole__EventChannelSinkConnectorCasted != null))
{
this._parent.SinkRole__EventChannelSinkConnector = sinkRole__EventChannelSinkConnectorCasted;
return;
}
}
if ((this._parent.FilterCondition__EventChannelSinkConnector == null))
{
IPCMRandomVariable filterCondition__EventChannelSinkConnectorCasted = item.As <IPCMRandomVariable>();
if ((filterCondition__EventChannelSinkConnectorCasted != null))
{
this._parent.FilterCondition__EventChannelSinkConnector = filterCondition__EventChannelSinkConnectorCasted;
return;
}
}
if ((this._parent.AssemblyContext__EventChannelSinkConnector == null))
{
IAssemblyContext assemblyContext__EventChannelSinkConnectorCasted = item.As <IAssemblyContext>();
if ((assemblyContext__EventChannelSinkConnectorCasted != null))
{
this._parent.AssemblyContext__EventChannelSinkConnector = assemblyContext__EventChannelSinkConnectorCasted;
return;
}
}
if ((this._parent.EventChannel__EventChannelSinkConnector == null))
{
IEventChannel eventChannel__EventChannelSinkConnectorCasted = item.As <IEventChannel>();
if ((eventChannel__EventChannelSinkConnectorCasted != null))
{
this._parent.EventChannel__EventChannelSinkConnector = eventChannel__EventChannelSinkConnectorCasted;
return;
}
}
}
private bool Check(IAssemblyContext assemblyContext, Dependency d)
{
bool ok = false;
if (Log.IsVerboseEnabled)
{
Log.WriteInfo("Checking " + d);
}
if (_forbidden.Any(r => r.Matches(d)))
{
goto DONE;
}
if (_allowed.Any(r => r.Matches(d)))
{
ok = true;
goto DONE;
}
if (_questionable.Any(r => r.Matches(d)))
{
var ruleViolation = new RuleViolation(d, ViolationType.Warning);
Log.WriteViolation(ruleViolation);
if (assemblyContext != null)
{
assemblyContext.Add(ruleViolation);
}
ok = true;
}
DONE:
if (!ok)
{
var ruleViolation = new RuleViolation(d, ViolationType.Error);
Log.WriteViolation(ruleViolation);
if (assemblyContext != null)
{
assemblyContext.Add(ruleViolation);
}
}
return(ok);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.ProvidedRole__AssemblyInfrastructureConnector == null))
{
IInfrastructureProvidedRole providedRole__AssemblyInfrastructureConnectorCasted = item.As <IInfrastructureProvidedRole>();
if ((providedRole__AssemblyInfrastructureConnectorCasted != null))
{
this._parent.ProvidedRole__AssemblyInfrastructureConnector = providedRole__AssemblyInfrastructureConnectorCasted;
return;
}
}
if ((this._parent.RequiredRole__AssemblyInfrastructureConnector == null))
{
IInfrastructureRequiredRole requiredRole__AssemblyInfrastructureConnectorCasted = item.As <IInfrastructureRequiredRole>();
if ((requiredRole__AssemblyInfrastructureConnectorCasted != null))
{
this._parent.RequiredRole__AssemblyInfrastructureConnector = requiredRole__AssemblyInfrastructureConnectorCasted;
return;
}
}
if ((this._parent.ProvidingAssemblyContext__AssemblyInfrastructureConnector == null))
{
IAssemblyContext providingAssemblyContext__AssemblyInfrastructureConnectorCasted = item.As <IAssemblyContext>();
if ((providingAssemblyContext__AssemblyInfrastructureConnectorCasted != null))
{
this._parent.ProvidingAssemblyContext__AssemblyInfrastructureConnector = providingAssemblyContext__AssemblyInfrastructureConnectorCasted;
return;
}
}
if ((this._parent.RequiringAssemblyContext__AssemblyInfrastructureConnector == null))
{
IAssemblyContext requiringAssemblyContext__AssemblyInfrastructureConnectorCasted = item.As <IAssemblyContext>();
if ((requiringAssemblyContext__AssemblyInfrastructureConnectorCasted != null))
{
this._parent.RequiringAssemblyContext__AssemblyInfrastructureConnector = requiringAssemblyContext__AssemblyInfrastructureConnectorCasted;
return;
}
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.ResourceContainer_AllocationContext == null))
{
IResourceContainer resourceContainer_AllocationContextCasted = item.As <IResourceContainer>();
if ((resourceContainer_AllocationContextCasted != null))
{
this._parent.ResourceContainer_AllocationContext = resourceContainer_AllocationContextCasted;
return;
}
}
if ((this._parent.AssemblyContext_AllocationContext == null))
{
IAssemblyContext assemblyContext_AllocationContextCasted = item.As <IAssemblyContext>();
if ((assemblyContext_AllocationContextCasted != null))
{
this._parent.AssemblyContext_AllocationContext = assemblyContext_AllocationContextCasted;
return;
}
}
if ((this._parent.Allocation_AllocationContext == null))
{
IAllocation allocation_AllocationContextCasted = item.As <IAllocation>();
if ((allocation_AllocationContextCasted != null))
{
this._parent.Allocation_AllocationContext = allocation_AllocationContextCasted;
return;
}
}
if ((this._parent.EventChannel__AllocationContext == null))
{
IEventChannel eventChannel__AllocationContextCasted = item.As <IEventChannel>();
if ((eventChannel__AllocationContextCasted != null))
{
this._parent.EventChannel__AllocationContext = eventChannel__AllocationContextCasted;
return;
}
}
}
/// <summary>
/// Check all dependencies against dependency rules created
/// with <c>AddDependencyRules</c>.
/// </summary>
/// <returns>true if no dependencies is illegal according to our rules</returns>
public bool Check(IAssemblyContext assemblyContext, IEnumerable <DependencyRuleGroup> groups, IEnumerable <Dependency> dependencies, bool showUnusedQuestionableRules)
{
bool result = true;
foreach (var g in groups)
{
result &= g.Check(assemblyContext, dependencies);
}
foreach (DependencyRuleRepresentation r in _representations)
{
if (showUnusedQuestionableRules && r.IsQuestionableRule && !r.WasHit)
{
Log.WriteInfo("Questionable rule " + r + " was never matched - maybe you can remove it!");
}
else
{
if (Log.IsVerboseEnabled)
{
Log.WriteInfo("Rule " + r + " was hit " + r.HitCount + " times.");
}
}
}
return(result);
}
public void SetTargetFramework(IAssemblyContext targetContext, TargetFramework targetVersion)
{
this.targetContext = targetContext;
this.targetVersion = targetVersion;
}
public ApplicationInstanceFactory(ISystemEnvironment systemEnvironment, IAssemblyContext assemblyContext, IConfigurationReader configurationReader)
{
_systemEnvironment = systemEnvironment;
_assemblyContext = assemblyContext;
_configurationReader = configurationReader;
}
public void Add (IAssemblyContext ctx)
{
sources.Add (ctx);
ctx.Changed += CtxChanged;
CtxChanged (null, null);
}
void AddRequiredPackages (IAssemblyContext assemblyContext, string variableName, string packageName, PackageContent packageContent)
{
SystemPackage package = assemblyContext.GetPackage (packageName);
if (package != null && !string.IsNullOrEmpty (package.Requires)) {
foreach (string requiredPackageName in package.Requires.Split (' ')) {
if (!pkgNameToPkgVarName.ContainsKey (requiredPackageName)) {
pkgNameToPkgVarName[requiredPackageName] = variableName;
packageContent.RequiredPackages.Add (requiredPackageName);
}
AddRequiredPackages (assemblyContext, variableName, requiredPackageName, packageContent);
}
}
}
public void Add(IAssemblyContext ctx)
{
sources.Add(ctx);
ctx.Changed += CtxChanged;
CtxChanged(null, null);
}
public override void Compile(IAssemblyContext context)
{
this.Stages.ForEach(stage => stage.Compile(context));
}
public void SetProject (DotNetProject netProject)
{
selection.Clear ();
configureProject = netProject;
if (netProject != null) {
SetTargetFramework (netProject.AssemblyContext, netProject.TargetFramework);
Reset ();
} else {
targetContext = null;
targetVersion = null;
store.Clear ();
}
}
/// <summary>
/// Adds all implementations from the specified assembly context.
/// </summary>
/// <param name="context">The context.</param>
public void Add(IAssemblyContext context)
{
this.Context = new MergedAssemblyContext(this.Context, context);
}
void RuntimeSystemAssemblyServiceDefaultRuntimeChanged (object sender, EventArgs e)
{
if (composedAssemblyContext != null) {
composedAssemblyContext.Replace (currentRuntimeContext, TargetRuntime.AssemblyContext);
currentRuntimeContext = TargetRuntime.AssemblyContext;
}
UpdateSystemReferences ();
}
public ApplicationInstanceFactory(ISystemEnvironment systemEnvironment, IAssemblyContext assemblyContext, IConfigurationReader configurationReader)
{
_systemEnvironment = systemEnvironment;
_assemblyContext = assemblyContext;
_configurationReader = configurationReader;
}
private bool Check(IAssemblyContext assemblyContext, Dependency d)
{
bool ok = false;
if (Log.IsVerboseEnabled) {
Log.WriteInfo("Checking " + d);
}
if (_forbidden.Any(r => r.Matches(d))) {
goto DONE;
}
if (_allowed.Any(r => r.Matches(d))) {
ok = true;
goto DONE;
}
if (_questionable.Any(r => r.Matches(d))) {
var ruleViolation = new RuleViolation(d, ViolationType.Warning);
Log.WriteViolation(ruleViolation);
if (assemblyContext != null) {
assemblyContext.Add(ruleViolation);
}
ok = true;
}
DONE:
if (!ok) {
var ruleViolation = new RuleViolation(d, ViolationType.Error);
Log.WriteViolation(ruleViolation);
if (assemblyContext != null) {
assemblyContext.Add(ruleViolation);
}
}
return ok;
}
/// <summary>
/// Instantiates and instance of <see cref="EventProcessorDiscoverer"/>
/// </summary>
/// <param name="assemblyContext"></param>
/// <param name="logger"></param>
public EventProcessorDiscoverer(IAssemblyContext assemblyContext, IBuildToolLogger logger)
{
_assemblyContext = assemblyContext;
_logger = logger;
}
/// <summary> /// Gets a proxy for the referenced value for a AssemblyContexts of the enclosing SystemArchitecture. /// </summary> public abstract INotifyValue <IResourceContainer> GetAssemblyContextsProxy(IAssemblyContext reference);
public abstract IResourceContainer GetAssemblyContextsValue(IAssemblyContext reference);
public void SetTargetFramework (IAssemblyContext targetContext, TargetFramework targetVersion)
{
this.targetContext = targetContext;
this.targetVersion = targetVersion;
}
/// <summary>
/// Instantiates and instance of <see cref="EventProcessorDiscoverer"/>
/// </summary>
/// <param name="assemblyContext"></param>
/// <param name="buildMessages"></param>
public EventProcessorDiscoverer(IAssemblyContext assemblyContext, IBuildMessages buildMessages)
{
_assemblyContext = assemblyContext;
_buildMessages = buildMessages;
}
