tech.einaregilsson.com

Module initializers in C#

einar — Wed, 16 Dec 2009 15:34:01 +0000

One feature of the CLR that is not available in C# or VB.NET are module initializers (or module constructors). A module initializer is simply a global function which is named .cctor and marked with the attributes SpecialName and RTSpecialName. It is run when a module (each .NET assembly is comprised of one or more modules, typically just one) is loaded for the first time, and is guaranteed to run before any other code in the module runs, before any type initializers, static constructors or any other initialization code. I wanted to use this feature for a project I was doing but was unable to use it directly in C# so I created my own solution.

Now, why did I need this? Well, I was loading my other assemblies from an unusual place and I wanted to subscribe to the AppDomain.AssemblyResolve event before any types in my assembly were initialized. This feature is clearly not something you’re going to need every day, (actually I can’t think of a single other use case where I’d need it) but if you do, here’s how I solved it.

I used the excellent Mono.Cecil library to create a small program that injects a module initializer into an existing assembly. Cecil is a fantastic library that makes it incredibly easy to manipulate assemblies and can do pretty much anything that you could possibly want to do with IL code. Using it I wrote a small program that simply takes in an assembly filename and the name of a parameterless static void method that exists in the assembly, and injects a module initializer that does nothing but call that method. The original code I wrote, the interesting part without all the error checking and stuff, is shown below:

string assemblyName = "Test.dll";
string typeName = "Foo.Bar.ModuleInit";
string methodName = "Run";

AssemblyDefinition assembly = AssemblyFactory.GetAssembly (assemblyName);
TypeReference voidRef = assembly.MainModule.Import(typeof(void));
var attributes = MethodAttributes.Static
                | MethodAttributes.SpecialName
                | MethodAttributes.RTSpecialName;
var cctor = new MethodDefinition( ".cctor", attributes, voidRef);

TypeDefinition type = assembly.MainModule.Types[typeName];
MethodReference methodRef = type.Methods.GetMethod(methodName,new Type[]{});
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Call, methodRef));
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Ret));
assembly.MainModule.Inject(cctor, assembly.MainModule.Types[""]);
AssemblyFactory.SaveAssembly(assembly, assemblyName);

I then added all the neccessary error handling, unit testing etc. and the resulting program can be downloaded here. The program is just a single executable since I merged Mono.Cecil into it using the excellent ILMerge tool. You can run it from the command line and give it the filename of your assembly and optionally specify the method to call. If no method is explicitly specified then the program looks for a type named ModuleInitializer (may be in any namespace) and looks for a method named Run in that type and calls that method in the module initializer.

Run without specifying the method, looks for ModuleInitializer::Run in any namespace.

InjectModuleInitializer.exe Test.dll

Run and specify the method as Foo.Bar.SomeClass::SomeMethod

InjectModuleInitializer.exe /m:Foo.Bar.SomeClass::SomeMethod Test.dll

Realistically though, if you want to do this you probably want to do it right after building your assembly. That’s why the assembly also includes an MSBuild task, so that it can be used directly in a .csproj file. The best target to use for this is the AfterBuild target. To use this task in your project you need to edit your .csproj file and add two things:

At the top, inside the
element include the following:
If the InjectModuleInitializer.exe assembly is registered in the global assembly cache you could also write that as
Add the AfterBuild target at the bottom of the file, or anywhere where
elements are allowed.
```
    
```
Or, if you want to explicitly specify the method to run:
```
    
```

And there you have it. You can download the console program/MSBuild task or download the source code and build it yourself. Enjoy.

Easy way to have custom icons in Visual Studio AddIn

einar — Fri, 20 Nov 2009 09:39:34 +0000

I’ve recently been developing a Visual Studio AddIn and I wanted to use custom icons for a command I had. Looking for a solution I found the offical MSDN article on the subject, that might possibly be the most misleading and useless article ever. Add the resource file in Visual Studio, then exclude from project, rename your images to numbers, edit with Notepad and then build satellite assemblies on the commandline? Really? That is a horrible way to do it and not at all necessary. I’ve found a very simple and easy way to add these icons without all that hassle.

There are a couple of other articles out there that approach the problem in a different way. Roy Osherove has an article where he shows how you can add icons without having satellite assemblies for them, but that has > 350 lines of code for loading the images yourself including P/Invokes and all sorts of stuff, and I didn’t really need such a heavyweight solution. To be fair, his solution does give you the ability to use .ico files as well, and offers transparency, but transparency can be achieved in an easier way.

I also found another article that shows how you can get transparency by using a special color that, as far as I know, is not documented anywhere officially. It also shows you how you can build a satellite assembly from Visual Studio without resorting to Notepad and the command line tools, but this approach uses a special project for the satellite assembly, which is completely unneccessary.

So, finally, my approach, which is really a refinement of the last article I mentioned. If your add-in is meant for only VS2008 then you can get away with having no satellite assembly, VS2008 falls back to looking in your main assembly for the resources if it doesn’t find a satellite assembly. If you want to support VS2005 you must have a satellite assembly for it to work.

So, assume we have a project named MyProject which will compile to an assembly called MyProject.dll. Here’s what you do:

Add a new ‘resources’ item to the project and give it the name “MyProject.en.resx”.
Go the properties for the item and set the “Custom Tool” field to nothing. This will remove the auto-generated code for the .resx file
Double click on the .resx file, this opens up the resource editor. There you can add an existing image (Add Resource->Add existing file). The image should be a 16×16 pixel bitmap image. It must be in True Color format. True Color is the same as a 24-bit bitmap.
If you want transparency in your image then use the special color: Red:0 , Green:254, Blue:0 . Note that it really is 254, NOT 255.
In the resource editor, give your image a name that is a number, e.g. 1. Note that you did not have to change the filename of your image file, just its name in the resource file.

Now add your command in your add-in file like so:

commands.AddNamedCommand2(_addInInstance, "MyProject",
      "MyProject", "Executes the command for MyProject",
      false,
      1,
      ref contextGUIDS,
      (int)vsCommandStatus.vsCommandStatusSupported +
      (int)vsCommandStatus.vsCommandStatusEnabled,
      (int)vsCommandStyle.vsCommandStylePictAndText,
      vsCommandControlType.vsCommandControlTypeButton);

There you must send in false and then the number you gave the icon in your .resx file, e.g. 1.

Now when you compile your solution, a satellite assembly with the name MyProject.resources.dll will automatically be created and put in a “en” subfolder of your output folder. If you only want to support VS2008 and don’t want satellite assemblies then you can name the .resx file just MyProject.resx instead, then no satellite assemblies will be created and the resources will be embedded in the main assembly.

And that’s it. Add more resources in Visual Studio, have things compile automatically and don’t touch command line tools, notepad, hundreds of lines of custom code or anything like that. I *think* it is enough to just have the “en” resources dll even if you use another locale, I’m pretty sure Visual Studio falls back to that if it doesn’t find a satellite assembly in your current culture. At least I have my Windows set up for Danish, but my “en” satellite assembly works just fine for me. Although, there doesn’t exist a Danish version of Visual Studio, maybe this works differently for localized Visual Studio, e.g. the German version. If someone has one of those and can test I’d love to know whether it falls back to “en” if nothing else is available. If it doesn’t then just create a few more MyProject.de.resx, MyProject.es.resx etc. to get more satellite assemblies. But like I said before, VS2008 and later doesn’t need this, so for that case just have the one MyProject.resx file.

I’ve made the small MyProject example and it can be downloaded here. Let me know if this works (or doesn’t) for you. Enjoy!

ZenCoding Visual Studio AddIn

einar — Thu, 12 Nov 2009 23:05:08 +0000

4 Feb 2010: I’m no longer working on this addin and cannot provide support for failed installations. I gave some information about possible causes for failed installations in this comment, you can see if that helps, or discuss with other users in the comments. There are unlikely to ever be new versions of this addin published by me, but Boris Sevo has forked the project and has a version with a newer zencoding library at http://zencoding.codeplex.com/. So go there for updates

The original blog post about the architecture of the addin is now completely out of date as 90% of the addin is now written in IronPython with just a tiny shim layer of C# to instantiate the IronPython classes. I’ll probably write a blog post about that architecture seperately (or generally about how to write addins for VS in IronPython). Those interested in the architecture can download the source and look at it.

A nice tutorial with screenshots on how to setup the keyboard mappings and use the addin has just been posted at http://www.netsi.dk/wordpress/index.php/2009/12/02/zen-coding-a-very-fast-way-of-generating-html-elements-in-your-editor/ so go there for your setup instructions. And there is now a dedicated rss feed for updates at http://tech.einaregilsson.com/zcupdates.aspx so subscribe to that to be notified of new versions. Eventually I’ll put an update check in the addin itself.

ZenCoding.VisualStudio v1.1.0.333

DOWNLOAD ADD-IN || DOWNLOAD SOURCE

RELEASE NOTES:

Version 1.1.0.333, 02.12.2009:

This release adds the following features

Uses latest version of zencoding python library
Wrap with abbreviation command
Use, create, edit, delete custom snippets (Tools->Options->ZenCoding)
Icons for commands
Some bug fixes

Also a total rewrite with everything now written in IronPython

Version 1.0, 12.11.2009:

Initial release, features:

Expand abbreviation

Original blog post follows:

Earlier this week, while reading Leon Bambrick’s blog I learned about a set of plugins, named “zen-coding”, which expand snippets of css-selector like code into full blown html and/or css elements. Leon’s article explains it better and there is also some documentation on the official zen-coding page. Anyway, this plugin is available for a number of text editors and IDE’s but not for Visual Studio. I use Visual Studio a lot and wanted zen-coding in there, so I decided to try and whip up a small add-in for it.

The original library is available both as JavaScript and Python. I really didn’t want to port or alter anything in the original code, since for future versions I want to be able to just drop in a couple of files from the original library and rebuild the add-in. The obvious choice then was to see if the library would work with IronPython. Fortunately the zen-coding library is just basic string manipulation and worked perfectly with IronPython right out of the box.

The next challenge was figuring out how to call into that from the add-in, which I wanted to write in C#. The library contained two functions I needed to be able to call. That turned out to be surprisingly easy. I made a wrapper class, ZenCodingEngine, which has two delegates with the correct method signatures, and then in its constructor I ran some custom python import code, and got references to the functions I needed and assigned them to my delegates. I changed that approach in the latest version and moved almost all of the logic into Python instead. Now the C# AddIn is very thin, it basically just receives events from VS and invokes a single exec_command() method that is defined in a python script. The interesting parts of that code are below:

private void ReloadPython()
{
  ScriptEngine engine = Python.CreateEngine();
  ScriptScope scope = engine.CreateScope();
  string folder = Path.GetDirectoryName(new
    Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
  List searchPaths = new List(engine.GetSearchPaths());
  searchPaths.Add(folder);
  engine.SetSearchPaths(searchPaths);
  scope = engine.ExecuteFile(Path.Combine(folder, "vs_zen_coding.py"));
  engine.SetVariable(scope, "App", _applicationObject);
  execCommand = engine.GetVariable>(scope, "exec_command");
}

public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
{
  handled = false;
  if (!CanExecuteCommand(commandName, executeOption))
  {
    return;
  }

  try
  {
    #if RELOAD_EVERY_TIME
    ReloadPython();
    #else
    if (execCommand == null)
    {
      //Load first time, to avoid making the VS startup slower
      ReloadPython();
    }
    #endif

    execCommand();
  }
  catch (Exception ex)
  {
    DisplayError(ex);
  }
  handled = true;
}

The ReloadPython() method is not called on startup, instead it is called the first time the command is called. IronPython performs well, but there is still some startup cost and I don’t want to add that to the startup time of Visual Studio. Instead you pay the price the first time you actually need it. Then we have the Exec method which is from a VS interface and is called when the command is invoked. There I use a compilation constant, RELOAD_EVERY_TIME, to check if I should reload my python script every time I invoke the command. This has proved to be INCREDIBLY useful, instead of constantly starting VS up again and again I just edit my python script, save it and the next time I execute the command the new code is used. And of course I turn this constant off for release builds.

Another nice trick to play around with the VS API, start up an IronPython shell and type:

>>> from System.Runtime.InteropServices import Marshal
>>> app = Marshal.GetActiveObject(”VisualStudio.DTE.9.0″)
>>> app.ActiveDocument.Name
‘ZenCodingAddIn.cs’

This gets you a reference to the running instance of VS2009 which you can then experiment with.

You can download an installer for the add-in or get the source. The add-in is licensed under the GPL v3, the same license the zen-coding library uses. The add-in works for Visual Studio 2005, 2008 and 2010 beta 2.

Now, once you’ve installed the add-in, nothing happens. Well, actually what happens is there’s a new command available in Visual Studio, named ZenCoding.Expand, or ZenCoding.VisualStudio.ZenCodingAddIn.Expand, depending on where you are looking for it. (The keyboard mapping uses the full command id, but when adding it to a toolbar you get a shorter friendly name for it). By default it is not mapped to any keyboard combination. This is because ~~it’s late and I can’t be bothered to figure it out~~ I strongly believe that add-ins should not force a keyboard shortcut on you, possibly overriding something you have set yourself. So, map the command to your preferred keyboard shortcut (mine is Ctrl+E,Ctrl+K). Or you can drag the command onto a toolbar, which is fairly useless, but possible.

Enjoy!

UPDATE 13.11.2009: The main zen-coding developer also told me that I’m using an older version, the latest version has a lot more features, including user defined snippets. I’ll start looking at that when I have time, which won’t be just yet.

URL-2-Titlebar Firefox Add-on

einar — Fri, 25 Sep 2009 11:48:04 +0000

Recently I got a request in the mail from a user of one of my Firefox add-ons. He asked me if I could make an add-on that displayed the url of the current tab in the titlebar instead of the actual title of the page being shown. I’m not interested in creating more add-ons for Firefox or Thunderbird, they take up quite a lot of time with user requests, getting approved by the Mozilla addons site, etc. That is why I’ve discontinued 6 out of the 9 add-ons I’ve created. But anyway, I knew that it would be trivial to make this add-on so I decided to help this person out.

You can download the add-on here. This add-on will never be updated or published on AMO, it is offered strictly as-is. The one thing I found interesting about this was figuring out how to do the absolute minimum to get this add-on working. There is no localization, no folder structure, just three files, install.rdf, chrome.manifest and url2titlebar.xul. Put those into a zip file, rename it to .xpi and you have your extension. These of course are not best practices in extension development, just an exercise in making the simplest extension possible. Below is the full content of the three files:

url2titlebar.xul

chrome.manifest

content url2titlebar file:./
overlay chrome://browser/content/browser.xul chrome://url2titlebar/content/url2titlebar.xul

install.rdf



  
    url2titlebar@einaregilsson.com
    URL-2-Titlebar
    0.0.1
    Einar Egilsson
    Set the title of the window to the current url
    
      
        {ec8030f7-c20a-464f-9b0e-13a3a9e97384} 
        3.0
        3.5.*

So, there you have it, the simplest possible Firefox add-on. Enjoy!

Chord Image Generator

einar — Thu, 23 Jul 2009 15:45:33 +0000

One of my non-programming related hobbies is playing guitar. I’ve used a lot of chord sheets and tablature from the internet and have often wanted to be able to print it out in a nicer format than plain ASCII. Chord definitions in online tablatures are usually written something like (xx0232) (a D chord), but I wanted to be able to get these nice chord diagrams like they have in the guitar magazines. So, I wrote my own little online chord image generator.

Actually what I originally planned to do was create a whole chord sheet editor online, which would accept plain text song files and convert them into nicely formatted sheets ready for printing. They would include non monospace fonts while still having the chords line up correctly with the lyrics, chord diagrams at the top and a nice header with the name and artist. But, since I don’t have that much free time and thought I’d probably never complete that project I just created the chord image generator itself. Others can then maybe use it for something like my idea.

After I had written the chord image generating code itself I decided to make a little test app for it, both to teach people the correct format and just to play with. That little application can be found at http://chords.einaregilsson.com/. The chord images can have muted and open strings, finger positions, display the beginning fret for chords higher than the first five frets and display below the image which fingers are used for which string. They can also be generated in ten different sizes.

Lets look at some examples. The format of an url for a chord is:

http://chords.einaregilsson.com/[chordname]/[fretpositions]/[fingers]/[size]

So, for a normally fingered E chord the url would be:

http://chords.einaregilsson.com/E/022100/-231–/2

The name is a simple string. The only thing to remember there is that if you want to use the # symbol you must encode it as %23, because otherwise the browser will not send the rest of the url to the server. If you have two chords with the same name you can differentiate them by naming for example one E5 and the other E5^II. This is done by writing the name as E5_II, with an underscore before the superscript. Below is an example of a C# chord in size 5

http://chords.einaregilsson.com/C%23/x4666x/-1333-/5

The fret positions run EAGDBE, use X for muted strings, 0 for open strings and other numbers for fret positions. If you are writing a chord that uses fret positions on and over the 10th fret you must write all the positions with a dash between them. A D bar chord on the 10th fret would then be written as

http://chords.einaregilsson.com/D/10-12-12-11-10-10/134211

The fingering positions also run EAGDBE. Use T for thumb, 1 for index finger, 2 for middle finger, 3 for ring finger and 4 for pinky. Use a dash, -, when no finger is on a particular string. Bar chords are inferred, if you write that you are using the same finger for different strings on the same fret, then a line will be drawn through them to indicate a barred chord. An example of that is the D chord above.

The size is just a number from 1-10. I like size 2 the best myself, and that is the default.

You can cut as much off the back of the url as you want. That is, you can skip the size, fingering positions and even fret positions, and they will use defaults instead. Default size is 2, default fingerings mean that no fingerings are written, and default fret positions are none. So, for example the following four urls are all legal (although the last one is not really a D chord since it contains no fret positions):

	http://chords.einaregilsson.com/D/xx0232/—132/2
	http://chords.einaregilsson.com/D/xx0232/—132
	http://chords.einaregilsson.com/D/xx0232
	http://chords.einaregilsson.com/D

You are free to link to images directly on http://chords.einaregilsson.com from your own website, although I make no guarantees about uptime, performance or anything like that. The images are cached for a week, so loading time should be fast after the first time.

The code for this was written in C# and is licensed under the GPL. The main class is called ChordBoxImage and it can save the generated image in a variety of formats to any output stream. The code for the image generator as well as the little test web site can be downloaded here. Enjoy!

ZenPhoto Uploader

einar — Mon, 20 Jul 2009 20:47:29 +0000

The photo album software I use to store my photos on the web is ZenPhoto. It is a very nice photo gallery system, with themes, lots of plugins, nice administrative interface and plenty of other good stuff. The only problem I had with it was getting my photos uploaded. Sure, they offer a web interface, or you can upload a zip file, or use FTP but I usually need to preprocess my photos a bit. Rotate them, throw out the ones I don’t want to upload, and most of all I need to make them smaller, uploading them in the size I use on my camera takes forever. So, I decided to make a simple program to do these things for me.

I had previously used the program Web Album Generator to make static html albums. I really liked its interface so I mostly copied it for my own program, ZenPhoto Uploader. Theres a list of the images on the left side and on the right side is a toolbar with all available operations, a big preview screen and textboxes for adding titles and descriptions.

The program is ONLY meant for uploading albums for the first time, not for working with albums once they are uploaded. The main features of the program are:

Create new albums (with descriptions) and upload images (obviously)
Resize photos before uploading
Rotate photos
Order photos in album
Remove photos from album and optionally delete the file itself
Save titles and descriptions for photos
Keyboard shortcuts for almost all actions

The program is very much “me-ware”. I made it to scratch my own itch, it may not fit or feel right to anyone else. It was thrown together and is fixed as I run into bugs while using it. It may well contain errors and might crash horribly. That said, everyone is welcome to use it and improve upon it if they wish. Just know that you are using this at your own risk. I cannot be held liable for any damages or problems this program may cause. It contains commands that you can use to delete photos from your hard disk, use it carefully and think about what you are doing.

Probably my favorite feature of the program is the ability to do everything from the keyboard. The available shortcuts are:

CTRL+U: Open the upload dialog
CTRL+UP, CTRL+DOWN: Move to previous/next photo even though the listbox is not selected
CTRL+SHIFT+UP, CTRL+SHIFT+DOWN: Move a photo higher or lower in the list
CTRL+T: Give focus to the Title textbox
CTRL+D: Give focus to the Description textbox
CTRL+LEFT, CTRL+RIGHT: Rotate the currently selected photo
DEL: Remove or delete the currently selected photo. There is a confirmation dialog that asks if you want to remove the photo from the album, or delete the photo. Do not choose “delete” unless you really want to delete the photo from your hard disk forever!

The source is available in SVN at http://einaregilsson.googlecode.com/svn/dotnet/ZenPhotoUploader/ and is licensed under the GPL v3.0. It is written in C# and requires .NET 3.5 to compile. There is a build.bat file in the root folder that can be used to build the program.

Finally, you can DOWNLOAD ZenPhotoUploader here, it is a single executable, no dependencies other than the .NET framework 2.0 or higher. The only version of ZenPhoto I’ve tested it against is v1.2.2, others may not work. Enjoy, and let me know if you have any problems with it.

Instant Rimshot

einar — Sat, 20 Jun 2009 08:52:20 +0000

It’s been a while since I’ve written anything here, I’ve been working on my master project like crazy, have a 6 month old baby and so haven’t had much time for programming pet projects. Tonight I spent a half hour making perhaps the most useless application I’ll ever make. It’s based on the single-serving website http://instantrimshot.com which only has one huge red button, if you press it a rimshot sound is played. I thought it might be fun to have that available as a keyboard shortcut in windows, and then I started wondering how it could be done in C#.

The only way to get a global keyboard working in .NET is by calling into the Win32 API. To register a global hotkey there is the aptly named function RegisterHotKey. That requires you to have a window handle however, and I wanted to make the application as simple as possible, so I used a lower level API call,
SetWindowsHookEx which lets you get notified of all keyboard activity on the system. I then check what keys are pressed and when the combination Ctrl+Shift+I is pressed the sound is played. There is only one way to exit the app, and that is by pressing the keyboard combination Ctrl+Shift+Alt+I, that cleans up the hook before exiting. So, the code is shown below, you can download the source or just download the program itself. Enjoy!

using System;
using System.IO;
using System.Media;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;

class InstantRimshot {

    const int WH_KEYBOARD_LL = 13;
    const int WM_KEYDOWN = 0x100;

    delegate int Hook(int code, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll")]
    static extern IntPtr SetWindowsHookEx(int code,
                                          Hook func,
                                          IntPtr hInstance,
                                          int threadID);

    [DllImport("user32.dll")]
    static extern int UnhookWindowsHookEx(IntPtr hookHandle);

    [DllImport("user32.dll")]
    static extern int CallNextHookEx(IntPtr hhook,
                                     int code,
                                     IntPtr wParam,
                                     IntPtr lParam);

    static bool IsPressed(Keys check) {
        return ((Control.ModifierKeys & check) == check);
    }

    static void Main() {

        Stream sound = Assembly.GetExecutingAssembly()
            .GetManifestResourceStream("InstantRimshot.rimshot.wav");
        SoundPlayer player = new SoundPlayer(sound);
        player.Load();
        IntPtr hookHandle = IntPtr.Zero;
        hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL,
            delegate(int code, IntPtr wParam, IntPtr lParam) {
                if (code >= 0 && wParam == (IntPtr) WM_KEYDOWN) {
                    Keys vkCode = (Keys)Marshal.ReadInt32(lParam);
                    if (Keys.I == vkCode
                    && IsPressed(Keys.Control)
                    && IsPressed(Keys.Shift)) {
                        if (IsPressed(Keys.Alt)) {
                            UnhookWindowsHookEx(hookHandle);
                            Application.Exit();
                            return CallNextHookEx(hookHandle, code, wParam, lParam);
                        } else {
                            player.Play();
                        }
                    }
                }
                return CallNextHookEx(hookHandle, code, wParam, lParam);
            }, IntPtr.Zero, 0);
        Application.Run();
    }

}

Coco/R plugin for Visual Studio

einar — Fri, 20 Mar 2009 21:43:42 +0000

I’ve blogged before about the excellent Coco/R parser generator. I’m using it a lot in my masters project and I’m happy with it but there were a few things I wished worked differently. The main thing was that I wanted better Visual Studio integration. I had set up a pre-build event that generated the parser and scanner before every build. However there is obviously no need to re-generate the files unless the grammar file has changed. Generating on every build also had the effect that Visual Studio kept prompting me about reloading changed files and I had to build to see if there were any errors in my grammar. So, I decided to create a Visual Studio plugin for Coco/R myself.

Coco/R is open source and written in C# (at least one version of it) so it was easy to get the source. I then looked at a couple of tutorials on Visual Studio plugins and managed to hack together an plugin that works well enough for my needs. I also made a small change to the way Coco/R generates its parsers and scanners from frame files. Here are the features that are unique to the plugin:

Works with Visual Studio 2005 and 2008
When you click ‘Add a new item’ in a C# project, you’ll find a ‘Coco/R Attributed Grammar’ option under My Templates at the bottom of the screen. The .atg file you get has a simple example grammar that just reads numbers or identifiers. I wanted this because everytime I create a new .atg I start by finding an old one and copying the basics from it.
Every time an .atg file is saved, the parser and scanner are re-generated. If the generated files are open then the AddIn closes them before re-generating, to avoid the dreaded “Files were reloaded” prompt.
Errors and warnings from Coco show up in Visual Studio’s error list window just like build errors as soon as you save the .atg file.
Instead of using frame files, the plugin uses partial classes for the parser and scanner. There are four files, Parser.cs, Parser.generated.cs, Scanner.cs and Scanner.generated.cs. This allows you to add stuff to your parser and scanner in an actual .cs file so you get the benefit of the Visual Studio editor, instead of having to write it in the .frame file or the .atg file.

So, that’s it. You can download an MSI installer for it and you can also view or checkout the source at http://einaregilsson.googlecode.com/svn/dotnet/CocoPlugin/. Enjoy.

JScript REPL

einar — Fri, 20 Feb 2009 20:09:02 +0000

Lately I have been doing some COM automation stuff on Windows. I’ve been using JScript (Microsoft’s JavaScript implementation) since that’s available on all Windows machines, and the other option, VBScript, is horrible. Normally I would use Python and the win32com package, but I needed to make some scripts that could work on any box without installing Python first. JScript is a pretty nice language, but it doesn’t come with a REPL built in, which is very handy when you’re doing experimental stuff (REPL = Read-Execute-Print-Loop). Now, writing your own REPL in a dynamic language with an eval statement is pretty easy, so I did just that. It took about 30 lines, of which about 10 are just about printing evaluated expressions nicely.

Here’s how it works. If you enter a single line that ends with ; it is evaluated immediately. If it doesn’t start with if,while,var,try,do,with,function,switch,for or print it is assumed to be an expression and its value is printed to the screen. If a new line doesn’t end with ; is is assumed to be the beginning of a larger code block. In that case the script will keep reading in code without evaluating until either you end a line with ;; or you enter a line which consists of only one ;. The script also includes a convenience function called print() to print expressions. The script just uses a single variable, _$, so it won’t conflict with variables you define when using it. Writing a single line with just the word ‘exit’ will stop the script. Below you can see an example of the usage of the REPL. This sample is actually a online version that I did for fun, you can write in any command in it and try it out, it works exactly the same as the real script, although the online version took quite a bit more code. It even has command history, activated with the up and down arrow keys. (There are some issues in Internet Explorer, tab key doesn’t work and strings with html entities my display incorrectly, because of weird behaviour with

tags and the .innerHTML property).

Download script | View script syntax highlighted

Enjoy!

While Compiler for the .NET Platform

einar — Fri, 06 Feb 2009 14:12:34 +0000

My masters project at DTU involves writing compilers for the .NET platform and since I had never written a compiler before I decided to start by writing a compiler for a simple language called While. This language is used in the Program Analysis course that is taught at DTU and has integer and boolean expressions, read and write commands, an if branching statement and a while looping statement. The compiler compiles this language and the programs can be run with the .NET CLR or Mono. The programs can also be debugged using a free graphical .NET debugger. I put the project up on Google Code, I think it is a fairly nice example of a simple compiler for .NET. It is currently written in Boo but will soon be rewritten in C#. The compiler and its source code is available at http://while-language.googlecode.com.