/// <summary>
/// Initializes a new instance of the <see cref="DiffFuncParser"/> class.
/// </summary>
public DiffFuncParser()
{
_state = State.OPEN_VAR;
_depth = 0;
_node = new DiffOperNode();
_childParser = new DefaultParser();
}
public void Parse_GivenTargetObjectPropertyOfMethod_ReturnsCorrectResult()
{
var lexer = new DefaultLexer();
const string queryText = "ensure target.SomeMethod() is within 10 of comparison.SomeProperty";
var tokens = lexer.Lex(queryText).ToList();
var sut = new DefaultParser();
var expected = new RuleDefinition
{
Id = null,
RuleConditions = new List <RuleCondition>
{
new RuleCondition
{
ComparisonType = RuleObject.ObjectProperty,
ComparisonAttribute = "SomeProperty",
ComparisonTypeName = "comparison",
LogicalOperator = RuleLogicalOperator.None,
Operator = RuleComparatorOperator.Within,
Value = "10"
}
},
TargetAttribute = "SomeMethod",
TargetType = RuleObject.ObjectMethod,
TargetTypeName = "target"
};
var actual = sut.Parse(tokens);
Assert.That(actual, Is.EqualTo(expected));
}
/// <summary>
/// Initializes a new instance of the <see cref="MatrixParser"/> class.
/// </summary>
public MatrixParser()
{
_childParser = new DefaultParser();
_state = State.OPEN_X;
_cache = string.Empty;
_sizes = new int[2];
}
private void arrCtl_CellClick(object sender, CellClickEventArgs e)
{
Array values = new DefaultParser(_arrayLoader).GetValues((Expression)e.Data);
Color color = ((SolidColorBrush)mainPanel.Background).Color;
((ArrayControl)sender).ShowArrayPopup((UIElement)e.Source, values, e.ToolTipPrefix, color);
}
public LineParser GetLineParser(string line)
{
if (line == null)
{
return(null);
}
// String[] lineWords = line.split(" ");
// Nhaaaaaaaaaaa, 3DS max doesn't use clean space but some other shity character :( !
// So I could use something like String regularExpression = "[A-Za-z]*([^\\-\\.0-9]*(\\-\\.0-9]*))";
// or be nasty :P
//line = Regex.Replace(line, "[^ \\.\\-A-Za-z0-9#/]", string.Empty);
line = Regex.Replace(line, @"\s+", " ");
string[] lineWords = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
// lineType is the first word in the line (except v, vp, vn, vt)
if (lineWords.Length < 1)
{
return(new DefaultParser());
}
;
string lineType = lineWords[0];
if (!Parsers.TryGetValue(lineType, out LineParser parser))
{
parser = new DefaultParser();
}
parser.Words = lineWords;
return(parser);
}
public void Parse_GivenValidTokens_ReturnsCorrectResult()
{
var lexer = new DefaultLexer();
const string queryText = "ensure holding.Nav is within 10 of fund.Nav";
var tokens = lexer.Lex(queryText).ToList();
var sut = new DefaultParser();
var expected = new RuleDefinition
{
Id = null,
RuleConditions = new List <RuleCondition>
{
new RuleCondition
{
ComparisonType = RuleObject.ObjectProperty,
ComparisonAttribute = "Nav",
ComparisonTypeName = "fund",
LogicalOperator = RuleLogicalOperator.None,
Operator = RuleComparatorOperator.Within,
Value = "10"
}
},
TargetAttribute = "Nav",
TargetType = RuleObject.ObjectProperty,
TargetTypeName = "holding"
};
var actual = sut.Parse(tokens);
Assert.That(actual, Is.EqualTo(expected));
}
public void Interpret_GivenValidRuleDefinition_ReturnsCorrectResult()
{
var lexer = new DefaultLexer();
const string queryText = "ensure holding.Nav is within 10 of fund.Nav";
var tokens = lexer.Lex(queryText).ToList();
var parser = new DefaultParser();
var ruleDefinition = parser.Parse(tokens);
var sut = new DefaultInterpreter();
var ruleFunc = sut.Interpret <Holding, Fund>(ruleDefinition);
var holding = new Holding
{
Nav = 5
};
var fund = new Fund
{
Nav = 6
};
var actual = ruleFunc(holding, fund);
Assert.That(actual, Is.True);
}
static void Main(string[] args)
{
if (args.Length != 1 || !File.Exists(args[0]))
{
return;
}
using (InitializeLLVM())
{
RegisterNative();
var session = new Session();
//var machine = new TargetMachine( Triple.HostTriple);
//var visitor = new CodeGenVisitor(false, session, machine);
//var listener = new CodeGenParserListener(visitor);
var visitor = new IlGeneratorVisitor(session);
var listener = new IlGeneratorParserListener(visitor);
var lexer = new DefaultLexer(File.OpenText(args[0]));
var parser = new DefaultParser(lexer, listener, session);
MainLoop(lexer, parser);
/*machine.EmitToFile(visitor.Module, "output.o", CodeGenFileType.ObjectFile);
* if( !visitor.Module.WriteToTextFile( "output.ll", out string msg ) )
* {
* Console.Error.WriteLine( msg );
* return;
* }
* machine.EmitToFile( visitor.Module, "output.s", CodeGenFileType.AssemblySource );*/
}
}
public void TestWhitespaces()
{
var p = new DefaultParser();
var args = p.Parse(" 123");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse(" 123");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse("123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse("123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse(" 123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse("\n123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse(" 123 456 789");
Assert.AreEqual(3, args.Length);
Assert.AreEqual("123", args[0]);
Assert.AreEqual("456", args[1]);
Assert.AreEqual("789", args[2]);
}
static void Main(string[] args)
{
// create Options object
Options options = new Options();
// add t option
options.AddOption("t", false, "display current time");
options.AddOption("h", false, "Display help options");
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.Parse(options, args);
options.AddOption("h", "help", false, "Print this usage information");
options.AddOption("v", "verbose", false, "Print out VERBOSE information");
OptionGroup optionGroup = new OptionGroup();
optionGroup.AddOption(new OptionBuilder("f").HasArg(true).ArgName("filename").Build());
optionGroup.AddOption(new OptionBuilder("m").HasArg(true).ArgName("email").Build());
options.AddOptionGroup(optionGroup);
if (cmd.HasOption("h"))
{
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("x", options, true);
return;
}
if (cmd.HasOption("t"))
{
Console.WriteLine(System.DateTime.Now);
}
}
public byte[] SaveToUncompressed()
{
byte[] uncompressedData;
using (var stream = new MemoryStream())
{
foreach (var node in Nodes)
{
var parser = _parsers.Where(p => p.ParsableNodeName == node.Name).FirstOrDefault();
if (parser != null)
{
stream.Write(parser.Write(node, _parsers));
}
else
{
var fallback = new DefaultParser();
stream.Write(fallback.Write(node, _parsers));
}
}
uncompressedData = stream.ToArray();
}
RecalculateOffsets();
var footerWithoutLast8Bytes = BuildFooterWithoutLastEightBytes();
var compressor = new SaveFileCompressionHelper();
var chunks = compressor.CompressToChunkList(uncompressedData);
foreach (var chunk in chunks)
{
chunk.CompressedChunkSize = 4 << 16;
chunk.DecompressedChunkSize = 4 << 16;
chunk.CompressedData = new byte[4 << 16];
chunk.DecompressedData = new byte[0];
}
var offset = (chunks.Count - 1) * 4;
chunks.Last().DecompressedChunkSize = uncompressedData.Length - (offset << 16);
chunks.Last().CompressedData = new byte[uncompressedData.Length - (offset << 16)];
var header = BuildHeader(chunks);
//var header = BuildHeader(new List<Lz4Chunk>());
byte[] result;
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream, Encoding.ASCII))
{
writer.Write(header);
writer.Write(uncompressedData);
int lastBlockOffset = (int)writer.BaseStream.Position;
writer.Write(footerWithoutLast8Bytes);
writer.Write(lastBlockOffset);
writer.Write(Encoding.ASCII.GetBytes(Constants.Magic.END_OF_FILE));
}
result = stream.ToArray();
}
return(result);
}
protected string Run(string input)
{
ExpTree tree;
ParserStatus result = DefaultParser.Parse(input, out tree);
Assert.IsFalse(result.Failed);
return(tree.Root.Execute(_simplifier).Print(_printer));
}
public void TestMultipleInvalidQuotes()
{
var p = new DefaultParser();
var args = p.Parse("\"123\" \"456");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
}
public void TestSimpleArgument()
{
var p = new DefaultParser();
var args = p.Parse("123");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
}
public void TestSimpleValidQuote()
{
var p = new DefaultParser();
var args = p.Parse("\"123\"");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="IntegralFuncParser"/> class.
/// </summary>
public IntegralFuncParser()
{
_state = State.OPEN_VAR;
_depth = 0;
_node = new IntegralOperNode {
IsDeterminate = false
};
_childParser = new DefaultParser();
}
public void TestMultipleSimpleArguments()
{
var p = new DefaultParser();
var args = p.Parse("123 456 789");
Assert.AreEqual(3, args.Length);
Assert.AreEqual("123", args[0]);
Assert.AreEqual("456", args[1]);
Assert.AreEqual("789", args[2]);
}
private INodeParser GetParser(string name)
{
var parser = _parsers.FirstOrDefault(p => p.ParsableNodeName == name);
if (parser == null)
{
parser = new DefaultParser();
}
return(parser);
}
public void UnComment()
{
if ((this._EditorControl.Document.Parser != null) && (this._EditorControl.Document.Parser is DefaultParser))
{
DefaultParser parser = this._EditorControl.Document.Parser as DefaultParser;
if (parser.Language != null)
{
this._EditorControl.Selection.Outdent("//");
}
}
}
public void ThrowOnBadInput()
{
var targetType = typeof(float);
var parser = new DefaultParser(targetType);
var input = "abc";
var ex = Assert.Throws <ParsingException>(() => parser.Parse(input));
Assert.That(ex.Input, Is.EqualTo(input));
Assert.That(ex.TargetType, Is.EqualTo(targetType));
}
public static AbacAuthorizationPolicy CreateFromGrammar(string policy, WellKnownGrammars grammar = WellKnownGrammars.Bal)
{
try
{
return(DefaultParser.Parse(policy, grammar));
}
catch (Exception exception)
{
throw new InvalidOperationException($"Policy can't be parsed using the grammar {Enum.GetName(typeof(WellKnownGrammars), grammar)} and policy is not created succcesfully.", exception);
}
}
private static void DefaultParserDemo()
{
var p = new DefaultParser();
PrintRes(p.Parse(" 123"));
PrintRes(p.Parse("123"));
PrintRes(p.Parse("123 456"));
PrintRes(p.Parse("\"123\""));
PrintRes(p.Parse("\"123\" \"456\""));
PrintRes(p.Parse("\"123\" \"456\" \"789"));
}
public void TestSimpleArgumentUsingQuoteChar()
{
var p = new DefaultParser();
p.QuoteChar = '`';
var args = p.Parse("`123 456` 789 `123456`");
Assert.AreEqual(3, args.Length);
Assert.AreEqual("123 456", args[0]);
Assert.AreEqual("789", args[1]);
Assert.AreEqual("123456", args[2]);
}
public static void Main(string[] args)
{
try
{
System.Console.Out.WriteLine("khubla.com Paradox DB reader");
/*
* options
*/
Options options = new Options();
Option oo = Option.Builder().ArgName(FileOption).LongOpt(FileOption).Type(Sharpen.Runtime.GetClassForType
(typeof(string))).HasArg().Required(true).Desc("file to read").Build();
options.AddOption(oo);
/*
* parse
*/
CommandLineParser parser = new DefaultParser();
CommandLine cmd = null;
try
{
cmd = parser.Parse(options, args);
}
catch (Exception e)
{
Sharpen.Runtime.PrintStackTrace(e);
HelpFormatter formatter = new HelpFormatter();
formatter.PrintHelp("posix", options);
System.Environment.Exit(0);
}
/*
* get file
*/
string filename = cmd.GetOptionValue(FileOption);
if (null != filename)
{
File inputFile = new File(filename);
if (inputFile.Exists())
{
DBTableFile pdxFile = new DBTableFile();
PDXReaderListener pdxReaderListener = new PDXReaderCSVListenerImpl();
pdxFile.Read(inputFile, pdxReaderListener);
System.Console.Out.WriteLine("done");
}
}
}
catch (Exception e)
{
Sharpen.Runtime.PrintStackTrace(e);
}
}
private static void Main(string[] args)
{
var parameters = DefaultParser.ParseOrExitWithUsageMessage <Parameters>(args);
Log.Logger = new LoggerConfiguration()
.WriteTo.LiterateConsole()
.MinimumLevel.Is(parameters.LogLevel)
.MinimumLevel.Verbose()
.CreateLogger();
var currentDirectory = new DirectoryInfo(parameters.Directory);
var bindingRedirector = new BindingRedirector(Log.Logger, new RecursingDirectoryScanner(), new CsprojReferenceScanner(), new AssemblyReferenceConsolidator());
bindingRedirector.AddBindingRedirects(currentDirectory);
}
private Context() {
#region Register app at windows startup
if (Properties.Settings.Default.RunAtWindowsStart) {
Utilities.RunOnStart("Handyman", Application.ExecutablePath);
} else {
Utilities.RemoveRunOnStart("Handyman");
}
#endregion
Suggestions = new List<string>();
Suggestions.AddRange(History.GetAll());
Parser = new DefaultParser();
Handymans = HandymansManager.Load();
Tools = PluginManager.LoadPlugins(out __components, out List<string> sgs);
Suggestions.AddRange(sgs);
Suggestions.AddRange(Handymans.Select(x => x.Alias));
}
private ParseError ParseExpression1(char c)
{
if (_depth == 0)
{
if (c == '}') return new ParseError(ErrorType.INADEQUATE_ARGUMENTS);
if (c == ',')
{
_state = State.EXPRESSION2_OPENING;
ParseError status = FinalizeChild();
if (!status.Failed) _childParser = new DefaultParser();
return status;
}
}
return ParseAsChild(c);
}
public static IParser BuildParser(ISetting setting)
{
IParser parser;
parser = new DefaultParser(setting.BlockBegin, setting.BlockContinue, setting.BlockEnd, setting.Escape);
if (setting.Optimize)
{
parser = new PostParser(parser, new IOptimizer[]
{
ConstantInvokeOptimizer.Instance,
ConstantMapOptimizer.Instance,
IfOptimizer.Instance,
ReturnOptimizer.Instance
});
}
return(parser);
}
/// <summary>
/// Initializes a safe parser of type <typeparamref name="T" />.
/// </summary>
/// <returns>
/// A delegate that parses the specified string using the
/// specified format provider to type <typeparamref name="T" />.
/// </returns>
/// <remarks>
/// The underlying parser uses the <see cref="DefaultParser{T}.TryParse" />
/// when the specified string is not null.
/// </remarks>
private static TPF <T?> InitTryParse()
{
return((string s, IFormatProvider provider, out T? result) =>
{
if (s == null)
{
result = default;
return true;
}
if (DefaultParser <T> .TryParse(s, provider, out var r))
{
result = r;
return true;
}
result = default;
return false;
});
}
private static void Main(string[] args)
{
try
{
Console.WriteLine("--------------------------------------------------------------------------------");
Console.WriteLine(" W A R N I N G W A R N I NG W A R N I N G ");
Console.WriteLine("--------------------------------------------------------------------------------");
Console.WriteLine(" THIS IS A HIGHLY PERSONALISED PROGRAM THAT WILL MOVE AND DELETE FILES! ");
Console.WriteLine(" DO NOT CONTINUE UNLESS YOU HAVE READ AND UNDERSTOOD THE CODE AND ARE WILLING ");
Console.WriteLine(" TO RISK LOSING YOUR FILES. ");
Console.WriteLine();
Console.WriteLine("-------------------------------------------------------------------------------");
Console.Write("DO YOU WISH TO CONTINUE [Y/N]: ");
var confirmationChar = Console.ReadKey().KeyChar;
Console.WriteLine();
if (confirmationChar != 'y' && confirmationChar != 'Y')
{
Console.WriteLine("Exiting without doing anything.");
return;
}
var configuration = DefaultParser.ParseOrExitWithUsageMessage <CommandLineParameters>(args);
configuration.Source = PromptForFolder("Source", configuration.Source);
configuration.Destination = PromptForFolder("Destination", configuration.Destination);
new PhotoImporter(configuration).Import();
}
catch (Exception e)
{
Console.WriteLine($"Failed with error: {e.Message}");
}
finally
{
#if DEBUG
Console.Write("Press any key to exit...");
Console.ReadKey();
#endif
}
}
/// <summary>
/// Constructor
/// </summary>
public ObjectBase()
{
Input = new DefaultInput();
Parser = new DefaultParser();
}