├── Compiler
    ├── AUTHORS
    ├── Framework.dll
    ├── Graph.cs
    ├── LICENCE
    ├── Log.cs
    ├── MK.CodeDom.Compiler
    │   ├── AssemblyCompiler.cs
    │   ├── Attributes.cs
    │   ├── CssSupport.cs
    │   ├── JSCompiler.cs
    │   ├── LabelsInliner.cs
    │   ├── MethodCompiler - js stack machine.cs
    │   ├── MethodCompiler.cs
    │   ├── Resources.cs
    │   ├── ServerManager.cs
    │   ├── Symbols.cs
    │   ├── defs.cs
    │   └── il's.cs
    ├── MK.Convert.cs
    ├── Main.cs
    ├── Mapping.xml
    ├── Mapping.xsd
    ├── Mapping.xsl
    ├── Mapping2.xml
    ├── Program.cs
    ├── README.md
    └── Runtime.js
├── Framework
    ├── AUTHORS
    ├── Ajax
    │   ├── Attributes.cs
    │   ├── Module.cs
    │   ├── Serialization.cs
    │   └── Server.cs
    ├── Attributes.cs
    ├── Core.cs
    ├── Extensions.cs
    ├── JS Global.cs
    ├── LICENCE
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── README.md
    ├── System.Runtime.Serialization.DataMemberAttribute [mock].cs
    ├── Tools.cs
    ├── Window - modules.cs
    ├── Window.cs
    ├── [namespace] .Css
    │   ├── Css Selectors.cs
    │   └── Css.cs
    ├── [namespace] .Dom
    │   ├── Dom.cs
    │   ├── Element - server side.cs
    │   └── Tags.cs
    ├── [namespace] .Framework.Mappings
    │   ├── IEnumerable.cs
    │   └── System.Threading.cs
    ├── [namespace] .Framework.cs
    ├── [namespace] .Reflection.cs
    └── [namespace] PrototypeJs.cs
└── README.md


/Compiler/AUTHORS:
--------------------------------------------------------------------------------
1 | Author:
2 |   Michael Kolarz (michael.kolarz@gmail.com)
3 | 


--------------------------------------------------------------------------------
/Compiler/Framework.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkol/il2js/e46e4cb302dbed0b426d31e29879a63362143eb2/Compiler/Framework.dll


--------------------------------------------------------------------------------
/Compiler/Graph.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using MK.CodeDom.Compiler;
 24 | 
 25 | namespace MK.Collections {
 26 | 	public class Graph<Vertice> {
 27 | 		private class VerticeData {
 28 | 			public readonly int Index;
 29 | 			public readonly Vertice Vertice;
 30 | 			public bool Visited;
 31 | 			public readonly HashSet<VerticeData> Neighbours = new HashSet<VerticeData>();
 32 | 			public VerticeData(int index, Vertice vertice) {
 33 | 				this.Index = index;
 34 | 				this.Vertice = vertice;
 35 | 			}
 36 | 		}
 37 | 
 38 | 		private readonly Dictionary<Vertice, VerticeData> vertices = new Dictionary<Vertice, VerticeData>();
 39 | 		private readonly Dictionary<Vertice, VerticeData> sources = new Dictionary<Vertice, VerticeData>();
 40 | 		private VerticeData doAdd(Vertice v) {
 41 | 			VerticeData data;
 42 | 			if (!this.vertices.TryGetValue(v, out data)) {
 43 | 				data = new VerticeData(this.vertices.Count, v);
 44 | 				this.vertices[v] = data;
 45 | 			}
 46 | 			return data;
 47 | 		}
 48 | 
 49 | 		public void AddVertice(Vertice v) {
 50 | 			this.sources[v] = this.doAdd(v);
 51 | 		}
 52 | 		public void AddEdge(Vertice parent, Vertice v) { this.doAdd(parent).Neighbours.Add(this.doAdd(v)); }
 53 | 
 54 | 		public IEnumerable<Vertice> TopologicalInverseOrder(IEnumerable<Vertice> vertices) {
 55 | 			HashSet<VerticeData> hashSet = new HashSet<VerticeData>();
 56 | 			foreach (var v in vertices) {
 57 | 				hashSet.Add(this.vertices[v]);
 58 | 			}
 59 | 			while (hashSet.Count > 0) {
 60 | 				bool found = false;
 61 | 				foreach (var self in hashSet) {
 62 | 					bool dependent = false;
 63 | 					foreach (var other in hashSet) {
 64 | 						if (other != self && this.IsPathFromTo(self.Vertice, other.Vertice)) {
 65 | 							dependent = true;
 66 | 							break;
 67 | 						}
 68 | 					}
 69 | 					if (!dependent) {
 70 | 						yield return self.Vertice;
 71 | 						hashSet.Remove(self);
 72 | 						found = true;
 73 | 						break;
 74 | 					}
 75 | 				}
 76 | 				if (!found) ThrowHelper.Throw("Cyclic calls in static constructors.");
 77 | 			}
 78 | 		}
 79 | 
 80 | 		public bool IsPathFromTo(Vertice v1, Vertice v2) {
 81 | 			//return true;
 82 | 			return this.GetComponentOf(v1).Contains(v2);
 83 | 			//return this.adj[this.vertices[v1].Index, this.vertices[v2].Index];
 84 | 		}
 85 | 
 86 | 		#region DFS
 87 | 		private HashSet<Vertice> GetComponentOf(Vertice v) {
 88 | 			HashSet<Vertice> value;
 89 | 			if (!this.componentsOfSource.TryGetValue(v, out value)) {
 90 | 				value=DFSFromSource(this.vertices[v]);
 91 | 			}
 92 | 			return value;
 93 | 		}
 94 | 		private Dictionary<Vertice, HashSet<Vertice>> componentsOfSource = new Dictionary<Vertice, HashSet<Vertice>>();
 95 | 		private static void DFS(HashSet<Vertice> component, VerticeData current) {
 96 | 			component.Add(current.Vertice);
 97 | 			current.Visited = true;
 98 | 			foreach (var neighbour in current.Neighbours.Where(n => !n.Visited)) {
 99 | 				DFS(component, neighbour);
100 | 			}
101 | 		}
102 | 		//public void DFSFromSources() { this.DFSFromSources(this.sources.Values); }
103 | 		private void DFSFromSources(IEnumerable<VerticeData> vs) {
104 | 			foreach (var source in vs) {
105 | 				this.DFSFromSource(source);
106 | 			}
107 | 		}
108 | 		private HashSet<Vertice> DFSFromSource(VerticeData source) {
109 | 			foreach (var item in this.vertices.Values) {
110 | 				item.Visited = false;
111 | 			}
112 | 			var component = new HashSet<Vertice>();
113 | 			this.componentsOfSource[source.Vertice] = component;
114 | 			DFS(component, source);
115 | 			return component;
116 | 		}
117 | 		#endregion
118 | 
119 | 		internal string Dump() {
120 | 			StringBuilder sb = new StringBuilder();
121 | 			foreach (var item in this.vertices.Values) {
122 | 				foreach (var v2 in item.Neighbours) {
123 | 					sb.Append(item.Vertice.ToString()+" -> "+v2.Vertice.ToString()+"\n");
124 | 				}
125 | 			}
126 | 			return sb.ToString();
127 | 		}
128 | 
129 | 		//private bool[,] adj;
130 | 
131 | 		//public void FloydWarshall() {
132 | 		//  this.adj = new bool[this.vertices.Count, this.vertices.Count];
133 | 		//  foreach (var data in this.vertices.Values) {
134 | 		//    this.adj[data.Index, data.Index] = true;
135 | 		//    foreach (var neighbour in data.Neighbours) {
136 | 		//      this.adj[data.Index, neighbour] = true;
137 | 		//    }
138 | 		//  }
139 | 		//  for (int k = 0; k < this.vertices.Count; ++k) {
140 | 		//    for (int i = 0; i < this.vertices.Count; ++i) {
141 | 		//      for (int j = 0; j < this.vertices.Count; ++j) {
142 | 		//        this.adj[i, j] = this.adj[i, j] || (this.adj[i, k] && this.adj[k, j]);
143 | 		//      }
144 | 		//    }
145 | 		//  }
146 | 		//}
147 | 
148 | 	}
149 | }
150 | 


--------------------------------------------------------------------------------
/Compiler/LICENCE:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mkol/il2js/e46e4cb302dbed0b426d31e29879a63362143eb2/Compiler/LICENCE


--------------------------------------------------------------------------------
/Compiler/Log.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using MK.JavaScript.CodeDom.Compiler;
 24 | 
 25 | namespace MK.JavaScript {
 26 | 
 27 | }
 28 | 
 29 | 
 30 | namespace MK.CodeDom.Compiler {
 31 | 
 32 | 	partial class MethodCompiler {
 33 | 
 34 | 
 35 | 		internal void DumpLogs() {
 36 | 			if (!Settings.DebugCompilation) return;
 37 | 
 38 | 			Program.XmlLog.WriteStartElement("mapping");
 39 | 
 40 | 			int nextJump = 0;
 41 | 			int cumulativeOffset = 0;
 42 | 
 43 | 			for (int i = 1; i < this.PositionMappings.Length; ++i) {
 44 | 				if (this.PositionMappings[i] == 0) {
 45 | 					this.PositionMappings[i] = this.PositionMappings[i - 1];
 46 | 				} else {
 47 | 					if (nextJump < this.jumpData.Length && this.jumpData[nextJump].WritePosition >= this.PositionMappings[i]) {
 48 | 						cumulativeOffset += this.jumpData[nextJump].SizeOfLabel;
 49 | 						++nextJump;
 50 | 					}
 51 | 					this.PositionMappings[i] += cumulativeOffset;
 52 | 				}
 53 | 			}
 54 | 
 55 | 
 56 | 
 57 | 			Program.XmlLog.WriteStartAttribute("map");
 58 | 
 59 | 			foreach (var position in this.PositionMappings) {
 60 | 				Program.XmlLog.WriteValue(position);
 61 | 				Program.XmlLog.WriteString("|");
 62 | 			}
 63 | 
 64 | 			Program.XmlLog.WriteEndAttribute();
 65 | 
 66 | 
 67 | 			//foreach (var item in this.il2js_2_ilMapping) {
 68 | 			//  Program.XmlLog.WriteStartElement("map");
 69 | 			//  Program.XmlLog.WriteAttributeString("il2js", item.Key.ToString());
 70 | 			//  Program.XmlLog.WriteAttributeString("il", item.Value.ToString());
 71 | 			//  Program.XmlLog.WriteEndElement();
 72 | 			//}
 73 | 
 74 | 			Program.XmlLog.WriteEndElement();
 75 | 		}
 76 | 	}
 77 | 
 78 | 
 79 | 	partial class AssemblyCompiler {
 80 | 
 81 | 		private void dumpLogs() {
 82 | 			if (!Settings.DebugCompilation) return;
 83 | 
 84 | 			if (this.staticFields.Count > 0) {
 85 | 				Program.XmlLog.WriteStartElement("statics");
 86 | 				foreach (var sf in this.staticFields.Values.OrderBy(sf => sf.Index)) {
 87 | 					Program.XmlLog.WriteStartElement("field");
 88 | 
 89 | 					Program.XmlLog.WriteAttributeString("name", sf.Field.DeclaringType.FullName + "." + sf.Field.Name);
 90 | 					Program.XmlLog.WriteAttributeString("metadataToken", "0x" + sf.Field.MetadataToken.ToString("X"));
 91 | 					Program.XmlLog.WriteAttributeString("index", sf.Index.ToString());
 92 | 					Program.XmlLog.WriteEndElement();//field
 93 | 				}
 94 | 				Program.XmlLog.WriteEndElement();//statics
 95 | 			}
 96 | 
 97 | 
 98 | 
 99 | 			//problem z meta
100 | 
101 | 			
102 | 			var types = from t in this.typeData.Values
103 | 									where !NativesManager.Instance.IsNative(t.Type)
104 | 									&& t.Type.IsClass
105 | 									orderby t.Index
106 | 									select t;
107 | 			if (types.Any()) {
108 | 
109 | 				Program.XmlLog.WriteStartElement("types");
110 | 
111 | 				foreach (var type in types) {
112 | 					TypeMeta meta;
113 | 
114 | 					if (TypeMeta.metas.TryGetValue(type.Type, out meta)) {
115 | 						if (meta.Fields.Count > 0) {
116 | 							Program.XmlLog.WriteStartElement("type");
117 | 							Program.XmlLog.WriteAttributeString("name", type.Type.FullName);
118 | 							Program.XmlLog.WriteAttributeString("metadataToken", "0x" + type.Type.MetadataToken.ToString("X"));
119 | 							foreach (var field in meta.Fields.Values) {
120 | 								Program.XmlLog.WriteStartElement("member");
121 | 								Program.XmlLog.WriteAttributeString("name", field.FieldInfo.Name);
122 | 								Program.XmlLog.WriteAttributeString("metadataToken", "0x" + field.FieldInfo.MetadataToken.ToString("X"));
123 | 								Program.XmlLog.WriteAttributeString("index", field.Token);
124 | 								Program.XmlLog.WriteEndElement();//element
125 | 							}
126 | 							Program.XmlLog.WriteEndElement();//type
127 | 						}
128 | 					}
129 | 				}
130 | 
131 | 				Program.XmlLog.WriteEndElement();//types
132 | 
133 | 			}
134 | 
135 | 		}
136 | 	}
137 | }


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/Attributes.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Compiler - JavaScript VM for .NET
 3 | Copyright (C) 2012 Michael Kolarz
 4 | 
 5 | This program is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU General Public License as published by
 7 | the Free Software Foundation, either version 3 of the License, or
 8 | (at your option) any later version.
 9 | 
10 | This program is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU General Public License for more details.
14 | 
15 | You should have received a copy of the GNU General Public License
16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Linq;
22 | using System.Text;
23 | using System.Reflection;
24 | using MK.JavaScript.Reflection;
25 | 
26 | namespace MK.JavaScript.Framework {
27 | 	//internal static class StringAttributeUtil {
28 | 	//  private static Dictionary<Type, string[]> _values = new Dictionary<Type, string[]>();
29 | 	//  private static string[] getValues(Type type) {
30 | 	//    string[] ret;
31 | 	//    if (!_values.TryGetValue(type, out ret)) {
32 | 	//      var fields=type.GetFields(BindingFlags.Static | BindingFlags.Public);
33 | 	//      ret = new string[fields.Length];
34 | 	//      _values[type] = ret;
35 | 	//      foreach (var fieldInfo in fields) {
36 | 	//        ret[(int)fieldInfo.GetValue(null)]=((ValueAttribute)fieldInfo.GetCustomAttributes(typeof(ValueAttribute), false)[0]).Value;
37 | 	//      }
38 | 	//    }
39 | 	//    return ret;
40 | 	//  }
41 | 	//  public static string GetValue(Type type, int value) {
42 | 	//    return getValues(type)[value];
43 | 	//  }
44 | 	//  public static string[] GetValues(Type type) {
45 | 	//    return getValues(type);
46 | 	//  }
47 | 	//}
48 | 
49 | 
50 | 	internal class FrameworkUtil {
51 | 
52 | 		public static ConstructorInfo _delegate_ = typeof(FrameworkUtil).GetConstructor(new[] { typeof(object), typeof(IntPtr) });
53 | 
54 | 		public FrameworkUtil(object o,IntPtr p) {	}
55 | 	}
56 | 
57 | }
58 | 


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/CssSupport.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | //#define FORMAT
 20 | using System;
 21 | using System.Collections.Generic;
 22 | using System.Linq;
 23 | using System.Text;
 24 | using MK.CodeDom.Compiler;
 25 | using System.IO;
 26 | using MK.JavaScript.Css;
 27 | using System.Reflection;
 28 | using MK.JavaScript.Css.Selectors;
 29 | using System.Text.RegularExpressions;
 30 | using System.Security.Permissions;
 31 | using System.Xml.Linq;
 32 | 
 33 | namespace MK.JavaScript.Compiler {
 34 | 
 35 | 	public static class CssSupport {
 36 | 
 37 | 		public class CssData {
 38 | 			public HashSet<PageFrameCompiler> Pages = new HashSet<PageFrameCompiler>();
 39 | 		}
 40 | 
 41 | 		private static Dictionary<Type, CssData> styles = new Dictionary<Type, CssData>();
 42 | 
 43 | 		public static CssData Resolve(Type cssType) { return styles[cssType]; }
 44 | 
 45 | 		static void Register(//PageFrameCompiler page, 
 46 | 			Type cssType) {
 47 | 			CssData data;
 48 | 			if (!styles.TryGetValue(cssType, out data)) {
 49 | 				data = new CssData();
 50 | 				styles[cssType] = data;
 51 | 			}
 52 | 		}
 53 | 
 54 | 		private static List<MethodBase> methods = new List<MethodBase>();
 55 | 
 56 | 		public static void Register(MethodBase methodBase, object[] attrs) {
 57 | 			methods.Add(methodBase);
 58 | 			foreach (ImportAttribute attr in attrs) {
 59 | 				foreach (var type in attr.CssTypes) {
 60 | 					Register(type);
 61 | 				}
 62 | 			}
 63 | 		}
 64 | 		public class CssFileData {
 65 | 			private string guid = Guid.NewGuid().ToString();
 66 | 			public readonly List<Type> StyleSheets = new List<Type>();
 67 | 			public readonly HashSet<PageFrameCompiler> Pages;
 68 | 			public CssFileData(HashSet<PageFrameCompiler> pages, Type cssType) {
 69 | 				this.Pages = pages;
 70 | 				this.AddStyleSheet(cssType);
 71 | 			}
 72 | 			public string CssFileName {
 73 | 				get {
 74 | 					return
 75 | #if !OBFUSCATE
 76 |  "Css=" + string.Join("_", this.StyleSheets.Select(ss => ss.GetType().Name).ToArray()) + "=" +
 77 | #endif
 78 |  this.guid;
 79 | 				}
 80 | 			}
 81 | 
 82 | 			public void AddStyleSheet(Type cssType) {
 83 | 				this.StyleSheets.Add(cssType);
 84 | 			}
 85 | 
 86 | 		}
 87 | 		private static List<CssFileData> cssFiles = new List<CssFileData>();
 88 | 		public static IEnumerable<CssFileData> CssFiles { get { return cssFiles; } }
 89 | 
 90 | 		public static IEnumerable<XElement> CreateConfigurationElements() {
 91 | 			
 92 | 			foreach (var cssFile in cssFiles) {
 93 | 				var css=new XElement("css",
 94 | 					new XAttribute("name",cssFile.CssFileName)
 95 | 				);
 96 | 				foreach (var type in cssFile.StyleSheets) {
 97 | 					css.Add(new XElement("type",
 98 | 						new XAttribute("name", type.FullName),
 99 | 						new XAttribute("assembly", type.Assembly.GetName().Name)
100 | 					));
101 | 				}
102 | 				yield return css;
103 | 			}
104 | 
105 | 		}
106 | 
107 | 		public static void Compute(PageFrameCompiler[] compilers) {
108 | 			foreach (var compiler in compilers) {
109 | 				foreach (var data in
110 | 									from method in methods
111 | 									where compiler.RuntimeFrameCompiler.Methods.ContainsKey(method)
112 | 										&& compiler.RuntimeFrameCompiler.Dependencies.IsPathFromTo(compiler.TypeData, compiler.RuntimeFrameCompiler.Methods[method])
113 | 									from MK.JavaScript.Css.ImportAttribute attr in method.GetCustomAttributes(typeof(MK.JavaScript.Css.ImportAttribute), false)
114 | 									from type in attr.CssTypes
115 | 									select CssSupport.Resolve(type)
116 | 				) {
117 | 					data.Pages.Add(compiler);
118 | 				}
119 | 			}
120 | 			foreach (var kv in styles) {
121 | 				foreach (var cssFile in cssFiles) {
122 | 					if (cssFile.Pages.SetEquals(kv.Value.Pages)) {
123 | 						cssFile.AddStyleSheet(kv.Key);
124 | 						goto end;
125 | 					}
126 | 				}
127 | 				cssFiles.Add(new CssFileData(kv.Value.Pages, kv.Key));
128 | 			end:
129 | 				;
130 | 			}
131 | 		}
132 | 	}
133 | }
134 | 


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/LabelsInliner.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | 
 24 | namespace MK.CodeDom.Compiler {
 25 | 	public class JumpData {
 26 | 		public readonly int WritePosition;
 27 | 		public readonly int BeginPosition;
 28 | 		public readonly int EndPosition;
 29 | 		public readonly int ToWriteOriginal;
 30 | 		public int ToWrite;
 31 | 		public int SizeOfLabel {
 32 | 			get {
 33 | 				if (ToWrite == 0) return 1;
 34 | 				if (ToWrite > 0) {
 35 | 					var tmp = ToWrite;
 36 | 					var value = 1;
 37 | 					while ((tmp >>= 4) != 0) ++value;
 38 | 					return value;
 39 | 				} else {
 40 | 					var tmp = -ToWrite;
 41 | 					var value = 2;//bo -
 42 | 					while ((tmp >>= 4) != 0) ++value;
 43 | 					return value;
 44 | 				}
 45 | 			}
 46 | 		}
 47 | 		public JumpData(int beginPosition, int endPosition, int writePosition) {
 48 | 			this.WritePosition = writePosition;
 49 | 			this.BeginPosition = beginPosition;
 50 | 			this.EndPosition = endPosition;
 51 | 			this.ToWrite = endPosition - beginPosition;
 52 | 			this.ToWriteOriginal = endPosition - beginPosition;
 53 | 		}
 54 | 	}
 55 | 	public class JumpsInliner {
 56 | 		//hm... dziwne ze wyszedl ten sam wzor na left i right...
 57 | 		//ale dziala ;) 
 58 | 		//to ze szuka sie left<=x<right to pewnie to powoduje ten sam wzor. i dobrze...
 59 | 
 60 | 		public static int Left(int[] ps, int p) {
 61 | 			int index = Array.BinarySearch(ps, p);
 62 | 			if (index >= 0) {
 63 | 				return index + 1;
 64 | 			} else {
 65 | 				return ~index;
 66 | 			}
 67 | 		}
 68 | 		public static int Right(int[] ps, int p) {
 69 | 			int index = Array.BinarySearch(ps, p);
 70 | 			if (index >= 0) {
 71 | 				return index + 1;
 72 | 			} else {
 73 | 				return ~index;
 74 | 			}
 75 | 		}
 76 | 		public static void Compute(JumpData[] jumps) {
 77 | 			var writePositions = jumps.Select(j => j.WritePosition).ToArray();
 78 | 			bool changed;
 79 | 			do {
 80 | 				changed = false;
 81 | 
 82 | 				foreach (var jump in jumps) {
 83 | 					int left, right, toWrite = jump.ToWriteOriginal;
 84 | 					if (toWrite >= 0) {
 85 | 						left = Left(writePositions, jump.BeginPosition);
 86 | 						right = Right(writePositions, jump.EndPosition);
 87 | 						for (int i = left; i < right; ++i) {
 88 | 							toWrite += jumps[i].SizeOfLabel;
 89 | 						}
 90 | 					} else {
 91 | 						left = Right(writePositions, jump.EndPosition);
 92 | 						right = Left(writePositions, jump.BeginPosition);
 93 | 						for (int i = left; i < right; ++i) {
 94 | 							toWrite -= jumps[i].SizeOfLabel;
 95 | 						}
 96 | 					}
 97 | 					if (jump.ToWrite != toWrite) {
 98 | 						jump.ToWrite = toWrite;
 99 | 						changed = true;
100 | 					}
101 | 				}
102 | 
103 | 			} while (changed);
104 | 		}
105 | 
106 | 	}
107 | }
108 | 


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/Resources.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using System.Reflection;
 24 | using MK.CodeDom.Compiler;
 25 | using System.CodeDom.Compiler;
 26 | using System.Resources;
 27 | using System.Globalization;
 28 | using System.Threading;
 29 | using MK.JavaScript.Ajax.Serialization;
 30 | using System.IO;
 31 | using MK.JavaScript.Reflection;
 32 | using System.Xml.Linq;
 33 | 
 34 | namespace MK.JavaScript.CodeDom.Compiler {
 35 | 	internal static class _Resources {
 36 | 		[JSFramework(Code = @"
 37 | function(a,b){
 38 | 	if(window.$resources$===undefined)
 39 | 		$resources$={};
 40 | 	if(!(a in $resources$))
 41 | 		$resources$[a]=eval(new Ajax.Request($path$+
 42 | //#if guid
 43 | 			$guid$+'.aspx?'
 44 | //#else
 45 | 			'$resourcesFileName$.aspx?'
 46 | //#endif
 47 | 			+a,{asynchronous:false}).transport.responseText);
 48 | 	return $resources$[a][b];
 49 | }
 50 | ")]
 51 | 		private static object _LoadResource(int resourcesIndex, int memberIndex) { throw new InvalidOperationException(); }
 52 | 		[JSFramework(Code = @"
 53 | function(a){
 54 | 	if(window.$resources$===undefined)
 55 | 		$resources$={};
 56 | 	eval(new Ajax.Request($path$+
 57 | //#if guid
 58 | 		$guid$+'.aspx?'
 59 | //#else
 60 | 		'$resourcesFileName$.aspx?'
 61 | //#endif
 62 | 		+(a=a.split(',').filter(function(b){return !(b in $resources$)})).join(','),{asynchronous:false}).transport.responseText).each(function(b,c){
 63 | 		$resources$[a[c]]=b;
 64 | 	});
 65 | }
 66 | ")]
 67 | 		private static void _LoadResources(string resources) { throw new InvalidOperationException(); }
 68 | 	}
 69 | 	public class Resources {
 70 | 
 71 | 		internal static MethodInfo LoadResource = typeof(_Resources).GetMethod("_LoadResource", BindingFlags.Static | BindingFlags.NonPublic);
 72 | 		internal static MethodInfo LoadResources = typeof(_Resources).GetMethod("_LoadResources", BindingFlags.Static | BindingFlags.NonPublic);
 73 | 
 74 | 		private class ResourcesManagerData {
 75 | 			public readonly int Index;
 76 | 			public ResourcesManagerData(int index) {
 77 | 				this.Index = index;
 78 | 			}
 79 | 			public Dictionary<MethodBase, int> Members = new Dictionary<MethodBase, int>();
 80 | 		}
 81 | 		private static readonly Dictionary<Type, ResourcesManagerData> resources = new Dictionary<Type, ResourcesManagerData>();
 82 | 
 83 | 		public static int Resolve(Type type) {
 84 | 			return GetTypeData(type).Index;
 85 | 		}
 86 | 		public static void Resolve(MethodBase method, out int resourcesIndex, out int memberIndex) {
 87 | 			ResourcesManagerData data = GetTypeData(method.DeclaringType);
 88 | 			resourcesIndex = data.Index;
 89 | 			if (!data.Members.TryGetValue(method, out memberIndex)) {
 90 | 				memberIndex = data.Members.Count;
 91 | 				data.Members[method] = data.Members.Count;
 92 | 			}
 93 | 		}
 94 | 
 95 | 		private static ResourcesManagerData GetTypeData(Type type) {
 96 | 			ResourcesManagerData data;
 97 | 			if (!resources.TryGetValue(type, out data)) {
 98 | 				data = new ResourcesManagerData(resources.Count);
 99 | 				resources[type] = data;
100 | 			}
101 | 			return data;
102 | 		}
103 | 
104 | 
105 | 		public static bool IsResourceClass(Type type) {
106 | 			var attribute = type.GetCustomAttribute<GeneratedCodeAttribute>();
107 | 			return attribute != null && attribute.Tool == "System.Resources.Tools.StronglyTypedResourceBuilder";
108 | 		}
109 | 
110 | 		public static XElement CreateConfigurationElement(string fileName, IEnumerable<CultureInfo> cultures) {
111 | 			if (resources.Count == 0) 
112 | 				return null;
113 | 
114 | 			var resourceElement = new XElement("resource",
115 | 				new XAttribute("name", fileName),
116 | 				new XAttribute("cultures", string.Join(",", cultures.Select(c => c.Name).ToArray()))
117 | 			);
118 | 			foreach (var kv in resources) {
119 | 				resourceElement.Add(new XElement("type",
120 | 					new XAttribute("name", kv.Key.FullName),
121 | 					new XAttribute("assembly", kv.Key.Assembly.GetName().Name),
122 | 					new XAttribute("members", string.Join(",", (from m in kv.Value.Members
123 | 																											orderby m.Value
124 | 																											select m.Key.Name.Substring(4)).ToArray()))
125 | 				));
126 | 			}
127 | 
128 | 			return resourceElement;
129 | 		}
130 | 	}
131 | }
132 | 


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/ServerManager.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using System.Reflection;
 24 | using System.Reflection.Emit;
 25 | using MK.CodeDom.Compiler;
 26 | using System.IO;
 27 | using MK.JavaScript.Ajax;
 28 | using System.Text.RegularExpressions;
 29 | 
 30 | namespace MK.JavaScript.CodeDom.Compiler {
 31 | 
 32 | 	static class CSharpType {
 33 | 
 34 | 		public static string CSharpName(string name, ref int pos) {
 35 | 			StringBuilder nameBuilder = new StringBuilder();
 36 | 			List<string> genericTypes = null;
 37 | 			do {
 38 | 				switch (name[pos]) {
 39 | 					case ',':
 40 | 					case ']':
 41 | 						int offset = 0;
 42 | 						return Regex.Replace(nameBuilder.ToString(), @"`([0-9]+)", m => {
 43 | 							int count = int.Parse(m.Groups[1].Value);
 44 | 							var sb = new StringBuilder();
 45 | 							sb.Append('<');
 46 | 							for (int i = 0; i < count; ++i) {
 47 | 								sb.Append(genericTypes[offset + i]).Append(',');
 48 | 							}
 49 | 							offset += count;
 50 | 							--sb.Length;
 51 | 							sb.Append('>');
 52 | 							return sb.ToString();
 53 | 						}, RegexOptions.Compiled);
 54 | 					case '[':
 55 | 						if (name[pos + 1] == ']') {
 56 | 							nameBuilder.Append("[]");
 57 | 							++pos;
 58 | 						} else {
 59 | 							genericTypes = new List<string>();
 60 | 							do {
 61 | 								++pos;
 62 | 								genericTypes.Add(CSharpName(name, ref pos));
 63 | 							} while (name[pos] != ']');
 64 | 						}
 65 | 						break;
 66 | 					case '+':
 67 | 						nameBuilder.Append('.');
 68 | 						break;
 69 | 					default:
 70 | 						nameBuilder.Append(name[pos]);
 71 | 						break;
 72 | 				}
 73 | 				++pos;
 74 | 			} while (true);
 75 | 		}
 76 | 		public static string GetCSharpName(this Type type) {
 77 | 			int pos = 0;
 78 | 			return CSharpType.CSharpName(type.ToString() + ",", ref pos);
 79 | 		}
 80 | 	}
 81 | 
 82 | 
 83 | 	class ServerManager {
 84 | 		private static Dictionary<MethodInfo, int> used = new Dictionary<MethodInfo, int>();
 85 | 		public static int Register(MethodInfo info, RunAtAttribute runAt) {
 86 | 			int index;
 87 | 			if (!used.TryGetValue(info, out index)) {
 88 | 				index = used.Count;
 89 | 				used[info] = index;
 90 | 				onRegistered(info, runAt, index);
 91 | 			}
 92 | 			return index;
 93 | 		}
 94 | 		public static int IndexOf(MethodInfo info) {
 95 | 			return used[info];
 96 | 		}
 97 | 		static string Name(Type type) {
 98 | 			return type.GetCSharpName();
 99 | 		}
100 | 
101 | 		private static void onRegistered(MethodInfo method, RunAtAttribute runAt, int index) {
102 | 			if (method.IsConstructor) ThrowHelper.Throw("{0} cannot be called @sever since it is constructor.", method.GetSignature());
103 | 			if (method.IsVirtual) ThrowHelper.Throw("{0} cannot be called @sever since it is virtual.", method.GetSignature());
104 | 			sb.Append("case ").Append(index).Append(":try{");
105 | 			if (!method.IsStatic || method.GetParameters().Length > 0) {
106 | 				sb.Append("args=Serializer.Deserialize(context");
107 | 				if (!method.IsStatic)
108 | 					sb.Append(",typeof(").Append(Name(method.DeclaringType)).Append(')');
109 | 				foreach (var param in method.GetParameters()) {
110 | 					sb.Append(",typeof(").Append(Name(param.ParameterType)).Append(')');
111 | 				}
112 | 				sb.Append(");");
113 | 			}
114 | 			if (method.ReturnParameter.ParameterType != typeof(void))
115 | 				sb.Append("context.Response.Write(\"(\"+Serializer.Serialize(");
116 | 			if (method.IsSpecialName) {
117 | 				if (method.Name.StartsWith("get_")) {
118 | 					appendThisOrType(method);
119 | 					sb.Append('.').Append(method.Name.Substring(4));
120 | 				} else if (method.Name.StartsWith("set_")) {
121 | 					appendThisOrType(method);
122 | 					sb.Append('.').Append(method.Name.Substring(4)).Append("=args[");
123 | 					sb.Append(method.IsStatic ? 0 : 1);
124 | 					sb.Append("]");
125 | 				} else {
126 | 					ThrowHelper.Throw("Special name method {0} cannot be called @server.", method.GetSignature());
127 | 				}
128 | 			} else {
129 | 				appendThisOrType(method);
130 | 				sb.Append('.').Append(method.Name).Append('(');
131 | 				var parameters = method.GetParameters();
132 | 				if (parameters.Length > 0) {
133 | 					for (int j = 0; j < parameters.Length; ++j) {
134 | 						sb.Append('(').Append(Name(parameters[j].ParameterType)).Append(")args[").Append(method.IsStatic ? j : (j + 1)).Append("],");
135 | 					}
136 | 					--sb.Length;
137 | 				}
138 | 				sb.Append(")");
139 | 			}
140 | 			if (method.ReturnParameter.ParameterType != typeof(void)) {
141 | 				sb.Append(")+\")\")");
142 | 			} else {
143 | 				sb.Append(";context.Response.Write(\"0\")");
144 | 			}
145 | 			sb.Append(";}catch(Exception e){context.Response.Write(");
146 | 
147 | 			if (runAt.HideExceptionMessage) {
148 | 				sb.Append("\"throw Error()\"");
149 | 			} else {
150 | 				sb.Append("\"throw Error(\"+Serializer.Serialize(e.Message)+\")\"");
151 | 			}
152 | 			sb.Append(");}break;");
153 | 		}
154 | 
155 | 		private static void appendThisOrType(MethodInfo method) {
156 | 			if (!method.IsStatic)
157 | 				sb.Append("((");
158 | 			sb.Append(Name(method.DeclaringType));
159 | 			if (!method.IsStatic)
160 | 				sb.Append(")args[0])");
161 | 		}
162 | 
163 | 		private const string header =
164 | @"<%@ WebHandler Language=""C#"" Class=""JavascriptHandler"" %>
165 | using System;
166 | using System.Web;
167 | using System.Linq;
168 | using System.Collections.Generic;
169 | using System.Text;
170 | using MK.JavaScript.Ajax.Serialization;
171 | 
172 | public class JavascriptHandler : IHttpHandler {
173 | 	public void ProcessRequest(HttpContext context) {
174 | 		context.Response.ContentType = ""text/plain"";
175 | 		List<object> args;
176 | 		switch(int.Parse(context.Request.QueryString[0])){
177 | ";
178 | 
179 | 		private static StringBuilder sb;
180 | 		static ServerManager() {
181 | 			sb = new StringBuilder();
182 | 			sb.Append(header);
183 | 		}
184 | 
185 | 		public static void Dump(string outputPath) {
186 | 			if (sb.Length == header.Length) return;
187 | 
188 | 			sb.Append(@"
189 | 		}
190 | 	}
191 | 	public bool IsReusable { get { return true; } }
192 | }
193 | ");
194 | 			File.WriteAllText(outputPath + Path.DirectorySeparatorChar + Settings.HandlerAshxFileName + ".ashx", sb.ToString());
195 | 		}
196 | 	}
197 | }
198 | 


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/Symbols.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using System.Reflection;
 24 | using System.Runtime.Serialization;
 25 | using MK.JavaScript.Framework;
 26 | 
 27 | namespace MK.CodeDom.Compiler {
 28 | 
 29 | 
 30 | 	public class FieldInfoMeta {
 31 | 		public readonly FieldInfo FieldInfo;
 32 | 		public readonly string Token;
 33 | 
 34 | 		public FieldInfoMeta(FieldInfo fieldInfo, string token) {
 35 | 			this.FieldInfo = fieldInfo;
 36 | 			this.Token = token;
 37 | 		}
 38 | 
 39 | 		#region static
 40 | 		public static FieldInfoMeta Get(FieldInfo info) { return TypeMeta.Get(info.DeclaringType).Fields[info]; }
 41 | 		#endregion
 42 | 	}
 43 | 	public class TypeMeta {
 44 | 		#region static
 45 | 		internal static Dictionary<Type, TypeMeta> metas = new Dictionary<Type, TypeMeta>();
 46 | 		public static TypeMeta Get(Type type) {
 47 | 			TypeMeta value;
 48 | 			if (!metas.TryGetValue(type, out value)) {
 49 | 				value = new TypeMeta(type);
 50 | 				metas[type] = value;
 51 | 			}
 52 | 			return value;
 53 | 		}
 54 | 		#endregion
 55 | 		public readonly Type Type;
 56 | 		private int tokenIndex;
 57 | 		public readonly Dictionary<FieldInfo, FieldInfoMeta> Fields;
 58 | 
 59 | 		private void assertTokens() {
 60 | 			if (this.Type.IsSubclassOf(typeof(MK.JavaScript.Window))) {
 61 | 				if (this.tokenIndex >= (Utils.Tokens.Length - 27)) {
 62 | 					ThrowHelper.Throw("Window class {0} togather with all classes it inherits contains more then {1} fields, which is not supported.", this.Type.GetSignature(), Utils.Tokens.Length - 27);
 63 | 				}
 64 | 			} else {
 65 | 				if (this.tokenIndex >= Utils.Tokens.Length) {
 66 | 					ThrowHelper.Throw("Class {0} togather with all classes it inherits contains more then {1} fields, which is not supported.", this.Type.GetSignature(), Utils.Tokens.Length);
 67 | 				}
 68 | 			}
 69 | 		}
 70 | 
 71 | 		private TypeMeta(Type type) {
 72 | 			this.Type = type;
 73 | 			this.tokenIndex = type.BaseType == typeof(object) ? 0 : Get(type.BaseType).tokenIndex;
 74 | 			//ten if jest rozdzielony z przyczyn czytelnosciowo-konwencyjnych.. tak naprawde tworza sie te same slowniki
 75 | 			//ale jesli jest datacontract to worningowane sa dodatkowe atrybuty datamember'a
 76 | 			if (this.Type.GetCustomAttribute<DataContractAttribute>() != null) {
 77 | 				this.Fields = new Dictionary<FieldInfo, FieldInfoMeta>();
 78 | #warning kombinowane bo problem: fieldy generic'a nei sa declaratedonly
 79 | 				//poniewaz field.DeclaringType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly) dla field.DeclaringType.IsGenericType && !field.DeclaringType.IsGenericTypeDefinition
 80 | 				//to tez powoduje ze nie mozna wziasc losowej kolejnosci!
 81 | 				foreach (var field in from f in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
 82 | 															where f.DeclaringType == type
 83 | 															orderby f.Name
 84 | 															select f
 85 | 																) {
 86 | 					var dataMember = field.GetCustomAttribute<DataMemberAttribute>();
 87 | 					if (dataMember != null) {
 88 | 						if (dataMember.Name != null) Program.XmlLog.WriteElementString("warning",
 89 | 							string.Format("[DataMember(Name=\"{0}\")] {1}; Name is ignored.", dataMember.Name, field.GetSignature()));
 90 | 						if (dataMember.Order != -1) Program.XmlLog.WriteElementString("warning",
 91 | 							string.Format("[DataMember(Order={0})] {1}; Order is ignored.", dataMember.Order, field.GetSignature()));
 92 | 					}
 93 | 					this.assertTokens();
 94 | 					this.Fields[field] = new FieldInfoMeta(field, Utils.Tokens[this.tokenIndex++].ToString());
 95 | 				}
 96 | 
 97 | 			} else {
 98 | 				this.Fields = (
 99 | 					from f in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
100 | 					where f.DeclaringType == type
101 | 					orderby f.Name
102 | 					select f
103 | 				).ToDictionary(
104 | 					field => field,
105 | 					field => {
106 | 						this.assertTokens();
107 | 						return new FieldInfoMeta(field, Utils.Tokens[this.tokenIndex++].ToString());
108 | 					}
109 | 				);
110 | 			}
111 | 
112 | 		}
113 | 	}
114 | }
115 | 


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/defs.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using System.Reflection.Emit;
 24 | 
 25 | namespace MK.CodeDom.Compiler {
 26 | 	public enum OpCodeValue : short {
 27 | 		#region
 28 | 		Nop = 0, Break = 1, Ldarg_0 = 2, Ldarg_1 = 3, Ldarg_2 = 4, Ldarg_3 = 5, Ldloc_0 = 6, Ldloc_1 = 7, Ldloc_2 = 8, Ldloc_3 = 9, Stloc_0 = 10, Stloc_1 = 11, Stloc_2 = 12, Stloc_3 = 13, Ldarg_S = 14, Ldarga_S = 15, Starg_S = 16, Ldloc_S = 17, Ldloca_S = 18, Stloc_S = 19, Ldnull = 20, Ldc_I4_M1 = 21, Ldc_I4_0 = 22, Ldc_I4_1 = 23, Ldc_I4_2 = 24, Ldc_I4_3 = 25, Ldc_I4_4 = 26, Ldc_I4_5 = 27, Ldc_I4_6 = 28, Ldc_I4_7 = 29, Ldc_I4_8 = 30, Ldc_I4_S = 31, Ldc_I4 = 32, Ldc_I8 = 33, Ldc_R4 = 34, Ldc_R8 = 35, Dup = 37, Pop = 38, Jmp = 39, Call = 40, Calli = 41, Ret = 42, Br_S = 43, Brfalse_S = 44, Brtrue_S = 45, Beq_S = 46, Bge_S = 47, Bgt_S = 48, Ble_S = 49, Blt_S = 50, Bne_Un_S = 51, Bge_Un_S = 52, Bgt_Un_S = 53, Ble_Un_S = 54, Blt_Un_S = 55, Br = 56, Brfalse = 57, Brtrue = 58, Beq = 59, Bge = 60, Bgt = 61, Ble = 62, Blt = 63, Bne_Un = 64, Bge_Un = 65, Bgt_Un = 66, Ble_Un = 67, Blt_Un = 68, Switch = 69, Ldind_I1 = 70, Ldind_U1 = 71, Ldind_I2 = 72, Ldind_U2 = 73, Ldind_I4 = 74, Ldind_U4 = 75, Ldind_I8 = 76, Ldind_I = 77, Ldind_R4 = 78, Ldind_R8 = 79, Ldind_Ref = 80, Stind_Ref = 81, Stind_I1 = 82, Stind_I2 = 83, Stind_I4 = 84, Stind_I8 = 85, Stind_R4 = 86, Stind_R8 = 87, Add = 88, Sub = 89, Mul = 90, Div = 91, Div_Un = 92, Rem = 93, Rem_Un = 94, And = 95, Or = 96, Xor = 97, Shl = 98, Shr = 99, Shr_Un = 100, Neg = 101, Not = 102, Conv_I1 = 103, Conv_I2 = 104, Conv_I4 = 105, Conv_I8 = 106, Conv_R4 = 107, Conv_R8 = 108, Conv_U4 = 109, Conv_U8 = 110, Callvirt = 111, Cpobj = 112, Ldobj = 113, Ldstr = 114, Newobj = 115, Castclass = 116, Isinst = 117, Conv_R_Un = 118, Unbox = 121, Throw = 122, Ldfld = 123, Ldflda = 124, Stfld = 125, Ldsfld = 126, Ldsflda = 127, Stsfld = 128, Stobj = 129, Conv_Ovf_I1_Un = 130, Conv_Ovf_I2_Un = 131, Conv_Ovf_I4_Un = 132, Conv_Ovf_I8_Un = 133, Conv_Ovf_U1_Un = 134, Conv_Ovf_U2_Un = 135, Conv_Ovf_U4_Un = 136, Conv_Ovf_U8_Un = 137, Conv_Ovf_I_Un = 138, Conv_Ovf_U_Un = 139, Box = 140, Newarr = 141, Ldlen = 142, Ldelema = 143, Ldelem_I1 = 144, Ldelem_U1 = 145, Ldelem_I2 = 146, Ldelem_U2 = 147, Ldelem_I4 = 148, Ldelem_U4 = 149, Ldelem_I8 = 150, Ldelem_I = 151, Ldelem_R4 = 152, Ldelem_R8 = 153, Ldelem_Ref = 154, Stelem_I = 155, Stelem_I1 = 156, Stelem_I2 = 157, Stelem_I4 = 158, Stelem_I8 = 159, Stelem_R4 = 160, Stelem_R8 = 161, Stelem_Ref = 162, Ldelem = 163, Stelem = 164, Unbox_Any = 165, Conv_Ovf_I1 = 179, Conv_Ovf_U1 = 180, Conv_Ovf_I2 = 181, Conv_Ovf_U2 = 182, Conv_Ovf_I4 = 183, Conv_Ovf_U4 = 184, Conv_Ovf_I8 = 185, Conv_Ovf_U8 = 186, Refanyval = 194, Ckfinite = 195, Mkrefany = 198, Ldtoken = 208, Conv_U2 = 209, Conv_U1 = 210, Conv_I = 211, Conv_Ovf_I = 212, Conv_Ovf_U = 213, Add_Ovf = 214, Add_Ovf_Un = 215, Mul_Ovf = 216, Mul_Ovf_Un = 217, Sub_Ovf = 218, Sub_Ovf_Un = 219, Endfinally = 220, Leave = 221, Leave_S = 222, Stind_I = 223, Conv_U = 224, Prefix7 = 248, Prefix6 = 249, Prefix5 = 250, Prefix4 = 251, Prefix3 = 252, Prefix2 = 253, Prefix1 = 254, Prefixref = 255, Arglist = -512, Ceq = -511, Cgt = -510, Cgt_Un = -509, Clt = -508, Clt_Un = -507, Ldftn = -506, Ldvirtftn = -505, Ldarg = -503, Ldarga = -502, Starg = -501, Ldloc = -500, Ldloca = -499, Stloc = -498, Localloc = -497, Endfilter = -495, Unaligned = -494, Volatile = -493, Tailcall = -492, Initobj = -491, Constrained = -490, Cpblk = -489, Initblk = -488, Rethrow = -486, Sizeof = -484, Refanytype = -483, Readonly = -482,
 29 | 		#endregion
 30 | 	}
 31 | 	public partial class ILParser {
 32 | 		private static OpCode[] byteCodes = new OpCode[] {
 33 | #region
 34 | //0
 35 | OpCodes.Nop,
 36 | //1
 37 | OpCodes.Break,
 38 | //2
 39 | OpCodes.Ldarg_0,
 40 | //3
 41 | OpCodes.Ldarg_1,
 42 | //4
 43 | OpCodes.Ldarg_2,
 44 | //5
 45 | OpCodes.Ldarg_3,
 46 | //6
 47 | OpCodes.Ldloc_0,
 48 | //7
 49 | OpCodes.Ldloc_1,
 50 | //8
 51 | OpCodes.Ldloc_2,
 52 | //9
 53 | OpCodes.Ldloc_3,
 54 | //10
 55 | OpCodes.Stloc_0,
 56 | //11
 57 | OpCodes.Stloc_1,
 58 | //12
 59 | OpCodes.Stloc_2,
 60 | //13
 61 | OpCodes.Stloc_3,
 62 | //14
 63 | OpCodes.Ldarg_S,
 64 | //15
 65 | OpCodes.Ldarga_S,
 66 | //16
 67 | OpCodes.Starg_S,
 68 | //17
 69 | OpCodes.Ldloc_S,
 70 | //18
 71 | OpCodes.Ldloca_S,
 72 | //19
 73 | OpCodes.Stloc_S,
 74 | //20
 75 | OpCodes.Ldnull,
 76 | //21
 77 | OpCodes.Ldc_I4_M1,
 78 | //22
 79 | OpCodes.Ldc_I4_0,
 80 | //23
 81 | OpCodes.Ldc_I4_1,
 82 | //24
 83 | OpCodes.Ldc_I4_2,
 84 | //25
 85 | OpCodes.Ldc_I4_3,
 86 | //26
 87 | OpCodes.Ldc_I4_4,
 88 | //27
 89 | OpCodes.Ldc_I4_5,
 90 | //28
 91 | OpCodes.Ldc_I4_6,
 92 | //29
 93 | OpCodes.Ldc_I4_7,
 94 | //30
 95 | OpCodes.Ldc_I4_8,
 96 | //31
 97 | OpCodes.Ldc_I4_S,
 98 | //32
 99 | OpCodes.Ldc_I4,
100 | //33
101 | OpCodes.Ldc_I8,
102 | //34
103 | OpCodes.Ldc_R4,
104 | //35
105 | OpCodes.Ldc_R8,
106 | OpCodes.Nop,
107 | //37
108 | OpCodes.Dup,
109 | //38
110 | OpCodes.Pop,
111 | //39
112 | OpCodes.Jmp,
113 | //40
114 | OpCodes.Call,
115 | //41
116 | OpCodes.Calli,
117 | //42
118 | OpCodes.Ret,
119 | //43
120 | OpCodes.Br_S,
121 | //44
122 | OpCodes.Brfalse_S,
123 | //45
124 | OpCodes.Brtrue_S,
125 | //46
126 | OpCodes.Beq_S,
127 | //47
128 | OpCodes.Bge_S,
129 | //48
130 | OpCodes.Bgt_S,
131 | //49
132 | OpCodes.Ble_S,
133 | //50
134 | OpCodes.Blt_S,
135 | //51
136 | OpCodes.Bne_Un_S,
137 | //52
138 | OpCodes.Bge_Un_S,
139 | //53
140 | OpCodes.Bgt_Un_S,
141 | //54
142 | OpCodes.Ble_Un_S,
143 | //55
144 | OpCodes.Blt_Un_S,
145 | //56
146 | OpCodes.Br,
147 | //57
148 | OpCodes.Brfalse,
149 | //58
150 | OpCodes.Brtrue,
151 | //59
152 | OpCodes.Beq,
153 | //60
154 | OpCodes.Bge,
155 | //61
156 | OpCodes.Bgt,
157 | //62
158 | OpCodes.Ble,
159 | //63
160 | OpCodes.Blt,
161 | //64
162 | OpCodes.Bne_Un,
163 | //65
164 | OpCodes.Bge_Un,
165 | //66
166 | OpCodes.Bgt_Un,
167 | //67
168 | OpCodes.Ble_Un,
169 | //68
170 | OpCodes.Blt_Un,
171 | //69
172 | OpCodes.Switch,
173 | //70
174 | OpCodes.Ldind_I1,
175 | //71
176 | OpCodes.Ldind_U1,
177 | //72
178 | OpCodes.Ldind_I2,
179 | //73
180 | OpCodes.Ldind_U2,
181 | //74
182 | OpCodes.Ldind_I4,
183 | //75
184 | OpCodes.Ldind_U4,
185 | //76
186 | OpCodes.Ldind_I8,
187 | //77
188 | OpCodes.Ldind_I,
189 | //78
190 | OpCodes.Ldind_R4,
191 | //79
192 | OpCodes.Ldind_R8,
193 | //80
194 | OpCodes.Ldind_Ref,
195 | //81
196 | OpCodes.Stind_Ref,
197 | //82
198 | OpCodes.Stind_I1,
199 | //83
200 | OpCodes.Stind_I2,
201 | //84
202 | OpCodes.Stind_I4,
203 | //85
204 | OpCodes.Stind_I8,
205 | //86
206 | OpCodes.Stind_R4,
207 | //87
208 | OpCodes.Stind_R8,
209 | //88
210 | OpCodes.Add,
211 | //89
212 | OpCodes.Sub,
213 | //90
214 | OpCodes.Mul,
215 | //91
216 | OpCodes.Div,
217 | //92
218 | OpCodes.Div_Un,
219 | //93
220 | OpCodes.Rem,
221 | //94
222 | OpCodes.Rem_Un,
223 | //95
224 | OpCodes.And,
225 | //96
226 | OpCodes.Or,
227 | //97
228 | OpCodes.Xor,
229 | //98
230 | OpCodes.Shl,
231 | //99
232 | OpCodes.Shr,
233 | //100
234 | OpCodes.Shr_Un,
235 | //101
236 | OpCodes.Neg,
237 | //102
238 | OpCodes.Not,
239 | //103
240 | OpCodes.Conv_I1,
241 | //104
242 | OpCodes.Conv_I2,
243 | //105
244 | OpCodes.Conv_I4,
245 | //106
246 | OpCodes.Conv_I8,
247 | //107
248 | OpCodes.Conv_R4,
249 | //108
250 | OpCodes.Conv_R8,
251 | //109
252 | OpCodes.Conv_U4,
253 | //110
254 | OpCodes.Conv_U8,
255 | //111
256 | OpCodes.Callvirt,
257 | //112
258 | OpCodes.Cpobj,
259 | //113
260 | OpCodes.Ldobj,
261 | //114
262 | OpCodes.Ldstr,
263 | //115
264 | OpCodes.Newobj,
265 | //116
266 | OpCodes.Castclass,
267 | //117
268 | OpCodes.Isinst,
269 | //118
270 | OpCodes.Conv_R_Un,
271 | OpCodes.Nop,
272 | OpCodes.Nop,
273 | //121
274 | OpCodes.Unbox,
275 | //122
276 | OpCodes.Throw,
277 | //123
278 | OpCodes.Ldfld,
279 | //124
280 | OpCodes.Ldflda,
281 | //125
282 | OpCodes.Stfld,
283 | //126
284 | OpCodes.Ldsfld,
285 | //127
286 | OpCodes.Ldsflda,
287 | //128
288 | OpCodes.Stsfld,
289 | //129
290 | OpCodes.Stobj,
291 | //130
292 | OpCodes.Conv_Ovf_I1_Un,
293 | //131
294 | OpCodes.Conv_Ovf_I2_Un,
295 | //132
296 | OpCodes.Conv_Ovf_I4_Un,
297 | //133
298 | OpCodes.Conv_Ovf_I8_Un,
299 | //134
300 | OpCodes.Conv_Ovf_U1_Un,
301 | //135
302 | OpCodes.Conv_Ovf_U2_Un,
303 | //136
304 | OpCodes.Conv_Ovf_U4_Un,
305 | //137
306 | OpCodes.Conv_Ovf_U8_Un,
307 | //138
308 | OpCodes.Conv_Ovf_I_Un,
309 | //139
310 | OpCodes.Conv_Ovf_U_Un,
311 | //140
312 | OpCodes.Box,
313 | //141
314 | OpCodes.Newarr,
315 | //142
316 | OpCodes.Ldlen,
317 | //143
318 | OpCodes.Ldelema,
319 | //144
320 | OpCodes.Ldelem_I1,
321 | //145
322 | OpCodes.Ldelem_U1,
323 | //146
324 | OpCodes.Ldelem_I2,
325 | //147
326 | OpCodes.Ldelem_U2,
327 | //148
328 | OpCodes.Ldelem_I4,
329 | //149
330 | OpCodes.Ldelem_U4,
331 | //150
332 | OpCodes.Ldelem_I8,
333 | //151
334 | OpCodes.Ldelem_I,
335 | //152
336 | OpCodes.Ldelem_R4,
337 | //153
338 | OpCodes.Ldelem_R8,
339 | //154
340 | OpCodes.Ldelem_Ref,
341 | //155
342 | OpCodes.Stelem_I,
343 | //156
344 | OpCodes.Stelem_I1,
345 | //157
346 | OpCodes.Stelem_I2,
347 | //158
348 | OpCodes.Stelem_I4,
349 | //159
350 | OpCodes.Stelem_I8,
351 | //160
352 | OpCodes.Stelem_R4,
353 | //161
354 | OpCodes.Stelem_R8,
355 | //162
356 | OpCodes.Stelem_Ref,
357 | //163
358 | OpCodes.Ldelem,
359 | //164
360 | OpCodes.Stelem,
361 | //165
362 | OpCodes.Unbox_Any,
363 | OpCodes.Nop,
364 | OpCodes.Nop,
365 | OpCodes.Nop,
366 | OpCodes.Nop,
367 | OpCodes.Nop,
368 | OpCodes.Nop,
369 | OpCodes.Nop,
370 | OpCodes.Nop,
371 | OpCodes.Nop,
372 | OpCodes.Nop,
373 | OpCodes.Nop,
374 | OpCodes.Nop,
375 | OpCodes.Nop,
376 | //179
377 | OpCodes.Conv_Ovf_I1,
378 | //180
379 | OpCodes.Conv_Ovf_U1,
380 | //181
381 | OpCodes.Conv_Ovf_I2,
382 | //182
383 | OpCodes.Conv_Ovf_U2,
384 | //183
385 | OpCodes.Conv_Ovf_I4,
386 | //184
387 | OpCodes.Conv_Ovf_U4,
388 | //185
389 | OpCodes.Conv_Ovf_I8,
390 | //186
391 | OpCodes.Conv_Ovf_U8,
392 | OpCodes.Nop,
393 | OpCodes.Nop,
394 | OpCodes.Nop,
395 | OpCodes.Nop,
396 | OpCodes.Nop,
397 | OpCodes.Nop,
398 | OpCodes.Nop,
399 | //194
400 | OpCodes.Refanyval,
401 | //195
402 | OpCodes.Ckfinite,
403 | OpCodes.Nop,
404 | OpCodes.Nop,
405 | //198
406 | OpCodes.Mkrefany,
407 | OpCodes.Nop,
408 | OpCodes.Nop,
409 | OpCodes.Nop,
410 | OpCodes.Nop,
411 | OpCodes.Nop,
412 | OpCodes.Nop,
413 | OpCodes.Nop,
414 | OpCodes.Nop,
415 | OpCodes.Nop,
416 | //208
417 | OpCodes.Ldtoken,
418 | //209
419 | OpCodes.Conv_U2,
420 | //210
421 | OpCodes.Conv_U1,
422 | //211
423 | OpCodes.Conv_I,
424 | //212
425 | OpCodes.Conv_Ovf_I,
426 | //213
427 | OpCodes.Conv_Ovf_U,
428 | //214
429 | OpCodes.Add_Ovf,
430 | //215
431 | OpCodes.Add_Ovf_Un,
432 | //216
433 | OpCodes.Mul_Ovf,
434 | //217
435 | OpCodes.Mul_Ovf_Un,
436 | //218
437 | OpCodes.Sub_Ovf,
438 | //219
439 | OpCodes.Sub_Ovf_Un,
440 | //220
441 | OpCodes.Endfinally,
442 | //221
443 | OpCodes.Leave,
444 | //222
445 | OpCodes.Leave_S,
446 | //223
447 | OpCodes.Stind_I,
448 | //224
449 | OpCodes.Conv_U,
450 | OpCodes.Nop,
451 | OpCodes.Nop,
452 | OpCodes.Nop,
453 | OpCodes.Nop,
454 | OpCodes.Nop,
455 | OpCodes.Nop,
456 | OpCodes.Nop,
457 | OpCodes.Nop,
458 | OpCodes.Nop,
459 | OpCodes.Nop,
460 | OpCodes.Nop,
461 | OpCodes.Nop,
462 | OpCodes.Nop,
463 | OpCodes.Nop,
464 | OpCodes.Nop,
465 | OpCodes.Nop,
466 | OpCodes.Nop,
467 | OpCodes.Nop,
468 | OpCodes.Nop,
469 | OpCodes.Nop,
470 | OpCodes.Nop,
471 | OpCodes.Nop,
472 | OpCodes.Nop,
473 | //248
474 | OpCodes.Prefix7,
475 | //249
476 | OpCodes.Prefix6,
477 | //250
478 | OpCodes.Prefix5,
479 | //251
480 | OpCodes.Prefix4,
481 | //252
482 | OpCodes.Prefix3,
483 | //253
484 | OpCodes.Prefix2,
485 | //254
486 | OpCodes.Prefix1,
487 | //255
488 | OpCodes.Prefixref, 
489 | #endregion
490 | 		};
491 | 		//index=512+code
492 | 		private static OpCode[] shortCodes = new OpCode[]{
493 | #region
494 | 			//-512
495 | OpCodes.Arglist,
496 | //-511
497 | OpCodes.Ceq,
498 | //-510
499 | OpCodes.Cgt,
500 | //-509
501 | OpCodes.Cgt_Un,
502 | //-508
503 | OpCodes.Clt,
504 | //-507
505 | OpCodes.Clt_Un,
506 | //-506
507 | OpCodes.Ldftn,
508 | //-505
509 | OpCodes.Ldvirtftn,
510 | OpCodes.Nop,
511 | //-503
512 | OpCodes.Ldarg,
513 | //-502
514 | OpCodes.Ldarga,
515 | //-501
516 | OpCodes.Starg,
517 | //-500
518 | OpCodes.Ldloc,
519 | //-499
520 | OpCodes.Ldloca,
521 | //-498
522 | OpCodes.Stloc,
523 | //-497
524 | OpCodes.Localloc,
525 | OpCodes.Nop,
526 | //-495
527 | OpCodes.Endfilter,
528 | //-494
529 | OpCodes.Unaligned,
530 | //-493
531 | OpCodes.Volatile,
532 | //-492
533 | OpCodes.Tailcall,
534 | //-491
535 | OpCodes.Initobj,
536 | //-490
537 | OpCodes.Constrained,
538 | //-489
539 | OpCodes.Cpblk,
540 | //-488
541 | OpCodes.Initblk,
542 | OpCodes.Nop,
543 | //-486
544 | OpCodes.Rethrow,
545 | OpCodes.Nop,
546 | //-484
547 | OpCodes.Sizeof,
548 | //-483
549 | OpCodes.Refanytype,
550 | //-482
551 | OpCodes.Readonly,
552 |  
553 | #endregion
554 | 		};
555 | 	}
556 | }
557 | 


--------------------------------------------------------------------------------
/Compiler/MK.CodeDom.Compiler/il's.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | #define DEGEN
 20 | using System;
 21 | using System.Collections.Generic;
 22 | using System.Linq;
 23 | using System.Text;
 24 | using System.Reflection;
 25 | using System.Reflection.Emit;
 26 | 
 27 | namespace MK.CodeDom.Compiler {
 28 | 
 29 | 	public static class MemberInfoExtensions {
 30 | 		public static MemberInfo GenericDefinitionOf(MemberInfo info) {
 31 | 			return info.DeclaringType.GetGenericTypeDefinition().GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static).Single(
 32 | 				i => i.MetadataToken == info.MetadataToken
 33 | 			);
 34 | 		}
 35 | 
 36 | 
 37 | 		public static MethodBase GetGenericIfNecessary(this MethodBase self) {
 38 | 			if (self.DeclaringType.IsGenericType) {
 39 | 				return (MethodBase)GenericDefinitionOf(self);
 40 | 			} else {
 41 | 				return self;
 42 | 			}
 43 | 		}
 44 | 	}
 45 | 
 46 | 	public class ILToken {
 47 | 		public bool IsEaten = false;
 48 | 		public int Position;
 49 | 		public int Size;
 50 | 		public object Value;
 51 | 		public ILToken(int position, int size, object value) {
 52 | 			this.Position = position;
 53 | 			this.Size = size;
 54 | 			this.Value = value;
 55 | 		}
 56 | 		public override string ToString() {
 57 | 			var sb = new StringBuilder().Append('[').Append(this.Position.ToString().PadLeft(3)).Append('+').Append(this.Size).Append("] ");
 58 | 			if (this.Value is MemberInfo) {
 59 | 				var member = (MemberInfo)this.Value;
 60 | 				if (member.DeclaringType != null)
 61 | 					sb.Append(member.DeclaringType.Name).Append("::");
 62 | 				sb.Append(member.Name).Append(' ');
 63 | 				var f = member as FieldInfo;
 64 | 				if (f != null) {
 65 | 					if (f.IsStatic) sb.Append(".static ");
 66 | 					sb.Append(": ").Append(f.FieldType.Name);
 67 | 				}
 68 | 				var m = member as MethodBase;
 69 | 				if (m != null) {
 70 | 					var mi = m as MethodInfo;
 71 | 					if (m.IsStatic) sb.Append(".static ");
 72 | 					foreach (var p in m.GetParameters()) {
 73 | 						sb.Append(p.ParameterType).Append(" ");
 74 | 					}
 75 | 					if (mi != null) sb.Append(": ").Append(mi.ReturnType.Name);
 76 | 				}
 77 | 			} else {
 78 | 				sb.Append(this.Value.GetType().Name + ": " + this.Value.ToString()).ToString();
 79 | 			}
 80 | 			return sb.ToString();
 81 | 		}
 82 | 	}
 83 | 	public partial class ILParser {
 84 | 		private int EatInt32() {
 85 | 			var value = BitConverter.ToInt32(il, position);
 86 | 			position += 4;
 87 | 			return value;
 88 | 		}
 89 | 		private uint EatUInt32() {
 90 | 			var value = BitConverter.ToUInt32(il, position);
 91 | 			position += 4;
 92 | 			return value;
 93 | 		}
 94 | 		private float EatFloat32() {
 95 | 			var value = BitConverter.ToSingle(il, position);
 96 | 			position += 4;
 97 | 			return value;
 98 | 		}
 99 | 		private double EatFloat64() {
100 | 			var value = BitConverter.ToDouble(il, position);
101 | 			position += 8;
102 | 			return value;
103 | 		}
104 | 		private Module Module;
105 | 
106 | 
107 | 		private FieldInfo parseInlineField() {
108 | 			var ret = Module.ResolveField(EatInt32(),
109 | 					this.method.DeclaringType.IsGenericType ? this.method.DeclaringType.GetGenericArguments() : null,
110 | 					this.method.IsGenericMethod ? this.method.GetGenericArguments() : null);
111 | #if DEGEN
112 | 			if (ret.DeclaringType.IsGenericType) {
113 | 				ret = (FieldInfo)MemberInfoExtensions.GenericDefinitionOf(ret);
114 | 			}
115 | #endif
116 | 			return ret;
117 | 		}
118 | 		private MethodBase parseInlineMethod() {
119 | 			var ret = Module.ResolveMethod(EatInt32(),
120 | 				this.method.DeclaringType.IsGenericType ? this.method.DeclaringType.GetGenericArguments() : null,
121 | 				this.method.IsGenericMethod ? this.method.GetGenericArguments() : null);
122 | #if DEGEN
123 | 			if (ret.DeclaringType.IsGenericType) {
124 | 				ret = (MethodBase)MemberInfoExtensions.GenericDefinitionOf(ret);
125 | 			}
126 | #endif
127 | 			return ret;
128 | 		}
129 | 		private Type parseInlineType() {
130 | 			var ret = Module.ResolveType(EatInt32(),
131 | 				this.method.DeclaringType.IsGenericType ? this.method.DeclaringType.GetGenericArguments() : null,
132 | 				this.method.IsGenericMethod ? this.method.GetGenericArguments() : null);
133 | #if DEGEN
134 | 			if (ret.IsGenericType) {
135 | 				ret = ret.GetGenericTypeDefinition();
136 | 			}
137 | #endif
138 | 			return ret;
139 | 		}
140 | 		private string parseInlineString() { return Module.ResolveString(EatInt32()); }
141 | #warning ??
142 | 		private FieldInfo parseInlineTok() { return Module.ResolveField(EatInt32()); }
143 | 
144 | 		private int position;
145 | 		private byte[] il;
146 | 		MethodBase method;
147 | 		public ILToken[] GetTokens(MethodBase method) {
148 | 			this.method = method;
149 | 			il = method.GetMethodBody().GetILAsByteArray();
150 | 			ILToken[] ret = new ILToken[il.Length];
151 | 			position = 0;
152 | 			this.Module = method.Module;
153 | 			while (position < il.Length) {
154 | 				var opCode = byteCodes[il[position]];
155 | 				var p = this.position;
156 | 				if (opCode == OpCodes.Prefix1) {
157 | 					opCode = shortCodes[512 + (short)((il[position] << 8) + il[position + 1])];
158 | 					++position;
159 | 				}
160 | 				ret[p] = new ILToken(position, opCode.Size, opCode);
161 | 				++this.position;
162 | 				p = this.position;
163 | 				if ((OpCodeValue)opCode.Value == OpCodeValue.Switch) {
164 | 					var count = this.EatUInt32();
165 | 					ret[p] = new ILToken(p, 4, count);
166 | 					for (int i = 0; i < count; ++i) {
167 | 						p = this.position;
168 | 						ret[p] = new ILToken(p, 4, this.EatInt32());
169 | 					}
170 | 				} else
171 | 					switch (opCode.OperandType) {
172 | 						case OperandType.InlineBrTarget: ret[p] = new ILToken(p, 4, this.EatInt32()); break;
173 | 						case OperandType.InlineField: ret[p] = new ILToken(p, 4, parseInlineField()); break;
174 | 						case OperandType.InlineI: ret[p] = new ILToken(p, 4, this.EatInt32()); break;
175 | 						//case OperandType.InlineI8:
176 | 						//  break;
177 | 						case OperandType.InlineMethod: ret[p] = new ILToken(p, 4, parseInlineMethod()); break;
178 | 						case OperandType.InlineNone: break;
179 | 						//case OperandType.InlinePhi:
180 | 						//  break;
181 | 						case OperandType.InlineR: ret[p] = new ILToken(p, 8, this.EatFloat64()); break;
182 | 						//case OperandType.InlineSig:
183 | 						//  break;
184 | 						case OperandType.InlineString: ret[p] = new ILToken(p, 4, parseInlineString()); break;
185 | 						//case OperandType.InlineTok: ret[p] = new ILToken(p, 4, parseInlineTok()); break;
186 | 						case OperandType.InlineType: ret[p] = new ILToken(p, 4, parseInlineType()); break;
187 | 						//case OperandType.InlineVar: 
188 | 						case OperandType.ShortInlineBrTarget: ret[p] = new ILToken(p, 1, (sbyte)this.il[this.position++]); break;
189 | 
190 | 						case OperandType.ShortInlineI: ret[p] = new ILToken(p, 1, (sbyte)this.il[this.position++]); break;
191 | 						case OperandType.ShortInlineR: ret[p] = new ILToken(p, 4, this.EatFloat32()); break;
192 | 						case OperandType.ShortInlineVar: ret[p] = new ILToken(p, 1, this.il[this.position++]); break;
193 | 						case OperandType.InlineSwitch: ret[p] = new ILToken(p, 4, this.EatInt32()); break;
194 | 						default:
195 | 							ThrowHelper.Method.Throw(this.method, this.position, "Not supported OperandType.{0}.", opCode.OperandType.ToString());
196 | 							break;
197 | 					}
198 | 			}
199 | 			return ret;
200 | 		}
201 | 	}
202 | 	public enum ILInstructionType : byte {
203 | 
204 | 		_Store = 128,
205 | 		_BeginBlock = 64,
206 | 		_EndBlock = 32,
207 | 
208 | 		None = 0,
209 | 		Return = 1,
210 | 		Statement = 2,
211 | 		LoadLocal = 3,
212 | 		Branch = 9,
213 | 		ConditionalBranch = 10,
214 | 		Label = 11,
215 | 		Push = 12,
216 | 
217 | 		StoreArgument = 1 | _Store,
218 | 		StoreLocal = 2 | _Store,
219 | 		StoreField = 3 | _Store,
220 | 		StoreStaticField = 4 | _Store,
221 | 
222 | 		BeginSwitch = 3 | _BeginBlock,
223 | 		EndSwitch = 3 | _EndBlock,
224 | 		BeginCase = 4 | _BeginBlock,
225 | 		EndCase = 4 | _EndBlock,
226 | 		BeginIf = 5 | _BeginBlock,
227 | 		EndIf = 5 | _EndBlock,
228 | 		BeginElse = 6 | _BeginBlock,
229 | 		EndElse = 6 | _EndBlock,
230 | 		BeginDoWhile = 7 | _BeginBlock,
231 | 		EndDoWhile = 7 | _EndBlock,
232 | 		BeginWhile = 8 | _BeginBlock,
233 | 		EndWhile = 8 | _EndBlock,
234 | 	}
235 | 	public class ILInstruction {
236 | 		public readonly ILInstructionType Type;
237 | 		public string[] Arguments;
238 | 		public readonly int NextInstructionPosition;
239 | 		public ILInstruction(int nextInstructionPosition, ILInstructionType type, params string[] args) {
240 | 			this.Type = type;
241 | 			this.Arguments = args;
242 | 			this.NextInstructionPosition = nextInstructionPosition;
243 | 		}
244 | 		public bool IsStoreInstruction { get { return (this.Type & ILInstructionType._Store) == ILInstructionType._Store; } }
245 | 		public override string ToString() {
246 | 			return this.Type + "(" + string.Join(",", this.Arguments) + ")@" + this.NextInstructionPosition;
247 | 		}
248 | 	}
249 | }


--------------------------------------------------------------------------------
/Compiler/MK.Convert.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Compiler - JavaScript VM for .NET
 3 | Copyright (C) 2012 Michael Kolarz
 4 | 
 5 | This program is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU General Public License as published by
 7 | the Free Software Foundation, either version 3 of the License, or
 8 | (at your option) any later version.
 9 | 
10 | This program is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU General Public License for more details.
14 | 
15 | You should have received a copy of the GNU General Public License
16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 | 
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Linq;
22 | using System.Text;
23 | 
24 | namespace MK{
25 | 	public static class Convert {
26 | 		public static string ToJSString(string s) {
27 | 			StringBuilder sb = new StringBuilder(s.Length + 8);
28 | 			sb.Append('"');
29 | 			//sb.Append('\'');
30 | 			for (int i = 0; i < s.Length; ++i) {
31 | 				switch (s[i]) {
32 | 					case '\\': sb.Append(@"\\"); break;
33 | 					case '\"': sb.Append("\\\""); break;
34 | 					//case '\'': sb.Append(@"\'"); break;
35 | 					case '\n': sb.Append(@"\n"); break;
36 | 					case '\r': break;
37 | 					default: sb.Append(s[i]); break;
38 | 				}
39 | 			}
40 | 			return sb.Append('"').ToString();
41 | 			//return sb.Append('\'').ToString();
42 | 		}
43 | 
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/Compiler/Main.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using System.IO;
 24 | using System.Diagnostics;
 25 | using System.Xml.Linq;
 26 | using System.Text.RegularExpressions;
 27 | using System.Reflection;
 28 | using System.Globalization;
 29 | 
 30 | 
 31 | public partial class Program {
 32 | 
 33 | 	static void Compile(string inputDll, string outputVirtualPath, string webAppDirectory, string outputDirectory, bool deleteOutputDirectory, bool ignoreFinallyClauses, bool inline, string prototypeJs) {
 34 | 
 35 | 		var inputDirectory = Path.GetDirectoryName(inputDll);
 36 | 
 37 | 		if (deleteOutputDirectory) {
 38 | 			try {
 39 | 				Directory.Delete(outputDirectory, true);
 40 | 			} catch { }
 41 | 		}
 42 | 
 43 | 		Directory.CreateDirectory(outputDirectory);
 44 | 
 45 | 
 46 | 		//dll mapping output culture resources
 47 | 		Main0(new[] { inputDll, outputVirtualPath, outputDirectory, "IFC=" + ignoreFinallyClauses + "&IA=" + inline });
 48 | 
 49 | 		var tmp = outputDirectory + Path.DirectorySeparatorChar + "error.txt";
 50 | 
 51 | 		if (File.Exists(tmp)) {
 52 | 			throw new Exception(File.ReadAllText(tmp));
 53 | 		}
 54 | 
 55 | 		//tmp = outputDirectory + Path.DirectorySeparatorChar + "generate.xml";
 56 | 
 57 | 		#region process todo.xml
 58 | 
 59 | 		//var doc = XDocument.Load(tmp);
 60 | 
 61 | 		foreach (var node in doc.Root.Elements()) {
 62 | 			switch (node.Name.LocalName) {
 63 | 				case "page": {
 64 | 						var pagePath = webAppDirectory + Path.DirectorySeparatorChar + node.Attribute("path").Value
 65 | 							.Substring(1)//skip ~
 66 | 							.Replace('/', Path.DirectorySeparatorChar);
 67 | 						var stringToAdd = node.Attribute("script").Value;
 68 | 
 69 | 						var render = node.Attribute("render");
 70 | 						if (render != null) {
 71 | 							MK.JavaScript.Compiler.HtmlWriter.Write(pagePath, prototypeJs, Assembly.LoadFrom(inputDll).GetType(render.Value));
 72 | 						}
 73 | 
 74 | 						bool replaced = false;
 75 | 						File.WriteAllText(pagePath, new Regex(
 76 | 							Regex.Escape("<!--powered by il2js framework (http://smp.if.uj.edu.pl/~mkol/il2js)-->") + ".*" +
 77 | 							Regex.Escape("<!--/il2js-->"), RegexOptions.Compiled | RegexOptions.Singleline
 78 | 							).Replace(File.ReadAllText(pagePath), m => {
 79 | 								replaced = true;
 80 | 								return stringToAdd;
 81 | 							}));
 82 | 						if (!replaced) {
 83 | 							File.WriteAllText(pagePath, File.ReadAllText(pagePath).Replace("</head>", stringToAdd + "</head>"));
 84 | 						}
 85 | 					}
 86 | 					break;
 87 | 				case "resource": {
 88 | 						var writer = new MK.JavaScript.Compiler.ResourceWriter(node.Attribute("cultures").Value.Split(',').Select(n => CultureInfo.GetCultureInfo(n)));
 89 | 						foreach (var type in node.Elements()) {
 90 | 							writer.AddResource(
 91 | 								Assembly.LoadFrom(inputDirectory + Path.DirectorySeparatorChar + type.Attribute("assembly").Value + ".dll").GetType(type.Attribute("name").Value),
 92 | 								type.Attribute("members").Value.Split(',')
 93 | 							);
 94 | 						}
 95 | 						writer.Write(outputDirectory, node.Attribute("name").Value + ".aspx");
 96 | 					} break;
 97 | 				case "css":
 98 | 					MK.JavaScript.Compiler.CssWriter.Write(
 99 | 						outputDirectory + Path.DirectorySeparatorChar + node.Attribute("name").Value + ".css",
100 | 						node.Elements().Select(type => Assembly.LoadFrom(inputDirectory + Path.DirectorySeparatorChar + type.Attribute("assembly").Value + ".dll").GetType(type.Attribute("name").Value))
101 | 					);
102 | 					break;
103 | 			}
104 | 		}
105 | 		#endregion
106 | 
107 | 
108 | 		//File.Delete(tmp);
109 | 	}
110 | 
111 | 
112 | 	static void Main(string[] args) {
113 | 		if (args.Length == 0) {
114 | 			Console.WriteLine(
115 | @"
116 | USAGE: il2js <Input Dll Path> [options...]
117 | 
118 |                  -OUTPUT OPTIONS-
119 | 
120 | If following options are not provided, it is assumed that
121 |   <Input Dll Path>
122 |  is in form of
123 |   <WebApp Parent Directory>\<WebApp Name>\Bin\<Input Dll File>.
124 | 
125 | /webdir=<path>   Directory containing WebApp.
126 |                  DEFAULT=<WebApp Parent Directory>\<WebApp Name>
127 | 
128 | /output=<path>   Phisical path for generated files.
129 |                  DEFAULT=<WebApp Parent Directory>\<WebApp Name>\_
130 | 
131 | /url=<path>      URL virtual path for generated files.
132 |                  DEFAULT=/<WebApp Name>/_/
133 | 
134 | /clean           Output directory will be deleted.
135 | 
136 |                  -COMPILATION OPTIONS-
137 | 
138 | /ignorefinally   Compiler will ignore finally clauses.
139 | 
140 | /dontinline      Compiler will not inline methods not explicit marked
141 |                  by Inline attribute.
142 |                  (By default, all methods are inlined, if possible.)
143 |            
144 | 
145 |                  -OTHER OPTIONS-
146 | 
147 | /prototypejs=<path>   Path to prototype.js file
148 |                       (required when using [Window(Render=true,...)]).
149 |                       DEFAULT=prototype.js														
150 | "
151 | 
152 | 
153 | ///vs													Indicates if compiler is called from Visual Studio
154 | 				//                            as Post-build event command like
155 | 				//                            <path to il2js.exe> $(TargetPath) --VS
156 | 				//                            If present, error message will be opened in default
157 | 				//                            text editor rather then shown on console.
158 | );
159 | 			return;
160 | 		}
161 | 		var il2js_js=AppDomain.CurrentDomain.BaseDirectory + Path.DirectorySeparatorChar + "il2js.js";
162 | 		if(!File.Exists(il2js_js)){
163 | 			Console.Write("generating " + il2js_js+ " ... ");
164 | 			File.WriteAllText(il2js_js, PackCode(File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + Path.DirectorySeparatorChar + "Runtime.js"), false));
165 | 			Console.WriteLine("done");
166 | 		}
167 | 
168 | 		switch (args[0]) {
169 | 			default: {
170 | 					string inputDll = args[0];
171 | 					string outputVirtualPath = "";
172 | 					string webAppDirectory = "";
173 | 					string outputDirectory = "";
174 | 					bool deleteOutputDirectory = false;
175 | 					bool ignoreFinallyClauses = false;
176 | 					bool inline = true;
177 | 					const bool vs = false;
178 | 					string prototypeJs = "prototype.js";
179 | 
180 | 					try {
181 | 						foreach (var option in args.Skip(1)) {
182 | 							var kv = option.Split('=');
183 | 							switch (kv[0]) {
184 | 								case "/url": outputVirtualPath = kv[1]; break;
185 | 								case "/webdir": webAppDirectory = kv[1]; break;
186 | 								case "/output": outputDirectory = kv[1]; break;
187 | 								case "/prototypejs": prototypeJs = kv[1]; break;
188 | 								case "/clean": deleteOutputDirectory = true; break;
189 | 								case "/ignorefinally": ignoreFinallyClauses = true; break;
190 | 								//case "/vs": vs = true; break;
191 | 								case "/dontinline": inline = false; break;
192 | 								case "/define": Program.Runtime_jsSymbols.Add(kv[1]); break;
193 | 								case "/debug":
194 | 									Settings.DebugCompilation = true;
195 | 									Program.Runtime_jsSymbols.Add("debug");
196 | 									break;
197 | 
198 | 								default: throw new ArgumentException("Option Error: unknown option " + kv[0]);
199 | 							}
200 | 						}
201 | 						if (webAppDirectory == "")
202 | 							webAppDirectory = Path.GetDirectoryName(Path.GetDirectoryName(inputDll));
203 | 						if (outputVirtualPath == "")
204 | 							outputVirtualPath = "/" + Path.GetFileName(webAppDirectory) + "/_/";
205 | 						if (outputDirectory == "")
206 | 							outputDirectory = webAppDirectory + Path.DirectorySeparatorChar + "_";
207 | 
208 | 						Compile(inputDll, outputVirtualPath, webAppDirectory, outputDirectory, deleteOutputDirectory, ignoreFinallyClauses, inline, prototypeJs);
209 | 
210 | 					} catch (Exception e) {
211 | 						if (vs) {
212 | 							var tmp = "IL2JSErrorLog.txt";
213 | 							File.WriteAllText(tmp, e.Message);
214 | 							Process.Start(tmp).WaitForExit();
215 | 							File.Delete(tmp);
216 | 						} else {
217 | 							Console.Error.WriteLine(e.Message);
218 | 						}
219 | 					}
220 | 
221 | 				} break;
222 | 		}
223 | 
224 | 	}
225 | 
226 | }
227 | 


--------------------------------------------------------------------------------
/Compiler/Mapping.xsd:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <xs:schema id="Mapping"
  3 |     targetNamespace="http://smp.if.uj.edu.pl/~mkol/il2js/Mapping.xsd"
  4 |     elementFormDefault="qualified"
  5 |     xmlns="http://smp.if.uj.edu.pl/~mkol/il2js/Mapping.xsd"
  6 |     xmlns:mstns="http://smp.if.uj.edu.pl/~mkol/il2js/Mapping.xsd"
  7 |     xmlns:xs="http://www.w3.org/2001/XMLSchema"
  8 | >
  9 | 	<xs:simpleType name="OpCode">
 10 | 		<xs:restriction base="xs:string">
 11 | 			<xs:enumeration value="Or"/>
 12 | 			<xs:enumeration value="And"/>
 13 | 			<xs:enumeration value="Ret"/>
 14 | 			<xs:enumeration value="Rem"/>
 15 | 			<xs:enumeration value="Add"/>
 16 | 			<xs:enumeration value="Div"/>
 17 | 			<xs:enumeration value="Mul"/>
 18 | 			<xs:enumeration value="Sub"/>
 19 | 			<xs:enumeration value="Xor"/>
 20 | 			<xs:enumeration value="Ldlen"/>
 21 | 			<xs:enumeration value="Pop"/>
 22 | 			<xs:enumeration value="Dup"/>
 23 | 			<xs:enumeration value="Ceq"/>
 24 | 			<xs:enumeration value="Clt"/>
 25 | 			<xs:enumeration value="Cgt"/>
 26 | 			<xs:enumeration value="Ldnull"/>
 27 | 			<xs:enumeration value="Throw"/>
 28 | 
 29 | 			<xs:enumeration value="Ldelem"/>
 30 | 			<xs:enumeration value="Stelem"/>
 31 | 
 32 | 			<xs:enumeration value="Sleep"/>
 33 | 
 34 | 		</xs:restriction>
 35 | 	</xs:simpleType>
 36 | 	<xs:simpleType name="CallType">
 37 | 		<xs:restriction base="xs:string">
 38 | 			<xs:enumeration value="instance">
 39 | 				<xs:annotation>
 40 | 					<xs:documentation>
 41 | 						Method will be called using instance syntax (varible.method()). Useful for extension methods.
 42 | 					</xs:documentation>
 43 | 				</xs:annotation>
 44 | 			</xs:enumeration>
 45 | 			<xs:enumeration value="static">
 46 | 				<xs:annotation>
 47 | 					<xs:documentation>
 48 | 						Method will be called using static call syntax (method(varible)).
 49 | 					</xs:documentation>
 50 | 				</xs:annotation>
 51 | 			</xs:enumeration>
 52 | 		</xs:restriction>
 53 | 	</xs:simpleType>
 54 | 
 55 | 	<xs:complexType name="TypeArray">
 56 | 		<xs:sequence minOccurs="0" maxOccurs="unbounded">
 57 | 			<xs:element name="type">
 58 | 				<xs:complexType>
 59 | 					<xs:attribute name="name" type="xs:string" use="required">
 60 | 						<xs:annotation>
 61 | 							<xs:documentation>
 62 | 								The assembly-qualified name of the type.
 63 | 								(See MSDN help for Type::GetType Method.)
 64 | 							</xs:documentation>
 65 | 						</xs:annotation>
 66 | 					</xs:attribute>
 67 | 				</xs:complexType>
 68 | 			</xs:element>
 69 | 		</xs:sequence>
 70 | 	</xs:complexType>
 71 | 	<xs:complexType name="PropertyAccessor">
 72 | 		<xs:sequence>
 73 | 			<xs:element ref="javascript"/>
 74 | 		</xs:sequence>
 75 | 	</xs:complexType>
 76 | 
 77 | 	<xs:element name="javascript">
 78 | 		<xs:annotation>
 79 | 			<xs:documentation>
 80 | 				Tells compiler how to handle this member at client side in JavaScript.
 81 | 			</xs:documentation>
 82 | 		</xs:annotation>
 83 | 		<xs:complexType>
 84 | 			<xs:sequence>
 85 | 				<xs:choice>
 86 | 					<xs:element name="ignore">
 87 | 						<xs:annotation>
 88 | 							<xs:documentation>
 89 | 								No code will be generated for this member.
 90 | 							</xs:documentation>
 91 | 						</xs:annotation>
 92 | 						<xs:complexType/>
 93 | 					</xs:element>
 94 | 					<xs:element name="method">
 95 | 						<xs:annotation>
 96 | 							<xs:documentation>
 97 | 								JavaScript method will be called for this member.
 98 | 							</xs:documentation>
 99 | 						</xs:annotation>
100 | 						<xs:complexType>
101 | 							<xs:attribute name="name" type="xs:string">
102 | 								<xs:annotation>
103 | 									<xs:documentation>
104 | 										If name is not provided - lower case started name of method (or original type name in case of constructors) will be used.
105 | 									</xs:documentation>
106 | 								</xs:annotation>
107 | 							</xs:attribute>
108 | 							<xs:attribute name="syntax" type="CallType"/>
109 | 						</xs:complexType>
110 | 					</xs:element>
111 | 					<xs:element name="opCode">
112 | 						<xs:complexType>
113 | 							<xs:attribute name="value" type="OpCode" use="required"/>
114 | 						</xs:complexType>
115 | 					</xs:element>
116 | 					<xs:element name="code">
117 | 						<xs:annotation>
118 | 							<xs:documentation>
119 | 								Function definition (example: ``function(a){return this+a;}'') or function body (example: ``this+$0''). Each line of code will be trimmed, and lines will be joinded into one. In case of function body - use ``$*'',``$0'',``$1'',... as placeholder for parameters (``$*'' will be converted to ``arguments'' and ``$i'' will be converted to ``arguments[i]'').
120 | 							</xs:documentation>
121 | 						</xs:annotation>
122 | 						<xs:complexType>
123 | 							<xs:simpleContent>
124 | 								<xs:extension base="xs:string">
125 | 									<xs:attribute name="syntax" type="CallType"/>
126 | 								</xs:extension>
127 | 							</xs:simpleContent>
128 | 						</xs:complexType>
129 | 					</xs:element>
130 | 				</xs:choice>
131 | 				<xs:element name="additionalCode" type="xs:string" minOccurs="0">
132 | 					<xs:annotation>
133 | 						<xs:documentation>
134 | 							Additional code that makes possible to call this member. During compilation, each line of this code will be trimmed, and lines will be joined into one. So don't use construction like
135 | 							<![CDATA[
136 | 							if(a)b=c
137 | 							else d=e
138 | 							]]>
139 | 							(no ``{}'' for blocks and ``;'' at the end of statements).
140 | 						</xs:documentation>
141 | 					</xs:annotation>
142 | 				</xs:element>
143 | 			</xs:sequence>
144 | 			<xs:attribute name="prototype_js" type="xs:boolean" default="false">
145 | 				<xs:annotation>
146 | 					<xs:documentation>
147 | 						Indicates if this member's call requires usage of prototype.js library. Since whole framework uses prototype.js, this attribute has no meaning for compilation, but it's reserved for future usage (and to honor author of prototype.js, when we explicit use it's library in transtation .NET->JavaScript).
148 | 					</xs:documentation>
149 | 				</xs:annotation>
150 | 			</xs:attribute>
151 | 		</xs:complexType>
152 | 	</xs:element>
153 | 
154 | 
155 | 	<xs:element name="mapping">
156 | 		<xs:complexType>
157 | 			<xs:sequence>
158 | 				<xs:element name="assembly" minOccurs="0" maxOccurs="unbounded">
159 | 					<xs:complexType>
160 | 						<xs:attribute name="name" type="xs:string" use="required"/>
161 | 						<xs:attribute name="fullName" type="xs:string" use="required">
162 | 							<xs:annotation>
163 | 								<xs:documentation>
164 | 									The long form of the assembly name.
165 | 								</xs:documentation>
166 | 							</xs:annotation>
167 | 						</xs:attribute>
168 | 					</xs:complexType>
169 | 				</xs:element>
170 | 				<xs:element ref="namespace" maxOccurs="unbounded"/>
171 | 			</xs:sequence>
172 | 		</xs:complexType>
173 | 	</xs:element>
174 | 	
175 | 	<xs:element name="namespace">
176 | 		<xs:complexType>
177 | 			<xs:choice minOccurs="0" maxOccurs="unbounded">
178 | 				<xs:element ref="namespace"/>
179 | 				<xs:element name="type">
180 | 					<xs:complexType>
181 | 						<xs:choice minOccurs="0" maxOccurs="unbounded">
182 | 							<xs:element name="constructor">
183 | 								<xs:complexType>
184 | 									<xs:sequence>
185 | 										<xs:element name="parameters" type="TypeArray"/>
186 | 										<xs:element ref="javascript"/>
187 | 									</xs:sequence>
188 | 								</xs:complexType>
189 | 							</xs:element>
190 | 							<xs:element name="property">
191 | 								<xs:complexType>
192 | 									<xs:sequence>
193 | 										<xs:element name="parameters" type="TypeArray" minOccurs="0">
194 | 											<xs:annotation>
195 | 												<xs:documentation>
196 | 													You don't have to specify parameters, if there is only one property with given name.
197 | 												</xs:documentation>
198 | 											</xs:annotation>
199 | 										</xs:element>
200 | 										<xs:element name="get" type="PropertyAccessor" minOccurs="0"/>
201 | 										<xs:element name="set" type="PropertyAccessor" minOccurs="0"/>
202 | 									</xs:sequence>
203 | 									<xs:attribute name="name" type="xs:string" use="required"/>
204 | 								</xs:complexType>
205 | 							</xs:element>
206 | 							<xs:element name="method">
207 | 								<xs:complexType>
208 | 									<xs:sequence>
209 | 										<xs:element name="parameters" type="TypeArray" minOccurs="0">
210 | 											<xs:annotation>
211 | 												<xs:documentation>
212 | 													You don't have to specify parameters, if there is only one method with given name.
213 | 												</xs:documentation>
214 | 											</xs:annotation>
215 | 										</xs:element>
216 | 										<xs:element ref="javascript"/>
217 | 									</xs:sequence>
218 | 									<xs:attribute name="name" type="xs:string" use="required"/>
219 | 								</xs:complexType>
220 | 							</xs:element>
221 | 							<xs:element name="operator">
222 | 								<xs:complexType>
223 | 									<xs:sequence>
224 | 										<xs:element name="parameters" type="TypeArray" minOccurs="0">
225 | 											<xs:annotation>
226 | 												<xs:documentation>
227 | 													You don't have to specify parameters, if there is only one operator with given name.
228 | 												</xs:documentation>
229 | 											</xs:annotation>
230 | 										</xs:element>
231 | 										<xs:element ref="javascript"/>
232 | 									</xs:sequence>
233 | 									<xs:attribute name="name" use="required">
234 | 										<xs:annotation>
235 | 											<xs:documentation>
236 | 												Name of operator (list based on Ecma-355.pdf).
237 | 											</xs:documentation>
238 | 										</xs:annotation>
239 | 										<xs:simpleType>
240 | 											<xs:restriction base="xs:string">
241 | 												<!--unary-->
242 | 												<xs:enumeration value="Decrement"/>
243 | 												<xs:enumeration value="Increment"/>
244 | 												<xs:enumeration value="UnaryNegation"/>
245 | 												<xs:enumeration value="UnaryPlus"/>
246 | 												<xs:enumeration value="LogicalNot"/>
247 | 												<xs:enumeration value="True"/>
248 | 												<xs:enumeration value="False"/>
249 | 												<xs:enumeration value="AddressOf"/>
250 | 												<xs:enumeration value="OnesComplement"/>
251 | 												<xs:enumeration value="PointerDereference"/>
252 | 												<!--binary-->
253 | 												<xs:enumeration value="Addition"/>
254 | 												<xs:enumeration value="Subtraction"/>
255 | 												<xs:enumeration value="Multiply"/>
256 | 												<xs:enumeration value="Division"/>
257 | 												<xs:enumeration value="Modulus"/>
258 | 												<xs:enumeration value="ExclusiveOr"/>
259 | 												<xs:enumeration value="BitwiseAnd"/>
260 | 												<xs:enumeration value="BitwiseOr"/>
261 | 												<xs:enumeration value="LogicalAnd"/>
262 | 												<xs:enumeration value="LogicalOr"/>
263 | 												<xs:enumeration value="Assign"/>
264 | 												<xs:enumeration value="LeftShift"/>
265 | 												<xs:enumeration value="RightShift"/>
266 | 												<xs:enumeration value="SignedRightShift"/>
267 | 												<xs:enumeration value="UnsignedRightShift"/>
268 | 												<xs:enumeration value="Equality"/>
269 | 												<xs:enumeration value="GreaterThan"/>
270 | 												<xs:enumeration value="LessThan"/>
271 | 												<xs:enumeration value="Inequality"/>
272 | 												<xs:enumeration value="GreaterThanOrEqual"/>
273 | 												<xs:enumeration value="LessThanOrEqual"/>
274 | 												<xs:enumeration value="UnsignedRightShiftAssignment"/>
275 | 												<xs:enumeration value="MemberSelection"/>
276 | 												<xs:enumeration value="RightShiftAssignment"/>
277 | 												<xs:enumeration value="MultiplicationAssignment"/>
278 | 												<xs:enumeration value="PointerToMemberSelection"/>
279 | 												<xs:enumeration value="SubtractionAssignment"/>
280 | 												<xs:enumeration value="ExclusiveOrAssignment"/>
281 | 												<xs:enumeration value="LeftShiftAssignment"/>
282 | 												<xs:enumeration value="ModulusAssignment"/>
283 | 												<xs:enumeration value="AdditionAssignment"/>
284 | 												<xs:enumeration value="BitwiseAndAssignment"/>
285 | 												<xs:enumeration value="BitwiseOrAssignment"/>
286 | 												<xs:enumeration value="Comma"/>
287 | 												<xs:enumeration value="DivisionAssignment"/>
288 | 											</xs:restriction>
289 | 										</xs:simpleType>
290 | 									</xs:attribute>
291 | 								</xs:complexType>
292 | 							</xs:element>
293 | 
294 | 						</xs:choice>
295 | 						<xs:attribute name="name" type="xs:string" use="required">
296 | 							<xs:annotation>
297 | 								<xs:documentation>
298 | 									Name of type.
299 | 									It will be concat with parent namespace name.
300 | 									(See MSDN help for Type::GetType Method.)
301 | 								</xs:documentation>
302 | 							</xs:annotation>
303 | 						</xs:attribute>
304 | 						<xs:attribute name="assembly" type="xs:string">
305 | 							<xs:annotation>
306 | 								<xs:documentation>
307 | 									The long form of the assembly name (or name defined in mapping assemblies).
308 | 									Must be set when type is not in Mscorlib.dll.
309 | 									If present, it overrides ancestor namespace assembly.
310 | 									(See MSDN help for Type::GetType Method.)
311 | 								</xs:documentation>
312 | 							</xs:annotation>
313 | 						</xs:attribute>
314 | 					</xs:complexType>
315 | 				</xs:element>
316 | 			</xs:choice>
317 | 			<xs:attribute name="name" type="xs:string" use="required">
318 | 				<xs:annotation>
319 | 					<xs:documentation>
320 | 						Name of namespace.
321 | 						It will be concat with parent namespace name.
322 | 						(See MSDN help for Type::GetType Method.)
323 | 					</xs:documentation>
324 | 				</xs:annotation>
325 | 			</xs:attribute>
326 | 			<xs:attribute name="assembly" type="xs:string">
327 | 				<xs:annotation>
328 | 					<xs:documentation>
329 | 						The long form of the assembly name (or name defined in mapping assemblies).
330 | 						Must be set when types in namespace are not in Mscorlib.dll.
331 | 						If present, it overrides ancestor namespace assembly.
332 | 						(See MSDN help for Type::GetType Method.)
333 | 					</xs:documentation>
334 | 				</xs:annotation>
335 | 			</xs:attribute>
336 | 
337 | 		</xs:complexType>
338 | 	</xs:element>
339 | </xs:schema>
340 | 


--------------------------------------------------------------------------------
/Compiler/Mapping.xsl:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <xsl:stylesheet version="1.0"
  3 | 								xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  4 | 								xmlns:i="http://smp.if.uj.edu.pl/~mkol/il2js/Mapping.xsd"
  5 | 								>
  6 | 	<xsl:template name="TypeFullName">
  7 | 		<xsl:param name="node"/>
  8 | 		<xsl:choose>
  9 | 			<xsl:when test="$node/..=/">
 10 | 				<xsl:value-of select="$node/@name"/>
 11 | 			</xsl:when>
 12 | 			<xsl:otherwise>
 13 | 				<xsl:call-template name="TypeFullName">
 14 | 					<xsl:with-param name="node" select="$node/.."/>
 15 | 				</xsl:call-template>.<xsl:value-of select="$node/@name"/>
 16 | 			</xsl:otherwise>
 17 | 		</xsl:choose>
 18 | 	</xsl:template>
 19 | 
 20 | 	<xsl:template match="/">
 21 | 		<html>
 22 | 			<head>
 23 | 				<title>Supported .NET types</title>
 24 | 				<style>
 25 | 					table{width:100%}
 26 | 				</style>
 27 | 			</head>
 28 | 			<body>
 29 | 				<xsl:apply-templates>
 30 | 					<xsl:sort select="@name"/>
 31 | 				</xsl:apply-templates>
 32 | 			</body>
 33 | 		</html>
 34 | 	</xsl:template>
 35 | 
 36 | 	<xsl:template match="i:namespace">
 37 | 		<xsl:apply-templates select="i:type">
 38 | 			<xsl:sort select="@name"/>
 39 | 		</xsl:apply-templates>
 40 | 		<xsl:apply-templates select="i:namespace">
 41 | 			<xsl:sort select="@name"/>
 42 | 		</xsl:apply-templates>
 43 | 	</xsl:template>
 44 | 
 45 | 	<xsl:template match="i:type">
 46 | 		<h1>
 47 | 			<xsl:call-template name="TypeFullName">
 48 | 				<xsl:with-param name="node" select="."/>
 49 | 			</xsl:call-template>
 50 | 		</h1>
 51 | 		<xsl:if test="i:constructor">
 52 | 			<h2>Constructors</h2>
 53 | 			<table rules="all" border="1">
 54 | 				<tr>
 55 | 					<th>.NET Signature</th>
 56 | 					<th>JavaScript equivalent</th>
 57 | 				</tr>
 58 | 				<xsl:apply-templates select="i:constructor"/>
 59 | 			</table>
 60 | 		</xsl:if>
 61 | 		<xsl:if test="i:method">
 62 | 			<h2>Methods</h2>
 63 | 			<table rules="all" border="1">
 64 | 				<tr>
 65 | 					<th>.NET Signature</th>
 66 | 					<th>JavaScript equivalent</th>
 67 | 				</tr>
 68 | 				<xsl:apply-templates select="i:method">
 69 | 					<xsl:sort select="@name"/>
 70 | 				</xsl:apply-templates>
 71 | 			</table>
 72 | 		</xsl:if>
 73 | 		<xsl:if test="i:operator">
 74 | 			<h2>Operators</h2>
 75 | 			<table rules="all" border="1">
 76 | 				<tr>
 77 | 					<th>.NET Signature</th>
 78 | 					<th>JavaScript equivalent</th>
 79 | 				</tr>
 80 | 				<xsl:apply-templates select="i:operator">
 81 | 					<xsl:sort select="@name"/>
 82 | 				</xsl:apply-templates>
 83 | 			</table>
 84 | 		</xsl:if>
 85 | 		<xsl:if test="i:property">
 86 | 			<h2>Properties</h2>
 87 | 			<table rules="all" border="1">
 88 | 				<tr>
 89 | 					<th colspan="2">.NET Signature</th>
 90 | 					<th>JavaScript equivalent</th>
 91 | 				</tr>
 92 | 				<xsl:apply-templates select="i:property">
 93 | 					<xsl:sort select="@name"/>
 94 | 				</xsl:apply-templates>
 95 | 			</table>
 96 | 		</xsl:if>
 97 | 	</xsl:template>
 98 | 
 99 | 	<xsl:template match="i:constructor">
100 | 		<tr>
101 | 			<td>
102 | 				<code>
103 | 					<xsl:value-of select="../@name"/>
104 | 					(
105 | 					<xsl:apply-templates select="i:parameters/i:type" mode="parameter"/>
106 | 					)
107 | 				</code>
108 | 			</td>
109 | 			<td>
110 | 				<xsl:apply-templates select="i:javascript"/>
111 | 			</td>
112 | 		</tr>
113 | 	</xsl:template>
114 | 
115 | 	<xsl:template match="i:method|i:operator">
116 | 		<tr>
117 | 			<td>
118 | 				<code>
119 | 					<xsl:value-of select="@name"/>
120 | 					<xsl:if test="i:parameters">
121 | 						(
122 | 						<xsl:apply-templates select="i:parameters/i:type" mode="parameter"/>
123 | 						)
124 | 					</xsl:if>
125 | 				</code>
126 | 			</td>
127 | 			<td>
128 | 				<xsl:apply-templates select="i:javascript"/>
129 | 			</td>
130 | 		</tr>
131 | 	</xsl:template>
132 | 
133 | 	<xsl:template match="i:property">
134 | 		<tr>
135 | 			<td>
136 | 				<code>
137 | 					<xsl:value-of select="@name"/>
138 | 
139 | 					<xsl:if test="i:parameters">
140 | 						(
141 | 						<xsl:apply-templates select="i:parameters/i:type" mode="parameter"/>
142 | 						)
143 | 					</xsl:if>
144 | 				</code>
145 | 			</td>
146 | 			<xsl:choose>
147 | 				<xsl:when test="i:get">
148 | 					<td>
149 | 						<code>{get}</code>
150 | 					</td>
151 | 					<td>
152 | 						<xsl:apply-templates select="i:get/i:javascript"/>
153 | 					</td>
154 | 				</xsl:when>
155 | 				<xsl:when test="i:set">
156 | 					<td>
157 | 						<code>{set}</code>
158 | 					</td>
159 | 					<td>
160 | 						<xsl:apply-templates select="i:set/i:javascript"/>
161 | 					</td>
162 | 				</xsl:when>
163 | 			</xsl:choose>
164 | 		</tr>
165 | 		<xsl:if test="i:get and i:set">
166 | 			<tr>
167 | 				<td></td>
168 | 				<td>
169 | 					<code>{set}</code>
170 | 				</td>
171 | 				<td>
172 | 					<xsl:apply-templates select="i:set/i:javascript"/>
173 | 				</td>
174 | 			</tr>
175 | 		</xsl:if>
176 | 	</xsl:template>
177 | 
178 | 	<xsl:template match="i:type" mode="parameter">
179 | 		<xsl:value-of select="@name"/>
180 | 		<xsl:if test="position()!=last()">, </xsl:if>
181 | 	</xsl:template>
182 | 
183 | 	<xsl:template match="i:javascript">
184 | 		<xsl:choose>
185 | 			<xsl:when test="i:method">
186 | 				<code>
187 | 					<xsl:value-of select="i:method/@name"/>
188 | 				</code> JavaScript function.
189 | 			</xsl:when>
190 | 			<xsl:when test="i:ignore">
191 | 				Method is ignored.
192 | 			</xsl:when>
193 | 			<xsl:when test="i:opCode">
194 | 				<code>
195 | 					<xsl:value-of select="i:opCode/@value"/>
196 | 				</code> IL operation code.
197 | 			</xsl:when>
198 | 			<xsl:when test="i:code">
199 | 				<code>
200 | 					<xsl:value-of select="i:code"/>
201 | 				</code> JavaScript code.
202 | 			</xsl:when>
203 | 		</xsl:choose>
204 | 	</xsl:template>
205 | </xsl:stylesheet>
206 | 


--------------------------------------------------------------------------------
/Compiler/Mapping2.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8" ?>
  2 | <mapping xmlns="http://smp.if.uj.edu.pl/~mkol/il2js/Mapping.xsd">
  3 | 	<assembly name="System.Core" fullName="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
  4 | 	<namespace name="System">
  5 | 		<type name="Int32">
  6 | 			<method name="TryParse">
  7 | 				<parameters>
  8 | 					<type name="String"/>
  9 | 					<type name="Int32&amp;"/>
 10 | 				</parameters>
 11 | 				<javascript>
 12 | 					<code>
 13 | 						<![CDATA[
 14 | function(a,b){
 15 | 	$set$(b,a=parseInt(a));
 16 | 	return !isNaN(a);
 17 | }
 18 | ]]>
 19 | 					</code>
 20 | 				</javascript>
 21 | 			</method>
 22 | 		</type>
 23 | 		<type name="Byte">
 24 | 			<method name="TryParse">
 25 | 				<parameters>
 26 | 					<type name="String"/>
 27 | 					<type name="Byte&amp;"/>
 28 | 				</parameters>
 29 | 				<javascript>
 30 | 					<code>
 31 | 						<![CDATA[
 32 | function(a,b){
 33 | 	$set$(b,a=parseInt(a));
 34 | 	return !isNaN(a)&&0<=a&&a<256;
 35 | }
 36 | ]]>
 37 | 					</code>
 38 | 				</javascript>
 39 | 			</method>
 40 | 		</type>
 41 | 		<type name="Double">
 42 | 			<method name="TryParse">
 43 | 				<parameters>
 44 | 					<type name="String"/>
 45 | 					<type name="Double&amp;"/>
 46 | 				</parameters>
 47 | 				<javascript>
 48 | 					<code>
 49 | 						<![CDATA[
 50 | function(a,b){
 51 | 	$set$(b,a=parseFloat(a));
 52 | 	return !isNaN(a);
 53 | }
 54 | ]]>
 55 | 					</code>
 56 | 				</javascript>
 57 | 			</method>
 58 | 		</type>
 59 | 		<namespace name="Collections.Generic">
 60 | 			<type name="Dictionary`2">
 61 | 				<method name="TryGetValue">
 62 | 					<javascript>
 63 | 						<code>
 64 | 							<![CDATA[
 65 | function(a,b){
 66 | 	$set$(b,this[a]);
 67 | 	return a in this;
 68 | }
 69 | ]]>
 70 | 						</code>
 71 | 					</javascript>
 72 | 				</method>
 73 | 			</type>
 74 | 		</namespace>
 75 | 		<namespace name="Threading">
 76 | 			<type name="Thread">
 77 | 				<constructor>
 78 | 					<parameters>
 79 | 						<type name="ThreadStart"/>
 80 | 					</parameters>
 81 | 					<javascript>
 82 | 						<code>{d:$0}</code>
 83 | 					</javascript>
 84 | 				</constructor>
 85 | 				<constructor>
 86 | 					<parameters>
 87 | 						<type name="ParameterizedThreadStart"/>
 88 | 					</parameters>
 89 | 					<javascript>
 90 | 						<code>{d:$0}</code>
 91 | 					</javascript>
 92 | 				</constructor>
 93 | 				<method name="Sleep">
 94 | 					<parameters>
 95 | 						<type name="Int32"/>
 96 | 					</parameters>
 97 | 					<javascript>
 98 | 						<opCode value="Sleep"/>
 99 | 					</javascript>
100 | 				</method>
101 | 				<method name="Start">
102 | 					<parameters/>
103 | 					<javascript>
104 | 						<code syntax="static">
105 | 							<![CDATA[
106 | function(a){
107 | 	a.t=$handler$(a.d,a).defer();
108 | }
109 | ]]>
110 | 						</code>
111 | 					</javascript>
112 | 				</method>
113 | 				<method name="Start">
114 | 					<parameters>
115 | 						<type name="Object"/>
116 | 					</parameters>
117 | 					<javascript>
118 | 						<code syntax="static">
119 | 							<![CDATA[
120 | function(a,b){
121 | 	a.t=$handler$(a.d,a).curry(b).defer();
122 | }
123 | ]]>
124 | 						</code>
125 | 					</javascript>
126 | 				</method>
127 | 				<method name="Abort">
128 | 					<parameters/>
129 | 					<javascript>
130 | 						<code syntax="static">
131 | 							<![CDATA[
132 | function(a){
133 | 	clearTimeout(a.t);
134 | }
135 | ]]>
136 | 						</code>
137 | 					</javascript>
138 | 				</method>
139 | 			</type>
140 | 		</namespace>
141 | 	</namespace>
142 | </mapping>


--------------------------------------------------------------------------------
/Compiler/Program.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Compiler - JavaScript VM for .NET
  3 | Copyright (C) 2012 Michael Kolarz
  4 | 
  5 | This program is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU General Public License as published by
  7 | the Free Software Foundation, either version 3 of the License, or
  8 | (at your option) any later version.
  9 | 
 10 | This program is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU General Public License
 16 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17 | 
 18 | */
 19 | #define TEST
 20 | using System;
 21 | using System.Collections.Generic;
 22 | using System.Globalization;
 23 | using System.IO;
 24 | using System.Linq;
 25 | using System.Reflection;
 26 | using System.Reflection.Emit;
 27 | using System.Text;
 28 | using System.Text.RegularExpressions;
 29 | using System.Xml;
 30 | using System.Xml.Linq;
 31 | using MK.CodeDom.Compiler;
 32 | using MK.JavaScript;
 33 | using MK.JavaScript.CodeDom.Compiler;
 34 | using MK.JavaScript.Compiler;
 35 | using MK.JavaScript.Dom;
 36 | using System.Drawing;
 37 | using MK.JavaScript.Css;
 38 | 
 39 | public class Settings {
 40 | 	public static string OutputDirectory;
 41 | 
 42 | 	internal static string Guid;
 43 | 
 44 | 	public static string ResourcesAspxFileName { get { return Guid; } }
 45 | 	public static string HandlerAshxFileName { get { return Guid; } }
 46 | 	public static string RuntimeJsFileName { get { return Guid; } }
 47 | 
 48 | 	//public static string RuntimeJsFileName = Guid.NewGuid().ToString();
 49 | 	//public static string ResourcesAspxFileName = "_";
 50 | 	//public static string HandlerAshxFileName = "_";
 51 | 
 52 | 	public static bool IgnoreFinally = false;
 53 | 	public static bool InlineAll = true;
 54 | 
 55 | 	public static bool DebugCompilation = false;
 56 | 
 57 | 	public const bool IgnoreClause = false;
 58 | }
 59 | 
 60 | public partial class Program {
 61 | 
 62 | 
 63 | 
 64 | 
 65 | 	public class Names {
 66 | 		internal static Dictionary<string, string> names = new Dictionary<string, string> {
 67 | 			//$ref$
 68 | 			{"ref_container","a"},
 69 | 			{"ref_index","b"},
 70 | 			//$leaveStackElement$
 71 | 			{"Handling_Type","a"},
 72 | 			{"Handling_Argument","b"},
 73 | 			//$execution$
 74 | 			{"local","a"},
 75 | 			{"position","b"},
 76 | 			{"args","c"},
 77 | 			{"il","d"},
 78 | 			{"tryStack","e"},
 79 | 			{"handlingStack","f"},
 80 | 			//przerzucone jako globalne dla przyspieszenia i kompresji
 81 | 			//{"eatInt","e"},
 82 | 			//{"eatUInt","f"},
 83 | 			//{"eatChar","g"},
 84 | 			//$call$:
 85 | 			{"callStack","e"},
 86 | 			{"stack","f"},
 87 | 			{"pop","g"},
 88 | 			{"pops","h"},
 89 | 			{"push","i"},
 90 | 			{"operator","j"},
 91 | 			{"br2","k"},
 92 | 			{"handleException","l"},
 93 | 
 94 | 			{"path","A"},
 95 | 			{"guid","B"},
 96 | 			{"method","C"},
 97 | 			{"methodLength","D"},
 98 | 			{"field","E"},
 99 | 			{"ctor","F"},
100 | 			{"string","G"},
101 | 			{"code","H"},
102 | 			{"loaded","I"},
103 | 			{"cctor_executed","J"},
104 | 			{"module","K"},
105 | 			{"apply","L"},
106 | 			{"getNativeMethod","M"},
107 | 			{"handler","N"},
108 | 			{"call","O"},
109 | 			{"execution","P"},
110 | 			{"eatInt","Q"},
111 | 			{"eatUInt","R"},
112 | 			{"eatChar","S"},
113 | 			{"ref","T"},
114 | 			{"set","U"},
115 | 			{"init","V"},
116 | 
117 | 		};
118 | #if OBFUSCATE
119 | 		private static char Current = 'W';
120 | #endif
121 | 		public static string GetName(string originalName) {
122 | #if OBFUSCATE
123 | 
124 | 			//return names[originalName];
125 | 
126 | 			string ret;
127 | 			if (!names.TryGetValue(originalName, out ret)) {
128 | 				ret = Current.ToString();
129 | 				if (Current++ > 'Z') throw new Exception("GetNames");
130 | 				names[originalName] = ret;
131 | 
132 | 				//Console.WriteLine("{\"" + originalName + "\",\"" + ret + "\"},");
133 | 
134 | 			}
135 | 			return ret;
136 | #else
137 | 			return "$" + originalName + "$";
138 | #endif
139 | 		}
140 | 		public static string PathValue;
141 | 		public static string _move_ { get { return GetName("move"); } }
142 | 		public static string _get_ { get { return GetName("get"); } }
143 | 		public static string _init_ { get { return GetName("init"); } }
144 | 		public static string _resources_ { get { return GetName("resources"); } }
145 | 		public static string _path_ { get { return GetName("path"); } }
146 | 	}
147 | 
148 | 
149 | 	static HashSet<string> Runtime_jsSymbols = new HashSet<string> {
150 | 		//TO MUSI BYC ZBIOR PREFIKSOWY
151 | //#if TEST
152 | //    "debug",
153 | //#endif
154 | 		"guid",
155 | 		"release",
156 | 		"IE",
157 | 		//"developer",
158 | 	};
159 | 	static void CreateRuntime_js() {
160 | 		File.WriteAllText(Settings.OutputDirectory + Path.DirectorySeparatorChar + Settings.RuntimeJsFileName + ".js",
161 | 			"//http://smp.if.uj.edu.pl/il2js framework (c) mkol@smp.if.uj.edu.pl\n" + PackCode(File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + Path.DirectorySeparatorChar + "il2js.js"), false));
162 | 	}
163 | 
164 | 	public static string PackCode(string value, bool forceLinePack) {
165 | 		#region PreProcessor #if .. #else .. #endif
166 | 		value = Regex.Replace(
167 | 			value,
168 | 			@"^\s*//#if\s+([a-zA-Z0-9]+)(.*?)((^\s*//#else)(.*?))?//\s*#endif",
169 | 			m => {
170 | 				if (Runtime_jsSymbols.Contains(m.Groups[1].Value)) {
171 | 					return m.Groups[2].Value;
172 | 				} else {
173 | 					if (m.Groups[3].Success) {
174 | 						return m.Groups[5].Value;
175 | 					} else {
176 | 						return "";
177 | 					}
178 | 				}
179 | 			},
180 | 			RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.Singleline
181 | 		);
182 | 		#endregion
183 | 		#region Replacements $...
184 | 		value = Regex.Replace(
185 | 			value,
186 | 			@"\$([a-zA-Z_][a-zA-Z0-9_]*)(\.([a-zA-Z_][a-zA-Z0-9_]*))?\$",
187 | 			m => {
188 | 				switch (m.Groups[1].Value) {
189 | 					case "resourcesFileName": return Settings.ResourcesAspxFileName == null ? "$resourcesFileName$" : Settings.ResourcesAspxFileName;
190 | 					case "handlerFileName": return Settings.HandlerAshxFileName == null ? "$handlerFileName$" : Settings.HandlerAshxFileName;
191 | 					case "guidValue": return Settings.Guid == null ? "$guidValue$" : MK.Convert.ToJSString(Settings.Guid);
192 | 					case "OpCode": return "\"" + typeof(MK.CodeDom.Compiler.MethodCompiler.JSOpCode).GetField(m.Groups[3].Value).GetValue(null) + "\""
193 | #if !OBFUSCATE
194 |  + "/*" + m.Groups[3].Value + "*/"
195 | #endif
196 | ;
197 | 					case "HandlingType":
198 | 						switch (m.Groups[3].Value) {
199 | 							case "Leave": return "0";
200 | 							case "Throw": return "1";
201 | 							default: throw new Exception("HandlingType." + m.Groups[3].Value);
202 | 						}
203 | 					case "debug": return m.Groups[0].Value;
204 | 					case "eatToken": return Names.GetName("eatChar");
205 | 					//case "eatUInt": return Names.GetName("eatInt");
206 | 					case "native": return Names.GetName("string");
207 | 					case "pathValue": return Names.PathValue ?? "$pathValue$";
208 | 					default:
209 | 						return Names.GetName(m.Groups[1].Value);
210 | 				}
211 | 
212 | 			},
213 | 			RegexOptions.Compiled
214 | 		);
215 | 		#endregion
216 | 		if (forceLinePack
217 | #if OBFUSCATE
218 |  || true
219 | #endif
220 | )
221 | 			value = string.Join("", (from l in value.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
222 | 															 let line = l.Trim()
223 | 															 where !line.StartsWith("//")
224 | 															 select line).ToArray());
225 | #if OBFUSCATE
226 | 		value = value
227 | 			.Replace(";}", "}")
228 | 			.Replace("case \"", "case\"")
229 | 		;
230 | #endif
231 | 		return value;
232 | 	}
233 | 
234 | 
235 | 
236 | 
237 | 
238 | 	private static XDocument doc;
239 | 
240 | 
241 | 	//nawet nie mysl o pozbyciu sie tego i wsadzeniu do dllki bo cie zjedza zmienne statyczne...
242 | 	static void Main0(string[] args) {
243 | 
244 | 		Settings.Guid = global::System.Guid.NewGuid().ToString();
245 | 
246 | #if !TEST
247 | 		try {
248 | #endif
249 | 
250 | 
251 | 		Settings.OutputDirectory = args[2];
252 | 
253 | 
254 | 
255 | 		if (Directory.Exists(Settings.OutputDirectory)) {
256 | 			try {
257 | 				Directory.Delete(Settings.OutputDirectory, true);
258 | 			} catch (IOException) { }
259 | 		}
260 | 		while (!Directory.Exists(Settings.OutputDirectory)) {
261 | 			try {
262 | 				Directory.CreateDirectory(Settings.OutputDirectory);
263 | 			} catch (IOException) { }
264 | 		}
265 | 
266 | 		var assembly = Assembly.LoadFrom(args[0]);
267 | 		string pathValue = args[1];
268 | 		Names.PathValue = MK.Convert.ToJSString(pathValue);
269 | 		LogPath = Settings.OutputDirectory + @"\log.xml";
270 | 		var inputDirectory = Path.GetDirectoryName(args[0]);
271 | 
272 | 		NativesManager.Instance = new NativesManager(inputDirectory + @"\Mapping.xml");
273 | 
274 | 		foreach (var option in args[3].Split('&')) {
275 | 			var kv = option.Split('=');
276 | 			switch (kv[0]) {
277 | 				case "IFC": Settings.IgnoreFinally = bool.Parse(kv[1]); break;
278 | 				case "IA": Settings.InlineAll = bool.Parse(kv[1]); break;
279 | 			}
280 | 		}
281 | 
282 | 
283 | 		CreateRuntime_js();
284 | 
285 | 
286 | 		XmlLog = XmlWriter.Create(LogPath);
287 | 		XmlLog.WriteStartElement("compilation");
288 | 
289 | 		if (Settings.DebugCompilation) {
290 | 			XmlLog.WriteAttributeString("dll", args[0]);
291 | 			XmlLog.WriteAttributeString("guid", Settings.RuntimeJsFileName);
292 | 
293 | 		}
294 | 		var compilers =/*
295 | 			new PageFrameCompiler(assembly.GetType("MK.JavaScript.Tests",true), new WindowAttribute("~/_test/dump.aspx"))
296 | 			/*/
297 | 			(
298 | 				from type in assembly.GetTypes()
299 | 				where type.IsSubclassOf(typeof(Window))
300 | 				let attrs = type.GetCustomAttributes(typeof(WindowAttribute), false)
301 | 				where attrs.Length == 1
302 | 				select new PageFrameCompiler(type, (WindowAttribute)attrs[0])
303 | 			).ToArray()
304 | 			//*/
305 | 			;
306 | 		PageFrameCompiler.CompileAll(compilers);
307 | 
308 | 		CssSupport.Compute(compilers);
309 | 
310 | 		#region todo.xml
311 | 
312 | 		var root = new XElement("generate");
313 | 
314 | 		doc = new XDocument(root);
315 | 
316 | 		foreach (var compiler in compilers) {
317 | 
318 | 
319 | 			var sb = new StringBuilder();
320 | 			sb.Append("<!--powered by il2js framework (http://smp.if.uj.edu.pl/~mkol/il2js)-->");
321 | 			foreach (var fileName in
322 | 				from file in CssSupport.CssFiles
323 | 				where file.Pages.Contains(compiler)
324 | 				select file.CssFileName
325 | 			) {
326 | 				sb.Append(@"<link type=""text/css"" rel=""stylesheet""  href=""" + pathValue + fileName + @".css"" />");
327 | 			}
328 | 			if (compiler.IsRuntimePage)
329 | 				sb.Append(@"<script type=""text/javascript"" src=""" + pathValue + Settings.RuntimeJsFileName + @".js""></script>");
330 | 			sb.Append(@"<script type=""text/javascript"" src=""" + pathValue + compiler.JsFileName + @".js""></script>");
331 | 			sb.Append(@"<!--/il2js-->");
332 | 
333 | 			XElement page = new XElement("page",
334 | 				new XAttribute("path", compiler.WindowAttribute.Path),
335 | 				new XAttribute("script", sb.ToString())
336 | 			);
337 | 
338 | 			if (compiler.WindowAttribute.Render) {
339 | 				page.Add(new XAttribute("render", compiler.WindowType.FullName));
340 | 			}
341 | 
342 | 			root.Add(page);
343 | 
344 | 
345 | 		}
346 | 		root.Add(Resources.CreateConfigurationElement(Settings.ResourcesAspxFileName, GetCultures(inputDirectory)));
347 | 		foreach (var element in CssSupport.CreateConfigurationElements()) {
348 | 			root.Add(element);
349 | 		}
350 | 
351 | 		doc.Save(Settings.OutputDirectory + "\\generate.xml");
352 | 
353 | 		#endregion
354 | 		XmlLog.WriteEndElement();
355 | 		XmlLog.Close();
356 | 
357 | 
358 | 		ServerManager.Dump(Settings.OutputDirectory);
359 | 
360 | #if !TEST
361 | 		} catch (CompilationException e) {
362 | 			File.WriteAllText(Settings.OutputDirectory + Path.DirectorySeparatorChar + "error.txt", e.Message);
363 | 		} catch (Exception e) {
364 | 			File.WriteAllText(Settings.OutputDirectory + Path.DirectorySeparatorChar + "error.txt", "Internal compiler error. Sending input directory to mkol@smp.if.uj.edu.pl will help to identify and to fix this problem in new version of compiler.");
365 | 			//File.WriteAllText(Settings.OutputDirectory + Path.DirectorySeparatorChar + "error.txt", e.StackTrace);
366 | 		}
367 | #endif
368 | 	}
369 | 	static IEnumerable<CultureInfo> GetCultures(string inputDirectory) {
370 | 		foreach (var name in Directory.GetDirectories(inputDirectory).Select(a => Path.GetFileName(a))) {
371 | 			CultureInfo culture;
372 | 			try {
373 | 				culture = CultureInfo.GetCultureInfo(name);
374 | 			} catch (ArgumentException) {
375 | 				continue;
376 | 			}
377 | 			yield return culture;
378 | 		}
379 | 	}
380 | 
381 | 	#region IL
382 | 	private static void GenerateOpCodeValueEnum() {
383 | 		StringBuilder output = new StringBuilder();
384 | 		foreach (var fieldInfo in typeof(OpCodes).GetFields()) {
385 | 			output.Append(fieldInfo.Name).Append('=').Append(((OpCode)fieldInfo.GetValue(null)).Value).Append(',');
386 | 		}
387 | 		File.WriteAllText("output", output.ToString());
388 | 	}
389 | 	private static void GenerateOpCodeValueEnumSwitch() {
390 | 		StringBuilder output = new StringBuilder();
391 | 		foreach (var fieldInfo in typeof(OpCodes).GetFields()) {
392 | 			output.Append("case OpCodeValue.").Append(fieldInfo.Name).Append(":\n");
393 | 		}
394 | 		File.WriteAllText("output", output.ToString());
395 | 	}
396 | 	private static void GenerateOpCodes() {
397 | 		StringBuilder output = new StringBuilder();
398 | 		var fields = typeof(OpCodes).GetFields();
399 | 		var i = 0;
400 | 		var index = 0;
401 | 		var nop = fields[i].Name;
402 | 		while (true) {
403 | 			var opCode = (OpCode)fields[i].GetValue(null);
404 | 			var opCodeName = fields[i].Name;
405 | 			if (opCode.Value < 0) {
406 | 				break;
407 | 			}
408 | 			while (index < opCode.Value) {
409 | 				output.Append("OpCodes.").Append(nop).Append(",\n");
410 | 				++index;
411 | 			}
412 | 			output.Append("//").Append(opCode.Value).Append("\nOpCodes.").Append(opCodeName).Append(",\n");
413 | 			++i;
414 | 			++index;
415 | 		}
416 | 		output.Append("\n--------------------------------------------\n");
417 | 		index = 0;
418 | 		while (i < fields.Length) {
419 | 			var opCode = (OpCode)fields[i].GetValue(null);
420 | 			var opCodeName = fields[i].Name;
421 | 			while (index < 512 + opCode.Value) {
422 | 				output.Append("OpCodes.").Append(nop).Append(",\n");
423 | 				++index;
424 | 			}
425 | 			output.Append("//").Append(opCode.Value).Append("\nOpCodes.").Append(opCodeName).Append(",\n");
426 | 			++i;
427 | 			++index;
428 | 		}
429 | 		output.Append('\n');
430 | 		File.WriteAllText("output", output.ToString());
431 | 	}
432 | 	#endregion
433 | 
434 | 
435 | 	public static XmlWriter XmlLog;
436 | 	private static string LogPath;
437 | }
438 | 


--------------------------------------------------------------------------------
/Compiler/README.md:
--------------------------------------------------------------------------------
 1 | # il2js Compiler - JavaScript VM for .NET
 2 | 
 3 | ## Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This program is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | 
16 | ## This part of il2js project contains sources of il2js.exe compiler
17 | 
18 | 
19 | ## Information for contributors
20 | 
21 | By merge requests with main repository you grant non-exclusive copirights for submited sources to il2js main author. In particular you agree with possible future changes to the licence. If you don't agree for such way of merging new branch within main repository can be created for LGPL licenced version.


--------------------------------------------------------------------------------
/Framework/AUTHORS:
--------------------------------------------------------------------------------
1 | Author:
2 |   Michael Kolarz (michael.kolarz@gmail.com)
3 | 


--------------------------------------------------------------------------------
/Framework/Ajax/Attributes.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Text;
22 | 
23 | namespace MK.JavaScript.Ajax {
24 | 	/// <summary>
25 | 	/// Indicates how the method should be invoked.
26 | 	/// </summary>
27 | 	public enum RunAt : byte {
28 | 		/// <summary>
29 | 		/// Method will be invoked at client side (using standart method(args...)) notation.
30 | 		/// </summary>
31 | 		Client = 0x1,
32 | 		/// <summary>
33 | 		/// Method will be invoked at server side.
34 | 		/// It may be called either in synchronous mode (method(args...) or Server.Call(method,args...))
35 | 		/// or in asynchronous mode (Sever.AsyncCall(method,args...[,callback])).
36 | 		/// No client code except call will be generated.
37 | 		/// </summary>
38 | 		Server = 0x2,
39 | 		/// <summary>
40 | 		/// Method can be invoked at client (method(args...)
41 | 		/// or at server (Server.Call(method,args...) or Sever.AsyncCall(method,args...[,callback])).
42 | 		/// </summary>
43 | 		ClientOrServer = Client | Server,
44 | 	}
45 | 	/// <summary>
46 | 	/// By default, all methods in assembly are treat as RunAt.Client. This attriute override this.
47 | 	/// </summary>
48 | 	[global::System.AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
49 | 	public sealed class RunAtAttribute : Attribute {
50 | 		public readonly RunAt RunAt;
51 | 		public bool HideExceptionMessage;
52 | 		public RunAtAttribute(RunAt runAt) {
53 | 			this.RunAt = runAt;
54 | 		}
55 | 	}
56 | 
57 | 	///// <summary>
58 | 	///// You may assign whole class or some of it's method to module.
59 | 	///// All used methods in module will be loaded when first method of module will about to be executed. 
60 | 	///// </summary>
61 | 	//[global::System.AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
62 | 	//public sealed class ModuleAttribute : Attribute {
63 | 	//  public readonly string Name;
64 | 	//  public ModuleAttribute() {
65 | 	//    this.Name = Guid.NewGuid().ToString();
66 | 	//  }
67 | 	//  public ModuleAttribute(string name) {
68 | 	//    this.Name = name;
69 | 	//  }
70 | 	//}
71 | }
72 | 


--------------------------------------------------------------------------------
/Framework/Ajax/Module.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Linq;
22 | using System.Text;
23 | using MK.JavaScript.Reflection;
24 | 
25 | namespace MK.JavaScript.Ajax {
26 | 	/// <summary>
27 | 	/// Base class for modules.
28 | 	/// </summary>
29 | 	/// <remarks>
30 | 	/// Module's code is loaded on client when first static method or first constructor of module is called.
31 | 	/// </remarks>
32 | 	public abstract class Module {
33 | 		[JSFramework(Ignore = true)]
34 | 		protected Module() { }
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/Framework/Ajax/Serialization.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | 
 24 | 
 25 | 
 26 | namespace MK.JavaScript.Ajax.Serialization {
 27 | 	using System;
 28 | 	using System.Collections.Generic;
 29 | 	using System.Text;
 30 | 	using System.Text.RegularExpressions;
 31 | 	using System.IO;
 32 | 	using System.Diagnostics;
 33 | 	using System.Reflection;
 34 | 	using System.Runtime.Serialization;
 35 | 	using System.Web;
 36 | 	using System.Collections;
 37 | 	using MK.JavaScript.Framework;
 38 | 
 39 | 	internal class Parser {
 40 | 		////bo prototype nie ma innych whitespacesow niz ' '
 41 | 		//private void skipWhitespaces() { 
 42 | 		//  while (char.IsWhiteSpace(this.source[this.position]))
 43 | 		//  ++this.position; 
 44 | 		//}
 45 | 		private object ParseObject() {
 46 | 			switch (this.source[this.position]) {
 47 | 				case '{':
 48 | 					#region object
 49 |  {
 50 | 						Dictionary<string, object> ret = new Dictionary<string, object>();
 51 | 						++this.position;// /{/
 52 | 						if (this.source[this.position] == '}') {
 53 | 							++this.position;
 54 | 							return ret;
 55 | 						} else do {
 56 | 								var index = this.ParseString();
 57 | 								this.position += 2;// /: /
 58 | 								ret[index] = this.ParseObject();
 59 | 								switch (this.source[this.position]) {
 60 | 									case ',':
 61 | 										this.position += 2;
 62 | 										break;
 63 | 									case '}':
 64 | 										++this.position;
 65 | 										return ret;
 66 | 								}
 67 | 							} while (true);
 68 | 					}
 69 | 					#endregion
 70 | 				case '[':
 71 |  #region array
 72 |  {
 73 | 	 List<object> ret = new List<object>();
 74 | 	 ++this.position;// /\[/
 75 | 	 if (this.source[this.position] == ']') {
 76 | 		 ++this.position;
 77 | 		 return ret;
 78 | 	 } else do {
 79 | 			 ret.Add(this.ParseObject());
 80 | 			 switch (this.source[this.position]) {
 81 | 				 case ',':
 82 | 					 this.position += 2;
 83 | 					 break;
 84 | 				 case ']':
 85 | 					 ++this.position;
 86 | 					 return ret;
 87 | 			 }
 88 | 		 } while (true);
 89 |  }
 90 |  #endregion
 91 | 				case '"': return ParseString();
 92 | 				case '-':
 93 | 				case '.':
 94 | 				case '0':
 95 | 				case '1':
 96 | 				case '2':
 97 | 				case '3':
 98 | 				case '4':
 99 | 				case '5':
100 | 				case '6':
101 | 				case '7':
102 | 				case '8':
103 | 				case '9':
104 | 					#region number
105 |  {
106 | 						int length = 1;
107 | 						while (new[] { '.', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }.Contains(this.source[this.position + length])) {
108 | 							++length;
109 | 						}
110 | 						var ret = this.source.Substring(this.position, length);
111 | 						this.position += length;
112 | 						return ret;
113 | 
114 | 					}
115 | 					#endregion
116 | 				case 'n':
117 |  #region null
118 |  if (
119 | 	 this.source[this.position + 1] == 'u' &&
120 | 	 this.source[this.position + 2] == 'l' &&
121 | 	 this.source[this.position + 3] == 'l') {
122 | 	 this.position += 4;
123 | 	 return null;
124 |  } else {
125 | 	 throw new Exception(this.source.Substring(this.position));
126 |  }
127 |  #endregion
128 | 				case 't':
129 |  #region true
130 |  if (
131 | 	 this.source[this.position + 1] == 'r' &&
132 | 	 this.source[this.position + 2] == 'u' &&
133 | 	 this.source[this.position + 3] == 'e') {
134 | 	 this.position += 4;
135 | 	 return true;
136 |  } else {
137 | 	 throw new Exception(this.source.Substring(this.position));
138 |  }
139 |  #endregion
140 | 				case 'f':
141 |  #region false
142 |  if (
143 | 	 this.source[this.position + 1] == 'a' &&
144 | 	 this.source[this.position + 2] == 'l' &&
145 | 	 this.source[this.position + 3] == 's' &&
146 | 	 this.source[this.position + 4] == 'e') {
147 | 	 this.position += 5;
148 | 	 return false;
149 |  } else {
150 | 	 throw new Exception(this.source.Substring(this.position));
151 |  }
152 |  #endregion
153 | 			}
154 | 			throw new Exception("Unknown character: " + this.source[this.position] + "@" + this.position);
155 | 		}
156 | 
157 | 		private string ParseString() {
158 | 			++this.position;
159 | 			StringBuilder sb = new StringBuilder("");
160 | 			do {
161 | 				switch (this.source[this.position]) {
162 | 					case '\"':
163 | 						++this.position;
164 | 						return sb.ToString();
165 | 					case '\\':
166 | 						++this.position;
167 | 						switch (this.source[this.position]) {
168 | 							case 'n': sb.Append('\n'); break;
169 | 							case 't': sb.Append('\t'); break;
170 | 							case '"': sb.Append('"'); break;
171 | 							default:
172 | 								throw new Exception(@"\" + this.source[this.position]);
173 | 						}
174 | 						++this.position;
175 | 						break;
176 | 					default:
177 | 						sb.Append(this.source[this.position++]);
178 | 						break;
179 | 				}
180 | 			} while (true);
181 | 		}
182 | 		private string source;
183 | 		private int position;
184 | 		public object Parse(string s) {
185 | 			this.source = s;
186 | 			this.position = 0;
187 | 			return this.ParseObject();
188 | 		}
189 | 	}
190 | 
191 | 	internal interface ISerializer {
192 | 		string Serialize(object obj);
193 | 		object Deserialize(object source);
194 | 	}
195 | 	internal class NumberSerializer : ISerializer {
196 | 		private readonly MethodInfo parse;
197 | 		public NumberSerializer(Type type) {
198 | 			this.parse = type.GetMethod("Parse", new[] { typeof(string) });
199 | 		}
200 | 		string ISerializer.Serialize(object obj) { return obj.ToString().Replace(',', '.'); }
201 | 		object ISerializer.Deserialize(object source) { return this.parse.Invoke(null, new[] { source }); }
202 | 	}
203 | 	internal class BooleanSerializer : ISerializer {
204 | 		string ISerializer.Serialize(object obj) { return true.Equals(obj) ? "true" : "false"; }
205 | 		object ISerializer.Deserialize(object source) { return source; }
206 | 	}
207 | 	internal class StringSerializer : ISerializer {
208 | 		string ISerializer.Serialize(object obj) {
209 | 			if (obj == null) return "null";
210 | 			StringBuilder sb = new StringBuilder();
211 | 			sb.Append('"');
212 | 			foreach (var c in (string)obj) {
213 | 				switch (c) {
214 | 					case '\\': sb.Append(@"\\"); break;
215 | 					case '\"': sb.Append("\\\""); break;
216 | 					case '\n': sb.Append(@"\n"); break;
217 | 					case '\r': break;
218 | 					default: sb.Append(c); break;
219 | 				}
220 | 			}
221 | 			sb.Append('"');
222 | 			return sb.ToString();
223 | 		}
224 | 		object ISerializer.Deserialize(object source) { return source; }
225 | 	}
226 | 	internal class IEnumerable1Serializer : ISerializer {
227 | 		string ISerializer.Serialize(object obj) {
228 | 			if (obj == null) return "null";
229 | 			StringBuilder sb = new StringBuilder();
230 | 			sb.Append('[');
231 | 			foreach (var item in (IEnumerable)obj) {
232 | 				sb.Append(Serializer.Serialize(item)).Append(',');
233 | 			}
234 | 			if (sb.Length > 1)
235 | 				--sb.Length;
236 | 			sb.Append(']');
237 | 			return sb.ToString();
238 | 		}
239 | 		object ISerializer.Deserialize(object source) {
240 | 			var values = (List<object>)source;
241 | 			var ret = (IList)typeof(List<>).MakeGenericType(this.type).GetConstructor(Type.EmptyTypes).Invoke(null);
242 | 			foreach (var item in values) {
243 | 				ret.Add(Serializer.Deserialize(this.type, item));
244 | 			}
245 | 			return ret;
246 | 		}
247 | 		private Type type;
248 | 		public IEnumerable1Serializer(Type type) { this.type = type; }
249 | 	}
250 | 	internal class ArraySerializer : ISerializer {
251 | 		string ISerializer.Serialize(object obj) {
252 | 			if (obj == null) return "null";
253 | 			StringBuilder sb = new StringBuilder();
254 | 			sb.Append('[');
255 | 			foreach (var item in (Array)obj) {
256 | 				sb.Append(Serializer.Serialize(item)).Append(',');
257 | 			}
258 | 			if (sb.Length > 1)
259 | 				--sb.Length;
260 | 			sb.Append(']');
261 | 			return sb.ToString();
262 | 		}
263 | 		object ISerializer.Deserialize(object source) {
264 | 			var values = (List<object>)source;
265 | 			var ret = Array.CreateInstance(this.type, values.Count);
266 | 			for (int i = 0; i < values.Count; ++i) {
267 | 				ret.SetValue(Serializer.Deserialize(this.type, values[i]), i);
268 | 			}
269 | 			return ret;
270 | 		}
271 | 		private Type type;
272 | 		public ArraySerializer(Type type) { this.type = type; }
273 | 	}
274 | 	internal class IDictionary2Serializer : ISerializer {
275 | 		string ISerializer.Serialize(object obj) {
276 | 			if (obj == null) return "null";
277 | 			StringBuilder sb = new StringBuilder();
278 | 			sb.Append('{');
279 | 			foreach (DictionaryEntry item in (IDictionary)obj) {
280 | 				sb.Append(Serializer.Serialize(item.Key)).Append(':').Append(Serializer.Serialize(item.Value)).Append(',');
281 | 			}
282 | 			if (sb.Length > 1)
283 | 				--sb.Length;
284 | 			sb.Append('}');
285 | 			return sb.ToString();
286 | 		}
287 | 		object ISerializer.Deserialize(object source) {
288 | 			var values = (Dictionary<string, object>)source;
289 | 			var ret = (IDictionary)typeof(Dictionary<,>).MakeGenericType(this.keyType, this.valueType).GetConstructor(Type.EmptyTypes).Invoke(null);
290 | 			foreach (var item in values) {
291 | 				ret[Serializer.Deserialize(this.keyType, item.Key)] = Serializer.Deserialize(this.valueType, item.Value);
292 | 			}
293 | 			return ret;
294 | 		}
295 | 		private Type keyType;
296 | 		private Type valueType;
297 | 		public IDictionary2Serializer(Type keyType, Type valueType) { this.keyType = keyType; this.valueType = valueType; }
298 | 	}
299 | 	internal class ClassSerializer : ISerializer {
300 | 		private class FieldSerializer {
301 | 			public void Set(object obj, object value) {
302 | 				this.Field.SetValue(obj, value);
303 | 			}
304 | 			public object Get(object obj) {
305 | 				return this.Field.GetValue(obj);
306 | 			}
307 | 			public readonly FieldInfo Field;
308 | 			public FieldSerializer(FieldInfo field) {
309 | 				this.Field = field;
310 | 			}
311 | 		}
312 | 		private Dictionary<char, FieldSerializer> fieldSerializers = new Dictionary<char, FieldSerializer>();
313 | 
314 | 		internal char GetToken(FieldInfo fieldInfo) {
315 | 			foreach (var item in this.fieldSerializers) {
316 | 				if (item.Value.Field == fieldInfo) {
317 | 					return item.Key;
318 | 				}
319 | 			}
320 | 			return ((ClassSerializer)Serializer.GetSerializer(this.type.BaseType)).GetToken(fieldInfo);
321 | 		}
322 | 
323 | 		private readonly Type type;
324 | 		private int tokenIndex;
325 | 		public ClassSerializer(Type type) {
326 | 			this.type = type;
327 | 			//throw new Exception(type+"|"+type.BaseType);
328 | 			this.tokenIndex = type.BaseType == typeof(object) ? 0 : ((ClassSerializer)Serializer.GetSerializer(type.BaseType)).tokenIndex;
329 | 
330 | 			foreach (var field in from f in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
331 | 														where f.DeclaringType == type
332 | 														orderby f.Name
333 | 														select f) {
334 | 				var attributes = field.GetCustomAttributes(typeof(DataMemberAttribute), false);
335 | 				if (attributes.Length == 1) {
336 | 					this.fieldSerializers[Utils.Tokens[this.tokenIndex]] = new FieldSerializer(field);
337 | 				}
338 | 				++this.tokenIndex;
339 | 			}
340 | 
341 | 
342 | 			//do {
343 | 			//  foreach (var field in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) {
344 | 			//    var attrs = field.GetCustomAttributes(typeof(DataMemberAttribute), false);
345 | 			//    if (attrs.Length == 1) {
346 | 			//      var data = (DataMemberAttribute)attrs[0];
347 | 			//      this.fieldSerializers[data.Order] = new FieldSerializer(field);
348 | 			//    }
349 | 			//  }
350 | 			//  type = type.BaseType;
351 | 			//} while (type.GetCustomAttributes(typeof(DataContractAttribute), false).Length == 1);
352 | 		}
353 | 		string ISerializer.Serialize(object obj) {
354 | 			if (obj == null) return "null";
355 | 			StringBuilder sb = new StringBuilder();
356 | 			sb.Append('{');
357 | 			var serializer = this;
358 | 			while (true) {
359 | 				foreach (var item in serializer.fieldSerializers) {
360 | 					sb.Append(item.Key).Append(':');
361 | 					sb.Append(Serializer.Serialize(item.Value.Get(obj)));
362 | 					sb.Append(',');
363 | 				}
364 | 				if (serializer.type.BaseType != typeof(object)) {
365 | 					serializer = (ClassSerializer)Serializer.GetSerializer(serializer.type.BaseType);
366 | 				} else {
367 | 					break;
368 | 				}
369 | 			}
370 | 			if (sb.Length > 1)
371 | 				--sb.Length;
372 | 			sb.Append('}');
373 | 			return sb.ToString();
374 | 		}
375 | 		object ISerializer.Deserialize(object source) {
376 | 			var values = (Dictionary<string, object>)source;
377 | 			var ret = this.type.GetConstructor(Type.EmptyTypes).Invoke(null);
378 | 			foreach (var item in values) {
379 | 				FieldSerializer serializer;
380 | 				if (this.fieldSerializers.TryGetValue(item.Key[0], out serializer))
381 | 					try {
382 | 						serializer.Set(ret, Serializer.Deserialize(serializer.Field.FieldType, item.Value));
383 | 					} catch (Exception e) {
384 | 						throw new Exception("Error while setting " + serializer.Field.Name + ":\n" + e);
385 | 					}
386 | 			}
387 | 			return ret;
388 | 		}
389 | 	}
390 | 
391 | 	public static class Serializer {
392 | 		private static Dictionary<Type, ISerializer> serializers = new Dictionary<Type, ISerializer>() {
393 | 			{typeof(byte),new NumberSerializer(typeof(byte))},
394 | 			{typeof(sbyte),new NumberSerializer(typeof(sbyte))},
395 | 			{typeof(ushort),new NumberSerializer(typeof(ushort))},
396 | 			{typeof(short),new NumberSerializer(typeof(short))},
397 | 			{typeof(uint),new NumberSerializer(typeof(uint))},
398 | 			{typeof(int),new NumberSerializer(typeof(int))},
399 | 			{typeof(ulong),new NumberSerializer(typeof(ulong))},
400 | 			{typeof(long),new NumberSerializer(typeof(long))},
401 | 			{typeof(decimal),new NumberSerializer(typeof(decimal))},
402 | 			{typeof(float),new NumberSerializer(typeof(float))},
403 | 			{typeof(double),new NumberSerializer(typeof(double))},
404 | 			{typeof(string),new StringSerializer()},
405 | 			{typeof(bool),new BooleanSerializer()},
406 | 		};
407 | 		internal static ISerializer GetSerializer(Type type) {
408 | 			ISerializer ret;
409 | 			if (!serializers.TryGetValue(type, out ret)) {
410 | 				if (type.IsArray) {
411 | 					ret = new ArraySerializer(type.GetElementType());
412 | 				} else {
413 | 					if (type.Namespace == "System.Collections.Generic") {
414 | 						switch (type.Name) {
415 | 							case "IDictionary`2": {
416 | 									Type[] types = type.GetGenericArguments();
417 | 									ret = new IDictionary2Serializer(types[0], types[1]);
418 | 									goto end;
419 | 								}
420 | 							case "IEnumerable`1":
421 | 								ret = new IEnumerable1Serializer(type.GetGenericArguments()[0]);
422 | 								goto end;
423 | 						}
424 | 					}
425 | 					foreach (var i in type.GetInterfaces().OrderBy(t => t.Name)) {//orderby zeby slownik jako slownik a nie jako enumeracje key/value
426 | 						switch (i.Name) {
427 | 							case "IDictionary`2": {
428 | 									Type[] types = i.GetGenericArguments();
429 | 									ret = new IDictionary2Serializer(types[0], types[1]);
430 | 									goto end;
431 | 								}
432 | 							case "IEnumerable`1":
433 | 								ret = new IEnumerable1Serializer(i.GetGenericArguments()[0]);
434 | 								goto end;
435 | 						}
436 | 					}
437 | 					ret = new ClassSerializer(type);
438 | 				}
439 | 			end:
440 | 				serializers[type] = ret;
441 | 			}
442 | 			return ret;
443 | 		}
444 | 
445 | 		public static List<object> Deserialize(HttpContext context, params Type[] types) {
446 | 
447 | 			//      var bytes = new byte[context.Request.TotalBytes];
448 | 			//      context.Request.InputStream.Read(bytes, 0, context.Request.TotalBytes);
449 | 			//#warning to nie bedzie dzialac dla unicode character
450 | 			//      var s = new string(bytes.Select(b => (char)b).ToArray());
451 | 
452 | 			byte[] bytes = new byte[context.Request.TotalBytes];
453 | 			context.Request.InputStream.Read(bytes, 0, bytes.Length);
454 | 			var s = context.Request.ContentEncoding.GetString(bytes);
455 | 
456 | 
457 | 			var ret = (List<object>)new Parser().Parse(s);
458 | 			for (int i = 0; i < types.Length; ++i) {
459 | 				ret[i] = Deserialize(types[i], ret[i]);
460 | 			}
461 | 			//throw new Exception(string.Join(",", ret.Select(r => r.GetType().Name).ToArray()));
462 | 			return ret;
463 | 		}
464 | 		public static string Serialize(object obj) {
465 | 			if (obj == null) return "null";
466 | 			return GetSerializer(obj.GetType()).Serialize(obj);
467 | 		}
468 | 		internal static object Deserialize(Type type, object source) {
469 | 			return source == null ? null : GetSerializer(type).Deserialize(source);
470 | 		}
471 | 	}
472 | 
473 | 
474 | }
475 | 


--------------------------------------------------------------------------------
/Framework/Attributes.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Linq;
22 | using System.Text;
23 | 
24 | namespace MK.JavaScript {
25 | 	/// <summary>
26 | 	/// Marks class as Window class.
27 | 	/// </summary>
28 | 	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
29 | 	public sealed class WindowAttribute : Attribute {
30 | 		/// <summary>
31 | 		/// Indicates if html content of page should be generated using page's Render method.
32 | 		/// </summary>
33 | 		/// <remarks>
34 | 		/// If true, IL2JS will search for `protected Element Render()` or `protected IEnumerable&lt;Element> Render()` method. In this case constructor of the page must be empty!
35 | 		/// </remarks>
36 | 		/// <example>
37 | 		/// [Window("~/NotExisting.html")]
38 | 		/// public class DefaultPage : Window {
39 | 		///		protected Element Render(){
40 | 		///			return new Span { InnedHTML = "Sample content of page" };
41 | 		///		}
42 | 		/// }
43 | 		/// </example>
44 | 		public bool Render;
45 | 		/// <summary>
46 | 		/// Virtual path of page. Must starts with tilde (~).
47 | 		/// </summary>
48 | 		public readonly string Path;
49 | 		/// <param name="path">
50 | 		/// Virtual path. Must starts with tilde (~).
51 | 		/// </param>
52 | 		/// <example>
53 | 		/// <code>
54 | 		/// [Window("~/Default.aspx")]
55 | 		/// public class DefaultPage : Window {}
56 | 		/// </code>
57 | 		/// </example>
58 | 		public WindowAttribute(string path) { this.Path = path; }
59 | 		/// <summary>
60 | 		/// If true, this class used methods will be placed in top .js file, regardles of which subframe depends on it.
61 | 		/// It reduces output .js total size.
62 | 		/// </summary>
63 | 		/// <example>
64 | 		/// When method is called on two subframes if MethodsOnTop is false - code of that method (with it's dependencies) will be placed in .js files for that subframes; if MethodsOnTop is true - all codes will be placed in top .js file only.
65 | 		/// </example>
66 | 		public bool MethodsOnTop = false;
67 | 		/// <summary>
68 | 		/// All members of this type will be placed in this window .js file.
69 | 		/// </summary>
70 | 		public Type[] RunAtThis = Type.EmptyTypes;
71 | 	}
72 | 
73 | 	/// <summary>
74 | 	/// Resources listed in this attribute will be loaded at tht beginning of method/constructor call.
75 | 	/// </summary>
76 | 	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor, Inherited = false, AllowMultiple = true)]
77 | 	public sealed class LoadResourcesAttribute : Attribute {
78 | 		/// <summary>
79 | 		/// Types generated using System.Resources.Tools.StronglyTypedResourceBuilder.
80 | 		/// </summary>
81 | 		public readonly Type[] ResourceTypes;
82 | 		/// <param name="resourceTypes">Types generated using System.Resources.Tools.StronglyTypedResourceBuilder.</param>
83 | 		public LoadResourcesAttribute(params Type[] resourceTypes) {
84 | 			this.ResourceTypes = resourceTypes;
85 | 		}
86 | 	}
87 | }
88 | 


--------------------------------------------------------------------------------
/Framework/Core.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Linq;
22 | using System.Text;
23 | using MK.JavaScript.Reflection;
24 | 
25 | namespace MK.JavaScript.Core {
26 | 	[JSNative]
27 | 	public class Image {
28 | 		[JSNative]
29 | 		public Image() { }
30 | 		[JSNative]
31 | 		public string Src;
32 | 	}
33 | }
34 | 


--------------------------------------------------------------------------------
/Framework/Extensions.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Collections;
22 | using MK.JavaScript.Reflection;
23 | namespace MK.JavaScript {
24 | 	/// <summary>
25 | 	/// Extensions of <value>object</value>.
26 | 	/// </summary>
27 | 	public static class Extensions {
28 | 		/// <summary>
29 | 		/// Treats self as <value>Dictionary&lt;string,<typeparamref name="T"/>></value>.
30 | 		/// </summary>
31 | 		/// <param name="self">
32 | 		/// Any JavaScript object.
33 | 		/// </param>
34 | 		/// <typeparam name="T">
35 | 		/// Any type.
36 | 		/// </typeparam>
37 | 		/// <returns><paramref name="self"/> as <value>Dictionary&lt;string,<typeparamref name="T"/>></value>.</returns>
38 | 		/// <remarks>
39 | 		/// Some browsers (like IE) doesn't supports delete operator for DOM elements, so avoid calling <value>aDomElement.AsDictionary&lt;<typeparamref name="T"/>>().Remove(aTKey)</value>.
40 | 		/// <value>1</value>, <value>true</value>, <value>"abc"</value> are not JavaScript objects.
41 | 		/// </remarks>
42 | 		[JSNative(Ignore = true)]
43 | 		public static Dictionary<string, T> AsDictionary<T>(this object self) {  throw new InvalidOperationException(JS.CannotRunAtServer); }
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/Framework/JS Global.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Text;
22 | using MK.JavaScript.Reflection;
23 | using MK.JavaScript.Framework;
24 | namespace MK.JavaScript {
25 | 	/// <summary>
26 | 	/// JavaScript global context class.
27 | 	/// </summary>
28 | 	public abstract class JS {
29 | 
30 | 		internal const string CannotRunAtServer = "This method cannot be called ad server side.";
31 | 
32 | 		/// <summary>
33 | 		/// Evaluates JavaScript code.
34 | 		/// <remarks>
35 | 		/// </remarks>
36 | 		/// Avoid situation when You expect return value of primitive type (number, boolean) and use T=Object with cast on primitive type.
37 | 		/// It should works but note that in JavaScript <value>eval("1")!==new Number(1)</value> but <value>eval("1")===1</value>.
38 | 		/// Framework may handle this but it wasn't good tested yet.
39 | 		/// </summary>
40 | 		[Obsolete("Some constructions, like int x=(int)JS.Eval<object>(\"1\"), may fails. See Remarks for details.")]
41 | 		[JSNative(GlobalMethod = true)]
42 | 		public static T Eval<T>(string value) { throw new InvalidOperationException(JS.CannotRunAtServer); }
43 | 		[JSNative(GlobalMethod = true)]
44 | 		public static bool IsNaN(int value) { throw new InvalidOperationException(JS.CannotRunAtServer); }
45 | 		[JSNative(GlobalMethod = true)]
46 | 		public static bool IsNaN(double value) { throw new InvalidOperationException(JS.CannotRunAtServer); }
47 | 		[JSNative(GlobalMethod = true)]
48 | 		public static string Escape(string value) { throw new InvalidOperationException(JS.CannotRunAtServer); }
49 | 		[JSNative(GlobalMethod = true)]
50 | 		public static string Unescape(string value) { throw new InvalidOperationException(JS.CannotRunAtServer); }
51 | 
52 | 		/// <summary>
53 | 		/// Accepts an array-like collection (anything with numeric indices) and returns its equivalent as an actual Array object. This method is a convenience alias of Array.from, but is the preferred way of casting to an Array.
54 | 		/// </summary>
55 | 		[PrototypeJS("$A", GlobalMethod = true)]
56 | 		public static T[] _A<T>(IEnumerable<T> value) { throw new InvalidOperationException(JS.CannotRunAtServer); }
57 | 
58 | 		/// <summary>
59 | 		/// Identity. Use this method to wrap result of two integers division.
60 | 		/// </summary>
61 | 		/// <remarks>
62 | 		/// This method is because in JavaScript there is no different types for integers and floats.
63 | 		/// In particular <c>(1/2)!=0</c> but <c>(1/2)==0.5</c>.
64 | 		/// </remarks>
65 | 		/// <param name="value">Result of two integers division</param>
66 | 		/// <returns>parseInt(<paramref name="value"/>)</returns>
67 | 		[JSNative("parseInt", GlobalMethod = true)]
68 | 		public static int Int(int value) { return value; }
69 | 
70 | 
71 | 		/// <summary>
72 | 		/// Client-side wrapper to creating an IEnumerable&lt;> that supports System.Linq.Enumerable methods.
73 | 		/// </summary>
74 | 		/// <remarks>This method cannot be called ad server-side.</remarks>
75 | 		/// <typeparam name="T"></typeparam>
76 | 		/// <param name="source"></param>
77 | 		/// <returns>JavaScript list.</returns>
78 | 		public static IEnumerable<T> IEnumerable<T>(IEnumerable<T> source) {
79 | 			//if (PrototypeJs._Object.IsArray(source)) {
80 | 			//  return (List<T>)source;
81 | 			//} else 
82 | 			{
83 | 				var value = new List<T>();
84 | 				foreach (var item in source) {
85 | 					value.Add(item);
86 | 				}
87 | 				return value;
88 | 			}
89 | 		}
90 | 	}
91 | }
92 | 


--------------------------------------------------------------------------------
/Framework/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("Framework")]
 9 | [assembly: AssemblyDescription("il2js framework assembly")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("mkol@smp.if.uj.edu.pl")]
12 | [assembly: AssemblyProduct("Framework")]
13 | [assembly: AssemblyCopyright("Copyright © mkol@smp.if.uj.edu.pl 2008")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("cc706972-7185-4a34-a3e7-05631cc5edd7")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/Framework/README.md:
--------------------------------------------------------------------------------
 1 | # il2js Framework.dll - JavaScript VM for .NET
 2 | 
 3 | ## Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | 
16 | ## This part of il2js project contains sources of Framework.dll
17 | 
18 | 
19 | ## Information for contributors
20 | 
21 | By merge requests with main repository you grant non-exclusive copirights for submited sources to il2js main author. In particular you agree with possible future changes to the licence. If you don't agree for such way of merging new branch within main repository can be created for LGPL licenced version.


--------------------------------------------------------------------------------
/Framework/System.Runtime.Serialization.DataMemberAttribute [mock].cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | //#define MONO
 20 | #if MONO
 21 | 
 22 | namespace System.Runtime.Serialization {
 23 | 
 24 | 	// Summary:
 25 | 	//     Specifies that the type defines or implements a data contract and is serializable
 26 | 	//     by a serializer, such as the System.Runtime.Serialization.DataContractSerializer.
 27 | 	//     To make their type serializable, type authors must define a data contract
 28 | 	//     for their type.
 29 | 	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, Inherited = false, AllowMultiple = false)]
 30 | 	public sealed class DataContractAttribute : Attribute {
 31 | 		// Summary:
 32 | 		//     Initializes a new instance of the System.Runtime.Serialization.DataContractAttribute
 33 | 		//     class.
 34 | 		public DataContractAttribute() { }
 35 | 
 36 | 		// Summary:
 37 | 		//     Gets or sets a value that indicates whether to preserve object reference
 38 | 		//     data.
 39 | 		//
 40 | 		// Returns:
 41 | 		//     true to keep object reference data using standard XML; otherwise, false.
 42 | 		//     The default is false.
 43 | 		public bool IsReference { get; set; }
 44 | 		//
 45 | 		// Summary:
 46 | 		//     Gets or sets the name of the data contract for the type.
 47 | 		//
 48 | 		// Returns:
 49 | 		//     The local name of a data contract. The default is the name of the class that
 50 | 		//     the attribute is applied to.
 51 | 		public string Name { get; set; }
 52 | 		//
 53 | 		// Summary:
 54 | 		//     Gets or sets the namespace for the data contract for the type.
 55 | 		//
 56 | 		// Returns:
 57 | 		//     The namespace of the contract.
 58 | 		public string Namespace { get; set; }
 59 | 	}
 60 | 
 61 | 
 62 | 	// Summary:
 63 | 	//     When applied to the member of a type, specifies that the member is part of
 64 | 	//     a data contract and is serializable by the System.Runtime.Serialization.DataContractSerializer.
 65 | 	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, Inherited = false, AllowMultiple = false)]
 66 | 	public sealed class DataMemberAttribute : Attribute {
 67 | 		// Summary:
 68 | 		//     Initializes a new instance of the System.Runtime.Serialization.DataMemberAttribute
 69 | 		//     class.
 70 | 		public DataMemberAttribute() { }
 71 | 
 72 | 		// Summary:
 73 | 		//     Gets or sets a value that specifies whether to serialize the default value
 74 | 		//     for a field or property being serialized.
 75 | 		//
 76 | 		// Returns:
 77 | 		//     true if the default value for a member should be generated in the serialization
 78 | 		//     stream; otherwise, false. The default is true.
 79 | 		public bool EmitDefaultValue { get; set; }
 80 | 		//
 81 | 		// Summary:
 82 | 		//     Gets or sets a value that instructs the serialization engine that the member
 83 | 		//     must be present when reading or deserializing.
 84 | 		//
 85 | 		// Returns:
 86 | 		//     true, if the member is required; otherwise, false.
 87 | 		//
 88 | 		// Exceptions:
 89 | 		//   System.Runtime.Serialization.SerializationException:
 90 | 		//     the member is not present.
 91 | 		public bool IsRequired { get; set; }
 92 | 		//
 93 | 		// Summary:
 94 | 		//     Gets or sets a data member name.
 95 | 		//
 96 | 		// Returns:
 97 | 		//     The name of the data member. The default is the name of the target that the
 98 | 		//     attribute is applied to.
 99 | 		public string Name { get; set; }
100 | 		//
101 | 		// Summary:
102 | 		//     Gets or sets the order of serialization and deserialization of a member.
103 | 		//
104 | 		// Returns:
105 | 		//     The numeric order of serialization or deserialization.
106 | 		public int Order { get; set; }
107 | 	}
108 | }
109 | 
110 | #endif


--------------------------------------------------------------------------------
/Framework/Tools.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using System.Globalization;
 24 | using System.IO;
 25 | using System.Resources;
 26 | using System.Reflection;
 27 | using MK.JavaScript.Ajax.Serialization;
 28 | using System.Text.RegularExpressions;
 29 | using MK.JavaScript.Css;
 30 | using MK.JavaScript.Dom;
 31 | using System.Runtime.Serialization;
 32 | 
 33 | namespace MK.JavaScript.Compiler {
 34 | 	/// <summary>
 35 | 	/// Utility class for creating css.
 36 | 	/// </summary>
 37 | 	public static class CssWriter {
 38 | 		private static FieldInfo fieldInfo = typeof(Style).GetField("_values", BindingFlags.Instance | BindingFlags.NonPublic);
 39 | 		private static string dasherize(string str) {
 40 | 			return new Regex(@"[A-Z]", RegexOptions.Compiled).Replace(str, m => {
 41 | 				return "-" + char.ToLower(m.Value[0]);
 42 | 			});
 43 | 		}
 44 | 		internal static void append(Style style, StringBuilder sb) {
 45 | 			int tmp = sb.Length;
 46 | 			foreach (var entry in (Dictionary<string, string>)fieldInfo.GetValue(style)) {
 47 | 				sb.Append(dasherize(entry.Key)).Append(':').Append(entry.Value).Append(';');
 48 | #if FORMAT
 49 | 					sb.Append('\n');
 50 | #endif
 51 | 			}
 52 | 			if (sb.Length != tmp)
 53 | 				--sb.Length;
 54 | #if FORMAT
 55 | 				sb.Append('\n');
 56 | #endif
 57 | 		}
 58 | 		private static void append(IEnumerable<Rule> rules, StringBuilder sb) {
 59 | 			foreach (var rule in rules) {
 60 | 				sb.Append(rule.Selector);
 61 | 				sb.Append('{');
 62 | #if FORMAT
 63 | 					sb.Append('\n');
 64 | #endif
 65 | 				append(rule.Style, sb);
 66 | 				sb.Append('}');
 67 | #if FORMAT
 68 | 					sb.Append('\n');
 69 | #endif
 70 | 			}
 71 | 		}
 72 | 
 73 | 		public static void Write(string outputPath, IEnumerable<Type> styleSheetTypes) {
 74 | 			StringBuilder sb = new StringBuilder();
 75 | 			foreach (var type in styleSheetTypes) {
 76 | 				append(((StyleSheet)type.GetConstructor(Type.EmptyTypes).Invoke(null)).GetRules(), sb);
 77 | 			}
 78 | 			File.WriteAllText(outputPath, sb.ToString());
 79 | 		}
 80 | 	}
 81 | 	/// <summary>
 82 | 	/// Utility class fof creating html.
 83 | 	/// </summary>
 84 | 	public static class HtmlWriter {
 85 | 		private const string idPrefix = "__";
 86 | 		private const string classPrefix = "__";
 87 | 
 88 | 		//private static string content(Element element) {
 89 | 		//  StringBuilder sb = new StringBuilder();
 90 | 		//  element.append(sb);
 91 | 		//  return sb.ToString();
 92 | 		//}
 93 | 
 94 | 
 95 | 		private static void gather(Dictionary<Style, string> css, IEnumerable<Element> elements) {
 96 | 			foreach (var element in elements) {
 97 | 				if (element.Style != null) {
 98 | 					string className;
 99 | 					if (!css.TryGetValue(element.Style, out className)) {
100 | 						className = classPrefix + css.Count.ToString("x");
101 | 						css[element.Style] = className;
102 | 					}
103 | 					if (element.ClassName == null) {
104 | 						element.ClassName = className;
105 | 					} else {
106 | 						element.ClassName += " " + className;
107 | 					}
108 | 				}
109 | 				gather(css, element.elements);
110 | 			}
111 | 		}
112 | 
113 | 		/// <summary>
114 | 		/// Creates page using Render method.
115 | 		/// </summary>
116 | 		/// <param name="path">Page path.</param>
117 | 		/// <param name="windowType">Page type.</param>
118 | 		public static void Write(string path, string prototypeJsPath, Type windowType) {
119 | 			var window = (Window)windowType.GetConstructor(Type.EmptyTypes).Invoke(null);
120 | 
121 | 			var render = windowType.GetMethod("Render", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
122 | 
123 | 			Element[] elements;
124 | 			if (render.ReturnType == typeof(Element)) {
125 | 				elements = new Element[] { (Element)render.Invoke(window, null) };
126 | 			} else {
127 | 				elements = ((IEnumerable<Element>)render.Invoke(window, null)).ToArray();
128 | 			}
129 | 			#region css
130 | 			Dictionary<Style, string> css = new Dictionary<Style, string>();
131 | 			gather(css, elements);
132 | 			#endregion
133 | 			#region binding
134 | 			int bindingsCount = 0;
135 | 			Dictionary<char, string> bindings = new Dictionary<char, string>();
136 | 			var serializer = (ClassSerializer)Serializer.GetSerializer(windowType);
137 | 			foreach (var fieldInfo in windowType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy).Where(
138 | 				f => {
139 | 					var type = f.FieldType.IsArray ? f.FieldType.GetElementType() : f.FieldType;
140 | 					return type == typeof(Element) || type.IsSubclassOf(typeof(Element));
141 | 				})) {
142 | 				if (fieldInfo.FieldType.IsArray) {
143 | 					var array = (Element[])fieldInfo.GetValue(window);
144 | 					if (array != null) {
145 | 						var attributes = fieldInfo.GetCustomAttributes(typeof(DataMemberAttribute), false);
146 | 						if (attributes.Length != 1) {
147 | 							throw new Exception("Field " + windowType.FullName + "::" + fieldInfo.Name + " cannot be set in Render method because it is not marked as DataMember.");
148 | 						}
149 | 						bindings[serializer.GetToken(fieldInfo)] = "[" + string.Join(",", array.Select(element => {
150 | 							if (element == null) return "null";
151 | 
152 | 							if (element.Id == null) {
153 | 								element.Id = idPrefix + (bindingsCount++).ToString("x");
154 | 
155 | 							}
156 | 							return "\"" + element.Id + "\"";
157 | 						}).ToArray()) + "]";
158 | 					}
159 | 				} else {
160 | 					var element = (Element)fieldInfo.GetValue(window);
161 | 					if (element != null) {
162 | 						var attributes = fieldInfo.GetCustomAttributes(typeof(DataMemberAttribute), false);
163 | 						if (attributes.Length != 1) {
164 | 							throw new Exception("Field " + windowType.FullName + "::" + fieldInfo.Name + " cannot be set in Render method because it is not marked as DataMember.");
165 | 						}
166 | 
167 | 						if (element.Id == null) {
168 | 							element.Id = idPrefix + (bindingsCount++).ToString("x");
169 | 						}
170 | 						bindings[serializer.GetToken(fieldInfo)] = "\"" + element.Id + "\"";
171 | 					}
172 | 				}
173 | 			}
174 | 			#endregion
175 | 			#region render
176 | 			var sb = new StringBuilder();
177 | 			sb.Append(
178 | @"<!DOCTYPE html PUBLIC ""-//W3C//DTD XHTML 1.0 Transitional//EN"" ""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd""><html xmlns=""http://www.w3.org/1999/xhtml""><!--page generated by il2js--><head><title>").Append(window.Document.Title).Append(@"</title><script type=""text/javascript"" src=""").Append(prototypeJsPath).Append(@"""></script>");
179 | 			if (css.Count != 0) {
180 | 				sb.Append(@"<link type=""text/css"" rel=""stylesheet""  href=""").Append(Path.GetFileName(path)).Append(".css\" />");
181 | 				var sbCss = new StringBuilder();
182 | 				foreach (var item in css) {
183 | 					sbCss.Append('.').Append(item.Value).Append('{');
184 | 					CssWriter.append(item.Key, sbCss);
185 | 					sbCss.Append('}');
186 | 				}
187 | 				File.WriteAllText(path + ".css", sbCss.ToString());
188 | 			}
189 | 			if (bindings.Count != 0) {
190 | 				sb.Append(@"<script type=""text/javascript"">function __(){document.observe(""dom:loaded"",function(x,y){x={")
191 | 					.Append(string.Join(",", bindings.Select(b => "\"" + b.Key + "\":" + b.Value).ToArray()))
192 | 					.Append("};for(y in x)window[y]=$.apply(0,Object.isArray(x[y])?x[y]:[x[y]])})};if(!Prototype.Browser.IE)__()</script>");
193 | 
194 | 			}
195 | 			sb.Append("<!--powered by il2js framework (http://smp.if.uj.edu.pl/~mkol/il2js)--><!--/il2js-->");
196 | 			if (bindings.Count != 0) {
197 | 				sb.Append(@"<script type=""text/javascript"">;if(Prototype.Browser.IE)__()</script>");
198 | 
199 | 			}
200 | 			sb.Append("</head><body>");
201 | 			foreach (var element in elements) {
202 | 				element.append(sb);
203 | 			}
204 | 			sb.Append(@"</body></html>");
205 | 			File.WriteAllText(path, sb.ToString());
206 | 			#endregion
207 | 		}
208 | 	}
209 | 
210 | 	/// <summary>
211 | 	/// Utility class for creating resources.
212 | 	/// </summary>
213 | 	public class ResourceWriter {
214 | 		private readonly IEnumerable<CultureInfo> cultures;
215 | 		private readonly List<KeyValuePair<Type, IEnumerable<string>>> resources = new List<KeyValuePair<Type, IEnumerable<string>>>();
216 | 		public ResourceWriter(IEnumerable<CultureInfo> cultures) {
217 | 			this.cultures = cultures;
218 | 		}
219 | 		/// <summary>
220 | 		/// Adds resource to list of resources.
221 | 		/// </summary>
222 | 		/// <param name="resource">Resource type</param>
223 | 		/// <param name="members">Members to serialize</param>
224 | 		public void AddResource(Type resource, IEnumerable<string> members) {
225 | 			this.resources.Add(new KeyValuePair<Type, IEnumerable<string>>(resource, members));
226 | 		}
227 | 		/// <summary>
228 | 		/// Writes resource files for web pages.
229 | 		/// </summary>
230 | 		/// <param name="outputPath">Output path for Resources.aspx.</param>
231 | 		/// <param name="fileName">Resources.aspx file name.</param>
232 | 		public void Write(string outputPath, string fileName) {
233 | 			File.WriteAllText(outputPath + Path.DirectorySeparatorChar + fileName,
234 | @"<%@ Page Language=""C#"" ContentType=""text/plain"" %><%
235 | 	var a = this.Request.QueryString[0].Split(',');
236 | 	if (a.Length == 1) {
237 | 		this.Response.Write(this.GetLocalResourceObject(a[0]));
238 | 	} else {
239 | 		this.Response.Write('[');
240 | 		this.Response.Write(this.GetLocalResourceObject(a[0]));
241 | 		for (int i = 1; i < a.Length; ++i) {
242 | 			this.Response.Write(',');
243 | 			this.Response.Write(this.GetLocalResourceObject(a[i]));
244 | 		}
245 | 		this.Response.Write(']');
246 | 	}
247 | %>");
248 | 
249 | 			Directory.CreateDirectory(outputPath + Path.DirectorySeparatorChar + "App_LocalResources");
250 | 
251 | 			this.write(outputPath + Path.DirectorySeparatorChar + "App_LocalResources" + Path.DirectorySeparatorChar + fileName + ".resx", CultureInfo.InvariantCulture);
252 | 			foreach (var culture in this.cultures) {
253 | 				this.write(outputPath + Path.DirectorySeparatorChar + "App_LocalResources" + Path.DirectorySeparatorChar + fileName + "." + culture.Name + ".resx", culture);
254 | 			}
255 | 		}
256 | 
257 | 		private void write(string output, CultureInfo culture) {
258 | 			ResXResourceWriter writer = new ResXResourceWriter(output);
259 | 			for (int i = 0; i < this.resources.Count; ++i) {
260 | 				this.resources[i].Key
261 | 					.GetProperty("Culture", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)
262 | 					.SetValue(null, culture, null);
263 | 				writer.AddResource(
264 | 					i.ToString(),
265 | 					Serializer.Serialize(
266 | 						this.resources[i].Value.Select(member => this.resources[i].Key.GetProperty(member, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static).GetValue(null, null))));
267 | 			}
268 | 			writer.Close();
269 | 		}
270 | 	}
271 | }
272 | 


--------------------------------------------------------------------------------
/Framework/Window - modules.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using MK.JavaScript.Reflection;
 24 | 
 25 | namespace MK.JavaScript {
 26 | 	partial class Window {
 27 | 		/// <summary>
 28 | 		/// Dynamically adds CSS StyleSheet to the window.
 29 | 		/// </summary>
 30 | 		/// <param name="uri">A CSS StyleSheet URI (may be relative wrt. <c>this</c> page).</param>
 31 | 		[JSNative(CallType = NativeCallType.Static, Code = @"
 32 | function(x,y,z){
 33 | 	if(x.$links$===undefined)
 34 | 		x.$links$={};
 35 | 	else if(x.$links$[y])
 36 | 		return;
 37 | 	x.$links$[y]=1;
 38 | 	z=new Element('link');
 39 | 	z.href=y;
 40 | 	z.rel='stylesheet';
 41 | 	z.type='text/css';
 42 | 	x.document.body.previousSibling.appendChild(z);
 43 | }
 44 | ")]
 45 | 		public void AddCssStylesheet(string uri) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 46 | 
 47 | 		#region Export
 48 | 		/// <summary>
 49 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
 50 | 		/// </summary>
 51 | 		/// <param name="name">A JavaScript identifier.</param>
 52 | 		/// <param name="method">A method.</param>
 53 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
 54 | 		public void Export(string name, Action method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 55 | 		/// <summary>
 56 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
 57 | 		/// </summary>
 58 | 		/// <param name="name">A JavaScript identifier.</param>
 59 | 		/// <param name="method">A method.</param>
 60 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
 61 | 		public void Export<T>(string name, Action<T> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 62 | 		/// <summary>
 63 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
 64 | 		/// </summary>
 65 | 		/// <param name="name">A JavaScript identifier.</param>
 66 | 		/// <param name="method">A method.</param>
 67 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
 68 | 		public void Export<T1, T2>(string name, Action<T1, T2> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 69 | 		/// <summary>
 70 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
 71 | 		/// </summary>
 72 | 		/// <param name="name">A JavaScript identifier.</param>
 73 | 		/// <param name="method">A method.</param>
 74 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
 75 | 		public void Export<T1, T2, T3>(string name, Action<T1, T2, T3> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 76 | 		/// <summary>
 77 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
 78 | 		/// </summary>
 79 | 		/// <param name="name">A JavaScript identifier.</param>
 80 | 		/// <param name="method">A method.</param>
 81 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
 82 | 		public void Export<T1, T2, T3, T4>(string name, Action<T1, T2, T3, T4> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 83 | 
 84 | 		/// <summary>
 85 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
 86 | 		/// </summary>
 87 | 		/// <param name="name">A JavaScript identifier.</param>
 88 | 		/// <param name="method">A method.</param>
 89 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
 90 | 		public void Export<TResult>(string name, Func<TResult> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 91 | 		/// <summary>
 92 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
 93 | 		/// </summary>
 94 | 		/// <param name="name">A JavaScript identifier.</param>
 95 | 		/// <param name="method">A method.</param>
 96 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
 97 | 		public void Export<T, TResult>(string name, Func<T, TResult> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 98 | 		/// <summary>
 99 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
100 | 		/// </summary>
101 | 		/// <param name="name">A JavaScript identifier.</param>
102 | 		/// <param name="method">A method.</param>
103 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
104 | 		public void Export<T1, T2, TResult>(string name, Func<T1, T2, TResult> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
105 | 		/// <summary>
106 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
107 | 		/// </summary>
108 | 		/// <param name="name">A JavaScript identifier.</param>
109 | 		/// <param name="method">A method.</param>
110 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
111 | 		public void Export<T1, T2, T3, TResult>(string name, Func<T1, T2, T3, TResult> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
112 | 		/// <summary>
113 | 		/// Binds JavaScript global method identifier to a method making method available from inline JavaScripts.
114 | 		/// </summary>
115 | 		/// <param name="name">A JavaScript identifier.</param>
116 | 		/// <param name="method">A method.</param>
117 | 		[JSNative(CallType = NativeCallType.Static, Code = @"function(_,a,b){_[a]=$handler$(b)}")]
118 | 		public void Export<T1, T2, T3, T4, TResult>(string name, Func<T1, T2, T3, T4, TResult> method) { throw new InvalidOperationException(JS.CannotRunAtServer); }
119 | 		#endregion
120 | 	}
121 | }
122 | 


--------------------------------------------------------------------------------
/Framework/Window.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | 
 20 | using System;
 21 | using System.Collections.Generic;
 22 | using System.Xml.Linq;
 23 | using System.Text;
 24 | using System.Reflection;
 25 | using System.Text.RegularExpressions;
 26 | using MK.JavaScript.Dom;
 27 | using PrototypeJs;
 28 | using MK.JavaScript.Reflection;
 29 | using System.Linq;
 30 | 
 31 | namespace MK.JavaScript {
 32 | 
 33 | 
 34 | 	public class Location {
 35 | 		[JSNative("search")]
 36 | 		public readonly string QueryString;
 37 | 		[JSNative("pathname")]
 38 | 		public readonly string Path;
 39 | 
 40 | 		public string Href { [Get] get; [Set] set; }
 41 | 		private Location() { }
 42 | 	}
 43 | 	public class Document {
 44 | 
 45 | 		public string Title { [Get] get; [Set] set; }
 46 | 		public string Cookie { [Get] get; [Set] set; }
 47 | 
 48 | 
 49 | 		public Element Body { [Get] get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
 50 | 		public Element[] Links { [Get] get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
 51 | 
 52 | 		[JSNative]
 53 | 		public Element[] GetElementsByTagName(string tagName) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 54 | 
 55 | 		internal Document() { }
 56 | 	}
 57 | 	/// <summary>
 58 | 	/// JavaScript event's data.
 59 | 	/// </summary>
 60 | 	public class JSEventArgs {
 61 | 		#region PrototypeJS: Event (prototypejs.org/api/event.html)
 62 | 		/// <summary>
 63 | 		/// Returns the DOM element on which the event occurred.
 64 | 		/// </summary>
 65 | 		public Element Element { [PrototypeJS("element")]get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
 66 | 		/// <summary>
 67 | 		/// Returns the absolute horizontal position for a mouse event.
 68 | 		/// </summary>
 69 | 		public int PointerX { [PrototypeJS("pointerX")]get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
 70 | 		/// <summary>
 71 | 		/// Returns the absolute vertical position for a mouse event.
 72 | 		/// </summary>
 73 | 		public int PointerY { [PrototypeJS("pointerY")]get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
 74 | 		#endregion
 75 | 		[JSNative]
 76 | 		public int Which;
 77 | 		[JSNative]
 78 | 		public KeyCode KeyCode;
 79 | 	}
 80 | 	/// <summary>
 81 | 	/// Represents the method that will handle an JavaScript event.
 82 | 	/// </summary>
 83 | 	/// <param name="args">JavaScript event.</param>
 84 | 	public delegate void JSEventHandler(JSEventArgs args);
 85 | 
 86 | 	/// <summary>
 87 | 	/// Window (page) class.
 88 | 	/// </summary>
 89 | 	//[JSNative]
 90 | 	public abstract partial class Window : JS {
 91 | 		#region to dawniej bylo w _window....
 92 | 		[JSNative(GlobalMethod = true)]
 93 | 		public static void Alert(string message) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 94 | 		[JSNative(GlobalMethod = true)]
 95 | 		public static string Prompt(string message) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 96 | 		[JSNative(GlobalMethod = true)]
 97 | 		public static string Prompt(string message, string defaultValue) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 98 | 		[JSNative(GlobalMethod = true)]
 99 | 		public static Window Open(String url) { throw new InvalidOperationException(JS.CannotRunAtServer); }
100 | 		[JSNative(GlobalMethod = true)]
101 | 		public static Window Open(String url, String name) { throw new InvalidOperationException(JS.CannotRunAtServer); }
102 | 		[JSNative(GlobalMethod = true)]
103 | 		public static Window Open(String url, String name, String features) { throw new InvalidOperationException(JS.CannotRunAtServer); }
104 | 		[JSNative(GlobalMethod = true)]
105 | 		public static Window Open(String url, String name, String features, Boolean replace) { throw new InvalidOperationException(JS.CannotRunAtServer); }
106 | 		/// <remarks>
107 | 		/// This method is obsolote. Instead of <c>Window.SetTimeout(func,timeout)</c>, use
108 | 		/// <code>
109 | 		/// new Thread(()=>{
110 | 		///		Thread.Sleep(timeout);
111 | 		///		func();
112 | 		/// }).Start();
113 | 		/// </code>
114 | 		/// </remarks>
115 | 		[Obsolete("See remarks.")]
116 | 		[JSNative(Code = "setTimeout($handler$($0),$1)", GlobalMethod = true)]
117 | 		public static int SetTimeout(Action func, int timeout) { throw new InvalidOperationException(JS.CannotRunAtServer); }
118 | 		/// <remarks>
119 | 		/// This method is obsolote. Instead of <c>Window.SetInterval(func,timeout)</c>, use
120 | 		/// <code>
121 | 		/// new Thread(() => {
122 | 		///		while (true) {
123 | 		///			Thread.Sleep(timeout);
124 | 		///			func();
125 | 		///		}
126 | 		/// }).Start();
127 | 		/// </code>
128 | 		/// </remarks>
129 | 		[Obsolete("See remarks.")]
130 | 		[JSNative(Code = "setInterval($handler$($0),$1)", GlobalMethod = true)]
131 | 		public static int SetInterval(Action func, int interval) { throw new InvalidOperationException(JS.CannotRunAtServer); }
132 | 		/// <remarks>
133 | 		/// This method is obsolote. Instead of 
134 | 		/// <code>
135 | 		/// var id=Window.SetTimeout(func,timeout);
136 | 		/// //...
137 | 		/// Window.ClearTimeout(id);
138 | 		/// </code>
139 | 		/// use
140 | 		/// <code>
141 | 		/// var thread=new Thread(()=>{
142 | 		///		Thread.Sleep(timeout);
143 | 		///		func();
144 | 		/// };
145 | 		/// thread.Start();
146 | 		/// //...
147 | 		/// thread.Abort();
148 | 		/// </code>
149 | 		/// </remarks>
150 | 		[Obsolete("See remarks.")]
151 | 		[JSNative(GlobalMethod = true)]
152 | 		public static void ClearTimeout(int timeout) { throw new InvalidOperationException(JS.CannotRunAtServer); }
153 | 		/// <remarks>
154 | 		/// This method is obsolote. Instead of 
155 | 		/// <code>
156 | 		/// var id=Window.SetInterval(func,timeout);
157 | 		/// //...
158 | 		/// Window.ClearInterval(id);
159 | 		/// </code>
160 | 		/// use
161 | 		/// <code>
162 | 		/// var thread=new Thread(()=>{
163 | 		///		while(true){
164 | 		///			Thread.Sleep(timeout);
165 | 		///			func();
166 | 		///		}
167 | 		/// };
168 | 		/// thread.Start();
169 | 		/// //...
170 | 		/// thread.Abort();
171 | 		/// </code>
172 | 		/// </remarks>
173 | 		[Obsolete("See remarks.")]
174 | 		[JSNative(GlobalMethod = true)]
175 | 		public static void ClearInterval(int timeout) { throw new InvalidOperationException(JS.CannotRunAtServer); }
176 | 
177 | 		[JSNative]
178 | 		public static readonly Window Top;
179 | 
180 | 		/// <summary>
181 | 		/// Returns the passed element. Element returned by the function is extended with Prototype DOM extensions.
182 | 		/// </summary>
183 | 		[PrototypeJS("$", GlobalMethod = true)]
184 | 		public static T _<T>(T element) where T : Element { throw new InvalidOperationException(JS.CannotRunAtServer); }
185 | 		#endregion
186 | 
187 | 		public string Title {
188 | 			[Inline]
189 | 			get { return this.Document.Title; }
190 | 			set { this.Document.Title = value; }
191 | 		}
192 | 
193 | 		/// <summary>
194 | 		/// Returns the element in the document with matching ID. Element returned by the function is extended with Prototype DOM extensions.
195 | 		/// </summary>
196 | 		[PrototypeJS("$")]
197 | 		public Element _(string id) { throw new InvalidOperationException(JS.CannotRunAtServer); }
198 | 		/// <summary>
199 | 		/// Returns the element in the document with matching ID. Element returned by the function is extended with Prototype DOM extensions.
200 | 		/// </summary>
201 | 		[PrototypeJS("$")]
202 | 		public T _<T>(string id) where T : Element { throw new InvalidOperationException(JS.CannotRunAtServer); }
203 | 		#region PrototypeJS: Utility (prototypejs.org/api/utility.html)
204 | 		/// <summary>
205 | 		/// Takes an arbitrary number of CSS selectors (strings) and returns a document-order array of extended DOM elements that match any of them.
206 | 		/// </summary>
207 | 		[PrototypeJS("$$")]
208 | 		public Element[] __(params string[] cssRule) { throw new InvalidOperationException(JS.CannotRunAtServer); }
209 | 		#endregion
210 | 
211 | 
212 | 		public Window Parent { [Get] get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
213 | 		public Dictionary<string, Window> Frames { [Get] get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
214 | 		public Location Location { [Get] get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
215 | 
216 | 		public Document Document { [Get] get; private set; }
217 | 
218 | 
219 | 		#region Events
220 | 		public event JSEventHandler Resize {
221 | 			[Inline]
222 | 			add { Event.Observe(this, value, "resize"); }
223 | 			[Inline]
224 | 			remove { Event.StopObserving(this, value, "resize"); }
225 | 		}
226 | 		public event JSEventHandler Load {
227 | 			[Inline]
228 | 			add { Event.Observe(this.Document, value, "dom:loaded"); }
229 | 			[Inline]
230 | 			remove { Event.StopObserving(this.Document, value, "dom:loaded"); }
231 | 		}
232 | 		public event JSEventHandler Unload {
233 | 			[Inline]
234 | 			add { Event.Observe(this, value, "unload"); }
235 | 			[Inline]
236 | 			remove { Event.StopObserving(this, value, "unload"); }
237 | 		}
238 | 		#endregion
239 | 
240 | 
241 | 		[JSNative(Ignore = true)]
242 | 		protected Window() {
243 | 			this.Document = new Document();
244 | 		}
245 | 	}
246 | 	/// <summary>
247 | 	/// Window that have Top.
248 | 	/// </summary>
249 | 	/// <remarks>
250 | 	/// To allow communication between frames, all frames' classes must inherit from Window&lt;T> for common T.
251 | 	/// </remarks>
252 | 	/// <typeparam name="T">Top window type</typeparam>
253 | 	[JSNative]
254 | 	public abstract class Window<T> : Window where T : Window {
255 | 		/// <summary>
256 | 		/// Top window.
257 | 		/// </summary>
258 | 		[JSNative]
259 | 		public readonly new T Top;
260 | 		[JSNative(Ignore = true)]
261 | 		protected Window() { }
262 | 	}
263 | 
264 | 
265 | }
266 | 
267 | 
268 | 


--------------------------------------------------------------------------------
/Framework/[namespace] .Dom/Dom.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System.Drawing;
 20 | using System;
 21 | using MK.JavaScript.Css;
 22 | 
 23 | using HTMLElement = MK.JavaScript.Dom.Element;
 24 | using System.Collections.Generic;
 25 | using PrototypeJs;
 26 | using MK.JavaScript.Reflection;
 27 | using System.Collections;
 28 | using MK.JavaScript.Framework;
 29 | using MK.JavaScript.Framework.Mappings;
 30 | namespace MK.JavaScript.Dom {
 31 | 
 32 | #warning SelectOptionsList
 33 | 
 34 | 	public class SelectOptionsList : IEnumerable<Option> {
 35 | 		private SelectOptionsList() { }
 36 | 		[JSNative]
 37 | 		public void Add(Option option) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 38 | 		[JSNative]
 39 | 		public void Add(Option option, int index) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 40 | 		public Option this[int index] {
 41 | 			[JSNative(OpCode = "Ldelem")]
 42 | 			get { throw new InvalidOperationException(JS.CannotRunAtServer); }
 43 | 			[JSNative(OpCode = "Stelem")]
 44 | 			set { throw new InvalidOperationException(JS.CannotRunAtServer); }
 45 | 		}
 46 | 		[JSNative("length")]
 47 | 		public int Count;
 48 | 
 49 | 		#region IEnumerable<Option> Members
 50 | 		public IEnumerator<Option> GetEnumerator() { return new JSArrayEnumerator<Option>(this); }
 51 | 		#endregion
 52 | 		#region IEnumerable Members
 53 | 		IEnumerator IEnumerable.GetEnumerator() { return new JSArrayEnumerator<Option>(this); }
 54 | 		#endregion
 55 | 	}
 56 | 
 57 | 	public class Option : Element {
 58 | 		[JSNative]
 59 | 		public bool DefaultSelected;
 60 | 		[JSNative]
 61 | 		public int Index;
 62 | 		public bool Selected {
 63 | 			[Get]
 64 | 			get { return bool.Parse(this["selected"]); }
 65 | 			[Set]
 66 | 			set { this["selected"] = value.ToString(); }
 67 | 		}
 68 | 		/// <summary>
 69 | 		/// TEXT attribute.
 70 | 		/// </summary>
 71 | 		public string Text {
 72 | 			[Get]
 73 | 			get { return this["text"]; }
 74 | 			[Set]
 75 | 			set { this["text"] = value; }
 76 | 		}
 77 | 		/// <summary>
 78 | 		/// VALUE attribute.
 79 | 		/// </summary>
 80 | 		public new string Value {
 81 | 			[Get]
 82 | 			get { return this["value"]; }
 83 | 			[Set]
 84 | 			set { this["value"] = value; }
 85 | 		}
 86 | 		[JSNative]
 87 | 		public Option() : base("option") { }
 88 | 	}
 89 | 
 90 | 
 91 | 	[PrototypeJS]
 92 | 	public class Offset {
 93 | 		[PrototypeJS]
 94 | 		public int Top;
 95 | 		[PrototypeJS]
 96 | 		public int Left;
 97 | 
 98 | 		private Offset() { }
 99 | 	}
100 | 	/// <summary>
101 | 	/// BODY tag.
102 | 	/// </summary>
103 | 	public class Body : Element {
104 | 		private Body() : base("body") { }
105 | 	}
106 | 	/// <summary>
107 | 	/// Base class for HTML elements.
108 | 	/// </summary>
109 | 	public partial class Element : IEnumerable<Element> {
110 | 
111 | 		#region IEnumerable<Element> Members
112 | 		[Inline]
113 | 		public IEnumerator<Element> GetEnumerator() { return (IEnumerator<Element>)this.ChildNodes.GetEnumerator(); }
114 | 		#endregion
115 | 		#region IEnumerable Members
116 | 		[Inline]
117 | 		IEnumerator IEnumerable.GetEnumerator() { return this.ChildNodes.GetEnumerator(); }
118 | 		#endregion
119 | 		#region ##### Node #####
120 | 		#region Properties
121 | 		/// <summary>
122 | 		/// Setting is equivalent for <value>this.Add(value)</value>.
123 | 		/// </summary>
124 | 		[JSNative]
125 | 		public Element[] ChildNodes {
126 | 			[Get]
127 | 			get { return this.elements.ToArray(); }
128 | 			[Inline]
129 | 			set { this.Add(value); }
130 | 		}
131 | 		[JSNative]
132 | 		public readonly Element NextSibling;
133 | 		[JSNative]
134 | 		public string NodeName;
135 | 		[JSNative]
136 | 		public readonly Element ParentNode;
137 | 		#endregion
138 | 		#region Methods
139 | 		[Obsolete("Use Add(element) instead.")]
140 | 		[JSNative]
141 | 		public void AppendChild(Element element) { this.Add(element); }
142 | 
143 | 		#region Add - smart initialization support
144 | 		/// <summary>
145 | 		/// Equivalent for <c>this.Add(new Span { InnerHTML = html });</c>.
146 | 		/// </summary>
147 | 		/// <param name="html">InnerHTML of Span element.</param>
148 | 		public void Add(string html) { this.Add(new Span { InnerHTML = html }); }
149 | 		/// <summary>
150 | 		/// Equivalent for <c>foreach (var element in elements) this.Add(element);</c>.
151 | 		/// </summary>
152 | 		[Inline]
153 | 		public void Add(IEnumerable<Element> elements) {
154 | 			this.AddRange(elements);
155 | 		}
156 | 		/// <summary>
157 | 		/// Equivalent for <c>foreach (var element in elements) this.Add(element);</c>.
158 | 		/// </summary>
159 | 		public void Add(params Element[] elements) {
160 | 			foreach (var element in elements) {
161 | 				this.Add(element);
162 | 			}
163 | 		}
164 | 		#endregion
165 | 
166 | 		/// <summary>
167 | 		/// Equivalent for <c>foreach (var element in elements) this.Add(element);</c>.
168 | 		/// </summary>
169 | 		public void AddRange(IEnumerable<Element> elements) {
170 | 			foreach (var element in elements) {
171 | 				this.Add(element);
172 | 			}
173 | 		}
174 | 		#endregion
175 | 		#endregion
176 | 
177 | 		#region Properties
178 | 		[JSNative]
179 | 		public string TagName {
180 | 			[Get("tagName")]
181 | 			get;
182 | 			#region ServerSide
183 | 			private set;
184 | 			#endregion
185 | 		}
186 | 
187 | 		#endregion
188 | 
189 | 		#region Methods
190 | 		[Obsolete("Use element[key]; instead.")]
191 | 		[JSNative]
192 | 		public string GetAttribute(string key) { throw new InvalidOperationException(JS.CannotRunAtServer); }
193 | 		[Obsolete("Use element[key]=value; instead.")]
194 | 		[JSNative]
195 | 		public void SetAttribute(string key, string value) { }
196 | 		[JSNative]
197 | 		public void RemoveAttribute(string key) { }
198 | 		[JSNative]
199 | 		public void ScrollIntoView(bool alignToTop) { throw new InvalidOperationException(JS.CannotRunAtServer); }
200 | 		#endregion
201 | 
202 | 
203 | 
204 | 		#region PrototypeJS: Element (prototypejs.org/api/element.html)
205 | 		/// <summary>
206 | 		/// Returns the offsets of element from the top left corner of the document.
207 | 		/// </summary>
208 | 		public Offset CumulativeOffset { [PrototypeJS("cumulativeOffset")] get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
209 | 		/// <summary>
210 | 		/// Sets the visual opacity of an element while working around inconsistencies in various browsers.
211 | 		/// The opacity argument should be a floating point number, where the value of 0 is fully transparent and 1 is fully opaque.
212 | 		/// </summary>
213 | 		public double Opacity { [PrototypeJS("setOpacity")]	set { throw new InvalidCastException(); } }
214 | 		/// <summary>
215 | 		/// Modifies element’s CSS style properties.
216 | 		/// Styles are passed as a hash of property-value pairs in which the properties are specified in their camelized form.
217 | 		/// </summary>
218 | 		public string StyleText { [Inline]	set { this.SetStyle(value); } }
219 | 		#endregion
220 | 
221 | 		#region PrototypeJS: Form.Element (prototypejs.org/api/form/element.html)
222 | 		/// <summary>
223 | 		/// Returns the current value of a form control. A string is returned for most controls; only multiple select boxes return an array of values. The global shortcut for this method is _F().
224 | 		/// </summary>
225 | 		public string Value {
226 | 			[PrototypeJS("getValue")]
227 | 			get { return this["value"]; }
228 | 			[PrototypeJS("setValue")]
229 | 			set { this["value"] = value; }
230 | 		}
231 | 		/// <summary>
232 | 		/// Returns true if a text input has contents, false otherwise.
233 | 		/// </summary>
234 | 		public bool IsPresent { [PrototypeJS("present")] get { throw new InvalidOperationException(JS.CannotRunAtServer); } }
235 | 		#endregion
236 | 
237 | 		[JSNative]
238 | 		public Element[] GetElementsByTagName(string tagName) { throw new InvalidOperationException(JS.CannotRunAtServer); }
239 | 		/// <summary>
240 | 		/// ownerDocument
241 | 		/// </summary>
242 | 		public Document Document {
243 | 			[Get("ownerDocument")]
244 | 			get { throw new InvalidOperationException(JS.CannotRunAtServer); }
245 | 		}
246 | 		/// <summary>
247 | 		/// ID attribute.
248 | 		/// </summary>
249 | 		public string Id {
250 | 			[Get]
251 | 			get { return this["id"]; }
252 | 			[Set]
253 | 			set { this["id"] = value; }
254 | 		}
255 | 		/// <summary>
256 | 		/// TITLE attribute.
257 | 		/// </summary>
258 | 		public string Title {
259 | 			[Get]
260 | 			get { return this["title"]; }
261 | 			[Set]
262 | 			set { this["title"] = value; }
263 | 		}
264 | 		[JSNative]
265 | 		public string InnerHTML;
266 | 
267 | #warning niekonsystencja dom'u i javascriptu
268 | 		public string ClassName {
269 | 			[Get]
270 | 			get { return this["class"]; }
271 | 			[Set]
272 | 			set { this["class"] = value; }
273 | 		}
274 | 
275 | 		/// <summary>
276 | 		/// Setting styles overrides element's style properties defined in value.
277 | 		/// </summary>
278 | 		public Style Style {
279 | 			[Get]
280 | 			get;
281 | 			[PrototypeJS("setStyle")]
282 | 			set;
283 | 		}
284 | 		[JSNative]
285 | 		public readonly int OffsetHeight;
286 | 		[JSNative]
287 | 		public readonly int OffsetWidth;
288 | 		#region Events
289 | 		public event JSEventHandler MouseOver {
290 | 			[Inline]
291 | 			add { Event.Observe(this, value, "mouseover"); }
292 | 			[Inline]
293 | 			remove { Event.StopObserving(this, value, "mouseover"); }
294 | 		}
295 | 		public event JSEventHandler MouseOut {
296 | 			[Inline]
297 | 			add { Event.Observe(this, value, "mouseout"); }
298 | 			[Inline]
299 | 			remove { Event.StopObserving(this, value, "mouseout"); }
300 | 		}
301 | 		public event JSEventHandler MouseDown {
302 | 			[Inline]
303 | 			add { Event.Observe(this, value, "mousedown"); }
304 | 			[Inline]
305 | 			remove { Event.StopObserving(this, value, "mousedown"); }
306 | 		}
307 | 		public event JSEventHandler MouseMove {
308 | 			[Inline]
309 | 			add { Event.Observe(this, value, "mousemove"); }
310 | 			[Inline]
311 | 			remove { Event.StopObserving(this, value, "mousemove"); }
312 | 		}
313 | 		public event JSEventHandler MouseUp {
314 | 			[Inline]
315 | 			add { Event.Observe(this, value, "mouseup"); }
316 | 			[Inline]
317 | 			remove { Event.StopObserving(this, value, "mouseup"); }
318 | 		}
319 | 		public event JSEventHandler KeyPress {
320 | 			[Inline]
321 | 			add { Event.Observe(this, value, "keypress"); }
322 | 			[Inline]
323 | 			remove { Event.StopObserving(this, value, "keypress"); }
324 | 		}
325 | 		public event JSEventHandler KeyDown {
326 | 			[Inline]
327 | 			add { Event.Observe(this, value, "keydown"); }
328 | 			[Inline]
329 | 			remove { Event.StopObserving(this, value, "keydown"); }
330 | 		}
331 | 		public event JSEventHandler Click {
332 | 			[Inline]
333 | 			add { Event.Observe(this, value, "click"); }
334 | 			[Inline]
335 | 			remove { Event.StopObserving(this, value, "click"); }
336 | 		}
337 | 		public event JSEventHandler DoubleClick {
338 | 			[Inline]
339 | 			add { Event.Observe(this, value, "dblclick"); }
340 | 			[Inline]
341 | 			remove { Event.StopObserving(this, value, "dblclick"); }
342 | 		}
343 | 		public event JSEventHandler Change {
344 | 			[Inline]
345 | 			add { Event.Observe(this, value, "change"); }
346 | 			[Inline]
347 | 			remove { Event.StopObserving(this, value, "change"); }
348 | 		}
349 | 		public event JSEventHandler Blur {
350 | 			[Inline]
351 | 			add { Event.Observe(this, value, "blur"); }
352 | 			[Inline]
353 | 			remove { Event.StopObserving(this, value, "blur"); }
354 | 		}
355 | 
356 | 		/// <summary>Equivalent for <c>this.MouseOver += value;</c>.</summary>
357 | 		public JSEventHandler OnMouseOver { [Inline] set { this.MouseOver += value; } }
358 | 		/// <summary>Equivalent for <c>this.MouseOut += value;</c>.</summary>
359 | 		public JSEventHandler OnMouseOut { [Inline] set { this.MouseOut += value; } }
360 | 		/// <summary>Equivalent for <c>this.MouseDown += value;</c>.</summary>
361 | 		public JSEventHandler OnMouseDown { [Inline] set { this.MouseDown += value; } }
362 | 		/// <summary>Equivalent for <c>this.MouseMove += value;</c>.</summary>
363 | 		public JSEventHandler OnMouseMove { [Inline] set { this.MouseMove += value; } }
364 | 		/// <summary>Equivalent for <c>this.MouseUp += value;</c>.</summary>
365 | 		public JSEventHandler OnMouseUp { [Inline] set { this.MouseUp += value; } }
366 | 		/// <summary>Equivalent for <c>this.KeyPress += value;</c>.</summary>
367 | 		public JSEventHandler OnKeyPress { [Inline] set { this.KeyPress += value; } }
368 | 		/// <summary>Equivalent for <c>this.KeyDown += value;</c>.</summary>
369 | 		public JSEventHandler OnKeyDown { [Inline] set { this.KeyDown += value; } }
370 | 		/// <summary>Equivalent for <c>this.Click += value;</c>.</summary>
371 | 		public JSEventHandler OnClick { [Inline] set { this.Click += value; } }
372 | 		/// <summary>Equivalent for <c>this.DoubleClick += value;</c>.</summary>
373 | 		public JSEventHandler OnDoubleClick { [Inline] set { this.DoubleClick += value; } }
374 | 		/// <summary>Equivalent for <c>this.Change += value;</c>.</summary>
375 | 		public JSEventHandler OnChange { [Inline] set { this.Change += value; } }
376 | 		/// <summary>Equivalent for <c>this.Blur += value;</c>.</summary>
377 | 		public JSEventHandler OnBlur { [Inline] set { this.Blur += value; } }
378 | 		#endregion
379 | 
380 | 		#region Element's children's
381 | 		#region Events
382 | 		public event JSEventHandler Load {
383 | 			[Inline]
384 | 			add { Event.Observe(this, value, "load"); }
385 | 			[Inline]
386 | 			remove { Event.StopObserving(this, value, "load"); }
387 | 		}
388 | 		/// <summary>Equivalent for <c>this.Load += value;</c>.</summary>
389 | 		public JSEventHandler OnLoad { [Inline] set { this.Load += value; } }
390 | 
391 | 		#endregion
392 | 
393 | 		public Window ContentWindow {
394 | 			[Get]
395 | 			get { throw new InvalidOperationException(JS.CannotRunAtServer); }
396 | 		}
397 | 		/// <summary>
398 | 		/// NAME attribute.
399 | 		/// </summary>
400 | 		public string Name {
401 | 			[Get]
402 | 			get { return this["name"]; }
403 | 			[Set]
404 | 			set { this["name"] = value; }
405 | 		}
406 | 
407 | 		#endregion
408 | 
409 | 	}
410 | 	public sealed class TableRules : EnumString {
411 | 		private TableRules(string value) : base(value) { }
412 | 		public static readonly TableRules
413 | 			Empty = new TableRules(""),
414 | 			All = new TableRules("all"),
415 | 			Cols = new TableRules("cols"),
416 | 			None = new TableRules("none"),
417 | 			Groups = new TableRules("groups"),
418 | 			Rows = new TableRules("rows");
419 | 	}
420 | }
421 | 


--------------------------------------------------------------------------------
/Framework/[namespace] .Dom/Element - server side.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using MK.JavaScript.Reflection;
 24 | using System.Reflection;
 25 | using MK.JavaScript.Ajax.Serialization;
 26 | using System.Text.RegularExpressions;
 27 | using MK.JavaScript.Compiler;
 28 | 
 29 | namespace MK.JavaScript.Dom {
 30 | 	partial class Element {
 31 | 		#region Client & Server side methods
 32 | 		/// <summary>
 33 | 		/// Creates DOM element with given tag name.
 34 | 		/// </summary>
 35 | 		/// <param name="name">The tag name of element.</param>
 36 | 		[Obsolete("If possible, call one of this class subclasses constructor instead of explicit calling this constructor.")]
 37 | 		[PrototypeJS]
 38 | 		public Element(string tagName) {
 39 | 			this.TagName = tagName;
 40 | 			this.elements = new List<Element>();
 41 | 			this.attributes = new Dictionary<string, string>();
 42 | 		}
 43 | 		/// <summary>
 44 | 		/// Adds element as a child of this element.
 45 | 		/// </summary>
 46 | 		/// <param name="element">An element to add.</param>
 47 | 		[JSNative("appendChild")]
 48 | 		public void Add(Element element) {
 49 | 			this.elements.Add(element);
 50 | 		}
 51 | 		[JSNative]
 52 | 		public void InsertBefore(Element what, Element where) {
 53 | 			this.elements.Insert(this.elements.IndexOf(where), what);
 54 | 		}
 55 | 		[JSNative]
 56 | 		public Element RemoveChild(Element child) {
 57 | 			this.elements.Remove(child);
 58 | 			return child;
 59 | 		}
 60 | 		public Element FirstChild {
 61 | 			[Get]
 62 | 			get { return this.elements[0]; }
 63 | 		}
 64 | 		[JSNative]
 65 | 		public Element LastChild {
 66 | 			[Get]
 67 | 			get { return this.elements[this.elements.Count - 1]; }
 68 | 		}
 69 | 		/// <summary>
 70 | 		/// Gets or sets a value of element's attribute.
 71 | 		/// </summary>
 72 | 		/// <param name="key">Name of attribute.</param>
 73 | 		/// <returns></returns>
 74 | 		public string this[string key] {
 75 | 			[JSNative("getAttribute")]
 76 | 			get {
 77 | 				string value;
 78 | 				return this.attributes.TryGetValue(key, out value) ? value : null;
 79 | 			}
 80 | 			[JSNative("setAttribute")]
 81 | 			set { this.attributes[key] = value; }
 82 | 		}
 83 | 
 84 | 		public override string ToString() {
 85 | 			var sb = new StringBuilder();
 86 | 			this.append(sb);
 87 | 			return sb.ToString();
 88 | 		}
 89 | 		public static string ToString(IEnumerable<Element> elements) {
 90 | 			var sb = new StringBuilder();
 91 | 			foreach (var item in elements) {
 92 | 				item.append(sb);
 93 | 			}
 94 | 			return sb.ToString();
 95 | 		}
 96 | 		#endregion
 97 | 
 98 | 
 99 | 
100 | 
101 | 		internal readonly List<Element> elements;
102 | 		private readonly Dictionary<string, string> attributes;
103 | 
104 | 		private static string escapeHtml(string s) {
105 | 			return Regex.Replace(s, @"[""&<]", match => {
106 | 				switch (match.Value) {
107 | 					case "\"": return "&quot;";
108 | 					case "&": return "&amp;";
109 | 					case "<": return "&lt;";
110 | 					default: throw new ArgumentException();
111 | 				}
112 | 			});
113 | 		}
114 | 
115 | 		internal void append(StringBuilder sb) {
116 | 			sb.Append('<').Append(this.TagName);
117 | 			foreach (var attr in this.attributes) {
118 | 				sb.Append(' ').Append(attr.Key).Append("=\"").Append(escapeHtml(attr.Value)).Append('"');
119 | 			}
120 | 			//if (this.Style != null) {
121 | 			//  sb.Append(" style=\"");
122 | 			//  CssWriter.append(this.Style, sb);
123 | 			//  sb.Append('"');
124 | 			//}
125 | 			if (this.InnerHTML != null) {
126 | 				sb.Append('>').Append(this.InnerHTML).Append("</").Append(this.TagName).Append('>');
127 | 			} else if (this.elements.Count != 0) {
128 | 				sb.Append('>');
129 | 				foreach (var element in this.elements) {
130 | 					element.append(sb);
131 | 				}
132 | 				sb.Append("</").Append(this.TagName).Append('>');
133 | 			} else {
134 | 				sb.Append("/>");
135 | 			}
136 | 		}
137 | 	}
138 | }
139 | 


--------------------------------------------------------------------------------
/Framework/[namespace] .Dom/Tags.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using MK.JavaScript.Reflection;
 24 | 
 25 | namespace MK.JavaScript.Dom {
 26 | 	/// <summary>
 27 | 	/// HR tag.
 28 | 	/// </summary>
 29 | 	public class HorizontalRule : Element {
 30 | 		public HorizontalRule() : base("hr") { }
 31 | 	}
 32 | 	/// <summary>
 33 | 	/// BR tag.
 34 | 	/// </summary>
 35 | 	public class LineBreak : Element {
 36 | 		public LineBreak() : base("br") { }
 37 | 	}
 38 | 
 39 | 	/// <summary>
 40 | 	/// LABEL tag.
 41 | 	/// </summary>
 42 | 	public class Label : Element {
 43 | 		public Label() : base("label") { }
 44 | #warning niekonsystencja dom i javascript
 45 | 		/// <summary>
 46 | 		/// FOR attribute.
 47 | 		/// </summary>
 48 | 		public string For {
 49 | 			[Get("htmlFor")]
 50 | 			get { return this["for"]; }
 51 | 			[Set("htmlFor")]
 52 | 			set { this["for"] = value; }
 53 | 		}
 54 | 	}
 55 | 	/// <summary>
 56 | 	/// PRE tag.
 57 | 	/// </summary>
 58 | 	public class PreformattedText : Element {
 59 | 		public PreformattedText() : base("pre") { }
 60 | 	}
 61 | 
 62 | 	/// <summary>
 63 | 	/// TABLE tag.
 64 | 	/// </summary>
 65 | 	public class Table : Element {
 66 | 		public Table() : base("table") { }
 67 | 		/// <summary>
 68 | 		/// CELLPADDING attribute.
 69 | 		/// </summary>
 70 | 		public int CellPadding {
 71 | 			[Get]
 72 | 			get { return int.Parse(this["cellPadding"]); }
 73 | 			[Set]
 74 | 			set { this["cellPadding"] = value.ToString(); }
 75 | 		}
 76 | 		/// <summary>
 77 | 		/// CELLSPACING attribute.
 78 | 		/// </summary>
 79 | 		public int CellSpacing {
 80 | 			[Get]
 81 | 			get { return int.Parse(this["cellSpacing"]); }
 82 | 			[Set]
 83 | 			set { this["cellSpacing"] = value.ToString(); }
 84 | 		}
 85 | 		/// <summary>
 86 | 		/// BORDER attribute.
 87 | 		/// </summary>
 88 | 		public int Border {
 89 | 			[Get]
 90 | 			get { return int.Parse(this["border"]); }
 91 | 			[Set]
 92 | 			set { this["border"] = value.ToString(); }
 93 | 		}
 94 | 		/// <summary>
 95 | 		/// RULES attribute.
 96 | 		/// </summary>
 97 | 		public TableRules Rules {
 98 | 			[Get]
 99 | 			get { return TableRules.Parse<TableRules>(this["rules"]); }
100 | 			[Set]
101 | 			set { this["rules"] = value.Value; }
102 | 		}
103 | 	}
104 | 	/// <summary>
105 | 	/// TEXTAREA tag.
106 | 	/// </summary>
107 | 	public class TextArea : Element {
108 | 		public TextArea() : base("textarea") { }
109 | 		/// <summary>
110 | 		/// Number of columns.
111 | 		/// </summary>
112 | 		public int Columns {
113 | 			[Get("cols")]
114 | 			get { return int.Parse(this["cols"]); }
115 | 			[Set("cols")]
116 | 			set { this["cols"] = value.ToString(); }
117 | 		}
118 | 		/// <summary>
119 | 		/// Number of rows.
120 | 		/// </summary>
121 | 		public int Rows {
122 | 			[Get]
123 | 			get { return int.Parse(this["rows"]); }
124 | 			[Set]
125 | 			set { this["rows"] = value.ToString(); }
126 | 		}
127 | 		/// <summary>
128 | 		/// READONLY attribute.
129 | 		/// </summary>
130 | 		public bool ReadOnly {
131 | 			[Get]
132 | 			get { return bool.Parse(this["readOnly"]); }
133 | 			[Set]
134 | 			set { this["readOnly"] = value.ToString(); }
135 | 		}
136 | 	}
137 | 	/// <summary>
138 | 	/// LI tag.
139 | 	/// </summary>
140 | 	public class ListItem : Element {
141 | 		public ListItem() : base("li") { }
142 | 	}
143 | 	/// <summary>
144 | 	/// UL tag.
145 | 	/// </summary>
146 | 	public class UnorderedList : Element {
147 | 		public UnorderedList() : base("ul") { }
148 | 	}
149 | 	/// <summary>
150 | 	/// THEAD tag.
151 | 	/// </summary>
152 | 	public class TableHeader : Element {
153 | 		public TableHeader() : base("thead") { }
154 | 	}
155 | 	/// <summary>
156 | 	/// TH tag.
157 | 	/// </summary>
158 | 	public class TableHeaderCell : Element {
159 | 		public TableHeaderCell() : base("th") { }
160 | 	}
161 | 	/// <summary>
162 | 	/// TBODY tag.
163 | 	/// </summary>
164 | 	public class TableBody : Element {
165 | 		public TableBody() : base("tbody") { }
166 | 	}
167 | 	/// <summary>
168 | 	/// TR tag.
169 | 	/// </summary>
170 | 	public class TableRow : Element {
171 | 		public TableRow() : base("tr") { }
172 | 	}
173 | 	/// <summary>
174 | 	/// TD tag.
175 | 	/// </summary>
176 | 	public class TableCell : Element {
177 | 		public TableCell() : base("td") { }
178 | 		/// <summary>
179 | 		/// COLSPAN attribute.
180 | 		/// </summary>
181 | 		public int ColumnSpan {
182 | 			[Get("colSpan")]
183 | 			get { return int.Parse(this["colSpan"]); }
184 | 			[Set("colSpan")]
185 | 			set { this["colSpan"] = value.ToString(); }
186 | 		}
187 | 		/// <summary>
188 | 		/// ROWSPAN attribute.
189 | 		/// </summary>
190 | 		public int RowSpan {
191 | 			[Get]
192 | 			get { return int.Parse(this["rowSpan"]); }
193 | 			[Set]
194 | 			set { this["rowSpan"] = value.ToString(); }
195 | 		}
196 | 	}
197 | 	/// <summary>
198 | 	/// DIV tag.
199 | 	/// </summary>
200 | 	public class Division : Element {
201 | 		public Division() : base("div") { }
202 | 	}
203 | 	/// <summary>
204 | 	/// SPAN tag.
205 | 	/// </summary>
206 | 	public class Span : Element {
207 | 		public Span() : base("span") { }
208 | 	}
209 | 	/// <summary>
210 | 	/// IMG tag.
211 | 	/// </summary>
212 | 	public class Image : Element {
213 | 		public Image() : base("img") { }
214 | 		/// <summary>
215 | 		/// SRC attribute.
216 | 		/// </summary>
217 | 		public string Source {
218 | 			[Get("src")]
219 | 			get { return this["src"]; }
220 | 			[Set("src")]
221 | 			set { this["src"] = value; }
222 | 		}
223 | 		/// <summary>
224 | 		/// ALT attribute.
225 | 		/// </summary>
226 | 		public string AlternativeText {
227 | 			[Get("alt")]
228 | 			get { return this["alt"]; }
229 | 			[Set("alt")]
230 | 			set { this["alt"] = value; }
231 | 		}
232 | 	}
233 | 	/// <summary>
234 | 	/// IFRAME tag.
235 | 	/// </summary>
236 | 	public class IFrame : Element {
237 | 		public IFrame() : base("iframe") { }
238 | 		/// <summary>
239 | 		/// SRC attribute.
240 | 		/// </summary>
241 | 		public string Source {
242 | 			[Get("src")]
243 | 			get { return this["src"]; }
244 | 			[Set("src")]
245 | 			set { this["src"] = value; }
246 | 		}
247 | 
248 | 	}
249 | 	/// <summary>
250 | 	/// A tag.
251 | 	/// </summary>
252 | 	public class Anchor : Element {
253 | 		/// <summary>
254 | 		/// HREF attribute.
255 | 		/// </summary>
256 | 		public string Href {
257 | 			[Get]
258 | 			get { return this["href"]; }
259 | 			[Set]
260 | 			set { this["href"] = value; }
261 | 		}
262 | 		public Anchor() : base("a") { }
263 | 		/// <summary>
264 | 		/// TARGET attribute.
265 | 		/// </summary>
266 | 		public string Target {
267 | 			[Get]
268 | 			get { return this["target"]; }
269 | 			[Set]
270 | 			set { this["target"] = value; }
271 | 		}
272 | 	}
273 | 	/// <summary>
274 | 	/// INPUT tag.
275 | 	/// </summary>
276 | 	public class Input : Element {
277 | 
278 | 		public string Type {
279 | 			[Get]
280 | 			get { return this["type"]; }
281 | 			[Set]
282 | 			set { this["type"] = value; }
283 | 		}
284 | 		private Input() : base("input") { }
285 | 		[Obsolete("If possible, call one of this class subclasses constructor instead of explicit calling this constructor.")]
286 | 		public Input(string type)
287 | 			: base("input") {
288 | 			this.Type = type;
289 | 		}
290 | 		#region subclasses
291 | 		/// <summary>
292 | 		/// INPUT tag with TYPE="text" attribute.
293 | 		/// </summary>
294 | 		public class Text : Input {
295 | 			public int MaxLength {
296 | 				[Get]
297 | 				get { return int.Parse(this["maxLength"]); }
298 | 				[Set]
299 | 				set { this["maxLength"] = value.ToString(); }
300 | 			}
301 | 			public Text() : base("text") { }
302 | 		}
303 | 		/// <summary>
304 | 		/// INPUT tag with TYPE="text" attribute.
305 | 		/// </summary>
306 | 		public class Password : Input {
307 | 			public Password() : base("password") { }
308 | 		}
309 | 		/// <summary>
310 | 		/// INPUT tag with TYPE="text" attribute.
311 | 		/// </summary>
312 | 		public class Reset : Input {
313 | 			public Reset() : base("reset") { }
314 | 		}
315 | 		/// <summary>
316 | 		/// INPUT tag with TYPE="submit" attribute.
317 | 		/// </summary>
318 | 		public class Submit : Input {
319 | 			public Submit() : base("submit") { }
320 | 		}
321 | 		/// <summary>
322 | 		/// INPUT tag with TYPE="image" attribute.
323 | 		/// </summary>
324 | 		public class Image : Input {
325 | 			public Image() : base("image") { }
326 | 		}
327 | 		/// <summary>
328 | 		/// INPUT tag with TYPE="hidden" attribute.
329 | 		/// </summary>
330 | 		public class Hidden : Input {
331 | 			public Hidden() : base("hidden") { }
332 | 		}
333 | 		/// <summary>
334 | 		/// INPUT tag with TYPE="file" attribute.
335 | 		/// </summary>
336 | 		public class FileUpload : Input {
337 | 			public FileUpload() : base("file") { }
338 | 		}
339 | 		/// <summary>
340 | 		/// INPUT tag with TYPE="button" attribute.
341 | 		/// </summary>
342 | 		public class Button : Input {
343 | 			public Button() : base("button") { }
344 | 		}
345 | 		/// <summary>
346 | 		/// INPUT tag with TYPE="checkbox" attribute.
347 | 		/// </summary>
348 | 		public class CheckBox : Input {
349 | 			public CheckBox() : base("checkbox") { }
350 | 			/// <summary>
351 | 			/// CHECKED attribute.
352 | 			/// </summary>
353 | 			public bool Checked {
354 | 				[Get]
355 | 				get { return bool.Parse(this["checked"]); }
356 | 				[Set]
357 | 				set { this["checked"] = value.ToString(); }
358 | 			}
359 | 		}
360 | 		/// <summary>
361 | 		/// INPUT tag with TYPE="Input" attribute.
362 | 		/// </summary>
363 | 		public class Radio : Input {
364 | 			/// <summary>
365 | 			/// CHECKED attribute.
366 | 			/// </summary>
367 | 			public bool Checked {
368 | 				[Get]
369 | 				get { return bool.Parse(this["checked"]); }
370 | 				[Set]
371 | 				set { this["checked"] = value.ToString(); }
372 | 			}
373 | 			public Radio() : base("radio") { }
374 | 		}
375 | 		#endregion
376 | 	}
377 | 	/// <summary>
378 | 	/// SELECT tag.
379 | 	/// </summary>
380 | 	public class Select : Element {
381 | 		public Select() : base("select") { }
382 | 		public int SelectedIndex {
383 | 			[Get]
384 | 			get { throw new InvalidOperationException(JS.CannotRunAtServer); }
385 | 			[Set]
386 | 			set { throw new InvalidOperationException(JS.CannotRunAtServer); }
387 | 		}
388 | 		[JSNative]
389 | 		public readonly SelectOptionsList Options;
390 | 		[JSNative]
391 | 		public void Remove(int index) { throw new InvalidOperationException(JS.CannotRunAtServer); }
392 | 
393 | 		public string SelectedText { get { return this.Options[this.SelectedIndex].Text; } }
394 | 
395 | 	}
396 | 
397 | }
398 | 


--------------------------------------------------------------------------------
/Framework/[namespace] .Framework.Mappings/IEnumerable.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections;
21 | using System.Collections.Generic;
22 | using MK.JavaScript.Reflection;
23 | using System.Reflection;
24 | 
25 | namespace MK.JavaScript.Framework.Mappings {
26 | 	public class JSEnumerable<T> : IEnumerable<T> {
27 | 
28 | 		private static IEnumerator<T> GetEnumerator(IEnumerable self) { return new JSArrayEnumerator<T>(self); }
29 | 
30 | 		public IEnumerator<T> GetEnumerator() { return GetEnumerator(this); }
31 | 		IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(this); }
32 | 		IEnumerator<T> IEnumerable<T>.GetEnumerator() { return GetEnumerator(this); }
33 | 
34 | 	}
35 | 
36 | 
37 | 	public struct JSArrayEnumerator<T> : IEnumerator<T> {
38 | 		private T[] array;
39 | 		private int index;
40 | 
41 | 		public JSArrayEnumerator(object array) {
42 | 			this.array = (T[])array;
43 | 			this.index = -1;
44 | 		}
45 | 
46 | 		public T Current {
47 | 			get {
48 | 				return this.array[this.index];
49 | 			}
50 | 		}
51 | 
52 | 		T IEnumerator<T>.Current {
53 | 			get {
54 | 				return this.array[this.index];
55 | 			}
56 | 		}
57 | 		object IEnumerator.Current {
58 | 			get {
59 | 				return this.array[this.index];
60 | 			}
61 | 		}
62 | 		bool IEnumerator.MoveNext() {
63 | 			return ++this.index < this.array.Length;
64 | 		}
65 | 		void IEnumerator.Reset() {
66 | 			this.index = -1;
67 | 		}
68 | 
69 | 		void IDisposable.Dispose() { }
70 | 
71 | 
72 | 
73 | 	}
74 | }


--------------------------------------------------------------------------------
/Framework/[namespace] .Framework.Mappings/System.Threading.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using MK.JavaScript.Reflection;
20 | using System;
21 | namespace MK.JavaScript.Framework.Mappings.System.Threading {
22 | 	public static class Monitor {
23 | 		public const string VaribleKey = "@l";
24 | 		public const string EnterCountVaribleKey = "@e";
25 | 
26 | 		public const int EnterSleepMillisecondsTimeout = 100;
27 | 
28 | 		public static void Enter(object obj) {
29 | 			while (
30 | 				obj.AsDictionary<global::System.Threading.Thread>().ContainsKey(VaribleKey) &&
31 | 				obj.AsDictionary<global::System.Threading.Thread>()[VaribleKey] != global::System.Threading.Thread.CurrentThread
32 | 			) {
33 | 				global::System.Threading.Thread.Sleep(EnterSleepMillisecondsTimeout);
34 | 			}
35 | 			if (obj.AsDictionary<int>().ContainsKey(EnterCountVaribleKey)) {
36 | 				++obj.AsDictionary<int>()[EnterCountVaribleKey];
37 | 			} else {
38 | 				obj.AsDictionary<int>()[EnterCountVaribleKey] = 1;
39 | 				obj.AsDictionary<global::System.Threading.Thread>()[VaribleKey] = global::System.Threading.Thread.CurrentThread;
40 | 			}
41 | 		}
42 | 		public static void Exit(object obj) {
43 | 			if (--obj.AsDictionary<int>()[EnterCountVaribleKey] == 0) {
44 | 				obj.AsDictionary<int>().Remove(EnterCountVaribleKey);
45 | 				obj.AsDictionary<object>().Remove(VaribleKey);
46 | 			}
47 | 		}
48 | 	}
49 | 	public class Thread {
50 | 		public const string ManagedThreadIdKey = "@t";
51 | 		public int ManagedThreadId {
52 | 			[JSNative(Code = "this.i?this.i:this.i=window['" + ManagedThreadIdKey + "']?++window['" + ManagedThreadIdKey + "']:window['" + ManagedThreadIdKey + "']=1")]
53 | 			get { throw new InvalidOperationException(JS.CannotRunAtServer); }
54 | 		}
55 | 	}
56 | }
57 | 


--------------------------------------------------------------------------------
/Framework/[namespace] .Framework.cs:
--------------------------------------------------------------------------------
 1 | /*
 2 | il2js Framework.dll - JavaScript VM for .NET
 3 | Copyright (C) 2011 Michael Kolarz
 4 | 
 5 | This library is free software: you can redistribute it and/or modify
 6 | it under the terms of the GNU Lesser General Public License as
 7 | published by the Free Software Foundation, either version 3 of
 8 | the License, or (at your option) any later version.
 9 | 
10 | This library is distributed in the hope that it will be useful,
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 | GNU Lesser General Public License for more details.
14 | 
15 | You should have received a copy of the GNU Lesser General Public
16 | License along with this library.
17 | If not, see <http://www.gnu.org/licenses/>.
18 | */
19 | using System;
20 | using System.Collections.Generic;
21 | using System.Linq;
22 | using System.Text;
23 | using System.Reflection;
24 | 
25 | namespace MK.JavaScript.Framework {
26 | 	/*
27 | 	 * dlaczego sie nie da inaczej, tzn nie da sie enumem:
28 | 	 * element.Style.Display=element.ClassName==xx?Display.None:Display.Block
29 | 	 * i to jest tlumaczone na inty dla enuma i nijak mozna stwierdzic kiedy int ba myc jako taki enum
30 | 	 * i trza by wszystkie wartosci wysylac do klienta
31 | 	 * co jest mocno nieefektywne bo wiekszoscie i tak nigdy nie uzyje...
32 | 	 * 
33 | 	 * inny problem to funkcje co biora to jako parametr - wtedy to juz zywcem sie nie da obeznac kiedy konwertowac na .ToString
34 | 	 */
35 | 	/// <summary>
36 | 	/// Base class for enum-like css classes.
37 | 	/// </summary>
38 | 	public abstract class EnumString {
39 | 		internal readonly string Value;
40 | 		internal static T Parse<T>(string value) where T : EnumString {
41 | 			return (T)typeof(T).GetField(value, BindingFlags.Public | BindingFlags.Static).GetValue(null);
42 | 		}
43 | 		protected EnumString(string value) { this.Value = value; }
44 | 	}
45 | 
46 | 	public static class Utils {
47 | 		public static char[] Tokens ={
48 | 																		'0','1','2','3','4','5','6','7','8','9',
49 | 																		'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
50 | 																		' ','!',
51 | 																	 //'\'',
52 | 																	 '#','%','&',
53 | 																	 //'"',
54 | 																	 '(',')','*','+',',','-','.','/',
55 | 																	 ':',';','<','=','>','?','@',
56 | 																	 
57 | 																	 '[',
58 | 																	 //'\\',
59 | 																	 ']','^','_',
60 | 																	 //'`',
61 | 																	 '{','|','}','~',
62 | 																 
63 | 																	 '$',
64 | 																	 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
65 | 																 };
66 | 	}
67 | 
68 | }
69 | 


--------------------------------------------------------------------------------
/Framework/[namespace] .Reflection.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Linq;
 22 | using System.Text;
 23 | using System.Reflection;
 24 | 
 25 | namespace MK.JavaScript.Reflection {
 26 | 	/// <summary>
 27 | 	/// Indicates if method should be inlined or not.
 28 | 	/// </summary>
 29 | 	/// <remarks>
 30 | 	/// This method overrides compilation option.
 31 | 	/// Target method must uses parameters in stack order and must use all parameters, cannot have branches and local varibles.
 32 | 	/// </remarks>
 33 | 	[global::System.AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
 34 | 	public sealed class Inline : Attribute {
 35 | 		/// <summary>
 36 | 		/// If true, target method will be inlined (if possible).
 37 | 		/// </summary>
 38 | 		public readonly bool Value;
 39 | 		public Inline() { Value = true; }
 40 | 		public Inline(bool inline) { Value = inline; }
 41 | 	}
 42 | 	/// <summary>
 43 | 	/// Calling syntax type for native method.
 44 | 	/// </summary>
 45 | 	public enum NativeCallType {
 46 | 		/// <summary>
 47 | 		/// Method will be called as it is declarated.
 48 | 		/// </summary>
 49 | 		Default,
 50 | 		/// <summary>
 51 | 		/// Method will be called as instance method (first parameter is referenced by this).
 52 | 		/// </summary>
 53 | 		Instance,
 54 | 		/// <summary>
 55 | 		/// Method will be called as static method (first parameter is referenced by $0).
 56 | 		/// </summary>
 57 | 		Static,
 58 | 	}
 59 | 	public enum NativeCommandType {
 60 | 		None,
 61 | 		Ldfld,
 62 | 		Stfld,
 63 | 	}
 64 | 
 65 | 	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)]
 66 | 	public class JSNative : Attribute {
 67 | 		public string Name;
 68 | 		public JSNative() { }
 69 | 		public JSNative(string name) { this.Name = name; }
 70 | 		
 71 | 		public string Ldfld {
 72 | 			set {
 73 | 				this.CommandType = NativeCommandType.Ldfld;
 74 | 				this.CommandArgument = value;
 75 | 			}
 76 | 			get { return this.CommandType == NativeCommandType.Ldfld ? this.CommandArgument : null; }
 77 | 		}
 78 | 		public string Stfld {
 79 | 			set {
 80 | 				this.CommandType = NativeCommandType.Stfld;
 81 | 				this.CommandArgument = value;
 82 | 			}
 83 | 			get { return this.CommandType == NativeCommandType.Stfld ? this.CommandArgument : null; }
 84 | 		}
 85 | 
 86 | 		public string Code;
 87 | 		public string OpCode;
 88 | 		public string AdditionalCode;
 89 | 		public object Value;
 90 | 		public bool Ignore;
 91 | 		public NativeCommandType CommandType = NativeCommandType.None;
 92 | 		public string CommandArgument;
 93 | 		NativeCallType _CallType = NativeCallType.Default;
 94 | 		public NativeCallType CallType {
 95 | 			get { return this._CallType; }
 96 | 			set {
 97 | 				this._CallType = value;
 98 | 				if (value == NativeCallType.Instance) {
 99 | 					GlobalMethod = true;
100 | 				}
101 | 			}
102 | 		}
103 | 		public bool GlobalMethod = false;
104 | 	}
105 | 	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)]
106 | 	public class Set : JSNative {
107 | 		public Set() {
108 | 			this.CommandType = NativeCommandType.Stfld;
109 | 		}
110 | 		public Set(string fieldName) {
111 | 			this.Stfld = fieldName;
112 | 		}
113 | 	}
114 | 	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)]
115 | 	public class Get : JSNative {
116 | 		public Get() {
117 | 			this.CommandType = NativeCommandType.Ldfld;
118 | 		}
119 | 		public Get(string fieldName) {
120 | 			this.Ldfld = fieldName;
121 | 		}
122 | 	}
123 | 
124 | 	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)]
125 | 	public class PrototypeJS : JSNative {
126 | 		public PrototypeJS() { }
127 | 		public PrototypeJS(string name) : base(name) { }
128 | 	}
129 | 	[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = false)]
130 | 	public class JSFramework : JSNative {
131 | 		public JSFramework() { }
132 | 	}
133 | }
134 | 


--------------------------------------------------------------------------------
/Framework/[namespace] PrototypeJs.cs:
--------------------------------------------------------------------------------
  1 | /*
  2 | il2js Framework.dll - JavaScript VM for .NET
  3 | Copyright (C) 2011 Michael Kolarz
  4 | 
  5 | This library is free software: you can redistribute it and/or modify
  6 | it under the terms of the GNU Lesser General Public License as
  7 | published by the Free Software Foundation, either version 3 of
  8 | the License, or (at your option) any later version.
  9 | 
 10 | This library is distributed in the hope that it will be useful,
 11 | but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 | GNU Lesser General Public License for more details.
 14 | 
 15 | You should have received a copy of the GNU Lesser General Public
 16 | License along with this library.
 17 | If not, see <http://www.gnu.org/licenses/>.
 18 | */
 19 | using System;
 20 | using System.Collections.Generic;
 21 | using System.Text;
 22 | using MK.JavaScript.Dom;
 23 | using MK.JavaScript;
 24 | using MK.JavaScript.Reflection;
 25 | 
 26 | 
 27 | using HTMLElement = MK.JavaScript.Dom.Element;
 28 | 
 29 | namespace PrototypeJs {
 30 | 	[PrototypeJS("Prototype.Browser")]
 31 | 	public static class Browser {
 32 | 		[PrototypeJS("IE")]
 33 | 		public static readonly bool IE;
 34 | 		[PrototypeJS("Gecko")]
 35 | 		public static readonly bool Gecko;
 36 | 		[PrototypeJS("Opera")]
 37 | 		public static readonly bool Opera;
 38 | 		[PrototypeJS("WebKit")]
 39 | 		public static readonly bool WebKit;
 40 | 		[PrototypeJS("MobileSafari")]
 41 | 		public static readonly bool MobileSafari;
 42 | 	}
 43 | 	/// <summary>
 44 | 	/// Methods from prototypejs.org/api/object.html.
 45 | 	/// </summary>
 46 | 	[PrototypeJS("Object")]
 47 | 	public static class _Object {
 48 | 		#region PrototypeJS: Object (prototypejs.org/api/object.html)
 49 | 		//generics to avoid boxing/unboxing
 50 | 
 51 | 		/// <summary>
 52 | 		/// Returns a JSON string.
 53 | 		/// </summary>
 54 | 		[PrototypeJS]
 55 | 		public static string ToJSON<T>(this T obj) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 56 | 		/// <summary>
 57 | 		/// Returns true if obj is an array, false otherwise.
 58 | 		/// </summary>
 59 | 		[PrototypeJS]
 60 | 		public static bool IsArray<T>(this T obj) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 61 | 		/// <summary>
 62 | 		/// Returns true if obj is of type string, false otherwise.
 63 | 		/// </summary>
 64 | 		[PrototypeJS]
 65 | 		public static bool IsString<T>(this T obj) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 66 | 		/// <summary>
 67 | 		/// Returns true if obj is of type number, false otherwise.
 68 | 		/// </summary>
 69 | 		[PrototypeJS]
 70 | 		public static bool IsNumber<T>(this T obj) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 71 | 		#endregion
 72 | 	}
 73 | 	/// <summary>
 74 | 	/// Methods from prototypejs.org/api/string.html.
 75 | 	/// </summary>
 76 | 	public static class _String {
 77 | 		#region PrototypeJS: String (prototypejs.org/api/string.html)
 78 | 		/// <summary>
 79 | 		/// Converts HTML special characters to their entity equivalents.
 80 | 		/// </summary>
 81 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
 82 | 		public static string EscapeHTML(this string self) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 83 | 		#endregion
 84 | 	}
 85 | 	/// <summary>
 86 | 	/// Methods from prototypejs.org/api/element.html.
 87 | 	/// </summary>
 88 | 	public static class _Element {
 89 | 		#region PrototypeJS: Element (prototypejs.org/api/element.html)
 90 | 		/// <summary>
 91 | 		/// Removes element’s CSS className and returns element.
 92 | 		/// </summary>
 93 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
 94 | 		public static HTMLElement RemoveClassName(this HTMLElement element, string className) { throw new InvalidOperationException(JS.CannotRunAtServer); }
 95 | 		/// <summary>
 96 | 		/// Adds a CSS class to element.
 97 | 		/// </summary>
 98 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
 99 | 		public static HTMLElement AddClassName(this HTMLElement element, string className) { throw new InvalidOperationException(JS.CannotRunAtServer); }
100 | 		/// <summary>
101 | 		/// Takes an arbitrary number of CSS selectors (strings) and returns an array of extended descendants of element that match any of them.
102 | 		/// </summary>
103 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
104 | 		public static HTMLElement[] Select(this HTMLElement element, params string[] selector) { throw new InvalidOperationException(JS.CannotRunAtServer); }
105 | 		/// <summary>
106 | 		/// Hides and returns element.
107 | 		/// </summary>
108 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
109 | 		public static HTMLElement Hide(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
110 | 		/// <summary>
111 | 		/// Displays and returns element.
112 | 		/// </summary>
113 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
114 | 		public static HTMLElement Show(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
115 | 		/// <summary>
116 | 		/// Modifies element’s CSS style properties. Styles are passed as a hash of property-value pairs in which the properties are specified in their camelized form.
117 | 		/// </summary>
118 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
119 | 		public static HTMLElement SetStyle(this HTMLElement element, string styles) {
120 | 			element["style"] = styles;
121 | 			return element;
122 | 		}
123 | 		/// <summary>
124 | 		/// Checks whether element has the given CSS className.
125 | 		/// </summary>
126 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
127 | 		public static bool HasClassName(this HTMLElement element, string className) { throw new InvalidOperationException(JS.CannotRunAtServer); }
128 | 		/// <summary>
129 | 		/// Inserts content before, after, at the top of, or at the bottom of element, as specified by the position property of the second argument. If the second argument is the content itself, insert will append it to element.
130 | 		/// </summary>
131 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
132 | 		public static HTMLElement Insert(this HTMLElement element, Dictionary<string, HTMLElement> content) { throw new InvalidOperationException(JS.CannotRunAtServer); }
133 | 		#endregion
134 | 	}
135 | 	/// <summary>
136 | 	/// Methods from prototypejs.org/api/form/element.html.
137 | 	/// </summary>
138 | 	public static class _Form_Element {
139 | 		#region PrototypeJS: Form.Element (prototypejs.org/api/form/element.html)
140 | 		/// <summary>
141 | 		/// Gives focus to a form control and selects its contents if it is a text input.
142 | 		/// </summary>
143 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
144 | 		public static HTMLElement Activate(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
145 | 		/// <summary>
146 | 		/// Clears the contents of a text input.
147 | 		/// </summary>
148 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
149 | 		public static HTMLElement Clear(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
150 | 		/// <summary>
151 | 		/// Disables a form control, effectively preventing its value to be changed until it is enabled again.
152 | 		/// </summary>
153 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
154 | 		public static HTMLElement Disable(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
155 | 		/// <summary>
156 | 		/// Enables a previously disabled form control.
157 | 		/// </summary>
158 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
159 | 		public static HTMLElement Enable(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
160 | 		/// <summary>
161 | 		/// Gives keyboard focus to an element.
162 | 		/// </summary>
163 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
164 | 		public static HTMLElement Focus(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
165 | 		/// <summary>
166 | 		/// Selects the current text in a text input.
167 | 		/// </summary>
168 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
169 | 		public static HTMLElement Select(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
170 | 		/// <summary>
171 | 		/// Creates an URL-encoded string representation of a form control in the name=value format.
172 | 		/// </summary>
173 | 		[PrototypeJS(CallType = NativeCallType.Instance)]
174 | 		public static string Serialize(this HTMLElement element) { throw new InvalidOperationException(JS.CannotRunAtServer); }
175 | 		#endregion
176 | 	}
177 | 	public enum KeyCode {
178 | 		Backspace = 8,
179 | 		Tab = 9,
180 | 		Return = 13,
181 | 		Escape = 27,
182 | 		Left = 37,
183 | 		Up = 38,
184 | 		Right = 39,
185 | 		Down = 40,
186 | 		Delete = 46,
187 | 		Home = 36,
188 | 		End = 35,
189 | 		PageUp = 33,
190 | 		PageDown = 34,
191 | 		Insert = 45,
192 | 	}
193 | 
194 | 	[PrototypeJS]
195 | 	public static class Event {
196 | 
197 | 		///// <summary>
198 | 		///// In order to use this function, add following to prototype.js:
199 | 		///// <para>version 1.6.0.3 (line 4052)</para>
200 | 		///// <![CDATA[
201 | 		///// //@author(mkol@smp.if.uj.edu.pl){
202 | 		/////		call:function(e,eventName){
203 | 		/////			var list=null;
204 | 		/////			if((list=cache[getEventID(e)])&&(list=list[eventName])){
205 | 		/////				var event={element:function(){return e}};
206 | 		/////				list.each(function(wrapper) {
207 | 		/////					wrapper.handler.call(e,event);
208 | 		/////	      });				
209 | 		/////			}
210 | 		/////      return e;
211 | 		/////		},
212 | 		///// //@}
213 | 		///// ]]>
214 | 		///// <para>version 1.7</para>
215 | 		///// Add content of https://github.com/kangax/protolicious/blob/5b56fdafcd7d7662c9d648534225039b2e78e371/event.simulate.js changing `simulate` to `call` to prototype.js
216 | 		///// </summary>
217 | 
218 | 		/// <summary>
219 | 		/// In order to use this function, add content of https://github.com/kangax/protolicious/blob/5b56fdafcd7d7662c9d648534225039b2e78e371/event.simulate.js changing `simulate` to `call` to prototype.js
220 | 		/// </summary>
221 | 		[PrototypeJS]
222 | 		public static Element Call(Element element, string eventName) { throw new InvalidOperationException(JS.CannotRunAtServer); }
223 | 		/// <summary>
224 | 		/// Stops the event’s propagation and prevents its default action from being triggered eventually.
225 | 		/// </summary>
226 | 		[PrototypeJS]
227 | 		public static void Stop(JSEventArgs args) { throw new InvalidOperationException(JS.CannotRunAtServer); }
228 | 
229 | 		[PrototypeJS(Code = "Event.observe($0,$2,$1)")]
230 | 		public static void Observe(object obj, JSEventHandler handler, string eventName) { throw new InvalidOperationException(JS.CannotRunAtServer); }
231 | 		[PrototypeJS(Code = "Event.stopObserving($0,$2,$1)")]
232 | 		public static void StopObserving(object obj, JSEventHandler handler, string eventName) { throw new InvalidOperationException(JS.CannotRunAtServer); }
233 | 
234 | 	}
235 | 
236 | 	[PrototypeJS]
237 | 	public static class Ajax {
238 | 		[PrototypeJS]
239 | 		public static class Responders {
240 | 			[PrototypeJS(
241 | 				Code = @"
242 | function(a,b,c){
243 | 	c={};
244 | 	c['on'+b]=$handler$(a);
245 | 	Ajax.Responders.register(c)
246 | }
247 | "
248 | 			)]
249 | 			public static void Register(Action handler, string eventName) { throw new InvalidOperationException(JS.CannotRunAtServer); }
250 | #warning public static void Unregister(Action handler, string eventName) { throw new Exception("Not supported by .net2js framework"); }
251 | 			[PrototypeJS]
252 | 			public static void Unregister(Action handler, string eventName) { throw new Exception("Not supported by .net2js framework"); }
253 | 		}
254 | 	}
255 | }
256 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## Framework
2 | 
3 | Contains source codes for Framework.dll.
4 | 
5 | ## Compiler
6 | 
7 | Contains source codes for il2js.exe compiler.
8 | 


--------------------------------------------------------------------------------