?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[mono/tests] Fix out of tree build.
[mono-project.git] / mcs / tools / culevel / CompileUplevel.cs
blob6eba5927897093b7c44b8ac1f93ff7a057e197e6
1 //
2 // Authors:
3 // Marek Habersack (mhabersack@novell.com)
4 //
5 // (C) 2007 Novell, Inc
6 //
7
8 //
9 // Permission is hereby granted, free of charge, to any person obtaining
10 // a copy of this software and associated documentation files (the
11 // "Software"), to deal in the Software without restriction, including
12 // without limitation the rights to use, copy, modify, merge, publish,
13 // distribute, sublicense, and/or sell copies of the Software, and to
14 // permit persons to whom the Software is furnished to do so, subject to
15 // the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be
18 // included in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 using System;
29 using System.CodeDom;
30 using System.CodeDom.Compiler;
31 using System.Collections;
32 using System.IO;
33 using System.Reflection;
34 using System.Text;
35 using System.Xml;
36 using Microsoft.CSharp;
37
38 namespace Mono.Tools
39 {
40 class Position
41 {
42 int start = -1;
43 int end = -1;
44
45 public int Start {
46 get { return start; }
47 }
48
49 public int End {
50 get { return end; }
51 }
52
53 public int RequiredUALength {
54 get {
55 if (end == -1)
56 return start;
57 return end;
58 }
59 }
60
61 public override string ToString ()
62 {
63 StringBuilder sb = new StringBuilder ("Position {");
64 sb.AppendFormat ("{0}", start);
65 if (end != -1)
66 sb.AppendFormat (",{0}}}", end);
67 else
68 sb.Append ("}");
69
70 return sb.ToString ();
71 }
72
73 public Position (string positions)
74 {
75 if (positions == null || positions.Length == 0)
76 throw new ArgumentException ("'positions' must not be null or empty");
77
78 string[] pa = positions.Split ('-');
79
80 if (pa.Length > 2)
81 throw new ApplicationException ("Syntax error in the positions attribute - only one dash can be present");
82
83 try {
84 start = Int32.Parse (pa [0]);
85 } catch (Exception) {
86 throw new ApplicationException ("The 'positions' attribute has invalid syntax");
87 }
88
89 if (start < 0)
90 throw new ApplicationException ("Start must be 0 or more.");
91
92 if (pa.Length == 2) {
93 try {
94 end = Int32.Parse (pa [1]);
95 } catch (Exception) {
96 throw new ApplicationException ("The 'positions' attribute has invalid syntax");
97 }
98
99 if (end < start)
100 throw new ApplicationException ("End of range must not be smaller than its start");
101
102 if (end == start)
103 end = -1;
104 }
105 }
106
107 public CodeBinaryOperatorExpression GetExpression (string match)
108 {
109 int poslen;
110
111 if (end == -1)
112 poslen = 0;
113 else
114 poslen = end - start;
115 poslen++;
116
117 if (match.Length != poslen)
118 throw new ApplicationException (
119 String.Format ("Match string '{0}' has incorrect length (expected {1})", match, poslen));
120
121 CodeBinaryOperatorExpression expr = new CodeBinaryOperatorExpression ();
122
123 if (poslen == 1) {
124 expr.Left = new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("ua"),
125 new CodePrimitiveExpression (Start));
126 expr.Operator = CodeBinaryOperatorType.ValueEquality;
127 expr.Right = new CodePrimitiveExpression (match [0]);
128 } else {
129 CodeBinaryOperatorExpression cur = expr, prev = expr, tmp;
130 int i, pos;
131
132 for (i = 0, pos = Start; i < poslen; i++, pos++) {
133 tmp = new CodeBinaryOperatorExpression ();
134 tmp.Left = new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("ua"),
135 new CodePrimitiveExpression (pos));
136 tmp.Operator = CodeBinaryOperatorType.ValueEquality;
137 tmp.Right = new CodePrimitiveExpression (match [i]);
138
139 if (i + 1 < poslen) {
140 cur.Left = tmp;
141 cur.Operator = CodeBinaryOperatorType.BooleanAnd;
142 prev.Right = cur;
143 prev = cur;
144 cur = new CodeBinaryOperatorExpression ();
145 } else
146 prev.Right = tmp;
147 }
148 }
149
150 return expr;
151 }
152 }
153
154 class GroupDefinition
155 {
156 readonly CodeMethodReturnStatement returnTrue = new CodeMethodReturnStatement (new CodePrimitiveExpression (true));
157 readonly CodeMethodReturnStatement returnFalse = new CodeMethodReturnStatement (new CodePrimitiveExpression (false));
158
159 ArrayList positions = null;
160 ArrayList matches = null;
161 ArrayList childGroups;
162 ArrayList exceptions;
163
164 bool defaultJS = true;
165 int scanfrom = -1;
166 int skip = -1;
167 int level = 0;
168 int groupId = 0;
169
170 public Position[] Positions {
171 get {
172 if (positions == null)
173 return null;
174 return (Position[]) positions.ToArray (typeof (Position));
175 }
176 }
177
178 public string[] Matches {
179 get {
180 if (matches == null)
181 return null;
182 return (string[]) matches.ToArray (typeof (string));
183 }
184 }
185
186 public ArrayList ChildGroups {
187 get { return childGroups; }
188 }
189
190 public bool DefaultJS {
191 get { return defaultJS; }
192 }
193
194 public int ScanFrom {
195 get { return scanfrom; }
196 }
197
198 public int Skip {
199 get { return skip; }
200 }
201
202 public bool Positional {
203 get { return positions != null; }
204 }
205
206 public bool GroupZero {
207 get { return positions == null && matches == null && scanfrom == -1 && skip == -1; }
208 }
209
210 public int Level {
211 get { return level; }
212 set { level = value; }
213 }
214
215 public int GroupId {
216 get { return groupId; }
217 set { groupId = value; }
218 }
219
220 public override string ToString ()
221 {
222 if (GroupZero)
223 return "GroupZero";
224
225 StringBuilder sb = new StringBuilder ("Group: ");
226 if (Positional) {
227 sb.Append ("positions =");
228 foreach (Position p in positions)
229 sb.AppendFormat (" [{0}]", p.ToString ());
230 } else {
231 sb.AppendFormat ("scanfrom {0}, skip {1}", scanfrom, skip);
232 }
233
234 sb.Append ("; matches =");
235 foreach (string m in matches)
236 sb.AppendFormat (" [{0}]", m);
237
238 return sb.ToString ();
239 }
240
241 public GroupDefinition ()
242 {
243 childGroups = new ArrayList ();
244 }
245
246 public GroupDefinition (XmlReader reader)
247 {
248 childGroups = new ArrayList ();
249
250 string positions = reader.GetAttribute ("positions");
251 string scanfrom = reader.GetAttribute ("scanfrom");
252
253 if (positions != null && scanfrom != null)
254 throw new ApplicationException ("The 'positions' and 'scanfrom' attributes are mutually exclusive");
255 if ((positions == null || positions.Length == 0) && (scanfrom == null || scanfrom.Length == 0))
256 throw new ApplicationException ("Exactly one of the 'positions' or 'scanfrom' attributes must be present and have a value");
257
258 if (positions != null)
259 InitPositions (reader, positions);
260 else
261 InitScanfrom (reader, scanfrom);
262
263 string javascript = reader.GetAttribute ("javascript");
264 if (javascript != null && javascript.Length > 0) {
265 try {
266 defaultJS = Boolean.Parse (javascript);
267 } catch (Exception) {
268 throw new ApplicationException ("Invalid value of the 'javascript' attribute. Must be a valid boolean value (true or false)");
269 }
270 }
271
272 string match = reader.GetAttribute ("match");
273 if (match == null || match.Length == 0)
274 throw new ApplicationException ("Missing the 'match' attribute");
275
276 InitMatches (match);
277 }
278
279 public void AddExcept (XmlReader reader)
280 {
281 if (exceptions == null)
282 exceptions = new ArrayList ();
283
284 exceptions.Add (new GroupDefinition (reader));
285 }
286
287 void InitMatches (string match)
288 {
289 if (positions != null) {
290 string[] ma = match.Split (',');
291
292 if (ma.Length != positions.Count)
293 throw new ApplicationException ("Number of matches provided in the 'match' attribute is different that the number of positions.");
294
295 matches = new ArrayList (ma.Length);
296 foreach (string m in ma)
297 matches.Add (m);
298 } else {
299 matches = new ArrayList (1);
300 matches.Add (match);
301 }
302 }
303
304 void InitPositions (XmlReader reader, string positions)
305 {
306 string[] pa = positions.Split (',');
307 this.positions = new ArrayList (pa.Length);
308 foreach (string p in pa)
309 this.positions.Add (new Position (p.Trim ()));
310 }
311
312 void InitScanfrom (XmlReader reader, string scanfrom)
313 {
314 string skip = reader.GetAttribute ("skip");
315
316 if (skip == null || skip.Length == 0)
317 this.skip = 0;
318 else {
319 try {
320 this.skip = Int32.Parse (skip);
321 } catch (Exception) {
322 throw new ApplicationException ("Invalid value of the 'skip' attribute. Must be an integer.");
323 }
324 }
325
326 try {
327 this.scanfrom = Int32.Parse (scanfrom);
328 } catch (Exception) {
329 throw new ApplicationException ("Invalid value of the 'scanfrom' attribute. Must be an integer.");
330 }
331 }
332
333 public CodeCompileUnit GenerateCode ()
334 {
335 if (!GroupZero)
336 throw new ApplicationException ("Code can be generated only by GroupZero");
337
338 CodeCompileUnit unit = new CodeCompileUnit ();
339 CodeNamespace ns = new CodeNamespace ("System.Web");
340 unit.Namespaces.Add (ns);
341
342 ns.Imports.Add (new CodeNamespaceImport ("System"));
343
344 CodeTypeDeclaration mainClass = new CodeTypeDeclaration ("UplevelHelper");
345 mainClass.TypeAttributes = TypeAttributes.Class |
346 TypeAttributes.Sealed |
347 TypeAttributes.NotPublic |
348 TypeAttributes.NestedAssembly;
349 ns.Types.Add (mainClass);
350
351 GenerateMethod (mainClass);
352 return unit;
353 }
354
355 CodeMemberMethod GetMainMethod ()
356 {
357 CodeMemberMethod mainMethod = new CodeMemberMethod ();
358 mainMethod.Name = "IsUplevel";
359 mainMethod.ReturnType = new CodeTypeReference (typeof (bool));
360 mainMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "ua"));
361 mainMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static | MemberAttributes.Final;
362
363 // if (ua == null)
364 // return false;
365 CodeBinaryOperatorExpression uaNull = new CodeBinaryOperatorExpression ();
366 uaNull.Left = new CodeArgumentReferenceExpression ("ua");
367 uaNull.Operator = CodeBinaryOperatorType.ValueEquality;
368 uaNull.Right = new CodePrimitiveExpression (null);
369 mainMethod.Statements.Add (new CodeConditionStatement (uaNull, returnFalse));
370
371 // int ualength = ua.Length;
372 mainMethod.Statements.Add (
373 new CodeVariableDeclarationStatement (
374 typeof (int),
375 "ualength",
376 new CodePropertyReferenceExpression (new CodeArgumentReferenceExpression ("ua"), "Length"))
377 );
378
379 // if (ualength == 0)
380 // return false;
381 CodeBinaryOperatorExpression uaEmpty = new CodeBinaryOperatorExpression ();
382 uaEmpty.Left = new CodeVariableReferenceExpression ("ualength");
383 uaEmpty.Operator = CodeBinaryOperatorType.ValueEquality;
384 uaEmpty.Right = new CodePrimitiveExpression (0);
385 mainMethod.Statements.Add (new CodeConditionStatement (uaEmpty, returnFalse));
386
387 // bool hasJavaScript = false;
388 mainMethod.Statements.Add (
389 new CodeVariableDeclarationStatement (typeof (bool), "hasJavaScript",
390 new CodePrimitiveExpression (false)));
391
392 return mainMethod;
393 }
394
395 CodeMemberMethod GetGroupMethod ()
396 {
397 CodeMemberMethod groupMethod = new CodeMemberMethod ();
398 groupMethod.Name = String.Format ("DetermineUplevel_{0}_{1}", level, groupId);
399 groupMethod.ReturnType = new CodeTypeReference (typeof (bool));
400 groupMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "ua"));
401 CodeParameterDeclarationExpression hasJavaScript =
402 new CodeParameterDeclarationExpression (typeof (bool), "hasJavaScript");
403
404 hasJavaScript.Direction = FieldDirection.Out;
405 groupMethod.Parameters.Add (hasJavaScript);
406 groupMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "ualength"));
407 groupMethod.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final;
408
409 // hasJavaScript = <valueOf_DefaultJS>;
410 CodeAssignStatement assign = new CodeAssignStatement (new CodeVariableReferenceExpression ("hasJavaScript"),
411 new CodePrimitiveExpression (DefaultJS));
412 groupMethod.Statements.Add (assign);
413
414 return groupMethod;
415 }
416
417 ArrayList GenerateExceptions (CodeTypeDeclaration mainClass, bool assignHasJavaScript)
418 {
419 if (exceptions == null || exceptions.Count == 0)
420 return null;
421
422 ArrayList matches = new ArrayList (exceptions.Count);
423 CodeConditionStatement match;
424
425 foreach (GroupDefinition gd in exceptions) {
426 match = gd.GenerateConditionStatement (mainClass);
427 matches.Add (match);
428
429 if (assignHasJavaScript && gd.Positional)
430 match.TrueStatements.Add (new CodeAssignStatement (
431 new CodeVariableReferenceExpression ("hasJavaScript"),
432 new CodePrimitiveExpression (false)));
433 if (!assignHasJavaScript || GroupZero)
434 match.TrueStatements.Add (returnFalse);
435 else
436 match.TrueStatements.Add (returnTrue);
437 }
438
439 return matches;
440 }
441
442 CodeMemberMethod GenerateMethod (CodeTypeDeclaration mainClass)
443 {
444 CodeMemberMethod method;
445
446 if (GroupZero)
447 method = GetMainMethod ();
448 else
449 method = GetGroupMethod ();
450
451 mainClass.Members.Add (method);
452 CodeConditionStatement matches, subMatches;
453 ArrayList reverseMatches;
454 CodeMemberMethod childMethod;
455 CodeExpression hasJSRef = GroupZero ?
456 (CodeExpression) new CodeVariableReferenceExpression ("hasJavaScript") :
457 (CodeExpression) new CodeArgumentReferenceExpression ("hasJavaScript");
458
459 reverseMatches = GenerateExceptions (mainClass, !GroupZero);
460 if (reverseMatches != null && reverseMatches.Count > 0)
461 foreach (CodeConditionStatement ccs in reverseMatches)
462 method.Statements.Add (ccs);
463
464 if (childGroups.Count > 0) {
465 CodeDirectionExpression hasJavaScript = new CodeDirectionExpression (FieldDirection.Out, hasJSRef);
466 CodeExpression ualengthRef = GroupZero ?
467 (CodeExpression) new CodeVariableReferenceExpression ("ualength") :
468 (CodeExpression) new CodeArgumentReferenceExpression ("ualength");
469
470 int groupId = 0;
471
472 CodeMethodReturnStatement returnHasJS = new CodeMethodReturnStatement (
473 new CodeVariableReferenceExpression ("hasJavaScript"));
474
475 foreach (GroupDefinition gd in childGroups) {
476 matches = gd.GenerateConditionStatement (mainClass);
477
478 if (gd.ChildGroups.Count > 0) {
479 childMethod = gd.GenerateMethod (mainClass);
480
481 subMatches = new CodeConditionStatement ();
482 subMatches.Condition = new CodeMethodInvokeExpression (
483 new CodeMethodReferenceExpression (
484 new CodeTypeReferenceExpression ("UplevelHelper"), childMethod.Name),
485 new CodeExpression[] {new CodeArgumentReferenceExpression ("ua"),
486 hasJavaScript, ualengthRef}
487 );
488 subMatches.TrueStatements.Add (returnHasJS);
489 subMatches.FalseStatements.Add (new CodeMethodReturnStatement (
490 new CodePrimitiveExpression (false))
491 );
492
493 matches.TrueStatements.Add (subMatches);
494 } else {
495 reverseMatches = gd.GenerateExceptions (mainClass, !GroupZero);
496 if (reverseMatches != null && reverseMatches.Count > 0)
497 foreach (CodeConditionStatement ccs in reverseMatches)
498 matches.TrueStatements.Add (ccs);
499
500 if (!GroupZero && gd.Positional)
501 matches.TrueStatements.Add (
502 new CodeAssignStatement (
503 new CodeVariableReferenceExpression ("hasJavaScript"),
504 new CodePrimitiveExpression (true))
505 );
506 matches.TrueStatements.Add (returnTrue);
507 }
508 method.Statements.Add (matches);
509 groupId++;
510 }
511
512 // return false;
513 method.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (false)));
514 } else
515 // return <valueOf_DefaultJS>
516 method.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (DefaultJS)));
517
518 return method;
519 }
520
521 CodeConditionStatement GenerateConditionStatement (CodeTypeDeclaration mainClass)
522 {
523 CodeConditionStatement ret = new CodeConditionStatement ();
524
525 if (Positional)
526 ret.Condition = GeneratePositionalExpression ();
527 else
528 ret.Condition = GenerateScanfromExpression (mainClass);
529
530 return ret;
531 }
532
533 CodeExpression GeneratePositionalExpression ()
534 {
535 Position[] positions = Positions;
536 string[] matches = Matches;
537 ArrayList components = new ArrayList ();
538
539 int i, reqLength = 0;
540 Position p;
541
542 for (i = 0; i < positions.Length; i++) {
543 p = positions [i];
544 components.Add (p.GetExpression (matches [i]));
545 if (p.RequiredUALength > reqLength)
546 reqLength = p.RequiredUALength;
547 }
548
549 CodeBinaryOperatorExpression expr = null;
550
551 int complen = components.Count;
552 i = 0;
553
554 if (complen == 1)
555 expr = components [0] as CodeBinaryOperatorExpression;
556 else {
557 expr = new CodeBinaryOperatorExpression ();
558 CodeBinaryOperatorExpression cur = expr, prev = expr;
559 foreach (CodeBinaryOperatorExpression op in components) {
560 if (i + 1 < complen) {
561 cur.Left = op;
562 cur.Operator = CodeBinaryOperatorType.BooleanAnd;
563 prev.Right = cur;
564 prev = cur;
565 cur = new CodeBinaryOperatorExpression ();
566 } else {
567 prev.Right = op;
568 }
569 i++;
570 }
571 }
572
573 CodeBinaryOperatorExpression sizeCheck = new CodeBinaryOperatorExpression ();
574 sizeCheck.Left = GroupZero ?
575 (CodeExpression) new CodeVariableReferenceExpression ("ualength") :
576 (CodeExpression) new CodeArgumentReferenceExpression ("ualength");
577 sizeCheck.Operator = CodeBinaryOperatorType.GreaterThan;
578 sizeCheck.Right = new CodePrimitiveExpression (reqLength);
579
580 CodeBinaryOperatorExpression ret = new CodeBinaryOperatorExpression ();
581 ret.Left = sizeCheck;
582 ret.Operator = CodeBinaryOperatorType.BooleanAnd;
583 ret.Right = expr;
584
585 return ret;
586 }
587
588 CodeMemberMethod GenerateScanMethod ()
589 {
590 CodeMemberMethod method = new CodeMemberMethod ();
591 method.Name = String.Format ("ScanForMatch_{0}_{1}", level, groupId);
592
593 method.ReturnType = new CodeTypeReference (typeof (bool));
594 method.Parameters.Add (new CodeParameterDeclarationExpression (typeof (string), "ua"));
595 CodeParameterDeclarationExpression hasJavaScript =
596 new CodeParameterDeclarationExpression (typeof (bool), "hasJavaScript");
597
598 hasJavaScript.Direction = FieldDirection.Out;
599 method.Parameters.Add (hasJavaScript);
600 method.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "ualength"));
601 method.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final;
602
603 // hasJavaScript = <valueOf_DefaultJS>;
604 CodeAssignStatement assign = new CodeAssignStatement (new CodeVariableReferenceExpression ("hasJavaScript"),
605 new CodePrimitiveExpression (DefaultJS));
606
607 method.Statements.Add (assign);
608 return method;
609 }
610
611 CodeBinaryOperatorExpression GenerateScanCondition (string match, int matchLength, int startPosition)
612 {
613 CodeBinaryOperatorExpression ret = new CodeBinaryOperatorExpression ();
614
615 int endPosition = startPosition + matchLength - 1;
616 int matchStartPosition = 0;
617 int matchEndPosition = matchLength - 1;
618 CodeArgumentReferenceExpression uaRef = new CodeArgumentReferenceExpression ("ua");
619
620 if (matchLength == 1) {
621 ret.Left = new CodeArrayIndexerExpression (uaRef, new CodePrimitiveExpression (startPosition));
622 ret.Operator = CodeBinaryOperatorType.ValueEquality;
623 ret.Right = new CodePrimitiveExpression (match [matchStartPosition]);
624 return ret;
625 }
626
627 CodeBinaryOperatorExpression cur = ret, prev = null, lhs, rhs, tmp;
628
629 if (matchLength == 2) {
630 lhs = new CodeBinaryOperatorExpression ();
631 lhs.Left = new CodeArrayIndexerExpression (uaRef, new CodePrimitiveExpression (startPosition++));
632 lhs.Operator = CodeBinaryOperatorType.ValueEquality;
633 lhs.Right = new CodePrimitiveExpression (match [matchStartPosition]);
634
635 rhs = new CodeBinaryOperatorExpression ();
636 rhs.Left = new CodeArrayIndexerExpression (uaRef, new CodePrimitiveExpression (endPosition--));
637 rhs.Operator = CodeBinaryOperatorType.ValueEquality;
638 rhs.Right = new CodePrimitiveExpression (match [matchEndPosition]);
639
640 ret.Left = lhs;
641 ret.Operator = CodeBinaryOperatorType.BooleanAnd;
642 ret.Right = rhs;
643
644 return ret;
645 }
646
647 bool matchOdd = matchLength % 2 != 0;
648
649 while (matchLength >= 0) {
650 matchLength--;
651 if (!matchOdd || (matchOdd && (matchLength - 1) > 0)) {
652 lhs = new CodeBinaryOperatorExpression ();
653 lhs.Left = new CodeArrayIndexerExpression (
654 uaRef,
655 new CodeBinaryOperatorExpression (
656 new CodeVariableReferenceExpression ("startPosition"),
657 CodeBinaryOperatorType.Add,
658 new CodePrimitiveExpression (matchStartPosition))
659 );
660 lhs.Operator = CodeBinaryOperatorType.ValueEquality;
661 lhs.Right = new CodePrimitiveExpression (match [matchStartPosition]);
662
663 rhs = new CodeBinaryOperatorExpression ();
664 rhs.Left = new CodeArrayIndexerExpression (
665 uaRef,
666 new CodeBinaryOperatorExpression (
667 new CodeVariableReferenceExpression ("endPosition"),
668 CodeBinaryOperatorType.Subtract,
669 new CodePrimitiveExpression (matchEndPosition - matchLength))
670 );
671
672 rhs.Operator = CodeBinaryOperatorType.ValueEquality;
673 rhs.Right = new CodePrimitiveExpression (match [matchEndPosition]);
674
675 tmp = new CodeBinaryOperatorExpression (lhs, CodeBinaryOperatorType.BooleanAnd, rhs);
676 matchLength--;
677 } else {
678 tmp = new CodeBinaryOperatorExpression ();
679 tmp.Left = new CodeArrayIndexerExpression (
680 uaRef,
681 new CodeBinaryOperatorExpression (
682 new CodeVariableReferenceExpression ("startPosition"),
683 CodeBinaryOperatorType.Add,
684 new CodePrimitiveExpression (matchStartPosition - 1))
685 );
686 tmp.Operator = CodeBinaryOperatorType.ValueEquality;
687 tmp.Right = new CodePrimitiveExpression (match [matchStartPosition - 1]);
688 }
689
690 if (matchLength - 1 >= 0) {
691 cur.Left = tmp;
692 cur.Operator = CodeBinaryOperatorType.BooleanAnd;
693 if (prev != null)
694 prev.Right = cur;
695 prev = cur;
696 cur = new CodeBinaryOperatorExpression ();
697 } else
698 prev.Right = tmp;
699
700 matchStartPosition++;
701 matchEndPosition--;
702 }
703
704 return ret;
705 }
706
707 CodeExpression GenerateScanfromExpression (CodeTypeDeclaration mainClass)
708 {
709 CodeMemberMethod method = GenerateScanMethod ();
710
711 int startPosition = scanfrom + skip;
712 string match = matches [0] as string;
713 int matchLength = match.Length;
714 int minsize = startPosition + matchLength + 1;
715
716 // if (ualength < minsize)
717 // return false;
718 CodeBinaryOperatorExpression uaSizeCheck = new CodeBinaryOperatorExpression ();
719 uaSizeCheck.Left = new CodeArgumentReferenceExpression ("ualength");
720 uaSizeCheck.Operator = CodeBinaryOperatorType.LessThan;
721 uaSizeCheck.Right = new CodePrimitiveExpression (minsize);
722 method.Statements.Add (
723 new CodeConditionStatement (uaSizeCheck,
724 new CodeMethodReturnStatement (new CodePrimitiveExpression (false))));
725
726 // int startPosition = 0;
727 method.Statements.Add (
728 new CodeVariableDeclarationStatement (typeof (int), "startPosition",
729 new CodePrimitiveExpression (0)));
730
731 // int endPosition = startPosition + matchLength;
732 method.Statements.Add (
733 new CodeVariableDeclarationStatement (
734 typeof (int), "endPosition",
735 new CodeBinaryOperatorExpression (
736 new CodeVariableReferenceExpression ("startPosition"),
737 CodeBinaryOperatorType.Add,
738 new CodePrimitiveExpression (matchLength - 1))
739 )
740 );
741
742 // for (int ualeft = ualength; ualeft >= matchlen; ualeft--) {
743 // if (<condition>) {
744 // hasJavaScript = true;
745 // return true;
746 // }
747 // startPosition++;
748 // endPosition++;
749 // }
750 CodeIterationStatement iter = new CodeIterationStatement ();
751 iter.InitStatement = new CodeVariableDeclarationStatement (
752 typeof (int), "ualeft", new CodeArgumentReferenceExpression ("ualength"));
753 iter.IncrementStatement = new CodeAssignStatement (
754 new CodeVariableReferenceExpression ("ualeft"),
755 new CodeBinaryOperatorExpression (new CodeVariableReferenceExpression ("ualeft"),
756 CodeBinaryOperatorType.Subtract,
757 new CodePrimitiveExpression (1))
758 );
759 iter.TestExpression = new CodeBinaryOperatorExpression (
760 new CodeVariableReferenceExpression ("ualeft"),
761 CodeBinaryOperatorType.GreaterThanOrEqual,
762 new CodePrimitiveExpression (matchLength)
763 );
764
765 CodeConditionStatement cond = new CodeConditionStatement (
766 GenerateScanCondition (match, matchLength, startPosition));
767
768 cond.TrueStatements.Add (
769 new CodeAssignStatement (new CodeArgumentReferenceExpression ("hasJavaScript"),
770 new CodePrimitiveExpression (true)));
771 cond.TrueStatements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (true)));
772 iter.Statements.Add (cond);
773 iter.Statements.Add (
774 new CodeAssignStatement (new CodeVariableReferenceExpression ("startPosition"),
775 new CodeBinaryOperatorExpression (
776 new CodeVariableReferenceExpression ("startPosition"),
777 CodeBinaryOperatorType.Add,
778 new CodePrimitiveExpression (1)))
779 );
780 iter.Statements.Add (
781 new CodeAssignStatement (new CodeVariableReferenceExpression ("endPosition"),
782 new CodeBinaryOperatorExpression (
783 new CodeVariableReferenceExpression ("endPosition"),
784 CodeBinaryOperatorType.Add,
785 new CodePrimitiveExpression (1)))
786 );
787 method.Statements.Add (iter);
788 method.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (false)));
789
790 mainClass.Members.Add (method);
791
792 return new CodeMethodInvokeExpression (
793 new CodeMethodReferenceExpression (new CodeTypeReferenceExpression ("UplevelHelper"), method.Name),
794 new CodeExpression[] {new CodeArgumentReferenceExpression ("ua"),
795 new CodeDirectionExpression (
796 FieldDirection.Out,
797 new CodeArgumentReferenceExpression ("hasJavaScript")),
798 new CodeArgumentReferenceExpression ("ualength")}
799 );
800 }
801 }
802
803 public class CompileUplevel
804 {
805 public static void Main (string[] args)
806 {
807 try {
808 CompileUplevel cu = new CompileUplevel ();
809 cu.Run (args);
810 } catch (Exception ex) {
811 Console.Error.WriteLine ("Exception caught while generating UplevelHelper code:");
812 Console.Error.Write (ex);
813 Console.Error.WriteLine ();
814 }
815 }
816
817 void Usage (string format, params object[] parms)
818 {
819 if (format != null && format.Length > 0) {
820 Console.Error.WriteLine (format, parms);
821 Environment.Exit (1);
822 }
823
824 Console.Error.WriteLine (@"Usage: culevel [OPTIONS] INPUT_FILE
825 Options:
826 -o|--o|-output|--output file to write the generated code to.
827 If not specified, output goes to the console
828 -h|--h|-help|--help show this usage information.
829 ");
830 Environment.Exit (0);
831 }
832
833 void DumpGroup (GroupDefinition gd, int indent)
834 {
835 Console.WriteLine ("{0}{1}", new String (' ', indent), gd.ToString ());
836 foreach (GroupDefinition gd2 in gd.ChildGroups)
837 DumpGroup (gd2, indent + 1);
838 }
839
840 void Run (string[] args)
841 {
842 if (args.Length < 1)
843 Usage ("Invalid number of parameters");
844
845 Stack context = new Stack ();
846 GroupDefinition groupZero = new GroupDefinition ();
847 GroupDefinition group, current;
848 XmlReader reader = null;
849 string outfile = null, infile = null;
850 string a;
851
852 for (int i = 0; i < args.Length; i++) {
853 a = args [i];
854 if (a [0] == '-' && a.Length > 1) {
855 a = a.Substring (1).Trim ();
856
857 switch (a.ToLower ()) {
858 case "o":
859 case "output":
860 case "-output":
861 i++;
862 if (i > args.Length)
863 Usage ("Missing output file name");
864 outfile = args [i];
865 break;
866
867 case "h":
868 case "help":
869 case "-help":
870 Usage (null);
871 break;
872
873 default:
874 Usage ("Unknown command line option: '{0}'", a);
875 break;
876 }
877 } else if (infile == null)
878 infile = args [i];
879 }
880
881 if (infile == null)
882 Usage ("Missing input file on the command line.");
883
884 try {
885 XmlNodeType nodeType;
886 int level = 1;
887 bool ingroup = false;
888
889 reader = new XmlTextReader (infile);
890 while (reader.Read ()) {
891 nodeType = reader.NodeType;
892 if (nodeType != XmlNodeType.Element && nodeType != XmlNodeType.EndElement)
893 continue;
894
895 current = context.Count > 0 ? context.Peek () as GroupDefinition : null;
896 if (ingroup && reader.LocalName == "except") {
897 if (current == null)
898 throw new ApplicationException ("Inside a group but there is no group on the stack");
899
900 current.AddExcept (reader);
901 continue;
902 }
903
904 if (reader.LocalName != "group")
905 continue;
906
907 if (reader.NodeType == XmlNodeType.EndElement) {
908 if (current == null)
909 throw new ApplicationException ("Found group end, but no current group on stack");
910 context.Pop ();
911 if (context.Count == 0) {
912 groupZero.ChildGroups.Add (current);
913 current.GroupId = groupZero.ChildGroups.Count;
914 }
915 level--;
916 ingroup = false;
917 continue;
918 }
919
920 group = new GroupDefinition (reader);
921 group.Level = level++;
922
923 if (current != null) {
924 current.ChildGroups.Add (group);
925 group.GroupId = current.ChildGroups.Count;
926 }
927
928 context.Push (group);
929 ingroup = true;
930 }
931 } catch (Exception) {
932 throw;
933 } finally {
934 if (reader != null)
935 reader.Close();
936 }
937
938 CodeCompileUnit unit = groupZero.GenerateCode ();
939 if (unit == null)
940 Environment.Exit (1);
941
942 CodeDomProvider provider = new CSharpCodeProvider ();
943 ICodeGenerator gen = provider.CreateGenerator ();
944
945 TextWriter tw;
946 if (outfile == null)
947 tw = Console.Out;
948 else
949 tw = new IndentedTextWriter (new StreamWriter (outfile, false), "\t");
950 gen.GenerateCodeFromCompileUnit (unit, tw, new CodeGeneratorOptions ());
951 if (outfile != null)
952 tw.Close ();
953 }
954 }
955 }
Mirror of the official Mono project git repository