|
private Parse ( |
||
| context | ||
| sourceText | string | |
| fileName | string | |
| return | ||
public void TestConflictGrammarWithHintsOnRules()
{
var grammar = new ConflictGrammarWithHintsInRules();
var parser = new Parser(grammar);
Assert.True(parser.Language.Errors.Count == 0);
// Field sample
var sample = FieldSample;
var tree = parser.Parse(sample);
Assert.NotNull(tree);
Assert.False(tree.HasErrors());
Assert.NotNull(tree.Root);
var term = tree.Root.Term as NonTerminal;
Assert.NotNull(term);
Assert.Equal("definition", term.Name);
Assert.Equal(1, tree.Root.ChildNodes.Count);
var modNode = tree.Root.ChildNodes[0].ChildNodes[0];
Assert.Equal("fieldModifier", modNode.Term.Name);
//Property
sample = PropertySample;
tree = parser.Parse(sample);
Assert.NotNull(tree);
Assert.False(tree.HasErrors());
Assert.NotNull(tree.Root);
term = tree.Root.Term as NonTerminal;
Assert.NotNull(term);
Assert.Equal("definition", term.Name);
Assert.Equal(1, tree.Root.ChildNodes.Count);
modNode = tree.Root.ChildNodes[0].ChildNodes[0];
Assert.Equal("propModifier", modNode.Term.Name);
}
public Ast.Block ParseString(string Chunk)
{
ParseTree parseTree = parser.Parse(Chunk);
ParseTreeNode root = parseTree.Root;
if (root == null)
{
Irony.LogMessage msg = parseTree.ParserMessages[0];
throw new LuaException("", msg.Location.Line, msg.Location.Column, msg.Message);
}
return(ParseBlock(root));
}
public void TestErrorRecovery() {
var grammar = new ErrorRecoveryGrammar();
var parser = new Parser(grammar);
TestHelper.CheckGrammarErrors(parser);
//correct sample
var parseTree = parser.Parse("x = y; y = z + m; m = n;");
Assert.IsFalse(parseTree.HasErrors(), "Unexpected parse errors in correct source sample.");
parseTree = parser.Parse("x = y; m = = d ; y = z + m; x = z z; m = n;");
Assert.AreEqual(2, parseTree.ParserMessages.Count, "Invalid # of errors.");
}
public override object Read(string path)
{
var obj = new TurbulencePropertiesData();
string text = Load(path);
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(text);
_fileHandler = null;
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
if (rootEntryNode.GetEntryIdentifier() == "simulationType")
{
obj.SimulationType = rootEntryNode.GetBasicValEnum<TurbulenceModel>();
if (obj.SimulationType == TurbulenceModel.RASModel)
{
_fileHandler = new RASPropertiesHandler();
obj.RasProperties = (RASPropertiesData) _fileHandler.Read(path);
}
else if (obj.SimulationType == TurbulenceModel.LESModel)
{
_fileHandler = new LESPropertiesHandler();
obj.LesProperties = (LESPropertiesData) _fileHandler.Read(path);
}
break;
}
}
return obj;
}
/// <summary>
/// retorna null si ocurrio un error al leer el archivo.
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
private StaticEntity CreateStaticEntity(string path)
{
var src = File.ReadAllText(path);
var grammar = new PyUsacGrammar();
var langData = new LanguageData(grammar);
var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser
var parseTree = parser.Parse(src);
bool hasErrors = false;
foreach (var error in parseTree.ParserMessages)
{
if (error.Level == Irony.ErrorLevel.Error)
{
hasErrors = true;
}
ErrorFactory.CreateParsingError(error, path);
}
if (hasErrors)
{
return(null);
}
var astBuilder = new PyAstBuilder(new AstContext(langData), path);
astBuilder.BuildAst(parseTree);
var programNode = (ProgramNode)parseTree.Root.AstNode;
var entity = new StaticEntity(programNode);
entity.InitVisitor(true);
return(entity);
}
public override object Read(string path)
{
var obj = new RASPropertiesData();
string text = Load(path);
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(text);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
switch (rootEntryNode.GetEntryIdentifier())
{
case "RASModel":
obj.RasModelName = rootEntryNode.GetBasicValString();
break;
case "turbulence":
obj.Turbulence = rootEntryNode.GetBasicValEnum<OnOffValue>();
break;
case "printCoeffs":
obj.PrintCoeffs = rootEntryNode.GetBasicValEnum<OnOffValue>();
break;
}
}
return obj;
}
private void button1_Click(object sender, EventArgs e)
{
string programText = textBox1.Text;
CameraControlGrammar grammar = new CameraControlGrammar();
Parser parser = new Parser(grammar);
ParseTree program = parser.Parse(programText);
//var ttt=program.ToXml();
var cameraSizeNode = program.Root.ChildNodes[0];
var widthNode = cameraSizeNode.ChildNodes[0];
int width = (int)widthNode.Token.Value;
var heightNode = cameraSizeNode.ChildNodes[1];
int height = (int)heightNode.Token.Value;
// loop through the movement commands
foreach (ParseTreeNode commandNode in program.Root.ChildNodes[2].ChildNodes)
{
// get the number of pixels to move
Token pixelsToken = commandNode.ChildNodes[0].Token;
int pixelsToMove = (int)pixelsToken.Value;
// get the direction
Token directionToken =commandNode.ChildNodes[1].Token;
string directionText = directionToken.Text.ToLower();
}
int u = 0;
}
public bool TryParse(string sourceText, out MarkupExtension graph)
{
graph = null;
try
{
ParseTree tree = _parser.Parse(sourceText);
#if DEBUG
// Save result tree for debugging purposes
LastParseTree = tree;
LastException = null;
#endif
if (tree.Status == ParseTreeStatus.Parsed)
{
graph = MarkupExtension.Create(tree.Root);
return(true);
}
}
#if DEBUG
catch (Exception ex)
{
LastParseTree = null;
LastException = ex;
}
#else
catch
{
// ignored
}
#endif
return(false);
}
/// <summary>
/// Insert the string from the include file inside the include directive tag
/// </summary>
/// <remarks></remarks>
private void ExpandIncludeFiles(ParseTreeNode rootNode, T4Grammar grammar, Parser parser)
{
var includes = from n in rootNode.ChildNodes
let segmentChild = n.ChildNodes.First()
where segmentChild.Term == grammar.Directive
let dir = segmentChild
let dirName = grammar.GetDirectiveName(dir)
where T4Grammar.IsEqualText(Convert.ToString(dirName), "include")
select dir;
var includeFiles = from incDir in includes
let filepath = grammar.GetDirectiveAttributes(incDir)["File"]
select new
{ DirectiveNode = incDir, File = GetIncludeFile(Convert.ToString(filepath)) };
foreach (var incFile in includeFiles)
{
//do not expand the same files, in case there's a multiple nested references to the same include files
if (_expandedFiles.Contains(incFile.File.FullName)) continue;
var text = File.ReadAllText(Convert.ToString(incFile.File.FullName));
var content = grammar.GetContentNode(parser.Parse(text));
incFile.DirectiveNode.Tag = new TranslationTag { ExpandedParseTreeNode = content };
//remember expanded file
_expandedFiles.Add(incFile.File.FullName);
//recursively process content from include file
ExpandIncludeFiles(content, grammar, parser);
}
}
public override object Read(string path)
{
var rawData = new FvSolutionData();
string txt;
using (var reader = new StreamReader(path))
{
txt = reader.ReadToEnd();
}
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
case "options":
ParseOptions(rootEntryNode.ChildNodes[2], rawData);
break;
case "solvers":
ParseSolvers(rootEntryNode.ChildNodes[2], rawData);
break;
}
}
return rawData;
}
private static void LoadBnfFile(string fileName, Builder mainBuilder)
{
Console.WriteLine("Parse BNF file: {0}", fileName);
var bnf = File.ReadAllText(fileName);
var metaParser = new MetaParser();
var meta = metaParser.Parse(bnf);
var oprimizedBnf = Optimize(bnf);
var parser = new Parser(new BnfGrammar(meta.Mode));
var tree = parser.Parse(oprimizedBnf, fileName);
if (tree.Status == ParseTreeStatus.Error)
{
throw new Exception((tree.ParserMessages.Count > 0)
? string.Format("{0}, in {3} file at line {1}, column {2}", tree.ParserMessages[0].Message, tree.ParserMessages[0].Location.Line, tree.ParserMessages[0].Location.Column, fileName)
: string.Format(@"Unknow error in BNF file {0}", fileName));
}
var builder = new Builder(tree, mainBuilder);
builder.BuildExpressions();
foreach (var @using in meta.Usings)
LoadBnfFile(@using, mainBuilder);
}
public void ShouldNotParseWithoutCases()
{
// Arrange
var grammar = new CicodeGrammar();
var parser = new Parser(grammar);
var sourceCode =
@"
FUNCTION A()
SELECT CASE a
END SELECT
END
";
// Act
var parseTree = parser.Parse(sourceCode);
// Assert
Assert.IsNotNull(parseTree);
Assert.IsTrue(parseTree.HasErrors());
// A parser error is expected at the end of line 4 because the expected list of cases which is missing
Assert.AreEqual<int>(1, parseTree.ParserMessages
.Where(m => m.Location.Line == 4)
.Where(m => m.ParserState.ExpectedTerminals.First().Name == "CASE")
.Count());
}
public override object Read(string path)
{
var rawData = new DecomposeParDictData();
string txt;
using (var reader = new StreamReader(path))
{
txt = reader.ReadToEnd();
}
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
case "numberOfSubdomains":
rawData.numberOfSubdomains = rootEntryNode.GetBasicValInt();
break;
}
}
return rawData;
}
public void ShouldNotParseCaseElseWhenNotAtTheEnd()
{
// Arrange
var grammar = new CicodeGrammar();
var parser = new Parser(grammar);
var sourceCode =
@"
FUNCTION A()
SELECT CASE a
CASE 1
A();
CASE ELSE
A();
CASE 1
A();
END SELECT
END
";
// Act
var parseTree = parser.Parse(sourceCode);
// Assert
Assert.IsNotNull(parseTree);
Assert.IsTrue(parseTree.HasErrors());
// A parser error is expected at line 7 because of the CASE ELSE clause which is not at then end of the case list
Assert.AreEqual<int>(1, parseTree.ParserMessages.Where(m => m.Location.Line == 7).Count());
}
private SourceUnitTree Parse(SourceUnit sourceUnit, bool allowSingle, out bool isExpression)
{
isExpression = false;
IronyParser parser = new IronyParser(allowSingle ? singleStatement : fullGrammar);
parser.Context.Mode = ParseMode.CommandLine;
scopes = new Stack<LexicalScopeBuilder>();
EnterTopLevelScope();
try
{
var parsedScript = parser.Parse(sourceUnit.GetCode());
if (parsedScript.HasErrors())
{
sourceUnit.CodeProperties = ScriptCodeParseResult.Invalid;
return null;
}
if (sourceUnit.Kind == SourceCodeKind.InteractiveCode && parser.Context.Status == ParserStatus.AcceptedPartial)
{
sourceUnit.CodeProperties = ScriptCodeParseResult.IncompleteStatement;
return null;
}
sourceUnit.CodeProperties = ScriptCodeParseResult.Complete;
return BuildSourceTree(parsedScript.Root, sourceUnit, allowSingle, out isExpression);
}
catch (Exception e)
{
throw;
}
finally
{
LeaveScope();
}
}
public override object Read(string path)
{
var obj = new FvSolutionData();
string txt = Load(path);
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
case "solvers":
obj.Solvers = GetSolvers(rootEntryNode.GetDictContent());
break;
case "PISO":
case "SIMPLE":
case "PIMPLE":
obj.Solution = GetSolution(identifier, rootEntryNode.GetDictContent());
break;
}
}
return obj;
}
public override object Read(string path)
{
var obj = new AirfoilPropertiesInstance();
string text = Load(path);
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(text);
obj.row = new List<Vertice>();
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var id = rootEntryNode.GetEntryIdentifier();
if (id == "airfoilData")
{
var dict = rootEntryNode.GetDictContent().ChildNodes[1];
foreach (ParseTreeNode t in dict.ChildNodes)
{
var array_head = t.ChildNodes[0].ChildNodes[1].ChildNodes;
var v = new Vertice
{
X = Convert.ToDecimal(array_head[0].ChildNodes[0].Token.Value),
Y = Convert.ToDecimal(array_head[1].ChildNodes[0].Token.Value),
Z = Convert.ToDecimal(array_head[2].ChildNodes[0].Token.Value)
};
obj.row.Add( v );
}
}
}
obj.airfoilName = FileName;
return obj;
}
public override object Read(string path)
{
var obj = new DecomposeParDictData();
string txt = Load(path);
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
case "numberOfSubdomains":
obj.numberOfSubdomains = rootEntryNode.GetBasicValInt();
break;
case "method":
obj.method = rootEntryNode.GetBasicValEnum<DecompositionMethod>();
break;
case "hierarchicalCoeffs":
obj.hCoefs = GetHierarchicalCoeffs(rootEntryNode.GetDictContent());
break;
}
}
return obj;
}
public void HandleFile(string file)
{
if (!System.IO.File.Exists(file))
return;
try
{
FileStream fileStream = System.IO.File.Open(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
using (StreamReader reader = new StreamReader(fileStream))
{
var parser = new Parser(LuaGrammar.Instance);
var tree = parser.Parse(reader.ReadToEnd());
var root = tree.Root;
if (root != null)
{
File = new LuaFile(file, tree.Tokens);
RefreshTree(root);
FileManager.Instance.AddFile(File);
}
else
{
System.Diagnostics.Debug.Print("***********error***********" + file);
}
}
}
catch(Exception e)
{
BabePackage.Setting.LogError("open file failed:" + e.GetType().FullName);
}
}
public ParseTree ParseString(string code)
{
var tree = _parser.Parse(code);
Assert.IsNotNull(tree);
return(tree);
}
public override object Read(string path)
{
var obj = new AirfoilPropertiesData();
string text;
using (var reader = new StreamReader(path))
{
text = reader.ReadToEnd();
}
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(text);
obj.airfoilData = new List<Vertice>();
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var id = rootEntryNode.GetEntryIdentifier();
if (id == "airfoilData")
{
var dict = rootEntryNode.GetDictContent().ChildNodes[1];
for (int i = 0; i < dict.ChildNodes.Count; i++)
{
var array_head = dict.ChildNodes[i].ChildNodes[0].ChildNodes[1].ChildNodes;
var v = new Vertice();
v.X = Convert.ToDecimal(array_head[0].ChildNodes[0].Token.Value);
v.Y = Convert.ToDecimal(array_head[1].ChildNodes[0].Token.Value);
v.Z = Convert.ToDecimal(array_head[2].ChildNodes[0].Token.Value);
obj.airfoilData.Add( v );
}
}
}
return obj;
}
/// <summary>
/// Build a parse tree from trip idl
/// </summary>
/// <param name="tripIdl">trip idl text</param>
/// <returns>a parse tree</returns>
public static ParseTree ParseTripIdl(string tripIdl)
{
Grammar g = new IdlGrammar();
var parser = new Parser(g);
var parseTree = parser.Parse(tripIdl);
return parseTree;
}
public void TestCase()
{
GLSLGrammar lang = new GLSLGrammar ();
var compiler = new Irony.Parsing.Parser(lang);
var tree = compiler.Parse ("void main(void) { float v = vec3(1,1,1); }");
//CheckNodes (tree.Root, 0);
}
public void StructTest01()
{
GLSLGrammar lang = new GLSLGrammar ();
var compiler = new Irony.Parsing.Parser(lang);
var tree = compiler.Parse ("struct Camera { float x;}");
//CheckNodes (tree.Root, 0);
}
public override object Read(string path)
{
string txt;
using (var reader = new StreamReader(path))
{
txt = reader.ReadToEnd();
}
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
var d = new Vertice();
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
case "value":
d.X = rootEntryNode.GetDictArrayBody().GetArrayOfDecimal()[0];
d.Y = rootEntryNode.GetDictArrayBody().GetArrayOfDecimal()[1];
d.Z = rootEntryNode.GetDictArrayBody().GetArrayOfDecimal()[2];
break;
}
}
return d;
}
public override object Read(string path)
{
var obj = new RefineMeshDictData();
string txt;
using (var reader = new StreamReader(path))
{
txt = reader.ReadToEnd();
}
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
string patch;
switch ( identifier )
{
case "set":
obj.setvalue = rootEntryNode.GetBasicValString();
break;
case "coordinateSystem":
obj.coordsys = rootEntryNode.GetBasicValEnum<CoordinateSystem>();
break;
case "globalCoeffs":
{
var dict = rootEntryNode.GetDictContent();
obj.globalCoeffs = GetCoeffs(ref dict, out patch);
}
break;
case "patchLocalCoeffs":
{
var dict = rootEntryNode.GetDictContent();
obj.patchLocalCoeffs = GetCoeffs(ref dict, out patch);
obj.patch = patch;
}
break;
case "directions":
{
obj.direction = new List<DirectionType>();
var s = rootEntryNode.ChildNodes[2].ChildNodes[1].GetArrayOfString();
foreach (string t in s)
{
obj.direction.Add(t.ToEnum<DirectionType>());
}
}
break;
case "useHexTopology":
obj.useHexTopology = rootEntryNode.GetBasicValBool();
break;
case "geometricCut":
obj.geometricCut = rootEntryNode.GetBasicValBool();
break;
case "writeMesh":
obj.writeMesh = rootEntryNode.GetBasicValBool();
break;
}
}
return obj;
}
static int Main(string[] args)
{
try
{
bool mode2 = (((args.Length >= 3) ? args[2] : "") == "mode2");
Console.WriteLine("Create grammar");
var grammar = new XbnfGrammar(mode2 ? XbnfGrammar.Mode.HttpCompatible : XbnfGrammar.Mode.Strict);
Console.WriteLine("Create parser");
var parser = new Parser(grammar);
Console.WriteLine("Read XBNF from {0}", args[0]);
var xbnf = File.ReadAllText(args[0]);
Console.WriteLine("Optimize");
var oprimized = Optimize(xbnf);
Console.WriteLine("Parse");
var tree = parser.Parse(oprimized, "<source>");
Console.WriteLine("Convert to C#");
var csharp = grammar.RunSample(tree);
Console.WriteLine("Write C# to {0}", args[1]);
File.WriteAllText(args[1], AddHeaderFooter(csharp));
}
catch (Exception ex)
{
Console.Write(ex.ToString());
return -1;
}
return 0;
}
public void TestCase()
{
GLSLGrammar lang = new GLSLGrammar();
var compiler = new Irony.Parsing.Parser(lang);
var tree = compiler.Parse("void main(void) { float v = vec3(1,1,1); }");
//CheckNodes (tree.Root, 0);
}
public static bool TestAst(string src)
{
var grammar = new PyUsacGrammar();
var langData = new LanguageData(grammar);
var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser
var parseTree = parser.Parse(src);
var root = parseTree.Root;
if (parseTree.HasErrors())
{
ErrorHelper.ErrorFactory.CreateParsingErrors(parseTree, "_null");
return(false);
}
else
{
var dotCode = GetDot(root);
var astBuilder = new AstBuilder(new AstContext(langData));
astBuilder.BuildAst(parseTree);
var astRoot = (AstNode)root.AstNode;
Debug.WriteLine("");
Debug.WriteLine("--------------------------------------------------");
Debug.WriteLine("");
GetDot(astRoot);
return(true);
}
}
public static bool TestSyntax(string src)
{
var grammar = new PyUsacGrammar();
var langData = new LanguageData(grammar);
var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser
var parseTree = parser.Parse(src);
var root = parseTree.Root;
if (parseTree.HasErrors())
{
ErrorHelper.ErrorFactory.CreateParsingErrors(parseTree, "_null");
return(false);
}
else
{
GetDot(root);
Debug.WriteLine("");
Debug.WriteLine("--------------------------------------------------");
Debug.WriteLine("");
return(true);
}
}
public void StructTest01()
{
GLSLGrammar lang = new GLSLGrammar();
var compiler = new Irony.Parsing.Parser(lang);
var tree = compiler.Parse("struct Camera { float x;}");
//CheckNodes (tree.Root, 0);
}
public override object Read(string path)
{
var rawData = new VelocityData();
string txt;
using (var reader = new StreamReader(path))
{
txt = reader.ReadToEnd();
}
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
//case "turbineArrayOn":
// rawData.TurbineArrayOn = rootEntryNode.GetBasicValBool();
// break;
}
}
return rawData;
}
public bool AssemblyBlock(eBLOCK200_BLOCKTYPES blockType, int blockNr, eBLOCK200_OB_VERSIONS blockVer,
bool forceExpandedFormat, bool bNoWizardInfo, bool bUseChineseOpcode,
string source, out byte[] dest)
{
dest = null;
var server = new CoMsSig200Lib.Sig200ServerClass();
Sig200SignatureList InsList = null;
server.CreateInstructionSignatures(null);
server.SetMnemonic(eSIG200_MNEMONICS.eSIG200_MNEMONIC_SIMATIC);
server.GetInstructionSignatureList(ref InsList);
var grammar = new STLCompiler.STLGrammar();
LanguageData language = new LanguageData(grammar);
Parser parser = new Parser(language);
ParseTree parseTree = parser.Parse(source);
ParseTreeNode root = parseTree.Root;
var project = new STLCompiler.S7Project(root.AstNode as Block, server);
var builder = new CoMsBlock200Lib.Block200Class() as IBlock200Fix;
int pnOBSize, pnOBSizeNoWiz, pnDBArea3Size;
builder.CalcBlockSizes(project, server,
(int)eBLOCK200_OB_VERSIONS.eBLOCK200_OB_VERSION_2ND_GEN_5,
2, /* Must 2, from reverse */
out pnOBSize,
out pnOBSizeNoWiz,
out pnDBArea3Size);
IntPtr ppbyDestBlock = Marshal.AllocCoTaskMem(pnOBSize);
IntPtr ppbyEdgeData = IntPtr.Zero;
int nDestBytes = pnOBSize, nEdges = 0;
try
{
builder.AssembleBlock(project,
server,
(int)eBLOCK200_BLOCKTYPES.eBLOCK200_BLOCKTYPE_OB,
1,
(int)eBLOCK200_OB_VERSIONS.eBLOCK200_OB_VERSION_2ND_GEN_5,
0,
1,
1,
out ppbyDestBlock,
out nDestBytes,
out ppbyEdgeData,
out nEdges);
dest = new byte[nDestBytes];
Marshal.Copy(ppbyDestBlock, dest, 0, nDestBytes);
}
catch(COMException e)
{
Console.Write(e.Message);
return false;
}
return true;
}
public ParseTreeNode getRoot(string sourceCode, Grammar fabricGrammar)
{
LanguageData fabric = new LanguageData(fabricGrammar);
Parser parser = new Parser(fabric);
ParseTree parseTree = parser.Parse(sourceCode);
ParseTreeNode root = parseTree.Root;
return root;
}
public static ParseTree GenerateParseTree(string statement)
{
Grammar grammar = new ID3SQLGrammar();
LanguageData languageData = new LanguageData(grammar);
Parser parser = new Parser(languageData);
ParseTree parseTree = parser.Parse(statement);
return parseTree;
}
private void button1_Click(object sender, EventArgs e)
{
Grammar grammar = new ExpressionGrammar();
Parser parser = new Parser(grammar);
ParseTree parseTree = parser.Parse(richTextBox1.Text);
if (parseTree.Status.ToString() != "Error")
listBox1.Items.Add(parseTree.SourceText);
}
public override object Read(string path)
{
var rawData = new AblPropertiesData();
string txt;
using (var reader = new StreamReader(path))
{
txt = reader.ReadToEnd();
}
var grammar = new OpenFoamGrammar();
var parser = new Parser(grammar);
var tree = parser.Parse(txt);
foreach (ParseTreeNode rootEntryNode in tree.Root.FindDictEntries(null))
{
var identifier = rootEntryNode.GetEntryIdentifier();
switch (identifier)
{
case "turbineArrayOn":
rawData.turbineArrayOn = rootEntryNode.GetBasicValBool();
break;
case "driveWindOn":
rawData.driveWindOn = rootEntryNode.GetBasicValBool();
break;
case "UWindSpeed":
rawData.UWindSpeedDim = rootEntryNode.GetDimVal();
break;
case "UWindDir":
rawData.UWindDir = rootEntryNode.GetBasicValDecimal();
break;
case "hWind":
rawData.HWindDim = rootEntryNode.GetDimVal();
break;
case "alpha":
rawData.alpha = rootEntryNode.GetBasicValDecimal();
break;
case "lowerBoundaryName":
rawData.lowerBoundaryName = rootEntryNode.GetBasicValString();
break;
case "upperBoundaryName":
rawData.upperBoundaryName = rootEntryNode.GetBasicValString();
break;
case "statisticsOn":
rawData.statisticsOn = rootEntryNode.GetBasicValBool();
break;
case "statisticsFrequency":
rawData.statisticsFrequency = rootEntryNode.GetBasicValDecimal();
break;
case "meanAvgStartTime":
rawData.meanAvgStartTime = rootEntryNode.GetBasicValDecimal();
break;
case "corrAvgStartTime":
rawData.corrAvgStartTime = rootEntryNode.GetBasicValDecimal();
break;
}
}
return rawData;
}
private void ParseSourceCode()
{
LanguageData language = new LanguageData(grammar);
Parser gridWorldParser = new Parser(language);
ParseTree parseTree = gridWorldParser.Parse(immediateRepresentation.ZestSourceCode);
immediateRepresentation.HasErrors = parseTree.HasErrors();
immediateRepresentation.ParseTreeRoot = parseTree.Root;
immediateRepresentation.ErrorList = parseTree.ParserMessages;
}
public ParseTreeNode getRoot(string sourceCode, Grammar grammar)
{
LanguageData language = new LanguageData(grammar);
Irony.Parsing.Parser parser = new Irony.Parsing.Parser(language);
ParseTree parseTree = parser.Parse(sourceCode);
ParseTreeNode root = parseTree.Root;
if (root == null)
{
throw new Exception(parseTree.ParserMessages[0].ToString());
}
return(root);
}
public static bool InterpretFromFileName(string filePath)
{
string src;
try
{
src = File.ReadAllText(filePath);
}
catch (Exception)
{
//Reprotar error de preprocesador
return(false);
}
var grammar = new PyUsacGrammar();
var langData = new LanguageData(grammar);
var parser = new Irony.Parsing.Parser(langData);//Para evitar conflicto con el namespace Parser
var parseTree = parser.Parse(src);
var root = parseTree.Root;
bool hasErrors = false;
foreach (var error in parseTree.ParserMessages)
{
if (error.Level == Irony.ErrorLevel.Error)
{
hasErrors = true;
}
ErrorHelper.ErrorFactory.CreateParsingError(error, filePath);
}
if (hasErrors)
{
return(false);
}
//var dotCode = GetDot(root);//Descomentar en debug mode! :)
var astBuilder = new PyAstBuilder(new AstContext(langData), filePath);
astBuilder.BuildAst(parseTree);
var programNode = (ProgramNode)parseTree.Root.AstNode;
//GetDot(programNode);//Descomentar en debug mode! :)
var entity = new StaticEntity(programNode);
entity.InitVisitor(true);
entity.InvokeMain();
TypeConstants.ClearTypeHashtable();
return(true);
}
bool ParseJava (string javaSourceText)
{
var parser = new Irony.Parsing.Parser (grammar);
var result = parser.Parse (javaSourceText);
foreach (var m in result.ParserMessages)
Console.WriteLine ($"{m.Level} {m.Location} {m.Message}");
if (result.HasErrors ())
return false;
var parsedPackage = (JavaPackage)result.Root.AstNode;
FlattenNestedTypes (parsedPackage);
var pkg = api.Packages.FirstOrDefault (p => p.Name == parsedPackage.Name);
if (pkg == null) {
api.Packages.Add (parsedPackage);
pkg = parsedPackage;
} else
foreach (var t in parsedPackage.Types)
pkg.Types.Add (t);
pkg.Types = pkg.Types.OrderBy (t => t.Name).ToList ();
return true;
}
public Hub ParseString(string text)
{
var grammar = new HubGrammar();
var language = new LanguageData(grammar);
var parser = new Irony.Parsing.Parser(language);
var tree = parser.Parse(text);
var hub = new Hub
{
Id = tree.Root.ChildNodes.Single(x => x.Term.Name == "Name").ChildNodes[0].Token.ValueString,
Name = tree.Root.ChildNodes.Single(x => x.Term.Name == "Name").ChildNodes[1].Token.ValueString,
HubType = tree.Root.ChildNodes.Single(x => x.Term.Name == "HubType").ChildNodes[0].Token.ValueString,
Lines = new List <string>(tree.Root.ChildNodes.Where(x => x.Term.Name == "Line").Select(x => x.ChildNodes[0].Token.ValueString)),
Lores = new List <string>(tree.Root.ChildNodes.Where(x => x.Term.Name == "Lore").Select(x => x.ChildNodes[0].Token.ValueString)),
};
return(hub);
}
// Build the Irony parse tree, then do a depth-first search through it, building an expression tree.
public override void Parse(Root root, string text)
{
if (text.Trim() == "")
{
return;
}
ParseTree parseTree = parser.Parse(text);
foreach (var parseError in parseTree.ParserMessages)
{
root.CompilerErrors.Add(new ParserCompilerError("", parseError.Location.Line, parseError.Location.Column, parseError.Message));
}
if (root.CompilerErrors.Count > 0)
{
return;
}
ConsumeParseTree(root, root, parseTree.Root);
}
public void GetDeclarations(LuaBlockNode block, LuaModel model)
{
// require("sample.lua")
if (Target != null &&
(Target.AsString == "require" ||
Target.AsString == "NPL.load") &&
Arguments.ChildNodes.Count == 1 &&
Arguments.ChildNodes[0] is LuaLiteralNode &&
((LuaLiteralNode)Arguments.ChildNodes[0]).Type == LuaType.String)
{
string fileName = ((LuaLiteralNode)Arguments.ChildNodes[0]).Value;
fileName = fileName.Substring(1, fileName.Length - 2);
try
{
string filePath = Path.Combine(Path.GetDirectoryName(model.FilePath), fileName);
// project mode
if (model.Entry != null && model.Entry.Analyzer != null && model.Entry.Analyzer.ContainsFile(filePath))
{
AnalysisEntry requiredEntry = model.Entry.Analyzer.GetAnalysisEntry(filePath);
if (requiredEntry.Model != null)
{
block.Requires.AddRange(requiredEntry.Model.GetGlobalDeclarations());
model.AddIncludedFile(filePath, requiredEntry.Model);
}
}
// singleton mode
else
{
string source = File.ReadAllText(filePath);
Irony.Parsing.Parser parser = new Irony.Parsing.Parser(LuaGrammar.Instance);
ParseTree tree = parser.Parse(source);
LuaModel requiredModel = new LuaModel(tree, filePath);
block.Requires.AddRange(requiredModel.GetGlobalDeclarations());
model.AddIncludedFile(filePath, requiredModel);
}
}
catch (Exception e)
{
}
}
}
static void Main(string[] args)
{
LanguageData LangData = new LanguageData(new UIGrammar());
Irony.Parsing.Parser Pars = new Irony.Parsing.Parser(LangData);
StringBuilder SBuilder = new StringBuilder();
foreach (string Statement in File.ReadLines("C:\\Program Files\\Maxis\\The Sims Online\\TSOClient\\gamedata\\uiscripts\\personselection.uis"))
{
SBuilder.Append(Statement + "\r\n");
}
Debug.WriteLine("Attempting to parse: " + SBuilder.ToString());
ParseTree Tree = Pars.Parse(SBuilder.ToString());
//DisplayTree((AstNode)Tree.Root.AstNode, 0);
WalkTree(Tree.Root);
Console.ReadLine();
}
public DeclaredObjectContainer Parse(string programFile)
{
string program = System.IO.File.ReadAllText(programFile);
var grammar = new BDVHDLGrammar();
var parser = new Irony.Parsing.Parser(grammar);
var ast = parser.Parse(program);
if (ast.Status != ParseTreeStatus.Parsed)
{
throw new ParserException(programFile, ast.Status, ast.ParserMessages);
}
(new TreeConverter()).Convert(ast, grammar);
var evaluator = new NodeEvaluator();
evaluator.EvaluateGeneral(ast.Root);
return(evaluator.declaredObjects);
}
public ParseTree Parse(string source, string fileName)
{
return(internalParser.Parse(source, fileName));
}
public void StructTest02()
{
GLSLGrammar lang = new GLSLGrammar();
var compiler = new Irony.Parsing.Parser(lang);
var tree = compiler.Parse("struct Camera { float x; int num; }; ");
}
public void StructTest04()
{
GLSLGrammar lang = new GLSLGrammar();
var compiler = new Irony.Parsing.Parser(lang);
var tree = compiler.Parse("struct Camera { float x; int num; vec3 output; vec2 data[10]; vec4 grid[3][4]; bool samples[]; };");
}
public ParseTree Parse(string instructions)
{
return(Parser.Parse(instructions));
}
