irony Wiki & Documentation Rss Feed

Updated Wiki: Contributors

rivantsov — Sun, 15 Nov 2009 17:14:06 GMT

Contributors

The following people made contributions to Irony project, and would like to express my gratitude to:

Philipp Serr: completed NumberLiteral implementation with advanced features for c#, python, VB
CodePlex user notmasteryet: improved GwBasic grammar to make it match the syntax rules of GwBasic
Benjamen Morrison: created an implementation of Language Services for Visual Studio integration based on Irony. This code is not a part of Irony codebase (yet), but you can find it in the article in CodeProject.com
Michael Coles - created SearchGrammar for converting Google-like search queries into MS SQL Server full-text search syntax. The code is used in his book "Pro Full-Text Search in SQL Server 2008".
Kirill Osenkov: created IronySilverlight, Irony version for Silverlight environment

Updated Wiki: Home

rivantsov — Sun, 15 Nov 2009 17:12:27 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET, SQL, GwBasic, JSON and others.
Sample expression grammar allows evaluation of arithmetic expressions using Irony's built-in AST interpreter.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!
Oct 12, 2009. Updated the release download version

More information
Contributors
Demo Running Instructions
Expression Grammar sample
Irony presentation at LangNET 2009 symposium
Irony blog

Updated Wiki: expression grammar sample

rivantsov — Thu, 12 Nov 2009 23:14:46 GMT


using System;
using System.Collections.Generic;
using System.Text;
using Irony.Parsing;
using Irony.Ast;

namespace Irony.Samples {
  // This grammar describes programs that consist of simple expressions and assignments
  // for ex:
  // x = 3
  // y = -x + 5
  //  the result of calculation is the result of last expression or assignment.
  //  Irony's default  runtime provides expression evaluation. 
  //  supports inc/dec operators (++,--), both prefix and postfix,
  //  and combined assignment operators like +=, -=, etc.

  [Language("ExpressionEvaluator", "1.0", "Multi-line expression evaluator")]
  public class ExpressionEvaluatorGrammar : Irony.Parsing.Grammar {
    public ExpressionEvaluatorGrammar() {

      // 1. Terminals
      var number = new NumberLiteral("number");
      //Let's allow big integers (with unlimited number of digits):
      number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
      var identifier = new IdentifierTerminal("identifier");
      var comment = new CommentTerminal("comment", "#", "\n", "\r"); 
      //comment must to be added to NonGrammarTerminals list; it is not used directly in grammar rules,
      // so we add it to this list to let Scanner know that it is also a valid terminal. 
      base.NonGrammarTerminals.Add(comment);

      // 2. Non-terminals
      var Expr = new NonTerminal("Expr");
      var Term = new NonTerminal("Term");
      var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode));
      var ParExpr = new NonTerminal("ParExpr");
      var UnExpr = new NonTerminal("UnExpr", typeof(UnExprNode));
      var UnOp = new NonTerminal("UnOp");
      var BinOp = new NonTerminal("BinOp", "operator");
      var PostFixExpr = new NonTerminal("PostFixExpr", typeof(UnExprNode));
      var PostFixOp = new NonTerminal("PostFixOp");
      var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssigmentNode));
      var AssignmentOp = new NonTerminal("AssignmentOp", "assignment operator");
      var Statement = new NonTerminal("Statement");
      var ProgramLine = new NonTerminal("ProgramLine");
      var Program = new NonTerminal("Program", typeof(StatementListNode));

      // 3. BNF rules
      Expr.Rule = Term | UnExpr | BinExpr | PostFixExpr;
      Term.Rule = number | ParExpr | identifier;
      ParExpr.Rule = "(" + Expr + ")";
      UnExpr.Rule = UnOp + Term;
      UnOp.Rule = ToTerm("+") | "-" | "++" | "--";
      BinExpr.Rule = Expr + BinOp + Expr;
      BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**";
      PostFixExpr.Rule = Term + PostFixOp;
      PostFixOp.Rule = ToTerm("++") | "--";
      AssignmentStmt.Rule = identifier + AssignmentOp + Expr;
      AssignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=";
      Statement.Rule = AssignmentStmt | Expr | Empty;
      ProgramLine.Rule = Statement + NewLine;
      Program.Rule = MakeStarRule(Program, ProgramLine);
      this.Root = Program;       // Set grammar root

      // 4. Operators precedence
      RegisterOperators(1, "+", "-");
      RegisterOperators(2, "*", "/");
      RegisterOperators(3, Associativity.Right, "**");

      // 5. Punctuation and transient terms
      RegisterPunctuation("(", ")");
      RegisterBracePair("(", ")"); 
      MarkTransient(Term, Expr, Statement, BinOp, UnOp, PostFixOp, AssignmentOp, ProgramLine, ParExpr);

      //automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
      this.LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.NewLineBeforeEOF | LanguageFlags.CanRunSample; 

    }
  }
}//namespace

Updated Wiki: expression grammar sample

rivantsov — Thu, 12 Nov 2009 03:38:33 GMT

using System;
using System.Collections.Generic;
using System.Text;
using Irony.Parsing;
using Irony.Ast;

namespace Irony.Samples {
  // This grammar describes programs that consist of simple expressions and assignments
  // for ex:
  // x = 3
  // y = -x + 5
  //  the result of calculation is the result of last expression or assignment.
  //  Irony's default  runtime provides expression evaluation. 
  //  supports inc/dec operators (++,--), both prefix and postfix,
  //  and combined assignment operators like +=, -=, etc.

  [Language("ExpressionEvaluator", "1.0", "Multi-line expression evaluator")]
  public class ExpressionEvaluatorGrammar : Irony.Parsing.Grammar {
    public ExpressionEvaluatorGrammar() {

      // 1. Terminals
      var number = new NumberLiteral("number");
      //Let's allow big integers (with unlimited number of digits):
      number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
      var identifier = new IdentifierTerminal("identifier");
      var comment = new CommentTerminal("comment", "#", "\n", "\r"); 
      //comment must to be added to NonGrammarTerminals list; it is not used directly in grammar rules,
      // so we add it to this list to let Scanner know that it is also a valid terminal. 
      base.NonGrammarTerminals.Add(comment);

      // 2. Non-terminals
      var Expr = new NonTerminal("Expr");
      var Term = new NonTerminal("Term");
      var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode));
      var ParExpr = new NonTerminal("ParExpr");
      var UnExpr = new NonTerminal("UnExpr", typeof(UnExprNode));
      var UnOp = new NonTerminal("UnOp");
      var BinOp = new NonTerminal("BinOp", "operator");
      var PostFixExpr = new NonTerminal("PostFixExpr", typeof(UnExprNode));
      var PostFixOp = new NonTerminal("PostFixOp");
      var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssigmentNode));
      var AssignmentOp = new NonTerminal("AssignmentOp", "assignment operator");
      var Statement = new NonTerminal("Statement");
      var ProgramLine = new NonTerminal("ProgramLine");
      var Program = new NonTerminal("Program", typeof(StatementListNode));

      // 3. BNF rules
      Expr.Rule = Term | UnExpr | BinExpr | PostFixExpr;
      Term.Rule = number | ParExpr | identifier;
      ParExpr.Rule = "(" + Expr + ")";
      UnExpr.Rule = UnOp + Term;
      UnOp.Rule = ToTerm("+") | "-" | "++" | "--";
      BinExpr.Rule = Expr + BinOp + Expr;
      BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**";
      PostFixExpr.Rule = Term + PostFixOp;
      PostFixOp.Rule = ToTerm("++") | "--";
      AssignmentStmt.Rule = identifier + AssignmentOp + Expr;
      AssignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=";
      Statement.Rule = AssignmentStmt | Expr | Empty;
      ProgramLine.Rule = Statement + NewLine;
      Program.Rule = MakeStarRule(Program, ProgramLine);
      this.Root = Program;       // Set grammar root

      // 4. Operators precedence
      RegisterOperators(1, "+", "-");
      RegisterOperators(2, "*", "/");
      RegisterOperators(3, Associativity.Right, "**");

      // 5. Punctuation and transient terms
      RegisterPunctuation("(", ")");
      RegisterBracePair("(", ")"); 
      MarkTransient(Term, Expr, Statement, BinOp, UnOp, PostFixOp, AssignmentOp, ProgramLine, ParExpr);

      //automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
      this.LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.NewLineBeforeEOF | LanguageFlags.CanRunSample; 

    }
  }
}//namespace

Updated Wiki: expression grammar sample

rivantsov — Sat, 07 Nov 2009 17:03:30 GMT

using System;
using System.Collections.Generic;
using System.Text;
using Irony.Parsing;
using Irony.Ast;

namespace Irony.Samples {
  // This grammar describes programs that consist of simple expressions and assignments
  // for ex:
  // x = 3
  // y = -x + 5
  //  the result of calculation is the result of last expression or assignment.
  //  Irony's default  runtime provides expression evaluation. 
  //  supports inc/dec operators (++,--), both prefix and postfix,
  //  and combined assignment operators like +=, -=, etc.

  [Language("ExpressionEvaluator", "1.0", "Multi-line expression evaluator")]
  public class ExpressionEvaluatorGrammar : Irony.Parsing.Grammar {
    public ExpressionEvaluatorGrammar() {

      // 1. Terminals
      var number = new NumberLiteral("number");
      //Let's allow big integers (with unlimited number of digits):
      number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
      var identifier = new IdentifierTerminal("identifier");
      var comment = new CommentTerminal("comment", "#", "\n", "\r"); //new
      //comment must to be added to NonGrammarTerminals list; it is not used directly in grammar rules,
      // so we add it to this list to let Scanner know that it is also a valid terminal. 
      base.NonGrammarTerminals.Add(comment);

      // 2. Non-terminals
      var Expr = new NonTerminal("Expr");
      var Term = new NonTerminal("Term");
      var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode));
      var ParExpr = new NonTerminal("ParExpr");
      var UnExpr = new NonTerminal("UnExpr", typeof(UnExprNode));
      var UnOp = new NonTerminal("UnOp");
      var BinOp = new NonTerminal("BinOp", "operator");
      var PostFixExpr = new NonTerminal("PostFixExpr", typeof(UnExprNode));
      var PostFixOp = new NonTerminal("PostFixOp");
      var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssigmentNode));
      var AssignmentOp = new NonTerminal("AssignmentOp", "assignment operator");
      var Statement = new NonTerminal("Statement");
      var ProgramLine = new NonTerminal("ProgramLine");
      var Program = new NonTerminal("Program", typeof(StatementListNode));

      // 3. BNF rules
      Expr.Rule = Term | UnExpr | BinExpr | PostFixExpr;
      Term.Rule = number | ParExpr | identifier;
      ParExpr.Rule = "(" + Expr + ")";
      UnExpr.Rule = UnOp + Term;
      UnOp.Rule = ToTerm("+") | "-" | "++" | "--";
      BinExpr.Rule = Expr + BinOp + Expr;
      BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**";
      PostFixExpr.Rule = Term + PostFixOp;
      PostFixOp.Rule = ToTerm("++") | "--";
      AssignmentStmt.Rule = identifier + AssignmentOp + Expr;
      AssignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=";
      Statement.Rule = AssignmentStmt | Expr | Empty;
      ProgramLine.Rule = Statement + NewLine;
      Program.Rule = MakeStarRule(Program, ProgramLine);
      this.Root = Program;       // Set grammar root

      // 4. Operators precedence
      RegisterOperators(1, "+", "-");
      RegisterOperators(2, "*", "/");
      RegisterOperators(3, Associativity.Right, "**");

      // 5. Punctuation and transient terms
      RegisterPunctuation("(", ")");
      RegisterBracePair("(", ")"); 
      MarkTransient(Term, Expr, Statement, BinOp, UnOp, PostFixOp, AssignmentOp, ProgramLine, ParExpr);

      //automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
      this.LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.NewLineBeforeEOF | LanguageFlags.CanRunSample; 

    }
  }
}//namespace

Updated Wiki: expression grammar sample

rivantsov — Sat, 07 Nov 2009 17:01:51 GMT

using System;
using System.Collections.Generic;
using System.Text;
using Irony.Parsing;
using Irony.Ast;

namespace Irony.Samples {
  // This grammar describes programs that consist of simple expressions and assignments
  // for ex:
  // x = 3
  // y = -x + 5
  //  the result of calculation is the result of last expression or assignment.
  //  Irony's default  runtime provides expression evaluation. 
  //  supports inc/dec operators (++,--), both prefix and postfix,
  //  and combined assignment operators like +=, -=, etc.

  [Language("ExpressionEvaluator", "1.0", "Multi-line expression evaluator")]
  public class ExpressionEvaluatorGrammar : Irony.Parsing.Grammar {
    public ExpressionEvaluatorGrammar() {

      // 1. Terminals
      var number = new NumberLiteral("number");
      //Let's allow big integers (with unlimited number of digits):
      number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
      var identifier = new IdentifierTerminal("identifier");
      var comment = new CommentTerminal("comment", "#", "\n", "\r"); //new
      //comment must to be added to NonGrammarTerminals list; it is not used directly in grammar rules,
      // so we add it to this list to let Scanner know that it is also a valid terminal. 
      base.NonGrammarTerminals.Add(comment);

      // 2. Non-terminals
      var Expr = new NonTerminal("Expr");
      var Term = new NonTerminal("Term");
      var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode));
      var ParExpr = new NonTerminal("ParExpr");
      var UnExpr = new NonTerminal("UnExpr", typeof(UnExprNode));
      var UnOp = new NonTerminal("UnOp");
      var BinOp = new NonTerminal("BinOp", "operator");
      var PostFixExpr = new NonTerminal("PostFixExpr", typeof(UnExprNode));
      var PostFixOp = new NonTerminal("PostFixOp");
      var AssignmentStmt = new NonTerminal("AssignmentStmt", typeof(AssigmentNode));
      var AssignmentOp = new NonTerminal("AssignmentOp", "assignment operator");
      var Statement = new NonTerminal("Statement");
      var ProgramLine = new NonTerminal("ProgramLine");
      var Program = new NonTerminal("Program", typeof(StatementListNode));

      // 3. BNF rules
      Expr.Rule = Term | UnExpr | BinExpr | PostFixExpr;
      Term.Rule = number | ParExpr | identifier;
      ParExpr.Rule = "(" + Expr + ")";
      UnExpr.Rule = UnOp + Term;
      UnOp.Rule = ToTerm("+") | "-" | "++" | "--";
      BinExpr.Rule = Expr + BinOp + Expr;
      BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**";
      PostFixExpr.Rule = Term + PostFixOp;
      PostFixOp.Rule = ToTerm("++") | "--";
      AssignmentStmt.Rule = identifier + AssignmentOp + Expr;
      AssignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=";
      Statement.Rule = AssignmentStmt | Expr | Empty;
      ProgramLine.Rule = Statement + NewLine;
      Program.Rule = MakeStarRule(Program, ProgramLine);
      this.Root = Program;       // Set grammar root

      // 4. Operators precedence
      RegisterOperators(1, "+", "-");
      RegisterOperators(2, "*", "/");
      RegisterOperators(3, Associativity.Right, "**");

      RegisterPunctuation("(", ")");
      RegisterBracePair("(", ")"); 
      MarkTransient(Term, Expr, Statement, BinOp, UnOp, PostFixOp, AssignmentOp, ProgramLine, ParExpr);

      //automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source
      this.LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.NewLineBeforeEOF | LanguageFlags.CanRunSample; 

    }
  }
}//namespace

Updated Wiki: Demo Running Instructions

rivantsov — Fri, 16 Oct 2009 22:34:28 GMT

Demo instructions

Open Irony_All.sln solution file in Visual Studio.
Right-click on the project "030.Irony.GrammarExplorer" and select "Set as StartUp project" from the context menu.
Click Run button on toolbar (F5). Grammar Explorer Window opens.
Important: if you are launching the Grammar Explorer for the first time after downloading Irony and if you see that Grammars combobox is not empty, then clear it: click on the button next to the combobox and select "Remove all"
If the Grammar combobox on top is empty, click on the button next to it (or right-click the combobox) and select "Add grammar" command. In the file-open window that appears, navigate to (root)\Irony.Samples\bin\debug folder and select Irony.Samples.dll. Application will popup a small window with a list of grammars in selected assembly. Leave all lines checked and click "OK". The newly added grammars will appear in the grammar combobox.
Select a grammar (language) in top combo-box. If you see exception window with error popping up, then go back to previous step and remove all old grammars by selecting "Remove all" command.
Browse form tabs to see grammar data.
To parse source code sample, switch to "Test" tab. Click "Load..." button on top of the form. Open file dialog opens.
Navigate to <root>\Irony.Samples\SourceSamples folder. Select source file appropriate for currently selected grammar.
Source file contents are loaded into text area in the form. Click Parse button on top of the form.
The Output Syntax Tree control on the right (in Results tab in the right tab control) would contain a parsed syntax tree.
If button "Run" is enabled, click it to execute the code. The results are shown in the Output window at the bottom of the form. For Expression Evaluator grammar, the output is the result of the last expression or assignment. Interpreter for Scheme can execute more complex programs found in SourceSamples\Scheme subfolder.
Alternatively you can paste or type your own sample program into source text area.
Repeat for other selections in the Grammar combobox.

Note that Grammar Explorer restores your last language selection and source sample after you close/restart the form.

Updated Wiki: Demo Running Instructions

rivantsov — Fri, 16 Oct 2009 22:33:42 GMT

Demo instructions

Open Irony_All.sln solution file in Visual Studio.
Right-click on the project "030.Irony.GrammarExplorer" and select "Set as StartUp project" from the context menu.
Click Run button on toolbar (F5). Grammar Explorer Window opens.
Important: if you are launching the Grammar Explorer for the first time after downloading Irony and

if you see that Grammars combobox is not empty, then clear it: click on the button next to the combobox and select "Remove all"

If the Grammar combobox on top is empty, click on the button next to it (or right-click the combobox) and select "Add grammar" command. In the file-open window that appears, navigate to (root)\Irony.Samples\bin\debug folder and select Irony.Samples.dll. Application will popup a small window with a list of grammars in selected assembly. Leave all lines checked and click "OK". The newly added grammars will appear in the grammar combobox.
Select a grammar (language) in top combo-box. If you see exception window with error popping up, then go back to previous step and remove all old grammars by selecting "Remove all" command.
Browse form tabs to see grammar data.
To parse source code sample, switch to "Test" tab. Click "Load..." button on top of the form. Open file dialog opens.
Navigate to <root>\Irony.Samples\SourceSamples folder. Select source file appropriate for currently selected grammar.
Source file contents are loaded into text area in the form. Click Parse button on top of the form.
The Output Syntax Tree control on the right (in Results tab in the right tab control) would contain a parsed syntax tree.
If button "Run" is enabled, click it to execute the code. The results are shown in the Output window at the bottom of the form. For Expression Evaluator grammar, the output is the result of the last expression or assignment. Interpreter for Scheme can execute more complex programs found in SourceSamples\Scheme subfolder.
Alternatively you can paste or type your own sample program into source text area.
Repeat for other selections in the Grammar combobox.

Note that Grammar Explorer restores your last language selection and source sample after you close/restart the form.

Updated Wiki: Home

rivantsov — Tue, 13 Oct 2009 13:20:59 GMT

Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!
Oct 12, 2009. Updated the release download version

More information
Demo Running Instructions
Expression Grammar sample
Irony presentation at LangNET 2009 symposium
Irony blog

Updated Wiki: Home

rivantsov — Tue, 13 Oct 2009 13:19:03 GMT

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
Irony presentation at LangNET 2009 symposium
Irony blog

Updated Wiki: Demo Running Instructions

rivantsov — Tue, 13 Oct 2009 07:40:40 GMT

Demo instructions

Open Irony_All.sln solution file in Visual Studio.
Right-click on the project "030.Irony.GrammarExplorer" and select "Set as StartUp project" from the context menu.
Click Run button on toolbar (F5). Grammar Explorer Window opens.
Important: if you are launching the Grammar Explorer for the first time after downloading Irony and

if you see that Grammars combobox is not empty, then make sure you clear: click on the button next to the combobox and select "Remove all"

If the Grammar combobox on top is empty, click on the button next to it (or right-click the combobox) and select "Add grammar" command. In the file-open window that appears, navigate to (root)\Irony.Samples\bin\debug folder and select Irony.Samples.dll. Application will popup a small window with a list of grammars in selected assembly. Leave all lines checked and click "OK". The newly added grammars will appear in the grammar combobox.
Select a grammar (language) in top combo-box. If you see exception window with error popping up, then go back to previous step and remove all old grammars by selecting "Remove all" command.
Browse form tabs to see grammar data.
To parse source code sample, switch to "Test" tab. Click "Load..." button on top of the form. Open file dialog opens.
Navigate to <root>\Irony.Samples\SourceSamples folder. Select source file appropriate for currently selected grammar.
Source file contents are loaded into text area in the form. Click Parse button on top of the form.
The Output Syntax Tree control on the right (in Results tab in the right tab control) would contain a parsed syntax tree.
If button "Run" is enabled, click it to execute the code. The results are shown in the Output window at the bottom of the form. For Expression Evaluator grammar, the output is the result of the last expression or assignment. Interpreter for Scheme can execute more complex programs found in SourceSamples\Scheme subfolder.
Alternatively you can paste or type your own sample program into source text area.
Repeat for other selections in the Grammar combobox.

Note that Grammar Explorer restores your last language selection and source sample after you close/restart the form.

Updated Wiki: Home

rivantsov — Sat, 05 Sep 2009 02:41:25 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
Irony presentation at LangNET 2009 symposium
Irony blog

Updated Wiki: Home

rivantsov — Wed, 20 May 2009 06:28:56 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
Irony presentation at LangNET 2009 symposium

Updated Wiki: Home

rivantsov — Wed, 20 May 2009 06:28:06 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
Irony presentations at 2008,2009 Lang.NET symposiums

Updated Wiki: Home

rivantsov — Wed, 20 May 2009 06:27:08 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
2009 Lang.NET symposium

Updated Wiki: Home

rivantsov — Wed, 20 May 2009 06:25:43 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
LangNET 2008/2009 presentations

Updated Wiki: Home

rivantsov — Sat, 02 May 2009 17:58:32 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.
May 2, 2009. Started a blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
LangNET 2008 presentations
Source changes history

Updated Wiki: Home

rivantsov — Sat, 02 May 2009 08:21:15 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.
May 2, 2009. Started my blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update. Enjoy it!

More information
Demo Running Instructions
Expression Grammar sample
LangNET 2008 presentations
Source changes history

Updated Wiki: Home

rivantsov — Sat, 02 May 2009 08:17:56 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.
May 2, 2009. Started my blog about Irony: http://irony-roman.blogspot.com/. The first post is about changes in April code update.

More information
Demo Running Instructions
Expression Grammar sample
LangNET 2008 presentations
Source changes history

Updated Wiki: Home

rivantsov — Sat, 25 Apr 2009 16:15:38 GMT

Irony is a development kit for implementing languages on .NET platform. It uses the flexibility and power of c# language and .NET Framework 3.5 to implement a completely new and streamlined technology of compiler construction.
Unlike most existing yacc/lex-style solutions Irony does not employ any scanner or parser code generation from grammar specifications written in a specialized meta-language. In Irony the target language grammar is coded directly in c# using operator overloading to express grammar constructs. Irony's scanner and parser modules use the grammar encoded as c# class to control the parsing process. See the expression grammar sample for an example of grammar definition in c# class, and using it in a working parser.

Initial Release
The initial release contains implementation of compiler front-end modules - scanner and LALR(1) parser. We provide several test grammars and parser implementations based on them: a grammar for simple arithmetic expressions and simplified grammars for c#, Scheme, Script.NET.
Scheme and expression samples are implemented with interpreter mode that allows direct evaluation of simple programs.

System Requirements
Windows XP/Vista, .NET Framework 3.5, Visual Studio 2008

Project News

The first implementation of interpreter/runtime infrastructure is available in changeset 10633
Writing your first Domain-Specific Language - two articles by Daniel Flower at CodeProject.com. An excellent introduction to using Irony for parsing "little" application-specific languages - DSLs.
A Google-like Full Text Search - an article by Michael Coles about Google-to-SQL Server full-text search query converter based on Irony.
10/27/2008 - Irony supports syntax highlighting. The first draft implementation of syntax colorizer is submitted in changset 13969.
11/25/2008 - Added JSON parser sample.
02/10/2009 - new article on CodeProject: Writing your first Visual Studio Language Service by Ben Morrison about using Irony for language integration into Visual Studio.
On April 14-16 Microsoft is hosting 2009 Lang.NET symposium. I (Roman, Irony coordinator) will be making 2 short presentations there, one of them about Irony. I will talk about project status and latest developments. Have a look at symposium agenda - quite interesting stuff will be there. Sign up if you can come, or visit the site later - MS will probably publish the presentations (audio and slides) as they did in previous years.
April 20 - Recordings of presentations at 2009 Lang.NET symposium are available online. I've made a couple of presentations there, the first one about Irony. Watch it, come back with comments. Watch other recordings - very interesting stuff!
April 24, 2009. Uploaded a "preview" version of new code. Not everything is working yet, will fix soon. The picture of Grammar Explorer above shows some new features - Parser tracing, choice of Parse method, etc.

More information
Demo Running Instructions
Expression Grammar sample
LangNET 2008 presentations
Source changes history