public void RemoveElement(bool join = false)
{
_primitives.RemoveAll(obj => obj.Container != null);
if (Connectors.RemoveAll(obj => true) > 0)
{
DisconnectSiblings();
RemovePowerLines();
}
if (Join.Any())
{
if (!join)
{
foreach (var j in Join)
{
j.RemoveElement(true);
}
}
Join.Clear();
}
Variables.Clear();
OverrideFunction = false;
Type = ElementType.None;
}
/// <summary>
/// Dispose the resources
/// </summary>
public override void Dispose()
{
Task.Run(() =>
{
ProgramDeclaration = null;
if (EntryPointInstance != null)
{
EntryPointInstance = null;
}
if (Variables != null)
{
foreach (var variable in Variables)
{
var value = variable.Value as IDisposable;
if (value != null)
{
value.Dispose();
}
}
Variables.Clear();
}
Variables = null;
if (Classes != null)
{
Classes.Clear();
}
Classes = null;
FreeWaiter();
FreeStepIntoOverOutWaiter();
});
}
public void LoadDataFromNsi(IEnumerable <string> lines)
{
Variables.Clear();
var filteredLines = lines.Where(x => x.ToLower().Contains("!define "));
var defineLength = "!define ".Length;
foreach (var line in filteredLines)
{
var temp = line.Remove(0, defineLength).Trim();
if (line.ToLower().Contains("\""))
{
var name = temp.Substring(0, temp.IndexOf(' '));
var value = temp.Replace(name, "").Replace("\"", "").Trim();
Variables.Add(new VariableModel
{
VariableName = name,
VariableValue = value,
UserDefined = true
});
}
else
{
Variables.Add(new VariableModel
{
VariableName = temp,
VariableValue = null,
UserDefined = false
});
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This method gets the updated content for the template.</summary>
///
/// <param name="parentModelContext">The parent model context from which to generate code.</param>
///
/// <returns>A string representing the generated code for the template.</returns>
///--------------------------------------------------------------------------------
public string GetContent(IDomainEnterpriseObject parentModelContext)
{
try
{
ContentCodeBuilder.Clear();
if (IsWatchTemplate == false)
{
// clear parameters and variables if not passed in for temporary watch templates
Parameters.Clear();
Variables.Clear();
}
if (ContentAST == null && TemplateContent != String.Empty)
{
ParseContent(Solution.IsSampleMode);
}
if (ContentAST != null && ContentAST.ChildNodes.Count > 0)
{
ContentAST.InterpretNode(InterpreterTypeCode.Content, Solution, this, GetTemplateModelContext(parentModelContext), null);
}
ContentCode = ContentCodeBuilder.ToString() + MessageBuilder.ToString();
return(ContentCode);
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
HasErrors = true;
Solution.ShowIssue(ex.Message + ex.StackTrace, DisplayValues.Exception_CodeGenerationTitle, Solution.IsSampleMode);
}
return(null);
}
///--------------------------------------------------------------------------------
/// <summary>This method generates the associated output path for the template.</summary>
///
/// <param name="parentModelContext">The parent model context from which to generate code.</param>
///
/// <returns>A string representing the generated code for the template.</returns>
///--------------------------------------------------------------------------------
public string GenerateOutput(IDomainEnterpriseObject parentModelContext)
{
try
{
MessageBuilder.Clear();
OutputCodeBuilder.Clear();
Parameters.Clear();
Variables.Clear();
if (OutputAST == null)
{
ParseOutput(Solution.IsSampleMode);
}
IDomainEnterpriseObject context = GetTemplateModelContext(parentModelContext);
if (OutputAST != null && OutputAST.ChildNodes.Count > 0)
{
OutputAST.InterpretNode(InterpreterTypeCode.Output, Solution, this, context, null);
OutputCode = OutputCodeBuilder.ToString() + MessageBuilder.ToString();
}
return(OutputCode);
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
HasErrors = true;
Solution.ShowIssue(ex.Message + ex.StackTrace, DisplayValues.Exception_CodeGenerationTitle, Solution.IsSampleMode);
}
return(null);
}
public void Start()
{
IsReady = false;
try
{
_runbookNameCache.Clear();
Runbooks.Clear();
Credentials.Clear();
Schedules.Clear();
Variables.Clear();
Modules.Clear();
Connections.Clear();
Tags.Clear();
Service.Load();
foreach (var rb in Runbooks)
{
_runbookNameCache.Add((rb.Tag as RunbookModelProxy).RunbookName);
}
Execute.OnUIThread(() => _statusManager.SetText(""));
}
catch (NotSupportedException)
{
// Ignore for now...
}
}
private void Reload()
{
var dtReader = new DataTableReader(testCaseCollectionManager.Scope.Content);
//Reset the state of the DataTable
//Remove the Sort Order or you'll be in troubles when loading the datatable
TestCases.DefaultView.Sort = String.Empty;
TestCases.Rows.Clear();
TestCases.Columns.Clear();
TestCases.RejectChanges();
//Load it
TestCases.Load(dtReader, LoadOption.PreserveChanges);
OnPropertyChanged("TestCases");
//Take care of variables
Variables.Clear();
foreach (var v in testCaseCollectionManager.Scope.Variables)
{
Variables.Add(v);
}
if (VariableSelectedIndex < 0 && Variables.Count > 0)
{
VariableSelectedIndex = 0;
}
}
public DataTable GetValues(string SortingType, string Format)
{
DataTable table = new DataTable();
table.Columns.Add("Переменная");
table.Columns.Add("Значение");
string otbor = String.Format("\"{0}{1}\"", Format, SortingType);
Answer answer = Database.SendGetAnswer(String.Format("USE {0}", this.DataBaseName), String.Format("VALUES FULL {0}", otbor));
if (answer.Info != Inf.OK)
{
answer.ShowMessage();
return(table);
}
Variables.Clear();
AnswerData data = answer.GetSerializedData(new string[] { "D| = ", "L|, " });
foreach (string val in data.GetEnumerable())
{
Value var = new Value(val, data[val].GetEnumerable().ToList());
if (SortingType == "" && Format == "")
{
Variables.Add(var);
}
table.Rows.Add(new object[] { val, var });
}
return(table);
}
public void FromString(string text)
{
Variables.Clear();
text.Deserialize()
.ApplySorting()
.ForEach(Variables.Add);
}
private static void Exit_Ini()
{
if (varsIni != null)
{
varsIni.Clear();
varsIni = null;
}
}
private static void Exit_Args()
{
if (varsArgs != null)
{
varsArgs.Clear();
varsArgs = null;
}
}
public void LoadVariablesFromFile(string fileName)
{
var lines = new List <string>();
if (File.Exists(fileName) == false)
{
return; // nothing to do.
}
using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var sr = new StreamReader(fs, Encoding.Default))
{
while (!sr.EndOfStream)
{
lines.Add(sr.ReadLine());
}
}
Variables.Clear();
LoadedVariableFile = fileName;
if (lines.Count > 0)
{
var headers = lines.First().ToLower().Split(',');
for (var i = 1; i < lines.Count; i++)
{
var data = lines[i].ToLower().Split(',');
var type = "unknown";
var name = "unknown";
for (var eIndex = 0; eIndex < data.Length && eIndex < headers.Length; eIndex++)
{
switch (headers[eIndex])
{
case "type":
type = data[eIndex];
break;
case "name":
name = data[eIndex];
break;
default:
throw new InvalidOperationException("Invalid parse column " + headers[eIndex]);
}
}
Variables.Add(type, name);
//VariableGrid.Items.Refresh();
}
ConfigHelper.Config.DefaultCSVPath = fileName;
// _dispatcher.Invoke(() =>
//{
//});
PropertyChanged(this, new PropertyChangedEventArgs(nameof(Variables)));
PropertyChanged(this, new PropertyChangedEventArgs(nameof(LoadedVariableFile)));
}
}
public StyleSheet Refresh()
{
Rules.Clear();
m_ResolvedSheet = null;
Variables.Clear();
ParentToChildren.Clear();
ChildToParent.Clear();
return(ResolvedSheet);
}
/// <summary>
/// Sets the patterns describing the variables that are assigned a new value.
/// </summary>
/// <param name="variables">The patterns describing the variables.</param>
/// <returns>The current pattern.</returns>
public AssignmentStatementPattern <TInstruction> WithVariables(params Pattern <IVariable>[] variables)
{
Variables.Clear();
foreach (var variable in variables)
{
Variables.Add(variable);
}
return(this);
}
/// <summary>
/// Indicates the pattern should match on instances with the provided number of variables on the left hand side.
/// </summary>
/// <param name="variablesCount">The number of variables the assignment statement should have.</param>
/// <returns>The current pattern.</returns>
public AssignmentStatementPattern <TInstruction> WithVariables(int variablesCount)
{
Variables.Clear();
for (int i = 0; i < variablesCount; i++)
{
Variables.Add(Pattern.Any <IVariable>());
}
return(this);
}
///--------------------------------------------------------------------------------
/// <summary>Interpret this node to produce content.</summary>
///
/// <param name="solutionContext">The associated solution.</param>
/// <param name="templateContext">The associated template.</param>
/// <param name="modelContext">The associated model context.</param>
/// <param name="appendToTemplateContext">Flag to append content.</param>
/// <param name="parameters">Template parameters.</param>
///--------------------------------------------------------------------------------
public void GenerateContent(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, bool appendToTemplateContext, NameObjectCollection parameters)
{
ModelContextStack = null;
PopCount = 0;
if (modelContext is Project)
{
BusinessConfiguration.CurrentProject = modelContext as Project;
}
PushModelContext(modelContext);
MessageBuilder.Clear();
ContentCodeBuilder.Clear();
Parameters.Clear();
Variables.Clear();
CurrentTabIndent = templateContext.CurrentTabIndent;
if (ContentAST == null && TemplateContent != String.Empty)
{
ParseContent(Solution.IsSampleMode);
}
if (Solution.UseTemplateCache == true && Solution.IsSampleMode == false && String.IsNullOrEmpty(TemplateOutput) && !String.IsNullOrEmpty(TemplateContent) && modelContext != null && CachedContent[modelContext.ID.ToString()] != null)
{
// use cached content
solutionContext.TemplatesExecuted++;
solutionContext.CachedTemplatesExecuted++;
ContentCodeBuilder.Append(CachedContent[modelContext.ID.ToString()] as String);
}
else
{
if (ContentAST != null)
{
ContentAST.InterpretNode(InterpreterTypeCode.Content, solutionContext, this, modelContext, parameters);
}
else
{
ContentCodeBuilder.Append("<" + TemplateName + ">");
}
}
if (Solution.UseTemplateCache == true && Solution.IsSampleMode == false && String.IsNullOrEmpty(TemplateOutput))
{
CachedContent[modelContext.ID.ToString()] = null;
// only cache smaller content that has no parameters or config settings
if (Parameters.Count == 0 && HasRelativeSettings == false && ContentCodeBuilder.Length <= Solution.TemplateCacheMaxContentSize)
{
CachedContent[modelContext.ID.ToString()] = ContentCodeBuilder.ToString();
}
}
if (appendToTemplateContext == true)
{
templateContext.ContentCodeBuilder.Append(ContentCodeBuilder.ToString());
}
ModelContextStack = null;
PopCount = 0;
}
/// <summary>
/// Destroys the simulation.
/// </summary>
protected virtual void Unsetup()
{
// Clear all parameters
EntityBehaviors.Clear();
EntityBehaviors = null;
EntityParameters.Clear();
EntityParameters = null;
// Clear all nodes
Variables.Clear();
Variables = null;
}
internal void Clear()
{
Variables.Clear();
Subroutines.Clear();
Labels.Clear();
Includes.Clear();
Imports.Clear();
Map.Clear();
Summary.Clear();
MainName = "";
MainPath = "";
}
public void Reduce(Func <Statement, bool> filter)
{
lock (_lock) {
(Body as SuiteStatement)?.FilterStatements(filter);
_attributes?.Clear();
Variables?.Clear();
CommentLocations = Array.Empty <SourceLocation>();
// DO keep NewLineLocations as they are required
// to calculate node positions for navigation;
base.Clear();
}
}
private void UpdateVariablesList()
{
foreach (VariableViewModel model in Variables)
{
model.Dispose();
}
Variables.Clear();
Variables.Add(new VariableViewModel());
foreach (string name in _globalVariables.VariableNames)
{
Variables.Add(new VariableViewModel(name));
}
}
private void UpdateVariablees()
{
var NoOfVariables = _functionDefinition.Function.getArgumentsNumber();
if (NoOfVariables != Variables.Count())
{
Variables.Clear();
for (int i = 0; i < NoOfVariables; i++)
{
Variables.Add(new Variable {
VariableName = _functionDefinition.Function.getArgument(i).getArgumentName(), Value = 0
});
}
}
}
private void UpdateVariables()
{
var variables = Interpreter.CurrentScope
.Select(x => new VariableViewModel()
{
Name = x.Key,
Value = x.Value?.Value,
})
.ToArray();
CodeViewer.BeginInvoke(() =>
{
Variables.Clear();
variables.For(Variables.Add);
});
}
public void Test()
{
// adjust culture
var cultureInfo = this.CultureInfo;
this.CultureInfo = System.Globalization.CultureInfo.InvariantCulture;
// test internal operators
Test("0", 0.0);
Test("+1", 1.0);
Test("-1", -1.0);
Test("1+1", 1 + 1.0);
Test("1*2*3*4*5*6*7*8*9", 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9.0);
Test("1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1))))))))))", 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1.0)))))))))));
Test("((1+2)*(2+3)/(4+5))^0.123", Math.Pow((1 + 2) * (2 + 3) / (4 + 5.0), 0.123));
Test("10%", 0.1);
Test("1e+3", 1000.0);
// test simple variables
Variables.Add("one", 1);
Variables.Add("two", 2);
Test("one + two", 3);
Test("(two + two)^2", 16);
Variables.Clear();
// test DataContext
var dc = DataContext;
var p = Person.CreateTestPerson();
DataContext = p;
Test("Name", "Test Person");
Test("Name.Length * 2", p.Name.Length * 2);
Test("Children.Count", p.Children.Count);
Test("Children(2).Name", p.Children[2].Name);
Test("ChildrenDct(\"Test Child 2\").Name", p.ChildrenDct["Test Child 2"].Name);
Test("ChildrenDct.Count", p.ChildrenDct.Count);
DataContext = dc;
// test functions
Logical.Test(this);
MathTrig.Test(this);
Text.Test(this);
Statistical.Test(this);
// restore culture
this.CultureInfo = cultureInfo;
}
public void Clear()
{
_schema = null;
Path.Clear();
Variables.Clear();
Fragments.Clear();
UsedVariables.Clear();
UnusedVariables.Clear();
DeclaredVariables.Clear();
Names.Clear();
Types.Clear();
Directives.Clear();
OutputFields.Clear();
InputFields.Clear();
Errors.Clear();
IsInError = false;
}
private void OpenCode(string file)
{
//Path.GetFileNameWithoutExtension(file);
if (!IsAppend)
{
Methods.Clear();
Variables.Clear();
}
GetMethods(file, isClassFileName);
GetVariables(file, isClassFileName);
string className = Path.GetFileNameWithoutExtension(file);
LogStatus("C# file " + className + ".cs parsed succesfully", true);
}
private void MergeVariables()
{
var list = new List <Variable>();
foreach (var kv in Variables)
{
list.Add(kv.Value);
}
list.Sort(MergedVariable.Compare);
Variables.Clear();
var index = 0;
var v = new MergedVariable(PLC, $"{ThreadName}--{index++}")
{
Communicator = Communicator
};
foreach (var x in list)
{
if (!v.Merge(x))
{
bool noMerge = !v.NeedMerge(x);
if (noMerge)
{
Variables.Add(x);
}
if (!v.IsEmpty)
{
v.MergeAddress();
Variables.Add(v);
}
v = new MergedVariable(PLC, $"{ThreadName}--{index++}")
{
Communicator = Communicator
};
}
}
if (!v.IsEmpty)
{
v.MergeAddress();
Variables.Add(v);
}
}
public override void ExecuteHotkey(int index)
{
base.ExecuteHotkey(index);
switch (index)
{
case 0:
ExecuteScriptCommand.Execute(null);
break;
case 1:
StopScriptCommand.Execute(null);
break;
case 2:
Variables.Clear();
break;
}
}
public virtual void Clear(bool RaiseChangedEvent)
{
if (RaiseChangedEvent)
{
ResourceID = 0;
ResourceName = String.Empty;
FullString = String.Empty;
Variables.Clear();
Styles.Clear();
}
else
{
resourceID = 0;
resourceName = String.Empty;
fullString = String.Empty;
Variables.Clear();
Styles.Clear();
}
}
public void Parse(IList <Token> tokens)
{
Counts[Scope.Global] = 0;
Counts[Scope.Flag] = 0;
Counts[Scope.Local] = 0;
Counts[Scope.Temp] = 0;
Counts[Scope.Const] = 0;
Contexts.Clear();
Variables.Clear();
Scripts.Clear();
InitConstants();
InScript = false;
Tokens = tokens;
Index = 0;
LineNumber = 0;
LastToken = null;
while (Index < Tokens.Count)
{
Token tok = Peek();
switch (tok.Type)
{
case TokenType.Keyword:
Keyword();
break;
case TokenType.Identifier:
Identifier();
break;
// Ignore EOL tokens entirely
case TokenType.EOL:
Consume();
LineNumber++;
break;
default:
throw new ParseException($"Cannot start line with {tok}");
}
}
}
/// <summary>
/// Dispose the resources
/// </summary>
public override void Dispose()
{
Task.Run(() =>
{
if (Variables != null)
{
foreach (var variable in Variables)
{
var value = variable.Value as IDisposable;
if (value != null)
{
value.Dispose();
}
}
Variables.Clear();
}
Variables = null;
MethodDeclaration = null;
});
}
