This repository was archived by the owner on Jun 5, 2020. It is now read-only.
Repository navigation
Expand file tree
/
Copy pathConsole.cs
More file actions
278 lines (235 loc) · 10.5 KB
/
Copy pathConsole.cs
File metadata and controls
278 lines (235 loc) · 10.5 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
/*
Copyright 2014 Daniel Wirtz <dcode@dcode.io>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
using Jurassic;
using Jurassic.Library;
using SharpJS.Helpers;
using System;
using System.Collections.Generic;
namespace SharpJS.Libraries
{
public class Console : Module {
public readonly ConsoleConstructor Constructor;
public readonly ConsoleInstance /* Context-bound */ Instance;
public Console(Context context) : base(context) {
Constructor = new ConsoleConstructor(context);
Instance = Constructor.Construct(null, null);
Populate();
}
public override object Run() {
return Instance;
}
public override Module RegisterGlobals() {
Engine.SetGlobalValue("console", Instance);
return this;
}
public enum MessageStyle
{
Regular,
Information,
Warning,
Error,
}
public class ConsoleConstructor : ConstructorFunction
{
public ConsoleConstructor(Context context) : base(context, "Console", new ConsoleInstance(context.Engine.Object.InstancePrototype, false)) {
Populate();
}
[JSConstructorFunction]
public ConsoleInstance Construct(object stdout, object stderr) {
return new ConsoleInstance(Context, this.InstancePrototype);
}
}
public delegate void LogEventHandler(object sender, LogEventArgs e);
public class LogEventArgs : EventArgs
{
public MessageStyle Style;
public string Message;
public LogEventArgs(MessageStyle style, string message) {
Style = style;
Message = message;
}
}
public class ConsoleInstance : ContextObjectInstance
{
public string Prefix = null;
public event LogEventHandler DoLog;
// Prototype constructor
public ConsoleInstance(ObjectInstance nextPrototype, bool extended) : base(nextPrototype, true) {
if (!extended)
Populate();
}
// Instance constructor
public ConsoleInstance(Context context, ObjectInstance thisPrototype) : base(context, thisPrototype) {
}
[JSProperty(Name = "Console", IsEnumerable = true)]
public ConsoleConstructor Console_ {
get {
return Context.Console.Constructor;
}
}
[JSFunction(Name = "dir", IsEnumerable = true)]
public void dir(params object[] arguments) {
// TODO
Log(arguments);
}
[JSFunction(Name = "log", IsEnumerable = true)]
public void Log(params object[] arguments) {
Log(MessageStyle.Regular, FormatObjects(arguments));
}
[JSFunction(Name = "info", IsEnumerable = true)]
public void Info(params object[] arguments) {
Log(MessageStyle.Information, FormatObjects(arguments));
}
[JSFunction(Name = "error", IsEnumerable = true)]
public void Error(params object[] arguments) {
Log(MessageStyle.Error, FormatObjects(arguments));
}
[JSFunction(Name = "warn", IsEnumerable = true)]
public void Warn(params object[] arguments) {
Log(MessageStyle.Warning, FormatObjects(arguments));
}
public void Time(string label) {
TimeLabel timeLabel = new TimeLabel();
timeLabel.Name = label;
timeLabel.StartTime = DateTime.Now.Ticks / 10000;
}
public struct TimeLabel
{
public string Name;
public long StartTime;
}
/// <summary>
/// Logs a message to the console.
/// </summary>
/// <param name="style"> A style which influences the icon and text color. </param>
/// <param name="objects"> The objects to output to the console. These can be strings or
/// ObjectInstances. </param>
public void Log(MessageStyle style, object[] objects) {
// Convert the objects to a string.
var message = new System.Text.StringBuilder();
if (Prefix != null && Prefix.Length > 0) {
message.Append(Prefix);
message.Append(' ');
}
for (int i = 0; i < objects.Length; i++) {
if (i > 0)
message.Append(' ');
message.Append(TypeConverter.ToString(objects[i]));
}
// Allow event handlers to override default behaviour
if (DoLog != null) {
DoLog(this, new LogEventArgs(style, message.ToString()));
return;
}
#if !SILVERLIGHT
var original = System.Console.ForegroundColor;
switch (style) {
case MessageStyle.Information:
System.Console.ForegroundColor = ConsoleColor.White;
break;
case MessageStyle.Warning:
System.Console.ForegroundColor = ConsoleColor.Yellow;
break;
case MessageStyle.Error:
System.Console.ForegroundColor = ConsoleColor.Red;
break;
}
#endif
// Output the message to the console.
System.Console.WriteLine(message.ToString());
#if !SILVERLIGHT
if (style != MessageStyle.Regular)
System.Console.ForegroundColor = original;
#endif
}
}
// From FirebugConsole.cs:
/// <summary>
/// Formats a message. The objects provided will be converted to strings then
/// joined together in a space separated line. The first parameter can be a string
/// containing the following patterns:
/// %s String
/// %d, %i Integer
/// %f Floating point number
/// %o Object hyperlink
/// </summary>
/// <param name="items"> The items to format. </param>
/// <returns> An array containing formatted strings interspersed with objects. </returns>
public static object[] FormatObjects(object[] items) {
if (items.Length == 0)
return new object[0];
var result = new List<object>();
var formattedString = new System.Text.StringBuilder();
// If the first item is a string, then it is assumed to be a format string.
int itemsConsumed = 1;
if (items[0] is string) {
string formatString = (string)items[0];
int previousPatternIndex = 0, patternIndex;
while (items.Length > itemsConsumed) {
// Find a percent sign.
patternIndex = formatString.IndexOf('%', previousPatternIndex);
if (patternIndex == -1 || patternIndex == formatString.Length - 1)
break;
// Append the text that didn't contain a pattern to the result.
formattedString.Append(formatString, previousPatternIndex, patternIndex - previousPatternIndex);
// Extract the pattern type.
char patternType = formatString[patternIndex + 1];
// Determine the replacement string.
string replacement;
switch (patternType) {
case 's':
replacement = TypeConverter.ToString(items[itemsConsumed++]);
break;
case 'd':
case 'i':
var number = TypeConverter.ToNumber(items[itemsConsumed++]);
replacement = (number >= 0 ? Math.Floor(number) : Math.Ceiling(number)).ToString();
break;
case 'f':
replacement = TypeConverter.ToNumber(items[itemsConsumed++]).ToString();
break;
case '%':
replacement = "%";
break;
case 'o':
replacement = string.Empty;
if (formattedString.Length > 0)
result.Add(formattedString.ToString());
result.Add(items[itemsConsumed++]);
formattedString.Remove(0, formattedString.Length);
break;
default:
replacement = "%" + patternType;
break;
}
// Replace the pattern with the corresponding argument.
formattedString.Append(replacement);
// Start searching just after the end of the pattern.
previousPatternIndex = patternIndex + 2;
}
// Append the text that didn't contain a pattern to the result.
formattedString.Append(formatString, previousPatternIndex, formatString.Length - previousPatternIndex);
// Add the formatted string to the resulting array.
if (formattedString.Length > 0)
result.Add(formattedString.ToString());
// Append the items that weren't consumed to the end of the resulting array.
for (int i = itemsConsumed; i < items.Length; i++)
result.Add(items[i]);
return result.ToArray();
} else {
// The first item is not a string - just return the objects verbatim.
return items;
}
}
}
}