Author: olivier
Date: 2007-05-26 03:47:27 -0400 (Sat, 26 May 2007)
New Revision: 77986

Added:
   trunk/olive/class/Mono.JScript.Compiler/
   trunk/olive/class/Mono.JScript.Compiler/Assembly/
   trunk/olive/class/Mono.JScript.Compiler/Assembly/AssemblyInfo.cs
   trunk/olive/class/Mono.JScript.Compiler/ChangeLog
   trunk/olive/class/Mono.JScript.Compiler/Makefile
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.Hosting/
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.ParseTree/
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.Shell/
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.csproj
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.dll.sources
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.sln
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.suo
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Comment.cs
   
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/IdentifierTable.cs
   
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/RegularExpressionLiteralToken.cs
   
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/SourceLocation.cs
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/TextSpan.cs
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Token.cs
   trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Tokenizer.cs
   
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler_test.dll.sources
   trunk/olive/class/Mono.JScript.Compiler/TODO.txt
   trunk/olive/class/Mono.JScript.Compiler/test/
   trunk/olive/class/Mono.JScript.Compiler/test/LexerTest.cs
   
trunk/olive/class/Mono.JScript.Compiler/test/Mono.JScript.Compiler.Tests.csproj
   trunk/olive/class/Mono.JScript.Compiler/test/ParserTest.cs
   trunk/olive/class/Mono.JScript.Compiler/test/Properties/
   trunk/olive/class/Mono.JScript.Compiler/test/Properties/AssemblyInfo.cs
Log:
2007-05-26  Olivier Dufour  <[EMAIL PROTECTED]>

        * initial commit of Mono.JScript.Compiler

Added: trunk/olive/class/Mono.JScript.Compiler/Assembly/AssemblyInfo.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Assembly/AssemblyInfo.cs    
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Assembly/AssemblyInfo.cs    
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Les informations générales relatives à un assembly dépendent de 
+// l'ensemble d'attributs suivant. Changez les valeurs de ces attributs pour 
modifier les informations
+// associées à un assembly.
+[assembly: AssemblyTitle("Mono.JScript.Compiler")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("PepsiCo France")]
+[assembly: AssemblyProduct("Mono.JScript.Compiler")]
+[assembly: AssemblyCopyright("Copyright © PepsiCo France 2007")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// L'affectation de la valeur false à ComVisible rend les types invisibles 
dans cet assembly 
+// aux composants COM. Si vous devez accéder à un type dans cet assembly à 
partir de 
+// COM, affectez la valeur true à l'attribut ComVisible sur ce type.
+[assembly: ComVisible(false)]
+
+// Le GUID suivant est pour l'ID de la typelib si ce projet est exposé à COM
+[assembly: Guid("bd021e21-0dfa-4ff9-a9d3-c66f81d30e1c")]
+
+// Les informations de version pour un assembly se composent des quatre 
valeurs suivantes :
+//
+//      Version principale
+//      Version secondaire 
+//      Numéro de build
+//      Révision
+//
+// Vous pouvez spécifier toutes les valeurs ou indiquer les numéros de 
révision et de build par défaut 
+// en utilisant '*', comme indiqué ci-dessous :
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Added: trunk/olive/class/Mono.JScript.Compiler/ChangeLog
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/ChangeLog   2007-05-26 05:43:04 UTC 
(rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/ChangeLog   2007-05-26 07:47:27 UTC 
(rev 77986)
@@ -0,0 +1,3 @@
+2007-05-26  Olivier Dufour  <[EMAIL PROTECTED]>
+
+       * initial commit
\ No newline at end of file

Added: trunk/olive/class/Mono.JScript.Compiler/Makefile
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Makefile    2007-05-26 05:43:04 UTC 
(rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Makefile    2007-05-26 07:47:27 UTC 
(rev 77986)
@@ -0,0 +1,8 @@
+thisdir = class/Mono.JScript.Compiler
+include ../../build/rules.make
+
+LIBRARY = Mono.JScript.Compiler.dll
+
+LIB_MCS_FLAGS = -r:WindowsBase.dll -r:System.dll
+
+include ../../build/library.make

Added: trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Comment.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Comment.cs    
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Comment.cs    
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Mono.JScript.Compiler
+{
+       public class Comment
+       {
+               public Comment (string Spelling, TextSpan Location)
+               {
+               }
+
+               public TextSpan Location {
+                       get { throw new NotImplementedException (); } 
+               }
+
+               public string Spelling {
+                       get { throw new NotImplementedException (); } 
+               }
+
+       }
+}

Added: 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/IdentifierTable.cs
===================================================================
--- 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/IdentifierTable.cs
    2007-05-26 05:43:04 UTC (rev 77985)
+++ 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/IdentifierTable.cs
    2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Mono.JScript.Compiler
+{
+       public class IdentifierTable
+       {
+
+       }
+}

Added: 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/RegularExpressionLiteralToken.cs
===================================================================
--- 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/RegularExpressionLiteralToken.cs
      2007-05-26 05:43:04 UTC (rev 77985)
+++ 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/RegularExpressionLiteralToken.cs
      2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Mono.JScript.Compiler
+{
+       public class RegularExpressionLiteralToken
+       {
+       }
+}

Added: 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/SourceLocation.cs
===================================================================
--- 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/SourceLocation.cs 
    2007-05-26 05:43:04 UTC (rev 77985)
+++ 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/SourceLocation.cs 
    2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Mono.JScript.Compiler
+{
+       public class SourceLocation
+       {
+       }
+}

Added: trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/TextSpan.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/TextSpan.cs   
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/TextSpan.cs   
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Mono.JScript.Compiler
+{
+       public class TextSpan
+       {
+       }
+}

Added: trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Token.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Token.cs      
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Token.cs      
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Mono.JScript.Compiler
+{
+       public struct Token
+       {
+               /// <summary>
+               /// Token types from ECMA-262
+               /// </summary>
+               public enum Type
+               {
+                       EOF = 0,
+
+                       //Punctuator
+                       LeftBrace,// {
+                       RightBrace,// }
+                       LeftParenthesis,// (
+                       RightParenthesis,// )
+                       LeftBracket,// [
+                       RightBracket,// ]
+                       Dot,// .
+                       SemiColon,// ;
+                       Coma,// , 
+                       Less,// < 
+                       Greater,// > 
+                       LessEqual,// <=
+                       GreaterEqual,// >= 
+                       EqualEqual,// == 
+                       BangEqual,// != 
+                       EqualEqualEqual,// === 
+                       BangEqualEqual,// !==
+                       Plus,// + 
+                       Minus,// - 
+                       Star,// * 
+                       Percent,// % 
+                       PlusPlus,// ++ 
+                       MinusMinus,// --
+                       LessLess,// << 
+                       GreaterGreater,// >> 
+                       GreaterGreaterGreater,// >>> 
+                       And,// & 
+                       Bar,// | 
+                       Circumflex,// ^
+                       Bang,// ! 
+                       Tilda,// ~ 
+                       AndAnd,// && 
+                       BarBar,// || 
+                       Question,// ? 
+                       Colon,// :
+                       Equal,// = 
+                       PlusEqual,// += 
+                       MinusEqual,// -= 
+                       StarEqual,// *= 
+                       PercentEqual,// %= 
+                       LessLessEqual,// <<=
+                       GreaterGreaterEqual,// >>= 
+                       GreaterGreaterGreaterEqual,// >>>= 
+                       AndEqual,// &= 
+                       BarEqual,// |= 
+                       CircumflexEqual,// ^=
+                       Slash,// / 
+                       SlashEqual,// /=
+
+                       //Keywords
+                       Break,
+                       Else,
+                       New,
+                       Var,
+                       Case,
+                       Finally,
+                       Return,
+                       Void,
+                       Catch,
+                       For,
+                       Switch,
+                       While,
+                       Continue,
+                       Function,
+                       This,
+                       With,
+                       Default,
+                       If,
+                       Throw,
+                       Delete,
+                       In,
+                       Try,
+                       Do,
+                       Instanceof,
+                       Typeof,
+
+                       //FuturekeyWord
+                       Abstract,
+                       Enum,
+                       Int,
+                       Short,
+                       Boolean,
+                       Export,
+                       Interface,
+                       Static,
+                       Byte,
+                       Extends,
+                       Long,
+                       Super,
+                       Char,
+                       Final,
+                       Native,
+                       Synchronized,
+                       Class,
+                       Float,
+                       Package,
+                       Throws,
+                       Const,
+                       Goto,
+                       Private,
+                       Transient,
+                       Debugger,
+                       Implements,
+                       Protected,
+                       Volatile,
+                       Double,
+                       Import,
+                       Public,
+
+                       //literal
+                       Null,
+                       True,
+                       False,
+                       NumericLiteral,
+                       HexIntegerLiteral,
+                       StringLiteral,
+                       RegularExpressionLiteral,
+
+                       Identifier,
+
+                       Error
+               }
+
+               public Token(Token.Type Kind, int StartPosition, int StartLine, 
int StartColumn, bool FirstOnLine)
+               {
+                       this.Kind = Kind;
+                       this.StartPosition = StartPosition;
+                       this.StartLine = StartLine;
+                       this.StartColumn = StartColumn;
+                       this.firstOnLine = FirstOnLine;
+               }
+
+               public readonly Token.Type Kind;
+               public readonly int StartColumn;
+               public readonly int StartLine;
+               public readonly int StartPosition;
+               private bool firstOnLine;
+
+               public bool FirstOnLine
+               {
+                       get { return firstOnLine; }
+               }
+               public Token this[Tokenizer InputStream]
+               {
+                       get { return InputStream.GetNext(); }
+               }
+
+       }
+}

Added: 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Tokenizer.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Tokenizer.cs  
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler/Tokenizer.cs  
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,564 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Globalization;
+
+namespace Mono.JScript.Compiler
+{
+       public class Tokenizer
+       {
+               private char[] source;
+               private IdentifierTable IDTable;
+               private IDictionary<string, Token.Type> keywords;
+               private int lineStartPosition;
+               private int row;
+               private int position;
+               private Token current;
+               private List<Comment> comments;
+
+               public Tokenizer (char[] Input, IdentifierTable IDTable)
+               {
+                       this.source = Input;
+                       this.IDTable = IDTable;
+                       this.position = 0;
+                       this.row = 1;
+                       this.lineStartPosition = 0;
+                       this.comments = new List<Comment> ();
+                       InitKeywords();
+               }
+
+               public Token GetNext()
+               {
+                       //Must use CreateToken everytime we create a Token to 
avoid issue of location
+                       //But not for token EOF which is more a end of Input 
than an end of file ;)
+                       // I can test in create token but it perform better to 
not test every time 
+                       //whereas we already know it here
+
+                       if (!Advance())
+                               return new Token (Token.Type.EOF, position, 
row, position - lineStartPosition, position == lineStartPosition);
+
+                       StripWhiteSpace();
+
+                       if (!Advance())
+                               return new Token (Token.Type.EOF, position, 
row, position - lineStartPosition, position == lineStartPosition);
+
+                       char next = source[position];
+                       int nextPos;
+                       switch (next)
+                       {
+                               case '{':
+                                       return 
CreateToken(Token.Type.LeftBrace);
+                               case '}':
+                                       return 
CreateToken(Token.Type.RightBrace);
+                               case '(':
+                                       return 
CreateToken(Token.Type.LeftParenthesis);
+                               case ')':
+                                       return 
CreateToken(Token.Type.RightParenthesis);
+                               case '[':
+                                       return 
CreateToken(Token.Type.LeftBracket);
+                               case ']':
+                                       return 
CreateToken(Token.Type.RightBracket);
+                               case '.':
+                                       return CreateToken(Token.Type.Dot);
+                               case ';':
+                                       return 
CreateToken(Token.Type.SemiColon);
+                               case ',':
+                                       return CreateToken(Token.Type.Coma);
+                               case '<':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.LessEqual);
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '<') {
+                                               position++;
+                                               nextPos = position + 1;
+                                               if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                                       position++;
+                                                       return 
CreateToken(Token.Type.LessLessEqual);
+                                               }
+                                               return 
CreateToken(Token.Type.LessLess);                                        
+                                       }
+                                       return CreateToken(Token.Type.Less);
+                               case '>':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.GreaterEqual);
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '>') {
+                                               position++;
+                                               nextPos = position + 1;
+                                               if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                                       position++;
+                                                       return 
CreateToken(Token.Type.GreaterGreaterEqual);
+                                               }
+                                               else if (nextPos < 
source.Length && source[nextPos] == '>') {
+                                                       position++;
+                                                       nextPos = position + 1;
+                                                       if (nextPos < 
source.Length && source[nextPos] == '=') {
+                                                               position++;
+                                                               return 
CreateToken(Token.Type.GreaterGreaterGreaterEqual);
+                                                       }
+                                                       return 
CreateToken(Token.Type.GreaterGreaterGreater);
+                                               }
+                                               return 
CreateToken(Token.Type.GreaterGreater);
+                                       }
+                                       return CreateToken(Token.Type.Greater);
+                               case '=':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               nextPos = position + 1;
+                                               if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                                       position++;
+                                                       return 
CreateToken(Token.Type.EqualEqualEqual);
+                                               }
+                                               else
+                                                       return 
CreateToken(Token.Type.EqualEqual);
+                                       }
+                                       else
+                                               return 
CreateToken(Token.Type.Equal);
+                               case '!':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               nextPos = position + 1;
+                                               if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                                       position++;
+                                                       return 
CreateToken(Token.Type.BangEqualEqual);
+                                               }
+                                               return 
CreateToken(Token.Type.BangEqual);
+                                       }
+                                       break;
+                               case '+':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '+') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.PlusPlus);
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.PlusEqual);
+                                       }
+                                       return CreateToken(Token.Type.Plus);
+                               case '-':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '-') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.MinusMinus);
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.MinusEqual);
+                                       }
+                                       return CreateToken(Token.Type.Minus);
+                               case '*':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.StarEqual);
+                                       }
+                                       return CreateToken(Token.Type.Star);
+                               case '%':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.PercentEqual);
+                                       }
+                                       return CreateToken(Token.Type.Percent);
+                               case '&':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '&') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.AndAnd);
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.AndEqual);
+                                       }
+                                       return CreateToken(Token.Type.And);
+                               case '|':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '|') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.BarBar);
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.BarEqual);
+                                       }
+                                       return CreateToken(Token.Type.Bar);
+                               case '^':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.CircumflexEqual);
+                                       }
+                                       return 
CreateToken(Token.Type.Circumflex);
+                               case '~':
+                                       return CreateToken(Token.Type.Tilda);
+                               case '?':
+                                       return CreateToken(Token.Type.Question);
+                               case ':':
+                                       return CreateToken(Token.Type.Colon);
+                               case '/':
+                                       nextPos = position + 1;
+                                       if (nextPos < source.Length && 
source[nextPos] == '=') {
+                                               position++;
+                                               return 
CreateToken(Token.Type.SlashEqual);
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '/') {
+                                               position++;
+                                               CreateLineComment();
+                                               return GetNext();
+                                       }
+                                       else if (nextPos < source.Length && 
source[nextPos] == '*') {
+                                               position++;
+                                               CreateBlockComment();
+                                               return GetNext ();
+                                       }
+                                       return CreateToken(Token.Type.Slash);
+                               case '0':
+                               case '1':
+                               case '2':
+                               case '3':
+                               case '4':
+                               case '5':
+                               case '6':
+                               case '7':
+                               case '8':
+                               case '9':
+                                       return CreateNumericLiteralToken();
+
+                               case 'a':
+                               case 'b':
+                               case 'c':
+                               case 'd':
+                               case 'e':
+                               case 'f':
+                               case 'g':
+                               case 'h':
+                               case 'i':
+                               case 'j':
+                               case 'k':
+                               case 'l':
+                               case 'm':
+                               case 'n':
+                               case 'o':
+                               case 'p':
+                               case 'q':
+                               case 'r':
+                               case 's':
+                               case 't':
+                               case 'u':
+                               case 'v':
+                               case 'w':
+                               case 'x':
+                               case 'y':
+                               case 'z':
+                               case 'A':
+                               case 'B':
+                               case 'C':
+                               case 'D':
+                               case 'E':
+                               case 'F':
+                               case 'G':
+                               case 'H':
+                               case 'I':
+                               case 'J':
+                               case 'K':
+                               case 'L':
+                               case 'M':
+                               case 'N':
+                               case 'O':
+                               case 'P':
+                               case 'Q':
+                               case 'R':
+                               case 'S':
+                               case 'T':
+                               case 'U':
+                               case 'V':
+                               case 'W':
+                               case 'X':
+                               case 'Y':
+                               case 'Z':
+                               case '$':
+                               case '_':
+                                       return this.CreateIdentOrKeyword();
+                       }
+                       return CreateToken(Token.Type.Error);
+               }
+
+               public RegularExpressionLiteralToken ScanRegularExpression 
(Token Divide)
+               {
+                       throw new NotImplementedException();
+               }
+               
+
+               private bool Advance()
+               {
+                       return ((source != null) && position < source.Length);
+               }
+
+               public List<Comment> Comments {
+                       get { return comments; }
+               }
+
+               public SourceLocation Position
+               {
+                       get { throw new NotImplementedException(); }
+                       set { throw new NotImplementedException(); }
+               }
+
+               #region token
+
+               private Token CreateToken(Token.Type tokenType)
+               {
+                       current = new Token (tokenType, position, row, position 
- lineStartPosition, position == lineStartPosition);
+                       position++;
+                       return current;
+               }
+
+               private Token CreateToken(Token.Type tokenType, string value)
+               {
+                       current = new Token (tokenType, position, row, position 
- lineStartPosition, position == lineStartPosition);
+                       position++;
+                       return current;
+               }
+               
+               private Token CreateIdentOrKeyword()
+               {
+                       StringBuilder builder = new StringBuilder();
+
+                       while (Advance()) {
+                               char next = source[position];
+                               switch (next) {
+                                       case '0':
+                                       case '1':
+                                       case '2':
+                                       case '3':
+                                       case '4':
+                                       case '5':
+                                       case '6':
+                                       case '7':
+                                       case '8':
+                                       case '9':
+                                       case 'a':
+                                       case 'b':
+                                       case 'c':
+                                       case 'd':
+                                       case 'e':
+                                       case 'f':
+                                       case 'g':
+                                       case 'h':
+                                       case 'i':
+                                       case 'j':
+                                       case 'k':
+                                       case 'l':
+                                       case 'm':
+                                       case 'n':
+                                       case 'o':
+                                       case 'p':
+                                       case 'q':
+                                       case 'r':
+                                       case 's':
+                                       case 't':
+                                       case 'u':
+                                       case 'v':
+                                       case 'w':
+                                       case 'x':
+                                       case 'y':
+                                       case 'z':
+                                       case 'A':
+                                       case 'B':
+                                       case 'C':
+                                       case 'D':
+                                       case 'E':
+                                       case 'F':
+                                       case 'G':
+                                       case 'H':
+                                       case 'I':
+                                       case 'J':
+                                       case 'K':
+                                       case 'L':
+                                       case 'M':
+                                       case 'N':
+                                       case 'O':
+                                       case 'P':
+                                       case 'Q':
+                                       case 'R':
+                                       case 'S':
+                                       case 'T':
+                                       case 'U':
+                                       case 'V':
+                                       case 'W':
+                                       case 'X':
+                                       case 'Y':
+                                       case 'Z':
+                                       case '$':
+                                       case '_': {
+                                                       builder.Append(next);
+                                                       position++;
+                                                       continue;
+                                       }
+                               }
+                               break;
+                       }
+                       string result = builder.ToString();
+                       Token.Type type;
+                       if (keywords.TryGetValue(result, out type)) {
+                               current = new Token (type, position, row, 
position - lineStartPosition, position == lineStartPosition);
+                               return current;
+                       }
+                       current = new Token (Token.Type.Identifier, position, 
row, position - lineStartPosition, position == lineStartPosition);
+                       return current;
+               }
+
+               private Token CreateNumericLiteralToken()
+               {
+                       StringBuilder builder = new StringBuilder();
+                       int dot = 0;
+
+                       while (Advance()) {
+                               char next = source[position];
+                               switch (next) {
+                                       case '0':
+                                       case '1':
+                                       case '2':
+                                       case '3':
+                                       case '4':
+                                       case '5':
+                                       case '6':
+                                       case '7':
+                                       case '8':
+                                       case '9': {
+                                                       builder.Append(next);
+                                                       position++;
+                                                       continue;
+                                               }
+                                       case '.': {
+                                                       dot++;
+                                                       if (dot > 1) {
+                                                               current = new 
Token (Token.Type.Error, position, row, position - lineStartPosition, position 
== lineStartPosition);
+                                                               return current;
+                                                       }
+                                                       builder.Append(next);
+                                                       position++;
+                                                       continue;
+                                               }
+                               }
+                               break;
+                       }
+                       string result = builder.ToString();
+                       current = new Token (Token.Type.NumericLiteral, 
position, row, position - lineStartPosition, position == lineStartPosition);
+                       return current;
+               }
+
+               #endregion
+               
+               private void InitKeywords()
+               {
+                       keywords = new Dictionary<string, Token.Type>();
+                       keywords.Add("break", Token.Type.Break);
+                       keywords.Add("else", Token.Type.Else);
+                       keywords.Add("new", Token.Type.New);
+                       keywords.Add("var", Token.Type.Var);
+                       keywords.Add("case", Token.Type.Case);
+                       keywords.Add("finally", Token.Type.Finally);
+                       keywords.Add("return", Token.Type.Return);
+                       keywords.Add("void", Token.Type.Void);
+                       keywords.Add("catch", Token.Type.Catch); 
+                       keywords.Add("for", Token.Type.For);
+                       keywords.Add("switch", Token.Type.Switch); 
+                       keywords.Add("while", Token.Type.While);
+                       keywords.Add("continue", Token.Type.Continue); 
+                       keywords.Add("function", Token.Type.Function); 
+                       keywords.Add("this", Token.Type.This); 
+                       keywords.Add("with", Token.Type.With);
+                       keywords.Add("default", Token.Type.Default); 
+                       keywords.Add("if", Token.Type.If); 
+                       keywords.Add("throw", Token.Type.Throw);
+                       keywords.Add("delete", Token.Type.Delete); 
+                       keywords.Add("in", Token.Type.In); 
+                       keywords.Add("try", Token.Type.Try);
+                       keywords.Add("do", Token.Type.Do); 
+                       keywords.Add("instanceof", Token.Type.Instanceof); 
+                       keywords.Add("typeof", Token.Type.Typeof);
+
+                       //FuturekeyWord
+                       keywords.Add("abstract", Token.Type.Abstract);
+                       keywords.Add("enum", Token.Type.Enum);
+                       keywords.Add("int", Token.Type.Int);
+                       keywords.Add("short", Token.Type.Short);
+                       keywords.Add("boolean", Token.Type.Boolean);
+                       keywords.Add("Export", Token.Type.Export);
+                       keywords.Add("interface", Token.Type.Interface);
+                       keywords.Add("static", Token.Type.Static);
+                       keywords.Add("byte", Token.Type.Byte);
+                       keywords.Add("extends", Token.Type.Extends);
+                       keywords.Add("long", Token.Type.Long);
+                       keywords.Add("super", Token.Type.Super);
+                       keywords.Add("char", Token.Type.Char);
+                       keywords.Add("final", Token.Type.Final);
+                       keywords.Add("native", Token.Type.Native);
+                       keywords.Add("synchronized", Token.Type.Synchronized);
+                       keywords.Add("class", Token.Type.Class);
+                       keywords.Add("float", Token.Type.Float);
+                       keywords.Add("package", Token.Type.Package);
+                       keywords.Add("throws", Token.Type.Throws);
+                       keywords.Add("const", Token.Type.Const);
+                       keywords.Add("goto", Token.Type.Goto);
+                       keywords.Add("private", Token.Type.Private);
+                       keywords.Add("transient", Token.Type.Transient);
+                       keywords.Add("debugger", Token.Type.Debugger);
+                       keywords.Add("implements", Token.Type.Implements);
+                       keywords.Add("protected", Token.Type.Protected);
+                       keywords.Add("volatile", Token.Type.Volatile);
+                       keywords.Add("double", Token.Type.Double);
+                       keywords.Add("import", Token.Type.Import);
+                       keywords.Add("public", Token.Type.Public);
+               
+                       //literal
+                       keywords.Add("null", Token.Type.Null);
+                       keywords.Add("true", Token.Type.True);
+                       keywords.Add("false", Token.Type.False);
+               }
+
+               private void StripWhiteSpace()
+               {
+                       char next = source[position];
+                       while (next == ' ' || next == '\t' || next == '\r' || 
next == '\n')
+                       {
+                               if (next == '\n')
+                               {
+                                       NextRow();
+                               }
+                               else if (next != '\r')
+                                       position++;
+                               if (position >= source.Length)
+                                       break;
+                               next = source[position];
+                       }
+               }
+
+               private void NextRow ()
+               {
+                       row++;
+                       lineStartPosition = position;
+                       position++;
+
+               }
+
+               private void CreateBlockComment()
+               {
+                       throw new Exception("The method or operation is not 
implemented.");
+               }
+
+               private void CreateLineComment()
+               {
+                       throw new Exception("The method or operation is not 
implemented.");
+               }
+       }
+}

Added: trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.csproj
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.csproj        
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.csproj        
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" 
xmlns="http://schemas.microsoft.com/developer/msbuild/2003";>
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{03952B85-C1DB-4253-B822-AF37BD6B1C66}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Mono.JScript.Compiler</RootNamespace>
+    <AssemblyName>Mono.JScript.Compiler</AssemblyName>
+    <StartupObject>
+    </StartupObject>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' 
">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 
'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets 
below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <ItemGroup>
+    <Compile Include="Mono.JScript.Compiler\Comment.cs" />
+    <Compile Include="Mono.JScript.Compiler\IdentifierTable.cs" />
+    <Compile Include="Mono.JScript.Compiler\RegularExpressionLiteralToken.cs" 
/>
+    <Compile Include="Mono.JScript.Compiler\SourceLocation.cs" />
+    <Compile Include="Mono.JScript.Compiler\TextSpan.cs" />
+    <Compile Include="Mono.JScript.Compiler\Tokenizer.cs" />
+    <Compile Include="Mono.JScript.Compiler\Token.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Mono.JScript.Compiler.Hosting\" />
+    <Folder Include="Mono.JScript.Compiler.ParseTree\" />
+    <Folder Include="Mono.JScript.Compiler.Shell\" />
+  </ItemGroup>
+</Project>
\ No newline at end of file

Added: trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.dll.sources
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.dll.sources   
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.dll.sources   
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,7 @@
+Mono.JScript.Compiler/ILexer.cs
+Mono.JScript.Compiler/IParser.cs
+Mono.JScript.Compiler/JScriptLexer.cs
+Mono.JScript.Compiler/JScriptParser.cs
+Mono.JScript.Compiler/Location.cs
+Mono.JScript.Compiler/SourceFile.cs
+Mono.JScript.Compiler/Token.cs
\ No newline at end of file

Added: trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.sln
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.sln   
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.sln   
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,26 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual C# Express 2005
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = 
"Mono.JScript.Compiler.Tests", "test\Mono.JScript.Compiler.Tests.csproj", 
"{AEABAFEC-B30F-429D-B6D5-7E70AE6D6BD9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.JScript.Compiler", 
"Mono.JScript.Compiler.csproj", "{03952B85-C1DB-4253-B822-AF37BD6B1C66}"
+EndProject
+Global
+       GlobalSection(SolutionConfigurationPlatforms) = preSolution
+               Debug|Any CPU = Debug|Any CPU
+               Release|Any CPU = Release|Any CPU
+       EndGlobalSection
+       GlobalSection(ProjectConfigurationPlatforms) = postSolution
+               {AEABAFEC-B30F-429D-B6D5-7E70AE6D6BD9}.Debug|Any CPU.ActiveCfg 
= Debug|Any CPU
+               {AEABAFEC-B30F-429D-B6D5-7E70AE6D6BD9}.Debug|Any CPU.Build.0 = 
Debug|Any CPU
+               {AEABAFEC-B30F-429D-B6D5-7E70AE6D6BD9}.Release|Any 
CPU.ActiveCfg = Release|Any CPU
+               {AEABAFEC-B30F-429D-B6D5-7E70AE6D6BD9}.Release|Any CPU.Build.0 
= Release|Any CPU
+               {03952B85-C1DB-4253-B822-AF37BD6B1C66}.Debug|Any CPU.ActiveCfg 
= Debug|Any CPU
+               {03952B85-C1DB-4253-B822-AF37BD6B1C66}.Debug|Any CPU.Build.0 = 
Debug|Any CPU
+               {03952B85-C1DB-4253-B822-AF37BD6B1C66}.Release|Any 
CPU.ActiveCfg = Release|Any CPU
+               {03952B85-C1DB-4253-B822-AF37BD6B1C66}.Release|Any CPU.Build.0 
= Release|Any CPU
+       EndGlobalSection
+       GlobalSection(SolutionProperties) = preSolution
+               HideSolutionNode = FALSE
+       EndGlobalSection
+EndGlobal

Added: trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.suo
===================================================================
(Binary files differ)


Property changes on: 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler.suo
___________________________________________________________________
Name: svn:mime-type
   + application/octet-stream

Added: 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler_test.dll.sources
===================================================================
--- 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler_test.dll.sources  
    2007-05-26 05:43:04 UTC (rev 77985)
+++ 
trunk/olive/class/Mono.JScript.Compiler/Mono.JScript.Compiler_test.dll.sources  
    2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,3 @@
+LexerTest.cs
+ParserTest.cs
+

Added: trunk/olive/class/Mono.JScript.Compiler/TODO.txt
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/TODO.txt    2007-05-26 05:43:04 UTC 
(rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/TODO.txt    2007-05-26 07:47:27 UTC 
(rev 77986)
@@ -0,0 +1,13 @@
+http://www.dotnetguru.org/articles/dossiers/creercompilo/compilateurdnet.htm
+http://tirania.org/blog/archive/2007/May-23.html
+http://www.mono-project.com/Moonlight#JavaScript_compiler
+
+
+
+TODO LIST:
+
+* Analyse lexicale: c'est � dire reconna�tre les mots dans le code source � 
compiler (par exemple pour le MyJScript: "var", "function", "if" ou "+"),
+* Analyse syntaxique: c'est � dire v�rifier que les mots sont bien dans le bon 
ordre,
+* Construction d'un arbre syntaxique: c'est � dire construire en m�moire un 
arbre repr�sentant le code � compiler,
+* G�n�rer: parcourir l'arbre en m�moire et g�n�rer le code,
+* Compiler: compiler le code en du code IL binaire.

Added: trunk/olive/class/Mono.JScript.Compiler/test/LexerTest.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/test/LexerTest.cs   2007-05-26 
05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/test/LexerTest.cs   2007-05-26 
07:47:27 UTC (rev 77986)
@@ -0,0 +1,49 @@
+using NUnit.Core;
+using NUnit.Framework;
+using Mono.JScript.Compiler;
+
+namespace Mono.JScript.Compiler.Tests
+{
+       [TestFixture]
+       public class LexerTest
+       {
+               [Test]
+               public void AffectTest()
+               {
+                       Tokenizer l1 = new Tokenizer ("var i = 
10;".ToCharArray(), new IdentifierTable ());
+                       Assert.AreEqual(Token.Type.Var, l1.GetNext().Kind);
+                       Assert.AreEqual (Token.Type.Identifier, 
l1.GetNext().Kind);
+                       //Assert.AreEqual("i", l1.Value());
+                       Assert.AreEqual (Token.Type.Equal, l1.GetNext().Kind);
+                       Assert.AreEqual (Token.Type.NumericLiteral, 
l1.GetNext().Kind);
+                       //Assert.AreEqual("10", l1.Value());
+                       Assert.AreEqual (Token.Type.SemiColon, 
l1.GetNext().Kind);    
+                       //Assert.IsFalse(l1.Advance());
+                       Assert.AreEqual (Token.Type.EOF, l1.GetNext().Kind);   
+               }
+
+               [Test]
+               public void PlusTest()
+               {
+                       Tokenizer l1 = new Tokenizer 
("$test_var++;".ToCharArray (), new IdentifierTable ());
+                       Assert.AreEqual (Token.Type.Identifier, 
l1.GetNext().Kind);
+                       //Assert.AreEqual("$test_var", l1.Value());
+                       Assert.AreEqual (Token.Type.PlusPlus, 
l1.GetNext().Kind);
+                       Assert.AreEqual (Token.Type.SemiColon, 
l1.GetNext().Kind);
+                       //Assert.IsFalse(l1.Advance());
+                       Assert.AreEqual (Token.Type.EOF, l1.GetNext().Kind);
+               }
+
+               [Test]
+               public void MinusTest()
+               {
+                       Tokenizer l1 = new Tokenizer 
("$test_var--;".ToCharArray (), new IdentifierTable ());
+                       Assert.AreEqual (Token.Type.Identifier, 
l1.GetNext().Kind);
+                       //Assert.AreEqual("$test_var", l1.Value());
+                       Assert.AreEqual (Token.Type.MinusMinus, 
l1.GetNext().Kind);
+                       Assert.AreEqual (Token.Type.SemiColon, 
l1.GetNext().Kind);
+                       //Assert.IsFalse(l1.Advance());
+                       Assert.AreEqual (Token.Type.EOF, l1.GetNext().Kind);
+               }
+       }
+}

Added: 
trunk/olive/class/Mono.JScript.Compiler/test/Mono.JScript.Compiler.Tests.csproj
===================================================================
--- 
trunk/olive/class/Mono.JScript.Compiler/test/Mono.JScript.Compiler.Tests.csproj 
    2007-05-26 05:43:04 UTC (rev 77985)
+++ 
trunk/olive/class/Mono.JScript.Compiler/test/Mono.JScript.Compiler.Tests.csproj 
    2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,53 @@
+<Project DefaultTargets="Build" 
xmlns="http://schemas.microsoft.com/developer/msbuild/2003";>
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{AEABAFEC-B30F-429D-B6D5-7E70AE6D6BD9}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Mono.JScript.Compiler.Tests</RootNamespace>
+    <AssemblyName>Mono.JScript.Compiler.Tests</AssemblyName>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' 
">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 
'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="LexerTest.cs" />
+    <Compile Include="ParserTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="nunit.core, Version=2.2.9.0, Culture=neutral, 
PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+    <Reference Include="nunit.framework, Version=2.2.9.0, Culture=neutral, 
PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Mono.JScript.Compiler.csproj">
+      <Project>{03952B85-C1DB-4253-B822-AF37BD6B1C66}</Project>
+      <Name>Mono.JScript.Compiler</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets 
below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

Added: trunk/olive/class/Mono.JScript.Compiler/test/ParserTest.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/test/ParserTest.cs  2007-05-26 
05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/test/ParserTest.cs  2007-05-26 
07:47:27 UTC (rev 77986)
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Core;
+using NUnit.Framework;
+
+namespace Mono.JScript.Compiler.Tests
+{
+       [TestFixture]
+       public class ParserTest
+       {
+               [Test]
+               public void GlobalTest()
+               {
+                       /*IParser p1 = new JScriptParser("var } function + i 
'Hello',");
+                       Assert.IsFalse(p1.Parse());
+                       Assert.AreEqual(1, p1.Errors.Count);
+                       Assert.AreEqual("MJS0300", p1.Errors[0].ErrorNumber); 
// MJS300 = Erreur de syntaxe
+                       Assert.AreEqual(1, p1.Errors[0].Line);
+                       Assert.AreEqual(5, p1.Errors[0].Column);*/
+               }
+       }
+}

Added: trunk/olive/class/Mono.JScript.Compiler/test/Properties/AssemblyInfo.cs
===================================================================
--- trunk/olive/class/Mono.JScript.Compiler/test/Properties/AssemblyInfo.cs     
2007-05-26 05:43:04 UTC (rev 77985)
+++ trunk/olive/class/Mono.JScript.Compiler/test/Properties/AssemblyInfo.cs     
2007-05-26 07:47:27 UTC (rev 77986)
@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// Les informations générales relatives à un assembly dépendent de 
+// l'ensemble d'attributs suivant. Changez les valeurs de ces attributs pour 
modifier les informations
+// associées à un assembly.
+[assembly: AssemblyTitle("Mono.JScript.Compiler.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("PepsiCo France")]
+[assembly: AssemblyProduct("Mono.JScript.Compiler.Tests")]
+[assembly: AssemblyCopyright("Copyright © PepsiCo France 2007")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// L'affectation de la valeur false à ComVisible rend les types invisibles 
dans cet assembly 
+// aux composants COM. Si vous devez accéder à un type dans cet assembly à 
partir de 
+// COM, affectez la valeur true à l'attribut ComVisible sur ce type.
+[assembly: ComVisible(false)]
+
+// Le GUID suivant est pour l'ID de la typelib si ce projet est exposé à COM
+[assembly: Guid("b1559ff8-f44f-4cab-a54e-faa001d91217")]
+
+// Les informations de version pour un assembly se composent des quatre 
valeurs suivantes :
+//
+//      Version principale
+//      Version secondaire 
+//      Numéro de build
+//      Révision
+//
+// Vous pouvez spécifier toutes les valeurs ou indiquer les numéros de 
révision et de build par défaut 
+// en utilisant '*', comme indiqué ci-dessous :
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to