public static CompileResult Compile(string typeSql, string typeSqlFileName)
{
//create the antlr-based lexer and parser
var lexer = new TypeSqlLexer(new ANTLRStringStream(typeSql));
var rewriteTokenStream = new TokenRewriteStream(lexer);
var parser = new TypeSqlParser(rewriteTokenStream);
//parse the typeSql, producing the AST
var ast = (CommonTree) parser.typesql().Tree;
var nodeStream = new CommonTreeNodeStream(ast);
//transform the AST into raw-sql
var rawSqlOutput = new RawSqlTransform(nodeStream);
nodeStream.TokenStream = rewriteTokenStream;
rawSqlOutput.typeSql();
string rawSql = rewriteTokenStream.ToString();
//reset
lexer.Reset();
rewriteTokenStream.Reset();
nodeStream.Reset();
//and transform the AST into DAO source code
var daoTransform = new DaoTransform(nodeStream){TemplateGroup = new StringTemplateGroup(
new StreamReader(typeof(TypeSqlCompiler).Assembly.GetManifestResourceStream("TypeSql.Parsing.DapperDao.stg")),
typeof (TemplateLexer))};
var template = daoTransform.typeSql(typeSqlFileName, rawSql).Template;
string daoSourceCode = template.ToString();
return new CompileResult(daoSourceCode, rawSql);
}
public void Load(string path)
{
var tokens = new CommonTokenStream(GetLexer(path));
var parser = new JavaParser(tokens);
parser.enableErrorMessageCollection(true);
var tree = parser.JavaSource().Tree;
var nodes = new CommonTreeNodeStream(tree);
var xs = new JavaTreeParser(nodes);
xs.enableErrorMessageCollection(true);
var rootNode = xs.JavaSource();
if (!parser.hasErrors() && !xs.hasErrors())
{
}
else
{
foreach (var message in parser.getMessages())
{
Console.WriteLine(message);
}
foreach (var message in xs.getMessages())
{
Console.WriteLine(message);
}
throw new NotImplementedException();
}
}
public OclCompilerResult CompileEvolutionScript(string text, Bridge.IBridgeToOCL bridge)
{
TypesTable.TypesTable tt = bridge.TypesTable;
ErrorCollection errColl = new ErrorCollection();
// lexer
ANTLRStringStream stringStream = new ANTLRStringStream(text);
OCLSyntaxLexer lexer = new OCLSyntaxLexer(stringStream, errColl);
// syntax
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
OCLSyntaxParser parser = new OCLSyntaxParser(tokenStream, errColl);
var output = parser.evolutionDeclarationList();
// semantic
Antlr.Runtime.Tree.CommonTreeNodeStream treeStream = new CommonTreeNodeStream(output.Tree);
OCLAst semantic = new OCLAst(treeStream, errColl);
semantic.TypesTable = tt;
semantic.Bridge = bridge;
semantic.EnvironmentStack.Push(new NamespaceEnvironment(tt.Library.RootNamespace));
AST.Constraints constraints;
AST.PropertyInitializations initializations;
// try {
OCLAst.evolutionDeclarationList_return evolutionDeclarationListReturn = semantic.evolutionDeclarationList();
constraints = evolutionDeclarationListReturn.Constraints;
initializations = evolutionDeclarationListReturn.PropertyInitializations;
// }
//catch{
// constraints = new AST.Constraints();
// errColl.AddError(new ErrorItem("Fatal error."));
// }
return(new OclCompilerResult(constraints, initializations, errColl, tt.Library, bridge));
}
/// <summary>
/// Compile stand-alone expression.
/// </summary>
/// <example>
/// Example shows how to parse stand-alone invariant.
/// <code>
/// <![CDATA[
/// // ...
/// Environment nsEnv = new NamespaceEnvironment(tt.Library.RootNamespace);
/// VariableDeclaration varSelf = new VariableDeclaration(selfName, contextClassifier, null);
/// Environment classifierEnv = nsEnv.CreateFromClassifier(contextClassifier, varSelf);
/// Environment selfEnv = Environment.AddElement(selfName, contextClassifier, varSelf, true);
///
/// Compiler.Compiler compiler = new Compiler.Compiler();
/// var result = compiler.CompileStandAloneExpression(expressionText, tt, selfEnv);
/// ]]>
/// </code>
/// </example>
public ExpressionCompilerResult CompileStandAloneExpression(string text, TypesTable.TypesTable tt, Environment env)
{
ErrorCollection errColl = new ErrorCollection();
// lexer
ANTLRStringStream stringStream = new ANTLRStringStream(text);
OCLSyntaxLexer lexer = new OCLSyntaxLexer(stringStream, errColl);
// syntax
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
OCLSyntaxParser parser = new OCLSyntaxParser(tokenStream, errColl);
var output = parser.oclExpression();
// semantic
Antlr.Runtime.Tree.CommonTreeNodeStream treeStream = new CommonTreeNodeStream(output.Tree);
OCLAst semantic = new OCLAst(treeStream, errColl);
semantic.TypesTable = tt;
semantic.EnvironmentStack.Push(env);
AST.OclExpression expression;
// try {
expression = semantic.oclExpression();
// }
//catch{
// constraints = new AST.Constraints();
// errColl.AddError(new ErrorItem("Fatal error."));
// }
return(new ExpressionCompilerResult(expression, errColl, tt.Library));
}
public static JsonArray Parse(string s)
{
var inputStream = new ANTLRStringStream(s);
var lexer = new JsonLexer(inputStream);
var tokens = new CommonTokenStream(lexer);
var parser = new JsonParser(tokens);
var parseTree = parser.array().Tree;
var stream = new CommonTreeNodeStream(parseTree);
var tree = new JsonTree(stream);
var @object = tree.array();
Contract.Assume(@object != null);
return(new JsonArray(JsonValueTypes.Interpret(@object)));
}
public virtual void ApplyOnce( object t, System.Action whichRule )
{
if ( t == null )
return;
try
{
// share TreeParser object but not parsing-related state
state = new RecognizerSharedState();
input = new CommonTreeNodeStream( originalAdaptor, t );
( (CommonTreeNodeStream)input ).TokenStream = originalTokenStream;
BacktrackingLevel = 1;
whichRule();
BacktrackingLevel = 0;
}
catch ( RecognitionException )
{
}
}
public static void Main(string[] args)
{
ICharStream input;
if ( args.Length>0 ) {
input = new ANTLRFileStream(args[0]);
}
else {
input = new ANTLRReaderStream(Console.In);
}
// BUILD AST
PolyLexer lex = new PolyLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lex);
PolyParser parser = new PolyParser(tokens);
PolyParser.poly_return r = parser.poly();
Console.Out.WriteLine("tree="+((ITree)r.Tree).ToStringTree());
// DIFFERENTIATE
CommonTreeNodeStream nodes = new CommonTreeNodeStream(r.Tree);
nodes.TokenStream = tokens;
PolyDifferentiator differ = new PolyDifferentiator(nodes);
PolyDifferentiator.poly_return r2 = differ.poly();
Console.Out.WriteLine("d/dx="+((ITree) r2.Tree).ToStringTree());
// SIMPLIFY / NORMALIZE
nodes = new CommonTreeNodeStream(r2.Tree);
nodes.TokenStream = tokens;
Simplifier reducer = new Simplifier(nodes);
Simplifier.poly_return r3 = reducer.poly();
Console.Out.WriteLine("simplified="+((ITree) r3.Tree).ToStringTree());
// CONVERT BACK TO POLYNOMIAL
nodes = new CommonTreeNodeStream(r3.Tree);
nodes.TokenStream = tokens;
PolyPrinter printer = new PolyPrinter(nodes);
PolyPrinter.poly_return r4 = printer.poly();
Console.Out.WriteLine(r4.ST);
}
