// Action Result methods for Language Views
#region Languages
public ActionResult Languages()
{
// the only fail case for this page is if there isn't a User - we can redirect to Index to handle this
if (Session["User"] == null)
{
return(RedirectToAction("Index", "Language"));
}
// check if there are no languages - if so, add an alert and redirect to create language page
if (LanguageProcessor.getLanguagesCount((int)Session["User"]) <= 0)
{
Session.Add("No Languages", true);
return(RedirectToAction("CreateLanguage", "Language"));
}
// load the languages
List <LanguageDataModel> dmLanguages = LanguageProcessor.LoadLanguages((int)Session["User"]);
// create and populate a list of language models
List <LanguageModel> mLanguages = new List <LanguageModel>();
foreach (LanguageDataModel language in dmLanguages)
{
mLanguages.Add(new LanguageModel
{
Id = language.Id,
Name = language.Name,
Description = language.Description
});
}
// return the view as a table of the languages
return(View(mLanguages));
}
public static void MakeDoc(string output, string rawsFolder, string extension, bool isDirectory, string header, string footer)
{
LanguageProcessor languageProcessor = new LanguageProcessor(true, (IComparer <ICodeTemplate>) new TemplateComparer(), Program.stringComparer);
if (isDirectory)
{
languageProcessor.ProcessCode(rawsFolder, extension);
}
else
{
languageProcessor.ProcessCode(rawsFolder);
}
using (StreamWriter text = File.CreateText(output)) {
if (header != null)
{
text.WriteLine(File.ReadAllText(header));
text.WriteLine();
}
languageProcessor.WriteDocs((TextWriter)text);
if (footer == null)
{
return;
}
text.WriteLine(File.ReadAllText(footer));
text.WriteLine();
}
}
public ActionResult CreateLanguage(LanguageModel language)
{
// We need to remove any "Name already used" alerts
if (Session["Name already used"] != null)
{
Session.Remove("Name already used");
}
if (ModelState.IsValid)
{
// we need to check if the Name is distint for that user
if (LanguageProcessor.CheckDistinct((int)Session["User"], language.Name))
{
// If the language already exists, we'll need to reload the page with a warning
Session.Add("Name already used", true);
return(View());
}
LanguageProcessor.CreateLanguage(language.Name, (int)Session["User"], language.Description);
// also check if the language is already stored in Session
if (Session["Language"] == null)
{
Session.Add("Language", LanguageProcessor.getLanguageId((int)Session["User"], language.Name));
}
// if it is, we'll replace it
else
{
Session["User"] = LanguageProcessor.getLanguageId((int)Session["User"], language.Name);
}
// the next step is to setup the letter types
return(RedirectToAction("SetupLetterTypes", "Languages"));
}
return(View());
}
public async Task GivenNegativeStringProcessorShouldNotContainGreaterAmountOfNegativeTokens()
{
var processor = new LanguageProcessor();
var processed = await processor.ProcessLanguageAsync(Constants.SimpleStrings.NegativeString.str, _defaultLanguage).ConfigureAwait(false);
Assert.True(processed.NegativeTokens.Count() > processed.PositiveTokens.Count());
}
public async Task GivenNeutralStringProcessorShouldNotContainPositiveOrNegativeTokens()
{
var processor = new LanguageProcessor();
var processed = await processor.ProcessLanguageAsync(Constants.SimpleStrings.NeutralString.str, _defaultLanguage).ConfigureAwait(false);
Assert.True(processed.NeutralTokens.Count() == Constants.SimpleStrings.NeutralString.tokenCount);
}
private void HandleTextRequest(Message message)
{
var action = LanguageProcessor.GetActionFromMessage(message);
if (action == null)
{
action = "PleaseRepeat";
}
SendMessageToHandler(message, action);
}
static async Task Main()
{
LanguageProcessor languageProcessor = new LanguageProcessor();
var allCountries = await InitCountriesAsync();
Console.WriteLine("Data set:");
Console.WriteLine(Encoding.UTF8.GetString(JsonSerializer.SerializeToUtf8Bytes(allCountries, options: new JsonSerializerOptions()
{
WriteIndented = true
})));
do
{
Console.WriteLine();
Console.WriteLine("Please enter expression, e.g: Name eq 'Australia' or Population ge 100 and Population lt 201");
Console.WriteLine($"Available operators: { string.Join(',', Enum.GetValues<Operator>())}");
string expression = Console.ReadLine();
if (string.IsNullOrEmpty(expression))
{
break;
}
try
{
var countries = languageProcessor.Find(allCountries, expression);
if (countries.Any())
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Matching countries:");
foreach (var country in countries)
{
Console.Write($"{country.Name}; ");
}
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
}
else
{
Console.WriteLine("Couldn't find any matching countries");
}
}
catch (ExpressionInvalidException ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"{ex.Message}: {ex.Details}");
Console.ForegroundColor = ConsoleColor.White;
}
catch (Exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Something went wrong, please try again");
Console.ForegroundColor = ConsoleColor.White;
}
}while (true);
}
private static void LoadCodes(bool collectDoc)
{
Program.languages = (IDictionary <string, EACodeLanguage>) new Dictionary <string, EACodeLanguage> ();
LanguageProcessor languageProcessor = new LanguageProcessor(collectDoc, new TemplateComparer(), Program.stringComparer);
IPointerMaker pointerMaker = (IPointerMaker) new GBAPointerMaker();
if (Program.RunConfig.isDirectory)
{
languageProcessor.ProcessCode(Program.RunConfig.rawsFolder, Program.RunConfig.rawsExtension);
}
else
{
languageProcessor.ProcessCode(Program.RunConfig.rawsFolder);
}
foreach (KeyValuePair <string, ICodeTemplateStorer> language in languageProcessor.Languages)
{
Tuple <string, List <Priority> >[][] pointerList;
switch (language.Key)
{
case "FE6":
pointerList = FE6CodeLanguage.PointerList;
break;
case "FE7":
case "FE7J":
pointerList = FE7CodeLanguage.PointerList;
break;
case "FE8":
case "FE8J":
// pointerList = DummyCodeLanguage.PointerList;
pointerList = FE8CodeLanguage.PointerList;
break;
default:
pointerList = DummyCodeLanguage.PointerList;
break;
// throw new NotSupportedException ("Language " + language.Key + " not supported.");
}
Program.languages [language.Key] = new EACodeLanguage(
language.Key,
pointerMaker,
pointerList,
language.Value,
Program.stringComparer
);
}
}
public static void CompileFile(string[] args)
{
string sourceFilePath = null;
try
{
sourceFilePath = args[0];
}
catch
{
throw new CommandException("Could not obtain input filename");
}
var extension = Path.GetExtension(sourceFilePath);
var src = File.ReadAllText(sourceFilePath);
var language = LanguageProcessor.GetLanguage(extension);
if (language == Language.Unknown)
{
throw new CommandException("Unsupported smart contract language extension: " + extension);
}
var processor = LanguageProcessor.GetProcessor(language);
var tokens = processor.Lexer.Execute(src);
var tree = processor.Parser.Execute(tokens);
var compiler = new Compiler();
var instructions = compiler.Execute(tree);
var generator = new ByteCodeGenerator(tree, instructions);
var outputName = sourceFilePath.Replace(extension, ScriptExtension);
try
{
File.WriteAllBytes(outputName, generator.Script);
}
catch
{
throw new CommandException("Error generating " + outputName);
}
}
