private void generalStringFormatTestToolStripMenuItem_Click(object sender, EventArgs e)
{
PrintLine("P E R F O R M I N G S T R I N G F O R M A T T E S T");
PrintLine("---------------------------------------------------------");
try
{
var U = new Variable();
var V = new Variable("V", "0");
var F1 = new Value(1.0 / 3.0);
var F2 = new Value(2.0 / 5.0);
PrintLine("DEFAULT:");
PrintLine("1/3 => " + F1.ToString(), Color.Blue);
PrintLine("2/5 => " + F2.ToString(), Color.Blue);
PrintLine("x => " + x.ToString(), Color.Blue);
PrintLine("U => " + U.ToString(), Color.Blue);
PrintLine("V_0 => " + V.ToString(), Color.Blue);
PrintLine("i => " + i.ToString(), Color.Blue);
PrintLine("C => " + C.ToString(), Color.Blue);
PrintLine("x + y => " + (x + y).ToString(), Color.Blue);
PrintLine("x - y => " + (x - y).ToString(), Color.Blue);
PrintLine("x * y => " + (x * y).ToString(), Color.Blue);
PrintLine("x / y => " + (x / y).ToString(), Color.Blue);
PrintLine("x ^ y => " + (x ^ y).ToString(), Color.Blue);
PrintLine("PARSE FRIENDLY:");
PrintLine("1/3 => " + F1.ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("2/5 => " + F2.ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("x => " + x.ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("U => " + U.ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("V_0 => " + V.ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("i => " + i.ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("C => " + C.ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("x + y => " + (x + y).ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("x - y => " + (x - y).ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("x * y => " + (x * y).ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("x / y => " + (x / y).ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("x ^ y => " + (x ^ y).ToString(ExpressionStringFormat.ParseFriendly), Color.Blue);
PrintLine("LATEX:");
PrintLine("1/3 => " + F1.ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("2/5 => " + F2.ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("x => " + x.ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("U => " + U.ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("V_0 => " + V.ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("i => " + i.ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("C => " + C.ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("x + y => " + (x + y).ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("x - y => " + (x - y).ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("x * y => " + (x * y).ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("x / y => " + (x / y).ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("x ^ y => " + (x ^ y).ToString(ExpressionStringFormat.LaTeX), Color.Blue);
PrintLine("SUCCESS", Color.Green);
}
catch (Exception ex)
{
PrintLine(ex.Message, Color.Red);
}
PrintLine();
}
private VariableInfo(bool isRelObject, Variable name, string value)
{
this.name = string.Format("{0}{1}", isRelObject ? "Rel" : "", name.ToString());
this.value = value;
}
/// <summary>
/// Set AGX environment variable for current process.
/// Note that the this method doesn't check whether the variable
/// is set (or appends to it), this method will set the environment
/// variable regardless of previous value.
/// </summary>
/// <param name="variable">Variable to set.</param>
/// <param name="value">Value for variable.</param>
public static void Set(Variable variable, string value)
{
System.Environment.SetEnvironmentVariable(variable.ToString(),
value,
System.EnvironmentVariableTarget.Process);
}
/// <summary>
/// Generates usage information for a terminal
/// </summary>
public static string HelpOn(ITerminal terminal)
{ //****************************************
var HasCommands = false;
var HasVariables = false;
var HasTypes = false;
var Builder = new StringBuilder();
bool IsFirst;
//****************************************
foreach (var Registry in terminal.Registries)
{
HasCommands |= Registry.Commands.Count > 0;
HasVariables |= Registry.Variables.Count > 0;
HasTypes |= Registry.TypeSets.Count > 0;
}
if (HasCommands)
{
Builder.AppendLine("Available Commands:").Append(" ");
IsFirst = true;
foreach (var Command in
terminal.Registries.SelectMany(registry => registry.Commands)
.Concat(terminal.Registries.SelectMany(registry => registry.DefaultInstances).SelectMany(instance => instance.Type.Commands))
.OrderBy(command => command)
)
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(Command.ToString());
}
}
if (HasVariables)
{
if (Builder.Length > 0)
{
Builder.AppendLine();
}
Builder.AppendLine("Available Variables:").Append(" ");
IsFirst = true;
foreach (var Variable in
terminal.Registries.SelectMany(registry => registry.Variables)
.Concat(terminal.Registries.SelectMany(registry => registry.DefaultInstances).SelectMany(instance => instance.Type.Variables))
.OrderBy(variable => variable))
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(Variable.ToString());
}
}
if (HasTypes)
{
if (Builder.Length > 0)
{
Builder.AppendLine();
}
Builder.AppendLine("Available Types:").Append(" ");
IsFirst = true;
foreach (var TypeSet in terminal.Registries.SelectMany(registry => registry.TypeSets).Where(type => type.HasInstance).OrderBy(type => type))
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(TypeSet.ToString());
}
}
return(Builder.ToString());
}
public static Property <string> prop(Variable var) => prop(var.ToString());
public override string ToString()
{
var x = new ArrayList();
for (int i = Coeffs.Length - 1; i > 0; i--)
{
if (Equals(Coeffs[i], Symbolic.ZERO))
{
continue;
}
var s = "";
if (Equals(Coeffs[i], Symbolic.MINUS))
{
s += "-";
}
else if (!Equals(Coeffs[i], Symbolic.ONE))
{
s += Coeffs[i] + "*";
}
s += _v.ToString();
if (i > 1)
{
s += "^" + i;
}
x.Add(s);
}
if (!Equals(Coeffs[0], Symbolic.ZERO))
{
x.Add(Coeffs[0].ToString());
}
var _s = "";
if (x.Count > 1)
{
_s += "(";
}
for (int i = 0; i < x.Count; i++)
{
_s += ( string )x[i];
if (i >= x.Count - 1 || (( string )x[i + 1])[0] == '-')
{
continue;
}
_s += "+";
}
if (x.Count > 1)
{
_s += ")";
}
return(_s);
}
private void StartButton_Click(object sender, EventArgs e)
{
ResultTextBox.Text = "";
double StartLevel;
double EndLevel;
double Increment;
double Variable;
try
{
StartLevel = Conversions.ToDouble(StartLevelTextBox.Text);
EndLevel = Conversions.ToDouble(EndLevelTextBox.Text);
if (Use1RadioButton.Checked == true)
{
Increment = Conversions.ToDouble(IncValueTextBox.Text);
}
else
{
Increment = Conversions.ToDouble(MultValueTextBox.Text);
}
Variable = Conversions.ToDouble(StartValueTextBox.Text);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
string ParamName = ParamNameTextBox.Text;
string LeftSym = LeftTextBox.Text;
string RightSym = RightTextBox.Text;
double iTemp;
var loopTo = EndLevel;
for (iTemp = StartLevel; iTemp <= loopTo; iTemp++)
{
ResultTextBox.AppendText(ParamName);
if (ParamAddNameCheckBox.Checked == true)
{
ResultTextBox.AppendText(Conversions.ToString(iTemp));
}
ResultTextBox.AppendText(" = " + LeftSym);
ResultTextBox.AppendText(Variable.ToString() + RightSym + Constants.vbNewLine);
if (Use1RadioButton.Checked == true)
{
Variable = Variable + Increment;
}
else
{
if (Variable < 0)
{
Increment = -Increment;
}
else if (Increment < 0)
{
Increment = Increment;
}
Variable = Variable + Variable * Increment;
}
}
TabControl1.SelectedIndex = 1;
}
/// <summary>
/// Called when [variable] is visited.
/// </summary>
/// <param name="v">The v.</param>
public override void OnVariable(Variable v)
{
_sb.AppendLine(v.ToString());
}
/// <summary>
/// Evaluates visual expression and converts it to result visualizer.
/// </summary>
private void Evaluate()
{
if (VisualizedExpression.TagValue == DkmVisualizedExpression.Tag.RootVisualizedExpression)
{
DkmRootVisualizedExpression rootVisualizedExpression = VisualizedExpression as DkmRootVisualizedExpression;
int processId = rootVisualizedExpression.InspectionSession?.Process?.LivePart?.Id ?? 0;
string moduleName = rootVisualizedExpression.Module?.Name;
string typeString = rootVisualizedExpression.Type;
ulong address = 0;
bool hasAddress = false;
if (VisualizedExpression.ValueHome.TagValue == DkmExpressionValueHome.Tag.PointerValueHome)
{
address = (VisualizedExpression.ValueHome as DkmPointerValueHome).Address;
hasAddress = true;
}
if (string.IsNullOrEmpty(typeString) || string.IsNullOrEmpty(moduleName) || !hasAddress)
{
string displayString = "{...SharpDebug failure...}";
EvaluationResult = DkmSuccessEvaluationResult.Create(
VisualizedExpression.InspectionContext,
VisualizedExpression.StackFrame,
rootVisualizedExpression.Name,
rootVisualizedExpression.FullName,
DkmEvaluationResultFlags.ReadOnly,
displayString,
"",
rootVisualizedExpression.Type,
DkmEvaluationResultCategory.Other,
DkmEvaluationResultAccessType.None,
DkmEvaluationResultStorageType.None,
DkmEvaluationResultTypeModifierFlags.None,
null,
null,
null,
null);
return;
}
string title;
try
{
Process process = Process.All.First(p => p.SystemId == processId);
Module module = process.ModulesByName[System.IO.Path.GetFileNameWithoutExtension(moduleName)];
CodeType codeType = ResolveCodeType(process, module, typeString);
Variable = codeType.IsPointer ? Variable.CreatePointer(codeType, address) : Variable.Create(codeType, address);
title = Variable.ToString();
ResultVisualizer = SharpDebug.UI.ResultVisualizers.ResultVisualizer.Create(Variable, Variable.GetType(), "result", CompletionDataType.Unknown, dummyInteractiveResultVisualizer);
}
catch
{
title = "{...SharpDebug...}";
}
DkmDataAddress dkmDataAddress = DkmDataAddress.Create(VisualizedExpression.RuntimeInstance, address, rootVisualizedExpression.StackFrame?.InstructionAddress);
EvaluationResult = DkmSuccessEvaluationResult.Create(
VisualizedExpression.InspectionContext,
VisualizedExpression.StackFrame,
rootVisualizedExpression.Name,
rootVisualizedExpression.FullName,
DkmEvaluationResultFlags.ReadOnly | DkmEvaluationResultFlags.Expandable,
title,
"",
rootVisualizedExpression.Type,
DkmEvaluationResultCategory.Other,
DkmEvaluationResultAccessType.None,
DkmEvaluationResultStorageType.None,
DkmEvaluationResultTypeModifierFlags.None,
dkmDataAddress,
VSUIVisualizerService.GetUIVisualizers(ResultVisualizer),
null,
null);
return;
}
// This should never happen...
throw new NotImplementedException();
}
public void ToString_ValidParameters_CorrectRepresentation(string name, int exponent, string expected)
{
var variable = new Variable(name, exponent);
Assert.AreEqual(expected, variable.ToString());
}
internal string GetDebuggerDisplay(VariableReference variableReference)
{
Variable variable = GetVariableForVariableReference(variableReference);
return(variable.ToString());
}
public override string ToString()
{
return("(@" + Variable.ToString() + "." + Expression.ToString() + ")");
}
private VariableInfo(bool isRelObject, Variable name, string value)
{
this.name = string.Format("{0}{1}", isRelObject ? "Rel" : "", name.ToString());
this.value = value;
}
protected override void Execute(CodeActivityContext context)
{
Variable <string> _CurrentTime = new Variable <string> {
Name = "CurrentTime"
};
Variable <string> _AmountTasks = new Variable <string> {
Name = "_AmountTasks"
};
Variable <string> _i = new Variable <string> {
Name = "_i"
};
var c = System.TimeSpan.Parse(context.GetValue(_TimeExecution));
Activity GetTrack = new Sequence
{
Variables = { _CurrentTime, _AmountTasks },
Activities =
{
new GetAmountTasksToWorkflow
{
Result = _AmountTasks
},
new WriteLine
{
Text = _AmountTasks
},
new Assign <string>
{
To = _i,
Value = "0"
},
new While
{
Condition = int.Parse(_i.Get(context)) < int.Parse(_AmountTasks.Get(context)),
Body = new Sequence
{
Activities =
{
new Assign <string>
{
To = _CurrentTime,
Value = "momento del Fin: " + DateTime.Now.ToString() + " duración: " + context.GetValue(_TimeExecution)
},
new WriteLine
{
Text = "ejecutando en _i " + _i.Get(context).ToString()
},
new Delay
{
Duration = System.TimeSpan.Parse(context.GetValue(_TimeExecution))
},
new Tracking
{
CurrentTime = _CurrentTime
},
new WriteLine
{
Text = _CurrentTime
},
new Assign <string>
{
To = _i,
Value = (int.Parse(_i.ToString()) + 1).ToString()
}
}
}
}
}
};
WorkflowInvoker.Invoke(GetTrack);
}
public void TestToString()
{
var v = new Variable(new uint[] { 1, 3, 6 });
Assert.AreEqual("Variable: Id: .1.3.6; Data: Null", v.ToString());
}
public override string ToString()
{
return(Function + Variable.ToString() + Expression.ToString());
}
public override string ToString()
{
return($"#{Index}:{(!string.IsNullOrWhiteSpace(Expression)?Expression:Variable.ToString())}");
}
public void TestToString()
{
var v = new Variable(new uint[] {1, 3, 6});
Assert.AreEqual("Variable: Id: .1.3.6; Data: Null", v.ToString());
}
//public AssignmentKind AssignmentKind
//{
// get
// {
// return this._assignmentKind;
// }
// set
// {
// this._assignmentKind = value;
// }
//}
internal override string ToString(string indent)
{
return("SET " + Variable.ToString() + " = " + (Expression.ToString()) + "\r\n");
}
public void TestToString()
{
var variable = new Variable("Name");
Assert.AreEqual("Name", variable.ToString());
}
/// <summary>
/// Generates usage information for a terminal object
/// </summary>
/// <param name="typeData">A <see cref="TerminalTypeSet"/>, <see cref="TerminalTypeInstance" />, <see cref="TerminalCommandSet" /> or <see cref="TerminalVariable" /></param>
public static string HelpOn(object typeData)
{
var Builder = new StringBuilder();
bool IsFirst;
if (typeData is TerminalTypeSet TypeSet)
{
Builder.AppendFormat("Usage information for Type: {0}", TypeSet.TypeName);
if (TypeSet.Default?.Target != null)
{
if (TypeSet.Default.Type.Commands.Count != 0)
{
Builder.AppendLine().AppendLine(" Available Default Commands:").Append(" ");
IsFirst = true;
foreach (var Command in TypeSet.Default.Type.Commands.OrderBy(set => set))
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(Command.ToString());
}
}
if (TypeSet.Default.Type.Variables.Count != 0)
{
Builder.AppendLine().AppendLine(" Available Default Variables:").Append(" ");
IsFirst = true;
foreach (var Variable in TypeSet.Default.Type.Variables.OrderBy(var => var))
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(Variable.ToString());
}
}
}
if (TypeSet.Instances.Count != 0)
{
Builder.AppendLine().AppendLine(" Available Instances:").Append(" ");
IsFirst = true;
foreach (var InstanceName in TypeSet.Instances.OrderBy(name => name))
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(InstanceName);
}
}
}
else if (typeData is TerminalTypeInstance Instance)
{
Builder.AppendFormat("Usage information for Instance: {0}", Instance.Target);
if (Instance.Type.Commands.Count != 0)
{
Builder.AppendLine().AppendLine(" Available Commands:").Append(" ");
IsFirst = true;
foreach (var Command in Instance.Type.Commands.OrderBy(set => set))
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(Command.ToString());
}
}
if (Instance.Type.Variables.Count != 0)
{
Builder.AppendLine().AppendLine(" Available Variables:").Append(" ");
IsFirst = true;
foreach (var Variable in Instance.Type.Variables.OrderBy(var => var))
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.Append(Variable.ToString());
}
}
}
else if (typeData is TerminalCommandSet CommandSet)
{
Builder.AppendFormat("Usage information for Command: {0}", CommandSet.Name);
foreach (var Command in CommandSet.Commands)
{
Builder.AppendLine().Append(Command.Name).Append('(');
IsFirst = true;
foreach (var Parameter in Command.ExternalParameters.Span)
{
if (IsFirst)
{
IsFirst = false;
}
else
{
Builder.Append(", ");
}
Builder.AppendFormat("{0}: {1}", Parameter.Name, Parameter.ParameterType.Name);
}
Builder.Append(") ").Append(Command.Description);
}
}
else if (typeData is TerminalVariable Variable)
{
Builder.AppendFormat("{0}: {1} {2}", Variable.Name, Variable.Type.Name, Variable.Description);
}
return(Builder.ToString());
}
/// <summary> /// Appends an indexer. /// </summary> /// <param name="indexer">The indexer variable.</param> public void AppendIndexer(Variable indexer) => AppendIndexer(indexer.ToString());
public override string ToString()
{
return("bound(" + itsVariable.ToString() + ")");
}
/// <summary>
/// Appends the given variable directly.
/// </summary>
/// <param name="variable">The variable to append.</param>
public void Append(Variable variable)
{
stringBuilder.Append(variable.ToString());
}
public override string ToString()
{
return(itsVariable.ToString());
}
protected Variable Add(Thread ScriptThread, Variable Operand0, Variable Operand1, Variable Operand2)
{
return (Operand0.ToString() + Operand1.ToString());
}
public override string ToString()
{
return($"let {Variable?.ToString()} : {Variable?.TypeName} = {Expression?.ToString()};");
}
protected Variable Neq(Thread ScriptThread, Variable Operand0, Variable Operand1, Variable Operand2)
{
return (Operand0.ToString() != Operand1.ToString() ? Variable.One : Variable.Zero);
}
static void homegear_DeviceVariableUpdated(Homegear sender, Device device, Channel channel, Variable variable)
{
Console.WriteLine("Variable updated: Device type: \"" + device.TypeString + "\", ID: " + device.ID.ToString() + ", Channel: " + channel.Index.ToString() + ", Variable Name: \"" + variable.Name + "\", Value: " + variable.ToString());
}
public override String ToString()
{
return((m_var == null)?m_name:m_var.ToString());
}
/// <summary>
/// Get the String representation of an parameter with a Sharing Mode.
/// Rule: TCCODEGEN_FUNCALL_PARAMS
/// </summary>
/// <param name="parameter">The Parameter</param>
/// <param name="node">The node</param>
/// <param name="mode">Argument mode Input, InOut, Output, etc...</param>
/// <param name="previousSharingMode">The previous Sharing Mode</param>
/// <param name="previousSpan">The previous marging span</param>
/// <returns>The String representation of the Sharing Mode paramaters</returns>
private string ToString(TypeCobol.Compiler.CodeElements.CallSiteParameter parameter, Node node, ArgMode mode,
ref TypeCobol.Compiler.CodeElements.ParameterSharingMode previousSharingMode, ref int previousSpan)
{
Variable variable = parameter.StorageAreaOrValue;
bool bTypeBool = false;
if (variable != null)
{//We must detect a boolean variable
if (!variable.IsLiteral)
{
var found = node.GetDataDefinitionFromStorageAreaDictionary(variable.StorageArea);
if (found != null)
{
var data = found as DataDescription;
bTypeBool = (data != null && data.DataType == DataType.Boolean);
}
}
}
var name = parameter.IsOmitted ? "omitted" : variable.ToString(true, bTypeBool);
string share_mode = "";
int defaultSpan = string.Intern("by reference ").Length;
if (parameter.SharingMode.Token != null)
{
if (previousSharingMode != parameter.SharingMode.Value)
{
share_mode = "by " + parameter.SharingMode.Token.Text;
share_mode += new string(' ', defaultSpan - share_mode.Length);
previousSharingMode = parameter.SharingMode.Value;
}
}
else
{
if (mode == ArgMode.InOut || mode == ArgMode.Output)
{
if (previousSharingMode != TypeCobol.Compiler.CodeElements.ParameterSharingMode.ByReference)
{
share_mode = string.Intern("by reference ");
previousSharingMode = TypeCobol.Compiler.CodeElements.ParameterSharingMode.ByReference;
}
}
}
if (share_mode.Length == 0)
{
share_mode = new string(' ', previousSpan == 0 ? defaultSpan : previousSpan);
}
else
{
previousSpan = share_mode.Length;
}
if (variable != null)
{
if (variable.IsLiteral)
{
return(share_mode + name);
}
var found = node.GetDataDefinitionFromStorageAreaDictionary(variable.StorageArea);
if (found == null) //this can happens for special register : LENGTH OF, ADDRESS OF
{
return(share_mode + variable.ToCobol85());
}
}
return(share_mode + name);
}
private static string CreateName(Variable<GaussianDistribution> sumVariable,
IList<Variable<GaussianDistribution>> variablesToSum, double[] weights)
{
var sb = new StringBuilder();
sb.Append(sumVariable.ToString());
sb.Append(" = ");
for (int i = 0; i < variablesToSum.Count; i++)
{
bool isFirst = (i == 0);
if (isFirst && (weights[i] < 0))
{
sb.Append("-");
}
sb.Append(Math.Abs(weights[i]).ToString("0.00"));
sb.Append("*[");
sb.Append(variablesToSum[i]);
sb.Append("]");
bool isLast = (i == variablesToSum.Count - 1);
if (!isLast)
{
if (weights[i + 1] >= 0)
{
sb.Append(" + ");
}
else
{
sb.Append(" - ");
}
}
}
return sb.ToString();
}
public void VariableToString()
{
Variable variable = new Variable("X");
Assert.AreEqual("X", variable.ToString());
}
public override string ToString()
{
return(string.Format("{0}/{1}", Variable.ToString(), Value.ToString()));
}
