?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* ExternTable.cs (ExternTable.GetModuleTypeRef): 'module_table' can be
[mcs.git] / mbas / block.cs
blob6d76661e6226f2c56f530b83c8721a21df2f37ea
1 //
2 // block.cs: Block representation for the IL tree.
3 //
4 // Author:
5 // Rafael Teixeira (rafaelteixeirabr@hotmail.com)
6 // Miguel de Icaza (miguel@ximian.com)
7 // Martin Baulig (martin@gnome.org)
8 // Anirban Bhattacharjee (banirban@novell.com)
9 // Manjula GHM (mmanjula@novell.com)
10 // Satya Sudha K (ksathyasudha@novell.com)
11 //
12 // (C) 2001, 2002, 2003, 2004, 2005 Ximian, Inc.
13 //
14
15 using System;
16 using System.Text;
17 using System.Reflection;
18 using System.Reflection.Emit;
19 using System.Diagnostics;
20
21 namespace Mono.MonoBASIC {
22
23 using System.Collections;
24
25 /// <summary>
26 /// Block represents a VB.NET block.
27 /// </summary>
28 ///
29 /// <remarks>
30 /// This class is used in a number of places: either to represent
31 /// explicit blocks that the programmer places or implicit blocks.
32 ///
33 /// Implicit blocks are used as labels or to introduce variable
34 /// declarations.
35 /// </remarks>
36 public class Block : Statement {
37 public Block Parent;
38 public readonly bool Implicit;
39 public readonly Location StartLocation;
40 public Location EndLocation;
41
42 //
43 // The statements in this block
44 //
45 public ArrayList statements;
46
47 //
48 // An array of Blocks. We keep track of children just
49 // to generate the local variable declarations.
50 //
51 // Statements and child statements are handled through the
52 // statements.
53 //
54 ArrayList children;
55
56 //
57 // Labels. (label, block) pairs.
58 //
59 CaseInsensitiveHashtable labels;
60
61 //
62 // Keeps track of (name, type) pairs
63 //
64 CaseInsensitiveHashtable variables;
65
66 //
67 // Keeps track of constants
68 CaseInsensitiveHashtable constants;
69
70 //
71 // Maps variable names to ILGenerator.LocalBuilders
72 //
73 //CaseInsensitiveHashtable local_builders;
74
75 // to hold names of variables required for late binding
76 public const string lateBindingArgs = "1_LBArgs";
77 public const string lateBindingArgNames = "1_LBArgsNames";
78 public const string lateBindingCopyBack = "1_LBCopyBack";
79
80 bool isLateBindingRequired = false;
81
82 bool used = false;
83
84 static int id;
85
86 int this_id;
87
88 public Block (Block parent)
89 : this (parent, false, Location.Null, Location.Null)
90 { }
91
92 public Block (Block parent, bool implicit_block)
93 : this (parent, implicit_block, Location.Null, Location.Null)
94 { }
95
96 public Block (Block parent, bool implicit_block, Parameters parameters)
97 : this (parent, implicit_block, parameters, Location.Null, Location.Null)
98 { }
99
100 public Block (Block parent, Location start, Location end)
101 : this (parent, false, start, end)
102 { }
103
104 public Block (Block parent, Parameters parameters, Location start, Location end)
105 : this (parent, false, parameters, start, end)
106 { }
107
108 public Block (Block parent, bool implicit_block, Location start, Location end)
109 : this (parent, implicit_block, Parameters.EmptyReadOnlyParameters,
110 start, end)
111 { }
112
113 public Block (Block parent, bool implicit_block, Parameters parameters,
114 Location start, Location end)
115 {
116 if (parent != null)
117 parent.AddChild (this);
118 else {
119 // Top block
120 // Add variables that may be required for late binding
121 variables = new CaseInsensitiveHashtable ();
122 ArrayList rank_specifier = new ArrayList ();
123 ArrayList element = new ArrayList ();
124 element.Add (new EmptyExpression ());
125 rank_specifier.Add (element);
126 Expression e = Mono.MonoBASIC.Parser.DecomposeQI ("System.Object[]", start);
127 AddVariable (e, Block.lateBindingArgs, null, start);
128 e = Mono.MonoBASIC.Parser.DecomposeQI ("System.String[]", start);
129 AddVariable (e, Block.lateBindingArgNames, null, start);
130 e = Mono.MonoBASIC.Parser.DecomposeQI ("System.Boolean[]", start);
131 AddVariable (e, Block.lateBindingCopyBack, null, start);
132 }
133
134 this.Parent = parent;
135 this.Implicit = implicit_block;
136 this.parameters = parameters;
137 this.StartLocation = start;
138 this.EndLocation = end;
139 this.loc = start;
140 this_id = id++;
141 statements = new ArrayList ();
142 }
143
144 public bool IsLateBindingRequired {
145 get {
146 return isLateBindingRequired;
147 }
148 set {
149 isLateBindingRequired = value;
150 }
151 }
152
153 public int ID {
154 get {
155 return this_id;
156 }
157 }
158
159 public void AddChild (Block b)
160 {
161 if (children == null)
162 children = new ArrayList ();
163
164 children.Add (b);
165 }
166
167 public void SetEndLocation (Location loc)
168 {
169 EndLocation = loc;
170 }
171
172 /// <summary>
173 /// Verify if the current block has a labeled statement.
174 /// </summary>
175 ///
176 /// <returns>
177 /// false if desn't exist a labeled statement in this block or in its children. true
178 /// otherwise.
179 /// </returns>
180 public bool HasLabeledStatement {
181 get {
182 foreach( Statement s in statements ) {
183 if( s is LabeledStatement )
184 return true;
185 else if (s is Block )
186 return ( ((Block) s).HasLabeledStatement);
187 }
188 return false;
189 }
190 }
191
192 public bool HasGotoStatement {
193 get {
194 foreach( Statement s in statements ) {
195 if( s is Goto )
196 return true;
197 else if (s is Block )
198 return ( ((Block) s).HasLabeledStatement);
199 }
200 return false;
201 }
202 }
203
204 public string LabelName {
205 get {
206 foreach( Statement s in statements ) {
207 if( s is LabeledStatement )
208 return ((LabeledStatement)s).LabelName;
209 else if (s is Block )
210 return ( ((Block) s).LabelName);
211 }
212 return "";
213 }
214 }
215
216 /// <summary>
217 /// Adds a label to the current block.
218 /// </summary>
219 ///
220 /// <returns>
221 /// false if the name already exists in this block. true
222 /// otherwise.
223 /// </returns>
224 ///
225 /**
226 public bool AddLabel (string name, LabeledStatement target)
227 {
228 if (labels == null)
229 labels = new CaseInsensitiveHashtable ();
230 if (labels.Contains (name))
231 return false;
232
233 labels.Add (name, target);
234 return true;
235 }
236 **/
237
238
239 public bool AddLabel (string name, LabeledStatement target, Location loc)
240 {
241 /**
242 if (switch_block != null)
243 return switch_block.AddLabel (name, target, loc);
244 **/
245 Block cur = this;
246 while (cur != null) {
247
248 if (cur.DoLookupLabel (name) != null) {
249 Report.Error (
250 140, loc, "The label '" + name +"' is a duplicate");
251 return false;
252 }
253
254 if (!Implicit)
255 break;
256
257 cur = cur.Parent;
258 }
259
260 while (cur != null) {
261 if (cur.DoLookupLabel (name) != null) {
262 Report.Error (
263 158, loc,
264 "The label '"+ name +"' shadows another label " +
265 "by the same name in a containing scope.");
266 return false;
267 }
268
269 if (children != null) {
270 foreach (Block b in children) {
271 LabeledStatement s = b.DoLookupLabel (name);
272 if (s == null)
273 continue;
274 Report.Error (
275 158, s.Location,
276 "The label '"+ name +"' shadows another " +
277 "label by the same name in a " +
278 "containing scope.");
279 return false;
280 }
281 }
282 cur = cur.Parent;
283 }
284 if (labels == null)
285 labels = new CaseInsensitiveHashtable ();
286 if (labels.Contains (name))
287 return false;
288
289 labels.Add (name, target);
290 return true;
291
292 }
293
294 public LabeledStatement LookupLabel (string name)
295 {
296 LabeledStatement s = DoLookupLabel (name);
297 if (s != null)
298 return s;
299
300 if (children == null)
301 return null;
302
303 foreach (Block child in children) {
304 // if (!child.Implicit)
305 // continue;
306
307 s = child.LookupLabel (name);
308 if (s != null)
309 return s;
310 }
311
312 return null;
313 }
314
315 public LabeledStatement DoLookupLabel (string name)
316 {
317 if (labels != null){
318 if (labels.Contains (name))
319 return ((LabeledStatement) labels [name]);
320 }
321 /**
322 if (Parent != null)
323 return Parent.LookupLabel (name);
324 **/
325 return null;
326 }
327
328 VariableInfo this_variable = null;
329
330 // <summary>
331 // Returns the "this" instance variable of this block.
332 // See AddThisVariable() for more information.
333 // </summary>
334 public VariableInfo ThisVariable {
335 get {
336 if (this_variable != null)
337 return this_variable;
338 else if (Parent != null)
339 return Parent.ThisVariable;
340 else
341 return null;
342 }
343 }
344
345 Hashtable child_variable_names;
346
347 // <summary>
348 // Marks a variable with name @name as being used in a child block.
349 // If a variable name has been used in a child block, it's illegal to
350 // declare a variable with the same name in the current block.
351 // </summary>
352 public void AddChildVariableName (string name)
353 {
354 if (child_variable_names == null)
355 child_variable_names = new CaseInsensitiveHashtable ();
356
357 if (!child_variable_names.Contains (name))
358 child_variable_names.Add (name, true);
359 }
360
361 // <summary>
362 // Marks all variables from block @block and all its children as being
363 // used in a child block.
364 // </summary>
365 public void AddChildVariableNames (Block block)
366 {
367 if (block.Variables != null) {
368 foreach (string name in block.Variables.Keys)
369 AddChildVariableName (name);
370 }
371
372 foreach (Block child in block.children) {
373 if (child.Variables != null) {
374 foreach (string name in child.Variables.Keys)
375 AddChildVariableName (name);
376 }
377 }
378 }
379
380 // <summary>
381 // Checks whether a variable name has already been used in a child block.
382 // </summary>
383 public bool IsVariableNameUsedInChildBlock (string name)
384 {
385 if (child_variable_names == null)
386 return false;
387
388 return child_variable_names.Contains (name);
389 }
390
391 // <summary>
392 // This is used by non-static 'struct' constructors which do not have an
393 // initializer - in this case, the constructor must initialize all of the
394 // struct's fields. To do this, we add a "this" variable and use the flow
395 // analysis code to ensure that it's been fully initialized before control
396 // leaves the constructor.
397 // </summary>
398 public VariableInfo AddThisVariable (TypeContainer tc, Location l)
399 {
400 if (this_variable != null)
401 return this_variable;
402
403 this_variable = new VariableInfo (tc, ID, l);
404
405 if (variables == null)
406 variables = new CaseInsensitiveHashtable ();
407 variables.Add ("this", this_variable);
408
409 return this_variable;
410 }
411
412 public VariableInfo AddVariable (EmitContext ec, Expression type, string name, Location l)
413 {
414 if (!variables_initialized)
415 throw new InvalidOperationException();
416
417 VariableInfo vi = AddVariable(type, name, null, loc);
418
419 int priorCount = count_variables;
420 DeclSpace ds = ec.DeclSpace;
421
422 if (!vi.Resolve (ds)) {
423 vi.Number = -1;
424 } else {
425 vi.Number = ++count_variables;
426 if (vi.StructInfo != null)
427 count_variables += vi.StructInfo.Count;
428 }
429 if (priorCount < count_variables)
430 ec.CurrentBranching.CurrentUsageVector.AddExtraLocals(count_variables - priorCount);
431
432 return vi;
433 }
434
435
436
437 public VariableInfo AddVariable (Expression type, string name, Parameters pars, Location l, string Alias)
438 {
439 VariableInfo vi = AddVariable (type, name, pars, l);
440 if (vi != null)
441 vi.Alias = Alias;
442
443 return vi;
444 }
445
446 public VariableInfo AddVariable (Expression type, string name, Parameters pars, Location l)
447 {
448 if (variables == null)
449 variables = new CaseInsensitiveHashtable ();
450
451 VariableInfo vi = GetVariableInfo (name);
452 if (vi != null) {
453 if (vi.Block != ID)
454 Report.Error (30616, l, "A local variable named '" + name + "' " +
455 "cannot be declared in this scope since it would " +
456 "give a different meaning to '" + name + "', which " +
457 "is already used in a 'parent or current' scope to " +
458 "denote something else");
459 else
460 Report.Error (30290, l, "A local variable '" + name + "' is already " +
461 "defined in this scope");
462 return null;
463 }
464
465 if (IsVariableNameUsedInChildBlock (name)) {
466 Report.Error (136, l, "A local variable named '" + name + "' " +
467 "cannot be declared in this scope since it would " +
468 "give a different meaning to '" + name + "', which " +
469 "is already used in a 'child' scope to denote something " +
470 "else");
471 return null;
472 }
473
474 if (pars != null) {
475 int idx = 0;
476 Parameter p = pars.GetParameterByName (name, out idx);
477 if (p != null) {
478 Report.Error (30616, l, "A local variable named '" + name + "' " +
479 "cannot be declared in this scope since it would " +
480 "give a different meaning to '" + name + "', which " +
481 "is already used in a 'parent or current' scope to " +
482 "denote something else");
483 return null;
484 }
485 }
486
487 vi = new VariableInfo (type, name, ID, l);
488
489 variables.Add (name, vi);
490
491 return vi;
492 }
493
494 public bool AddConstant (Expression type, string name, Expression value, Parameters pars, Location l)
495 {
496 if (AddVariable (type, name, pars, l) == null)
497 return false;
498
499 if (constants == null)
500 constants = new CaseInsensitiveHashtable ();
501
502 constants.Add (name, value);
503 return true;
504 }
505
506 public Hashtable Variables {
507 get {
508 return variables;
509 }
510 }
511
512 public VariableInfo GetVariableInfo (string name)
513 {
514 if (variables != null) {
515 object temp;
516 temp = variables [name];
517
518 if (temp != null){
519 return (VariableInfo) temp;
520 }
521 }
522
523 if (Parent != null)
524 return Parent.GetVariableInfo (name);
525
526 return null;
527 }
528
529 public Expression GetVariableType (string name)
530 {
531 VariableInfo vi = GetVariableInfo (name);
532
533 if (vi != null)
534 return vi.Type;
535
536 return null;
537 }
538
539 public Expression GetConstantExpression (string name)
540 {
541 if (constants != null) {
542 object temp;
543 temp = constants [name];
544
545 if (temp != null)
546 return (Expression) temp;
547 }
548
549 if (Parent != null)
550 return Parent.GetConstantExpression (name);
551
552 return null;
553 }
554
555 /// <summary>
556 /// True if the variable named @name has been defined
557 /// in this block
558 /// </summary>
559 public bool IsVariableDefined (string name)
560 {
561 // Console.WriteLine ("Looking up {0} in {1}", name, ID);
562 if (variables != null) {
563 if (variables.Contains (name))
564 return true;
565 }
566
567 if (Parent != null)
568 return Parent.IsVariableDefined (name);
569
570 return false;
571 }
572
573 /// <summary>
574 /// True if the variable named @name is a constant
575 /// </summary>
576 public bool IsConstant (string name)
577 {
578 Expression e = null;
579
580 e = GetConstantExpression (name);
581
582 return e != null;
583 }
584
585 /// <summary>
586 /// Use to fetch the statement associated with this label
587 /// </summary>
588 public Statement this [string name] {
589 get {
590 return (Statement) labels [name];
591 }
592 }
593
594 Parameters parameters = null;
595 public Parameters Parameters {
596 get {
597 if (Parent != null)
598 return Parent.Parameters;
599
600 return parameters;
601 }
602 }
603
604 /// <returns>
605 /// A list of labels that were not used within this block
606 /// </returns>
607 public string [] GetUnreferenced ()
608 {
609 // FIXME: Implement me
610 return null;
611 }
612
613 public void AddStatement (Statement s)
614 {
615 statements.Add (s);
616 used = true;
617 }
618
619 public bool Used {
620 get {
621 return used;
622 }
623 }
624
625 public void Use ()
626 {
627 used = true;
628 }
629
630 bool variables_initialized = false;
631 int count_variables = 0, first_variable = 0;
632
633 void UpdateVariableInfo (EmitContext ec)
634 {
635 DeclSpace ds = ec.DeclSpace;
636
637 first_variable = 0;
638
639 if (Parent != null)
640 first_variable += Parent.CountVariables;
641
642 count_variables = first_variable;
643 if (variables != null) {
644 foreach (VariableInfo vi in variables.Values) {
645 if (!vi.Resolve (ds)) {
646 vi.Number = -1;
647 continue;
648 }
649
650 vi.Number = ++count_variables;
651
652 if (vi.StructInfo != null)
653 count_variables += vi.StructInfo.Count;
654 }
655 }
656
657 variables_initialized = true;
658 }
659
660 //
661 // <returns>
662 // The number of local variables in this block
663 // </returns>
664 public int CountVariables
665 {
666 get {
667 if (!variables_initialized)
668 throw new Exception ();
669
670 return count_variables;
671 }
672 }
673
674 /// <summary>
675 /// Emits the variable declarations and labels.
676 /// </summary>
677 /// <remarks>
678 /// tc: is our typecontainer (to resolve type references)
679 /// ig: is the code generator:
680 /// toplevel: the toplevel block. This is used for checking
681 /// that no two labels with the same name are used.
682 /// </remarks>
683 public void EmitMeta (EmitContext ec, Block toplevel)
684 {
685 //DeclSpace ds = ec.DeclSpace;
686 ILGenerator ig = ec.ig;
687
688 if (!variables_initialized)
689 UpdateVariableInfo (ec);
690
691 //
692 // Process this block variables
693 //
694 if (variables != null){
695 //local_builders = new CaseInsensitiveHashtable ();
696
697 foreach (DictionaryEntry de in variables){
698 string name = (string) de.Key;
699 /*
700 if (!isLateBindingRequired) {
701 if (name.Equals (Block.lateBindingArgs) ||
702 name.Equals (Block.lateBindingArgNames) ||
703 name.Equals (Block.lateBindingCopyBack))
704 continue;
705 }
706 */
707 VariableInfo vi = (VariableInfo) de.Value;
708
709 if (vi.VariableType == null)
710 continue;
711
712 if (vi.Alias == null)
713 vi.LocalBuilder = ig.DeclareLocal (vi.VariableType);
714
715 if (CodeGen.SymbolWriter != null && vi.LocalBuilder != null)
716 vi.LocalBuilder.SetLocalSymInfo (name);
717
718 if (constants == null)
719 continue;
720
721 Expression cv = (Expression) constants [name];
722 if (cv == null)
723 continue;
724
725 Expression e = cv.Resolve (ec);
726 if (e == null)
727 continue;
728
729 if (!(e is Constant)){
730 Report.Error (133, vi.Location,
731 "The expression being assigned to '" +
732 name + "' must be constant (" + e + ")");
733 continue;
734 }
735
736 constants.Remove (name);
737 constants.Add (name, e);
738 }
739 }
740
741 //
742 // Now, handle the children
743 //
744 if (children != null){
745 foreach (Block b in children)
746 b.EmitMeta (ec, toplevel);
747 }
748 }
749
750 public void UsageWarning ()
751 {
752 string name;
753
754 if (variables != null){
755 foreach (DictionaryEntry de in variables){
756 VariableInfo vi = (VariableInfo) de.Value;
757
758 if (vi.Used)
759 continue;
760
761 name = (string) de.Key;
762
763 if (vi.Assigned){
764 Report.Warning (
765 219, vi.Location, "The variable '" + name +
766 "' is assigned but its value is never used");
767 } else {
768 if (!(name.Equals(lateBindingArgs)||name.Equals(lateBindingArgNames)||name.Equals(lateBindingCopyBack)))
769 Report.Warning (
770 168, vi.Location, "The variable '" +
771 name +"' is declared but never used");
772 }
773 }
774 }
775
776 if (children != null)
777 foreach (Block b in children)
778 b.UsageWarning ();
779 }
780
781 bool has_ret = false;
782
783 public override bool Resolve (EmitContext ec)
784 {
785 Block prev_block = ec.CurrentBlock;
786 bool ok = true;
787
788 ec.CurrentBlock = this;
789
790 if (!variables_initialized)
791 UpdateVariableInfo (ec);
792
793 ec.StartFlowBranching (this);
794
795 Report.Debug (1, "RESOLVE BLOCK", StartLocation, ec.CurrentBranching);
796
797 ArrayList new_statements = new ArrayList ();
798 bool unreachable = false, warning_shown = false;
799
800 foreach (Statement s in statements) {
801
802 if (unreachable && !(s is LabeledStatement)) {
803 if ( !(s is Block && ((Block)s).HasLabeledStatement) ) {
804 if (!warning_shown && !(s is EmptyStatement)) {
805 warning_shown = true;
806 Warning_DeadCodeFound (s.loc);
807 }
808 continue;
809 }
810 }
811
812 if (s.Resolve (ec) == false) {
813 ok = false;
814 continue;
815 }
816
817 if (s is LabeledStatement)
818 unreachable = false;
819 else
820 unreachable = ! ec.CurrentBranching.IsReachable ();
821
822 new_statements.Add (s);
823 }
824
825 statements = new_statements;
826
827 Report.Debug (1, "RESOLVE BLOCK DONE", StartLocation, ec.CurrentBranching);
828
829 FlowReturns returns = ec.EndFlowBranching ();
830 ec.CurrentBlock = prev_block;
831
832 // If we're a non-static 'struct' constructor which doesn't have an
833 // initializer, then we must initialize all of the struct's fields.
834 if ((this_variable != null) && (returns != FlowReturns.EXCEPTION) &&
835 !this_variable.IsAssigned (ec, loc))
836 ok = false;
837
838 if ((labels != null) && (RootContext.WarningLevel >= 2)) {
839 foreach (LabeledStatement label in labels.Values)
840 if (!label.HasBeenReferenced)
841 Report.Warning (164, label.Location,
842 "This label has not been referenced");
843 }
844
845 if ((returns == FlowReturns.ALWAYS) ||
846 (returns == FlowReturns.EXCEPTION) ||
847 (returns == FlowReturns.UNREACHABLE))
848 has_ret = true;
849
850 return ok;
851 }
852
853 protected override bool DoEmit (EmitContext ec)
854 {
855 Block prev_block = ec.CurrentBlock;
856
857 ec.CurrentBlock = this;
858
859 ec.Mark (StartLocation);
860 foreach (Statement s in statements)
861 s.Emit (ec);
862
863 ec.Mark (EndLocation);
864
865 ec.CurrentBlock = prev_block;
866 return has_ret;
867 }
868
869 public override string ToString ()
870 {
871 return String.Format ("{0} ({1}:{2})", GetType (),ID, StartLocation);
872 }
873
874 } // class Block
875
876 /// <summary>
877 /// Block represents a VB.NET method block.
878 /// </summary>
879 ///
880 /// <remarks>
881 /// This class is used in a number of places: either to represent
882 /// explicit blocks that the programmer places or implicit blocks.
883 ///
884 /// Implicit blocks are used as labels or to introduce variable
885 /// declarations.
886 /// </remarks>
887 public class MethodBlock : Block {
888 public readonly string MethodName;
889 public Block onerror;
890 public ArrayList Pending_Assigns;
891
892 public MethodBlock (Block parent, string MethodName)
893 : base (parent, false, Location.Null, Location.Null)
894 {
895 this.MethodName = MethodName;
896 }
897
898 public MethodBlock (Block parent, bool implicit_block, string MethodName)
899 : base (parent, implicit_block, Location.Null, Location.Null)
900 {
901 this.MethodName = MethodName;
902 }
903
904 public MethodBlock (Block parent, bool implicit_block, Parameters parameters, string MethodName)
905 : base (parent, implicit_block, parameters, Location.Null, Location.Null)
906 {
907 this.MethodName = MethodName;
908 }
909
910 public MethodBlock (Block parent, Location start, Location end, String MethodName)
911 : base (parent, false, start, end)
912 {
913 this.MethodName = MethodName;
914 }
915
916 public MethodBlock (Block parent, Parameters parameters, Location start, Location end, string MethodName)
917 : base (parent, false, parameters, start, end)
918 {
919 this.MethodName = MethodName;
920 }
921
922 public MethodBlock (Block parent, bool implicit_block, Location start, Location end, string MethodName)
923 : base (parent, implicit_block, Parameters.EmptyReadOnlyParameters,
924 start, end)
925 {
926 this.MethodName = MethodName;
927 }
928
929 public MethodBlock (Block parent, bool implicit_block, Parameters parameters,
930 Location start, Location end, string MethodName)
931 : base (parent, implicit_block, parameters, start, end)
932 {
933 this.MethodName = MethodName;
934 }
935
936 }
937
938 } // namespace Mono.MonoBASIC
git-svn mirror of mcs