Seattle skyline

Next to this event I have some time off to go to Olympic National Park; roam downtown Seattle and have a look on how the American Dream is lived. Or do you have to be asleep to believe it?

The reason they call it the American Dream is because you have to be asleep to believe it.
- George Carlin

Hang around for photos! :-)

Developing:
First of a snippet from the input Makefile:

######################################
# m builds
+m #executable
    @All #target
        files 	= m\*.m
	out	= bin\mx\Image.mx
	package = Image

    @AllToRepository
	files 	= m\*.m
	out	= bin\sql\ImageRep.sql
	target 	= Repository

    @AllToTsql
	files 	= m\*.m
	out	= bin\sql\ImageTsql.sql
	target	= Tsql10

After specifying the input file, we continue..

• Create MGrammar to parse Makefile to a graph.
• Compile MGrammar to Mgx or MgxResource to use in the runtime.
• Build a runtime: at first I wanted to build a runtime in Intellipads scriptengine (IronPython), but I encountered errors on DynamicParser.Parse(), which I couldn’t resolve. Since IronPython was no use for me at the moment, I used the .NET 3.5 Console Application (mmake.exe <executable>.<target>) to parse the graph and execute the build command with the proper parameters from the graph.
• Create a new Minibuffer command in IronPython which takes a <executable>.<target> as parameter (eg m.All). A new process will be created to call mmake.exe m.All and its stdout will be redirected to a new BufferView in Intellipad.

Python Magic

FindHelper.py

from Microsoft.Intellipad.Host import HostWindow
from System.Windows import MessageBox, MessageBoxButton, MessageBoxImage
from System.Diagnostics import Process, ProcessStartInfo
from System.IO import Directory, Path
...
def BuildImpl(activeView, target):
    filePath = GetFriendlyFilePath(activeView.Buffer.Uri.AbsolutePath)    

    if filePath.find("Makefile") >= 0:
        hostWindow = HostWindow.GetHostWindowForBufferView(activeView)
        buildBuffer = Common.BufferManager.GetBuffer(System.Uri('transient://build'))
        Common.Clear(buildBuffer)

        view = Common.GetView(hostWindow, buildBuffer)
        if view is None:
            hostWindow.ShowInRoot(buildBuffer, 40.0)

        fileDir = Path.GetDirectoryName(filePath)
        (exitCode, stdout, stderr) = RunBuildCommand("mmake", fileDir, target)
        Common.Write(buildBuffer, stdout + "\n" + stderr)
    else:
        message = "Error: Makefile needs to be in the active buffer."
        MessageBox.Show(message, IntellipadMessageBoxTitle , MessageBoxButton.OK,
 MessageBoxImage.Information)

def GetFriendlyFilePath(fileUri):
    path = str(fileUri).replace('%20', ' ')
    return path.replace('/', '\\')

def RunBuildCommand(cmd, pwd, args):
    processStartInfo = ProcessStartInfo()
    processStartInfo.WorkingDirectory = pwd
    processStartInfo.FileName = cmd
    processStartInfo.Arguments = args
    processStartInfo.UseShellExecute = False
    processStartInfo.RedirectStandardOutput = True
    processStartInfo.RedirectStandardError = True

    process = Process()
    process.StartInfo = processStartInfo
    process.Start()
    process.WaitForExit()

    stdout = process.StandardOutput.ReadToEnd()
    stderr = process.StandardError.ReadToEnd()
    return process.ExitCode, stdout, stderr

MiniBufferCommandSetup.py

def Build(target):
        FindHelper.BuildImpl(MiniBufferHelper.GetActiveView(), target)

Running the Makefile:
When I use Intellipad to work on my grammars and models, I have the following directory setup:

Now open up the Makefile in Intellipad:
Note: All paths specified in the Makefile are relative to the path of the Makefile.

Hit Ctrl+/ to bring up the Minibuffer and type: Build(’<executable>.<target>’)
Note: Intellipad needs to know what directory the Makefile is in, so the Makefile buffer should be active (selected) before bringing up the Minibuffer.

Command will run and output to a new BufferView:

Download:

• Sample project directory (Makefile and samples from Oslo SDK 1.0 for sample builds).
• mmake (1 runtime, 1 mgx and 2 .py): Extract archive in %PATH_TO_OSLO_SDK%\Bin

Install notes:

• Add %PATH_TO_OSLO_SDK%\Bin to system var: PATH
• Backup .py files in case Intellipad stops working: FindHelper.py and MiniBufferCommandSetup.
  %PATH_TO_OSLO_SDK%\Bin\Intellipad\FindHelper.py
  %PATH_TO_OSLO_SDK%\Bin\Intellipad\Components\Microsoft.Intellipad.Scripting\PrivateScripts
• Write permission errors on %PATH_TO_OSLO_SDK%: fix directory settings.

What’s next?

• Hyperlinks on buildtargets in Intellipad: click to compile.
• Resolving IronPython issues with DynamicParser.Parse().
• Build a horizontal DSL instead of a vertical DSL for Makefiles.

Bugs and errors:
Post bugs or suggestions in the comments or drop me a line via email. :-)

References:

• http://blogs.msdn.com/Intellipad/
• http://www.ironpython.info/index.php/Contents
• http://www.sellsbrothers.com/news/showTopic.aspx?ixTopic=2256

Dear readers,

I’ve been working on a small project called “OsloTool” and I thought it would be best to share this with the rest of the Oslo developers. It saved me a lot of time developing Oslo applications.

Basically it’s a Graphical User Interface on top of the commandline tools: mg.exe, mgx.exe, m.exe and mx.exe. Untill Microsoft Implements build-options into IntelliPad u can use this (if you hate commandline as much as I do).

I’ll post the source as well, so you can modify and maybe even expand it.

Screenshot:
http://img9.imageshack.us/img9/1353/oslotool.jpg

Download:
http://michaelwolbert.nl/projects/Oslo/OsloTool.zip (thanks to my dear colleague and friend, Michael Wolbert)

Mirror:
http://www.zshare.net/download/56614958a3fce0d5/

Note:
In “Commands.cs” there is this line of code which specifies Oslo Directory:
static string OsloDirectory = “C:/program files/microsoft oslo sdk 1.0″;

If you got any questions concerning OsloTool feel free to leave a message!

Greeting,
Bryan Sumter

Oslo MSDN Community post

Grab the executable and source here!

I’ve defined the way I’d like to create my blogs, posts and blogrolls in a textual way:

Blog
    With Title OsloBlog
    Section Posts
        Post With Title MGrammar And Desc MGrammar
        Post With Title Quadrant And Desc Quadrant
    End Section
    Section Blogroll
        Link With Title Oslo And Url http://microsoft.com
        Link With Title Michael And Url http://michaelwolbert.nl
    End Section
End Blog
Blog
    With Title MichaelBlog
    Section Posts
        Post With Title Avanade And Desc Ava
        Post With Title Testing123 And Desc Testing123456789
    End Section
End Blog

With our grammar (parser) we can now create projections of our textual DSL:

Blog[
    Title[
      "MichaelBlog"
    ],
    Sections[
      Posts[
        Post[
          Title[
            "Avanade"
          ],
          Desc[
            "Ava"
          ]
        ],
        Post[
          Title[
            "Testing123"
          ],
          Desc[
            "Testing123456789"
          ]
        ]
      ]
    ]
  ]

Next step would be to push this projections to Oslo’s repository (just a plain ol’ SQL 2008 database), so a runtime can access it. We could also create a runtime which uses a set of classes to parse our textual DSL directly to the runtime. But that will be covered later on.

See this Intellipad screenshot for the textual DSL, the MGrammar and the projections (from L to R).

Some nice samples can be found in the “M” Language Gallery. Especially Natural Language Dates has some good pointers to get started.