public static void StoreAtomicExpression(
[NotNull] StringBuilder builder,
[NotNull] AtomicExpression expression,
ref ulong varName)
{
switch (expression)
{
case IntLiteralExpression integer:
builder.AppendLine(
$" store {integer.Type} {integer.Value},{integer.Type}* %var{varName},align {integer.Type.Align}");
break;
case BoolLiteralExpression boolean:
builder.AppendLine(
$" store i8 {boolean.ValueToInt()},i8* %var{varName},align 1");
break;
case VariableExpression variable:
var type = variable.GetExpressionType();
var varAddress = variable.Declaration.Address;
builder.AppendLine(
$" store {type} %var{varAddress},{type}* %var{varAddress},align {type.Align}");
break;
}
}
private IExpression ReadAtomicExpression(IParseContext context)
{
if (AtomicExpression.IsTokenKindValid(context.NextCodeToken.Kind))
{
return(new AtomicExpression(context.ReadCodeToken()));
}
context.Panic($"Expected {nameof(AtomicExpression)}, but got: {context.NextCodeToken}");
return(null);
}
public static void StoreAtomicExpression(
LLVMBuilderRef builder,
[NotNull] AtomicExpression expression)
{
switch (expression)
{
case IntLiteralExpression integer:
case BoolLiteralExpression boolean:
case VariableExpression variable:
break;
}
}
private FilterExpression GetFilter()
{
#region "SimpleCriterion"
PicklistItem fieldName = new PicklistItem("Customer");
MultiplePicklistFieldValue fieldValue = new MultiplePicklistFieldValue("Microsoft");
fieldValue.Add(fieldName);
#endregion
#region "SimpleFilter"
AtomicExpression filter = new AtomicExpression(fieldValue, AtomicExpression.Operator.Equal);
return(filter);
#endregion
}
private FilterExpression GetExportFilter()
{
PicklistItem i1 = new PicklistItem("Sample field");
MultiplePicklistFieldValue v1 = new MultiplePicklistFieldValue("yes");
v1.Add(i1);
AtomicExpression e1 = new AtomicExpression(v1, AtomicExpression.Operator.Contains);
MultipleStringFieldValue v2 = new MultipleStringFieldValue("Sample text field");
v2.Add("new item");
AtomicExpression e2 = new AtomicExpression(v2, AtomicExpression.Operator.Contains);
ComposedExpression filter = new ComposedExpression(e1, ComposedExpression.Operator.Or, e2);
return(filter);
}
private FilterExpression GetFilterAdvanced()
{
#region "AdvancedCriterion1"
PicklistItem fieldName1 = new PicklistItem("Customer");
MultiplePicklistFieldValue fieldValue1 = new MultiplePicklistFieldValue("Microsoft");
fieldValue1.Add(fieldName1);
AtomicExpression expression1 = new AtomicExpression(fieldValue1, AtomicExpression.Operator.Equal);
#endregion
#region "AdvancedCriterion2"
MultipleStringFieldValue fieldName2 = new MultipleStringFieldValue("Project id");
fieldName2.Add("2010");
AtomicExpression expression2 = new AtomicExpression(fieldName2, AtomicExpression.Operator.Contains);
#endregion
#region "AdvancedFilter"
ComposedExpression filter = new ComposedExpression(expression1, ComposedExpression.Operator.Or, expression2);
return(filter);
#endregion
}
public void ConfigureTmSettings(FileBasedProject project)
{
#region "GetSettingsBundle"
ISettingsBundle settings = project.GetSettings();
TranslationMemorySettings tmSettings = settings.GetSettingsGroup <TranslationMemorySettings>();
#endregion
#region "TmSearchSettings"
tmSettings.TranslationMinimumMatchValue.Value = 80;
tmSettings.TranslationMaximumResults.Value = 10;
tmSettings.TranslationFullSearch.Value = true;
#endregion
#region "ConcordanceSettings"
tmSettings.ConcordanceMinimumMatchValue.Value = 30;
tmSettings.ConcordanceMaximumResults.Value = 50;
#endregion
#region "Penalties"
tmSettings.MissingFormattingPenalty.Value = 0;
tmSettings.DifferentFormattingPenalty.Value = 0;
tmSettings.MultipleTranslationsPenalty.Value = 2;
#endregion
#region "AutoLocalization"
tmSettings.NumbersAutoLocalizationEnabled.Value = true;
tmSettings.DatesAutoLocalizationEnabled.Value = true;
tmSettings.MeasurementsAutoLocalizationEnabled.Value = true;
tmSettings.TimesAutoLocalizationEnabled.Value = true;
#endregion
#region "DatePatterns"
tmSettings.ShortDatePattern.Value = "dd.MM.yy";
#endregion
#region "FieldUpdate"
FieldValues fieldValuesCollection = new FieldValues();
FileBasedTranslationMemory tm = new FileBasedTranslationMemory(@"c:\ProjectFiles\Tms\General En-De.sdltm");
FieldDefinition field = tm.FieldDefinitions["Type"];
FieldValue fv = field.CreateValue();
fv.Name = "Technical documentation";
fieldValuesCollection.Add(fv);
tmSettings.ProjectSettings.Value = fieldValuesCollection;
#endregion
#region "TmFilterPenalty"
PicklistItem fieldName = new PicklistItem("Type");
MultiplePicklistFieldValue fieldValue = new MultiplePicklistFieldValue("Technical documentation");
fieldValue.Add(fieldName);
AtomicExpression filter = new AtomicExpression(fieldValue, AtomicExpression.Operator.Equal);
Filter updateFilter = new Filter(filter, "Filter_name", 1);
List <Filter> filterList = new List <Filter>();
filterList.Add(updateFilter);
tmSettings.Filters.Value = filterList;
#endregion
#region "TmHardFilter"
PicklistItem hardFilterFieldName = new PicklistItem("Type");
MultiplePicklistFieldValue hardFilterFieldValue = new MultiplePicklistFieldValue("Technical documentation");
hardFilterFieldValue.Add(hardFilterFieldName);
AtomicExpression hardFilterExpression = new AtomicExpression(hardFilterFieldValue, AtomicExpression.Operator.Equal);
tmSettings.HardFilter.Value = hardFilterExpression;
#endregion
#region "update"
project.UpdateSettings(settings);
#endregion
}
public override List <TestResult> run()
{
//Do some tests, make results, pass back a list
List <TestResult> results = new List <TestResult>();
double expected = 5.0;
Expression expr = new AtomicExpression(expected);
double actual = expr.evaluate();
TestResult res = new TestResult("Atomic Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = -5.0;
expr = new AtomicExpression(expected);
actual = expr.evaluate();
res = new TestResult("Atomic Negative Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 0;
expr = new AtomicExpression(expected);
actual = expr.evaluate();
res = new TestResult("Atomic 0 Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 5.0;
expr = new ParenExpression(new AtomicExpression(expected));
actual = expr.evaluate();
res = new TestResult("Paren Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = -5.0;
expr = new ParenExpression(new AtomicExpression(expected));
actual = expr.evaluate();
res = new TestResult("Paren Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 0;
expr = new ParenExpression(new AtomicExpression(expected));
actual = expr.evaluate();
res = new TestResult("Paren 0 Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 7;
expr = new AddExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Add Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 3;
expr = new SubtractExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Subtract Postive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 10;
expr = new MultiplyExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Multiply Positive Int", expected, actual, compare(expected, actual));
results.Add(res);
expected = 2.5;
expr = new DivideExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Divide Positive Float", expected, actual, compare(expected, actual));
results.Add(res);
expected = 25;
expr = new ExponentExpression(new AtomicExpression(5), new AtomicExpression(2));
actual = expr.evaluate();
res = new TestResult("Exponent Positive Float", expected, actual, compare(expected, actual));
results.Add(res);
return(results); //I can be reasonably certain they won't mess up in different circumstances. It's just wrappers for primitive expressions.
}
public ExitStatement(
MetaData metaData,
[NotNull] AtomicExpression expression) : base(metaData) => Expression = expression;
