<< Oslo - My First Language in MGrammar | LEAP 2009 : MC3 & MC4 >>

Oslo – In Memory / Dynamic MGrammar compilation using the MGrammarCompiler

Robert Jan - Friday, November 07, 2008 - 11:28 AM

At the last day of the PDC, Chris Anderson and Giovanni Della-Libera showed us how to build textual DSL’s with the Oslo modeling language. I wrote a blog post about this session and in that post you can find this image:

Normally you would use the MG.exe compiler or the MG Build Task to compile your languages. But as the slide above indicates, the MGrammar team provided us with an in-memory version of the MG build task. So let’s try this out!

For this exercise I reuse the language and instance data I created in my blog post: My First Language in MGrammar

Module

First, I created the Module class. This class represents the MGrammar textual DSL. It also contains the name of the parser you want to create (more on that later on in this post) and the result bytes of the compiled DSL:

        1: public class Module

       2: {

       3:     public string MGrammar { get; set; }

       4:     public string ParserName { get; set; }

       5:     public byte[] Bytes { get; set; }

       6: }

DynamicMGrammarCompiler

The dynamic compiler class I created can be used in two scenarios:

You compile the module, cache it in your host application and reuse this module when parsing data through your DSL. Compiling a module is an expensive operation; it burns quite some CPU cycles, so reusing it seems like a good idea.
You compile the module and parse your data through your DSL every single call.

The above scenarios result in three methods: CompileModule, ParseData and CompileModuleAndParseData:

       1: public class DynamicMGrammarCompiler

       2: {

       3:  

       4:     /// <summary>

       5:     /// Compile the module, and store the graph in the byte[], so the 

       6:     /// client application can cache this compiled image

       7:     /// </summary>

       8:     /// <param name="module"></param>

       9:     /// <returns></returns>

    public Module CompileModule(Module module) 

    {

  

        MGrammarCompiler compiler = new MGrammarCompiler(); 

        ErrorReporter reporter = ErrorReporter.Standard;

        TextReader reader = new StringReader(module.MGrammar);

        FileStream fs = null;

        try

        {

            SourceItem item = new SourceItem(module.ParserName, reader);

            item.ContentType = GContentType.Mg;

            SourceItem[] items = new SourceItem[] { item };

            compiler.SourceItems = items;

            compiler.Target = Target.Mgx;

            compiler.TypeCheckActions = true;

            compiler.OutFile = Path.GetTempFileName();

            compiler.Execute(reporter);

            //read bytes 

            string filepath = Path.Combine(Path.GetDirectoryName(compiler.OutFile), Path.GetFileNameWithoutExtension(compiler.OutFile) + ".mgx");

            fs = new FileStream(filepath, FileMode.Open, FileAccess.Read);

            byte[] bytes = new byte[fs.Length];

            fs.Read(bytes, (int)0, (int)fs.Length);

            fs.Close();

            module.Bytes = bytes;

        }

        finally

        {

            if (null!=fs)

            {

                fs.Close();

            }

            reader.Close();

        }

        return module; 

    }

  

    /// <summary>

    /// Parse the instancedata through the compiled image within the module

    /// </summary>

    /// <param name="module"></param>

    /// <param name="instanceData"></param>

    /// <returns></returns>

    public object ParseData(Module module, string instanceData) 

    {

  

        object result = null;

        MemoryStream ms = null;

        StringReader sr = new StringReader(instanceData);

        try

        {

            ms = new MemoryStream(module.Bytes);

            DynamicParser parser = MGrammarCompiler.LoadParserFromMgx(ms, module.ParserName);

            if (null == parser)

            {

                throw new NullReferenceException(string.Format("Language with name '{0}' not found in MGrammar image!", module.ParserName));

            }

            

            result = parser.ParseObject(sr, ErrorReporter.Standard);

        }

        finally

        {

            if (null != ms)

            {

                ms.Close();

            }

            sr.Close();

        }

        return result;

    }

  

    /// <summary>

    /// Both Compile and Parse.

    /// </summary>

    /// <param name="module"></param>

    /// <param name="instanceData"></param>

    /// <returns></returns>

    public object CompileModuleAndParseData(Module module, string instanceData)

    {

        module = CompileModule(module);

        return ParseData(module, instanceData);

    }

}

CompileModule creates a MGrammarCompiler instance and loads theMGrammar we want to compile in a TextReader. Then, I create a SourceItem instance which will tell the MGrammarCompiler what type of source it can expect and provides the source (textual DSL) itself.
Then, I tell the compiler that the target of the compilation should be a MGX file. I also provide a temporary file name to write the result to, and then call Execute!
The last step is opening the created file and reading its bytes and returning them within the module instance.

ParseData receives a module and some input instance data. I first read the instance data and create a stream of the module bytes. Then I create a DynamicParser using the stream and the provided ParserName. Important to know here is that the parser name should be the module name and the language name concatenated with a dot. As I’m using my RssLanguage from the inwit module, my parser name should be “inwit.RssLanguage”.
If a correct parser is created, we use it parse our instance data and create a graph. I just return this graph to the caller.

CompileModuleAndParseData just combines the above two steps in one call.

Test Application

As a test application I created a console App:

       1: class Program

       2: {

       3:     static void Main(string[] args)

       4:     {

       5:         Console.WriteLine(">>Initializing...");

       6:         string filePathMGrammar =       @"C:\Users\Robert Jan\Desktop\My Documents\Oslo\MyOslo\RssLanguage.mg";

       7:         string filePathInstanceData =   @"C:\Users\Robert Jan\Desktop\My Documents\Oslo\MyOslo\FeedsInput.m";

       8:         

       9:         string mGrammar = File.ReadAllText(filePathMGrammar);

        string instanceData = File.ReadAllText(filePathInstanceData);

  

        inwit.Module module = new inwit.Module();

        module.MGrammar = mGrammar;

        module.ParserName = "inwit.RssLanguage";

  

        inwit.DynamicMGrammarCompiler compiler = new inwit.DynamicMGrammarCompiler();

        

        //first compile and cache module

        Console.WriteLine(">>Step 1: compiling module");

        module = compiler.CompileModule(module);

  

        //second reuse module, and just parse instancedata

        Console.WriteLine(">>Step 2a: parsing instance data");

        object graph = compiler.ParseData(module, instanceData);

        Console.WriteLine(">>Step 2b: Writing result:");

        inwit.Helper.WalkMGraphTree(graph);

        

        //third, do all in one call

        Console.WriteLine(">>Step 3a: compiling module and parsing data in one call...");

        graph = compiler.CompileModuleAndParseData(module, instanceData);

        Console.WriteLine(">>Step 3b: Writing result:");

        inwit.Helper.WalkMGraphTree(graph);

  

        Console.ReadLine();

    }

}

I’m using the Helper.WalkMGraphTree method from my previous post again to output the result graph.

The result of the console app looks like:

Posted in: Oslo , MGrammar Tags:

Actions: E-mail | Permalink | Comments (0)

| Kick it! | DZone it! | del.icio.us

Currently rated 5.0 by 1 people

Currently 5/5 Stars.
1
2
3
4
5

Oslo - My First Language in MGrammar Update: Something went wrong with the code snippets; should be shown correctly now! Now we h...Oslo – Enabling MGrammarMode in Intellipad I installed the Oslo CTP SDK on my laptop, and wanted to try out some MGrammar stuff. I looked all...PDC – Final Day – Building Textual DSL’s with the “Oslo” Modeling Language Again an Oslo session :) By the way, I really like how Chris Anderson presents these subjects. W...

Mo	Tu	We	Th	Fr	Sa	Su
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	1	2	3
4	5	6	7	8	9	10

Oslo – In Memory / Dynamic MGrammar compilation using the MGrammarCompiler

Related posts

Categories

Page List

Calendar

Month List

Recent Posts

Recent Comments

Mo	Tu	We	Th	Fr	Sa	Su
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	1	2	3
4	5	6	7	8	9	10

Mo	Tu	We	Th	Fr	Sa	Su
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	1	2	3
4	5	6	7	8	9	10

Oslo – In Memory / Dynamic MGrammar compilation using the MGrammarCompiler

Related posts

Categories

Page List

Calendar

Blog Roll

Month List

Recent Posts

Recent Comments

Mo	Tu	We	Th	Fr	Sa	Su
30	31	1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	1	2	3
4	5	6	7	8	9	10