| blob | 2f46f758b5aaa6e698a9e3654593b4554240c6c6 |
1 //
2 // statement.cs: Statement representation for the IL tree.
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 // Martin Baulig (martin@gnome.org)
7 // Anirban Bhattacharjee (banirban@novell.com)
8 //
9 // (C) 2001, 2002 Ximian, Inc.
10 //
25 ///
26 /// Resolves the statement, true means that all sub-statements
27 /// did resolve ok.
28 //
30 {
32 }
34 /// <summary>
35 /// Return value indicates whether all code paths emitted return.
36 /// </summary>
39 /// <summary>
40 /// Return value indicates whether all code paths emitted return.
41 /// </summary>
43 {
47 }
50 {
57 }
62 }
67 }
69 /// <remarks>
70 /// Encapsulates the emission of a boolean test and jumping to a
71 /// destination.
72 ///
73 /// This will emit the bool expression in `bool_expr' and if
74 /// `target_is_for_true' is true, then the code will generate a
75 /// brtrue to the target. Otherwise a brfalse.
76 /// </remarks>
79 {
90 }
96 }
104 else
109 else
111 }
112 }
115 {
117 }
118 }
122 {
124 }
127 {
129 }
130 }
133 Expression expr;
138 {
142 }
145 Statement trueStatement,
146 Statement falseStatement,
147 Location l)
148 {
153 }
156 {
162 }
169 }
176 }
183 }
186 {
189 Label end;
192 //
193 // Dead code elimination
194 //
201 }
207 }
208 }
222 }
232 }
235 }
236 }
239 WHILE,
240 UNTIL,
241 TEST_BEFORE,
242 TEST_AFTER
243 };
248 //public DoOptions type;
254 {
257 // type = do_type;
260 }
263 {
279 }
286 }
289 {
307 //
308 // Dead code elimination
309 //
319 }
320 else
321 {
325 //
326 // Dead code elimination
327 //
339 }
347 else
349 }
350 }
358 {
362 }
365 {
374 //
375 // Inform whether we are infinite or not
376 //
386 //
387 // We are not infinite, so the loop may or may not be executed.
388 //
390 }
401 }
404 }
407 {
423 //
424 // Inform whether we are infinite or not
425 //
433 //
434 // Inform that we are infinite (ie, `we return'), only
435 // if we do not `break' inside the code.
436 //
453 }
461 }
462 }
465 Expression Test;
472 Expression test,
473 Statement increment,
474 Statement statement,
475 Location l)
476 {
482 }
486 {
492 }
506 }
513 }
528 }
531 }
534 {
564 //
565 // If test is null, there is no test, and we are just
566 // an infinite loop
567 //
570 else
579 //
580 // Inform whether we are infinite or not
581 //
588 }
592 }
593 }
599 {
602 }
605 {
608 }
611 {
619 }
622 }
625 {
627 }
628 }
630 /// <summary>
631 /// Implements the return statement
632 /// </summary>
637 {
640 }
643 {
648 }
654 else
660 }
663 {
667 }
673 }
680 }
693 }
699 }
705 }
706 }
710 Block block;
711 LabeledStatement label;
714 {
721 }
723 // If this is a forward goto.
730 }
733 {
737 }
742 }
743 }
746 {
751 }
752 }
759 Label label;
761 ArrayList vectors;
764 {
767 }
770 {
777 }
782 }
783 }
788 }
789 }
792 {
797 }
800 {
806 }
811 }
814 {
819 }
820 }
823 /// <summary>
824 /// `goto default' statement
825 /// </summary>
829 {
831 }
834 {
837 }
840 {
844 }
849 }
852 }
853 }
855 /// <summary>
856 /// `goto case' statement
857 /// </summary>
859 Expression expr;
860 Label label;
863 {
866 }
869 {
873 }
882 }
896 }
902 }
905 {
908 }
909 }
912 Expression expr;
915 {
918 }
921 {
933 }
944 }
945 }
950 }
953 {
962 }
964 }
971 }
972 }
977 {
979 }
982 {
986 }
989 {
995 }
999 else
1003 }
1004 }
1007 DO,
1008 FOR,
1009 WHILE,
1010 SELECT,
1011 SUB,
1012 FUNCTION,
1013 PROPERTY,
1014 TRY
1015 };
1020 {
1023 }
1026 {
1030 }
1033 {
1049 }
1053 else
1060 }
1066 }
1072 }
1075 }
1076 }
1081 {
1083 }
1086 {
1089 }
1092 {
1098 }
1100 //
1101 // UGH: Non trivial. This Br might cross a try/catch boundary
1102 // How can we tell?
1103 //
1104 // while () {
1105 // try { ... } catch { continue; }
1106 // }
1107 //
1108 // From:
1109 // try {} catch { while () { continue; }}
1110 //
1115 else
1118 }
1119 }
1121 // <summary>
1122 // This is used in the control flow analysis code to specify whether the
1123 // current code block may return to its enclosing block before reaching
1124 // its end.
1125 // </summary>
1127 // It can never return.
1128 NEVER,
1130 // This means that the block contains a conditional return statement
1131 // somewhere.
1132 SOMETIMES,
1134 // The code always returns, ie. there's an unconditional return / break
1135 // statement in it.
1136 ALWAYS,
1138 // The code always throws an exception.
1139 EXCEPTION,
1141 // The current code block is unreachable. This happens if it's immediately
1142 // following a FlowReturns.ALWAYS block.
1143 UNREACHABLE
1144 }
1146 // <summary>
1147 // This is a special bit vector which can inherit from another bit vector doing a
1148 // copy-on-write strategy. The inherited vector may have a smaller size than the
1149 // current one.
1150 // </summary>
1156 BitArray vector;
1160 { }
1163 {
1166 }
1168 // <summary>
1169 // Checks whether this bit vector has been modified. After setting this to true,
1170 // we won't use the inherited vector anymore, but our own copy of it.
1171 // </summary>
1175 }
1180 }
1181 }
1183 // <summary>
1184 // Get/set bit `index' in the bit vector.
1185 // </summary>
1187 {
1192 // We're doing a "copy-on-write" strategy here; as long
1193 // as nobody writes to the array, we can use our parent's
1194 // copy instead of duplicating the vector.
1203 else
1207 }
1213 // Only copy the vector if we're actually modifying it.
1219 }
1220 }
1221 }
1223 // <summary>
1224 // If you explicitly convert the MyBitVector to a BitArray, you will get a deep
1225 // copy of the bit vector.
1226 // </summary>
1228 {
1231 }
1233 // <summary>
1234 // Performs an `or' operation on the bit vector. The `new_vector' may have a
1235 // different size than the current one.
1236 // </summary>
1238 {
1246 else
1251 }
1253 // <summary>
1254 // Perfonrms an `and' operation on the bit vector. The `new_vector' may have
1255 // a different size than the current one.
1256 // </summary>
1258 {
1269 }
1276 }
1278 // <summary>
1279 // This does a deep copy of the bit vector.
1280 // </summary>
1282 {
1288 }
1290 BitArray Vector {
1300 }
1307 }
1308 }
1311 {
1320 }
1323 {
1335 }
1339 }
1340 }
1342 // <summary>
1343 // The type of a FlowBranching.
1344 // </summary>
1346 // Normal (conditional or toplevel) block.
1347 BLOCK,
1349 // A loop block.
1350 LOOP_BLOCK,
1352 // Try/Catch block.
1353 EXCEPTION,
1355 // Switch block.
1356 SWITCH,
1358 // Switch section.
1359 SWITCH_SECTION
1360 }
1362 // <summary>
1363 // A new instance of this class is created every time a new block is resolved
1364 // and if there's branching in the block's control flow.
1365 // </summary>
1367 // <summary>
1368 // The type of this flow branching.
1369 // </summary>
1372 // <summary>
1373 // The block this branching is contained in. This may be null if it's not
1374 // a top-level block and it doesn't declare any local variables.
1375 // </summary>
1378 // <summary>
1379 // The parent of this branching or null if this is the top-block.
1380 // </summary>
1383 // <summary>
1384 // Start-Location of this flow branching.
1385 // </summary>
1388 // <summary>
1389 // A list of UsageVectors. A new vector is added each time control flow may
1390 // take a different path.
1391 // </summary>
1394 // <summary>
1395 // If this is an infinite loop.
1396 // </summary>
1399 // <summary>
1400 // If we may leave the current loop.
1401 // </summary>
1404 //
1405 // Private
1406 //
1407 InternalParameters param_info;
1411 ArrayList finally_vectors;
1416 // <summary>
1417 // Performs an `And' operation on the FlowReturns status
1418 // (for instance, a block only returns ALWAYS if all its siblings
1419 // always return).
1420 // </summary>
1422 {
1430 else
1439 else
1447 else
1449 }
1452 }
1454 // <summary>
1455 // The vector contains a BitArray with information about which local variables
1456 // and parameters are already initialized at the current code position.
1457 // </summary>
1459 // <summary>
1460 // If this is true, then the usage vector has been modified and must be
1461 // merged when we're done with this branching.
1462 // </summary>
1465 // <summary>
1466 // The number of parameters in this block.
1467 // </summary>
1470 // <summary>
1471 // The number of locals in this block.
1472 // </summary>
1475 // <summary>
1476 // If not null, then we inherit our state from this vector and do a
1477 // copy-on-write. If null, then we're the first sibling in a top-level
1478 // block and inherit from the empty vector.
1479 // </summary>
1482 //
1483 // Private.
1484 //
1492 //
1493 // Normally, you should not use any of these constructors.
1494 //
1496 {
1513 }
1516 }
1520 { }
1522 // <summary>
1523 // This does a deep copy of the usage vector.
1524 // </summary>
1526 {
1536 }
1538 //
1539 // State of parameter `number'.
1540 //
1542 {
1550 }
1559 }
1560 }
1562 //
1563 // State of the local variable `vi'.
1564 // If the local variable is a struct, use a non-zero `field_idx'
1565 // to check an individual field in it.
1566 //
1568 {
1576 }
1585 }
1586 }
1588 // <summary>
1589 // Specifies when the current block returns.
1590 // If this is FlowReturns.UNREACHABLE, then control can never reach the
1591 // end of the method (so that we don't need to emit a return statement).
1592 // The same applies for FlowReturns.EXCEPTION, but in this case the return
1593 // value will never be used.
1594 // </summary>
1598 }
1602 }
1603 }
1605 // <summary>
1606 // Specifies whether control may return to our containing block
1607 // before reaching the end of this block. This happens if there
1608 // is a break/continue/goto/return in it.
1609 // This can also be used to find out whether the statement immediately
1610 // following the current block may be reached or not.
1611 // </summary>
1615 }
1619 }
1620 }
1627 }
1628 }
1633 }
1634 }
1640 }
1641 }
1647 }
1648 }
1650 // <summary>
1651 // Merge a child branching.
1652 // </summary>
1654 {
1670 // If Returns is already set, perform an
1671 // `And' operation on it, otherwise just set just.
1678 }
1680 // If Breaks is already set, perform an
1681 // `And' operation on it, otherwise just set just.
1688 }
1690 // Ignore unreachable children.
1694 // A local variable is initialized after a flow branching if it
1695 // has been initialized in all its branches which do neither
1696 // always return or always throw an exception.
1697 //
1698 // If a branch may return, but does not always return, then we
1699 // can treat it like a never-returning branch here: control will
1700 // only reach the code position after the branching if we did not
1701 // return here.
1702 //
1703 // It's important to distinguish between always and sometimes
1704 // returning branches here:
1705 //
1706 // 1 int a;
1707 // 2 if (something) {
1708 // 3 return;
1709 // 4 a = 5;
1710 // 5 }
1711 // 6 Console.WriteLine (a);
1712 //
1713 // The if block in lines 3-4 always returns, so we must not look
1714 // at the initialization of `a' in line 4 - thus it'll still be
1715 // uninitialized in line 6.
1716 //
1717 // On the other hand, the following is allowed:
1718 //
1719 // 1 int a;
1720 // 2 if (something)
1721 // 3 a = 5;
1722 // 4 else
1723 // 5 return;
1724 // 6 Console.WriteLine (a);
1725 //
1726 // Here, `a' is initialized in line 3 and we must not look at
1727 // line 5 since it always returns.
1728 //
1738 }
1747 }
1751 }
1753 // An `out' parameter must be assigned in all branches which do
1754 // not always throw an exception.
1762 }
1766 }
1767 }
1768 }
1769 }
1782 }
1784 //
1785 // We've now either reached the point after the branching or we will
1786 // never get there since we always return or always throw an exception.
1787 //
1788 // If we can reach the point after the branching, mark all locals and
1789 // parameters as initialized which have been initialized in all branches
1790 // we need to look at (see above).
1791 //
1802 }
1815 }
1821 // We're actually infinite.
1825 }
1827 // If we're an infinite loop and do not break, the code after
1828 // the loop can never be reached. However, if we may return
1829 // from the loop, then we do always return (or stay in the loop
1830 // forever).
1835 }
1836 }
1839 }
1841 // <summary>
1842 // Tells control flow analysis that the current code position may be reached with
1843 // a forward jump from any of the origins listed in `origin_vectors' which is a
1844 // list of UsageVectors.
1845 //
1846 // This is used when resolving forward gotos - in the following example, the
1847 // variable `a' is uninitialized in line 8 becase this line may be reached via
1848 // the goto in line 4:
1849 //
1850 // 1 int a;
1851 //
1852 // 3 if (something)
1853 // 4 goto World;
1854 //
1855 // 6 a = 5;
1856 //
1857 // 7 World:
1858 // 8 Console.WriteLine (a);
1859 //
1860 // </summary>
1862 {
1876 }
1879 }
1881 // <summary>
1882 // This is used at the beginning of a finally block if there were
1883 // any return statements in the try block or one of the catch blocks.
1884 // </summary>
1886 {
1897 }
1902 }
1905 {
1908 }
1910 // <summary>
1911 // Performs an `or' operation on the locals and the parameters.
1912 // </summary>
1914 {
1918 }
1920 // <summary>
1921 // Performs an `and' operation on the locals.
1922 // </summary>
1924 {
1926 }
1928 // <summary>
1929 // Returns a deep copy of the parameters.
1930 // </summary>
1935 else
1937 }
1938 }
1940 // <summary>
1941 // Returns a deep copy of the locals.
1942 // </summary>
1946 }
1947 }
1949 //
1950 // Debugging stuff.
1951 //
1954 {
1966 }
1972 }
1973 }
1976 {
1982 }
1984 // <summary>
1985 // Creates a new flow branching for `block'.
1986 // This is used from Block.Resolve to create the top-level branching of
1987 // the block.
1988 // </summary>
1991 {
2015 }
2019 }
2021 // <summary>
2022 // Creates a new flow branching which is contained in `parent'.
2023 // You should only pass non-null for the `block' argument if this block
2024 // introduces any new variables - in this case, we need to create a new
2025 // usage vector with a different size than our parent's one.
2026 // </summary>
2030 {
2039 }
2041 UsageVector vector;
2045 else
2057 }
2058 }
2060 // <summary>
2061 // Returns the branching's current usage vector.
2062 // </summary>
2063 public UsageVector CurrentUsageVector
2064 {
2067 }
2068 }
2070 // <summary>
2071 // Creates a sibling of the current usage vector.
2072 // </summary>
2074 {
2078 }
2080 // <summary>
2081 // Creates a sibling for a `finally' block.
2082 // </summary>
2084 {
2091 }
2093 // <summary>
2094 // Check whether all `out' parameters have been assigned.
2095 // </summary>
2097 {
2110 // If it's a struct, we must ensure that all its fields have
2111 // been assigned. If the struct has any non-public fields, this
2112 // can only be done by assigning the whole struct.
2122 }
2133 }
2134 }
2135 }
2136 }
2138 // <summary>
2139 // Merge a child branching.
2140 // </summary>
2142 {
2147 else
2151 }
2153 // <summary>
2154 // Does the toplevel merging.
2155 // </summary>
2157 {
2178 }
2181 {
2186 else
2188 }
2191 {
2195 }
2199 else
2201 }
2204 {
2207 else
2209 }
2212 {
2215 else
2217 }
2220 {
2225 }
2228 {
2233 }
2236 {
2245 // Parameter is not assigned, so check whether it's a struct.
2246 // If it's either not a struct or a struct which non-public
2247 // fields, return false.
2252 // Ok, so each field must be assigned.
2258 }
2261 {
2274 }
2277 {
2283 }
2286 {
2300 }
2303 {
2308 // The code following a switch block is reachable unless the switch
2309 // block always returns.
2314 // The code following a loop is reachable unless the loop always
2315 // returns or it's an infinite loop without any `break's in it.
2321 // The code following a block or exception is reachable unless the
2322 // block either always returns or always breaks.
2326 }
2332 }
2335 {
2346 }
2353 }
2354 }
2367 // Private constructor. To save memory usage, we only need to create one instance
2368 // of this class per struct type.
2370 {
2383 else
2385 }
2386 }
2398 else
2401 }
2402 }
2410 }
2424 }
2430 else
2432 }
2433 }
2439 else
2441 }
2442 }
2445 {
2459 }
2462 {
2470 }
2471 }
2488 {
2494 }
2497 {
2503 }
2505 MyStructInfo struct_info;
2509 }
2510 }
2514 if (!ec.DoFlowAnalysis || ec.CurrentBranching.IsVariableAssigned (this))
2515 return true;
2517 MyStructInfo struct_info = StructInfo;
2518 if ((struct_info == null) || (struct_info.HasNonPublicFields && (Name != null))) {
2519 Report.Error (165, loc, "Use of unassigned local variable `" + Name + "'");
2520 ec.CurrentBranching.SetVariableAssigned (this);
2521 return false;
2522 }
2524 int count = struct_info.Count;
2526 for (int i = 0; i < count; i++) {
2527 if (!ec.CurrentBranching.IsVariableAssigned (this, i+1)) {
2528 if (Name != null) {
2529 Report.Error (165, loc,
2530 "Use of unassigned local variable `" +
2531 Name + "'");
2532 ec.CurrentBranching.SetVariableAssigned (this);
2533 return false;
2534 }
2536 FieldInfo field = struct_info [i];
2537 Report.Error (171, loc,
2538 "Field `" + TypeManager.MonoBASIC_Name (VariableType) +
2539 "." + field.Name + "' must be fully initialized " +
2540 "before control leaves the constructor");
2541 return false;
2542 }
2543 }
2544 */
2546 }
2549 {
2563 }
2566 }
2569 {
2572 }
2575 {
2578 }
2581 {
2594 }
2597 {
2599 }
2602 {
2604 }
2605 }
2607 /// <summary>
2608 /// Block represents a C# block.
2609 /// </summary>
2610 ///
2611 /// <remarks>
2612 /// This class is used in a number of places: either to represent
2613 /// explicit blocks that the programmer places or implicit blocks.
2614 ///
2615 /// Implicit blocks are used as labels or to introduce variable
2616 /// declarations.
2617 /// </remarks>
2624 //
2625 // The statements in this block
2626 //
2629 //
2630 // An array of Blocks. We keep track of children just
2631 // to generate the local variable declarations.
2632 //
2633 // Statements and child statements are handled through the
2634 // statements.
2635 //
2636 ArrayList children;
2638 //
2639 // Labels. (label, block) pairs.
2640 //
2641 CaseInsensitiveHashtable labels;
2643 //
2644 // Keeps track of (name, type) pairs
2645 //
2646 CaseInsensitiveHashtable variables;
2648 //
2649 // Keeps track of constants
2650 CaseInsensitiveHashtable constants;
2652 //
2653 // Maps variable names to ILGenerator.LocalBuilders
2654 //
2655 CaseInsensitiveHashtable local_builders;
2665 { }
2669 { }
2673 { }
2677 { }
2681 { }
2686 { }
2690 {
2702 }
2707 }
2708 }
2711 {
2716 }
2719 {
2721 }
2723 /// <summary>
2724 /// Adds a label to the current block.
2725 /// </summary>
2726 ///
2727 /// <returns>
2728 /// false if the name already exists in this block. true
2729 /// otherwise.
2730 /// </returns>
2731 ///
2733 {
2741 }
2744 {
2748 }
2754 }
2758 // <summary>
2759 // Returns the "this" instance variable of this block.
2760 // See AddThisVariable() for more information.
2761 // </summary>
2768 else
2770 }
2771 }
2773 Hashtable child_variable_names;
2775 // <summary>
2776 // Marks a variable with name @name as being used in a child block.
2777 // If a variable name has been used in a child block, it's illegal to
2778 // declare a variable with the same name in the current block.
2779 // </summary>
2781 {
2787 }
2789 // <summary>
2790 // Marks all variables from block @block and all its children as being
2791 // used in a child block.
2792 // </summary>
2794 {
2798 }
2804 }
2805 }
2806 }
2808 // <summary>
2809 // Checks whether a variable name has already been used in a child block.
2810 // </summary>
2812 {
2817 }
2819 // <summary>
2820 // This is used by non-static `struct' constructors which do not have an
2821 // initializer - in this case, the constructor must initialize all of the
2822 // struct's fields. To do this, we add a "this" variable and use the flow
2823 // analysis code to ensure that it's been fully initialized before control
2824 // leaves the constructor.
2825 // </summary>
2827 {
2838 }
2841 {
2853 else
2857 }
2866 }
2878 }
2879 }
2888 // Console.WriteLine ("Adding {0} to {1}", name, ID);
2890 }
2892 public bool AddConstant (Expression type, string name, Expression value, Parameters pars, Location l)
2893 {
2902 }
2907 }
2908 }
2911 {
2918 }
2919 }
2925 }
2928 {
2935 }
2938 {
2945 }
2951 }
2953 /// <summary>
2954 /// True if the variable named @name has been defined
2955 /// in this block
2956 /// </summary>
2958 {
2959 // Console.WriteLine ("Looking up {0} in {1}", name, ID);
2963 }
2969 }
2971 /// <summary>
2972 /// True if the variable named @name is a constant
2973 /// </summary>
2975 {
2981 }
2983 /// <summary>
2984 /// Use to fetch the statement associated with this label
2985 /// </summary>
2989 }
2990 }
2999 }
3000 }
3002 /// <returns>
3003 /// A list of labels that were not used within this block
3004 /// </returns>
3006 {
3007 // FIXME: Implement me
3009 }
3012 {
3015 }
3020 }
3021 }
3024 {
3026 }
3032 {
3046 }
3052 }
3053 }
3056 }
3058 //
3059 // <returns>
3060 // The number of local variables in this block
3061 // </returns>
3062 public int CountVariables
3063 {
3069 }
3070 }
3072 /// <summary>
3073 /// Emits the variable declarations and labels.
3074 /// </summary>
3075 /// <remarks>
3076 /// tc: is our typecontainer (to resolve type references)
3077 /// ig: is the code generator:
3078 /// toplevel: the toplevel block. This is used for checking
3079 /// that no two labels with the same name are used.
3080 /// </remarks>
3082 {
3089 //
3090 // Process this block variables
3091 //
3123 }
3127 }
3128 }
3130 //
3131 // Now, handle the children
3132 //
3136 }
3137 }
3140 {
3159 name +
3161 }
3162 }
3163 }
3168 }
3173 {
3193 }
3196 }
3201 }
3205 else
3209 }
3218 // If we're a non-static `struct' constructor which doesn't have an
3219 // initializer, then we must initialize all of the struct's fields.
3229 }
3237 }
3240 {
3253 }
3254 }
3257 Expression label;
3263 //
3264 // if expr == null, then it is the default case.
3265 //
3267 {
3270 }
3275 }
3276 }
3281 }
3282 }
3284 //
3285 // Resolves the expression, reduces it to a literal if possible
3286 // and then converts it to the requested type.
3287 //
3289 {
3305 }
3312 }
3313 }
3320 }
3321 }
3324 // An array of SwitchLabels.
3329 {
3332 }
3333 }
3339 /// <summary>
3340 /// Maps constants whose type type SwitchType to their SwitchLabels.
3341 /// </summary>
3344 /// <summary>
3345 /// The governing switch type
3346 /// </summary>
3349 //
3350 // Computed
3351 //
3353 Label default_target;
3354 Expression new_expr;
3356 //
3357 // The types allowed to be implicitly cast from
3358 // on the governing type
3359 //
3363 {
3367 }
3372 }
3373 }
3378 }
3379 }
3381 //
3382 // Determines the governing type for a switch. The returned
3383 // expression might be the expression from the switch, or an
3384 // expression that includes any potential conversions to the
3385 // integral types or to string.
3386 //
3388 {
3415 TypeManager.string_type
3416 };
3417 }
3419 //
3420 // Try to find a *user* defined implicit conversion.
3421 //
3422 // If there is no implicit conversion, or if there are multiple
3423 // conversions, we have to report an error
3424 //
3427 Expression e;
3440 }
3442 }
3445 {
3449 }
3451 //
3452 // Performs the basic sanity checks on the switch statement
3453 // (looks for duplicate keys and non-constant expressions).
3454 //
3455 // It also returns a hashtable with the keys that we will later
3456 // use to compute the switch tables
3457 //
3459 {
3460 Type compare_type;
3476 }
3482 }
3485 }
3501 else
3508 else
3515 else
3522 else
3529 else
3536 else
3543 else
3550 else
3556 else
3563 else
3565 }
3571 else
3578 else
3580 }
3581 else
3582 {
3585 }
3590 }
3591 }
3592 }
3597 }
3600 {
3605 }
3609 {
3611 {
3614 }
3615 else
3617 }
3619 {
3621 {
3624 }
3625 else
3626 {
3628 }
3629 }
3642 else
3644 }
3646 // structure used to hold blocks of keys while calculating table switch
3648 {
3650 {
3652 }
3656 public int Length
3657 {
3658 get { return (int) (nLast - nFirst + 1); }
3659 }
3661 {
3663 }
3665 {
3672 }
3673 }
3675 /// <summary>
3676 /// This method emits code for a lookup-based switch statement (non-string)
3677 /// Basically it groups the cases into blocks that are at least half full,
3678 /// and then spits out individual lookup opcodes for each block.
3679 /// It emits the longest blocks first, and short blocks are just
3680 /// handled with direct compares.
3681 /// </summary>
3682 /// <param name="ec"></param>
3683 /// <param name="val"></param>
3684 /// <returns></returns>
3686 {
3692 // initialize the block list with one element per key
3697 KeyBlock kbCurr;
3698 // iteratively merge the blocks while they are at least half full
3699 // there's probably a really cool way to do this with a tree...
3701 {
3705 {
3708 {
3709 // merge blocks
3711 }
3712 else
3713 {
3714 // start a new block
3717 }
3718 }
3723 }
3725 // initialize the key lists
3729 // fill the key lists
3734 {
3735 bool fNextBlock = (key is UInt64) ? (ulong) key > (ulong) kbCurr.nLast : Convert.ToInt64 (key) > kbCurr.nLast;
3739 }
3740 }
3742 // sort the blocks so we can tackle the largest ones first
3745 // okay now we can start...
3755 {
3759 {
3761 {
3766 }
3767 }
3768 else
3769 {
3770 // TODO: if all the keys in the block are the same and there are
3771 // no gaps/defaults then just use a range-check.
3774 {
3775 // TODO: optimize constant/I4 cases
3777 // check block range (could be > 2^31)
3785 // normalize range
3788 {
3791 }
3793 }
3794 else
3795 {
3796 // normalize range
3800 {
3803 }
3805 {
3808 }
3809 }
3811 // first, build the list of labels for the switch
3816 {
3819 {
3822 iKey++;
3823 }
3824 else
3826 }
3827 // emit the switch opcode
3829 }
3831 // mark the default for this block
3834 }
3836 // TODO: find the default case and emit it here,
3837 // to prevent having to do the following jump.
3838 // make sure to mark other labels in the default section
3840 // the last default just goes to the end
3843 // now emit the code for the sections
3847 {
3849 {
3853 {
3856 }
3857 }
3860 //ig.Emit (OpCodes.Br, lblEnd);
3861 }
3866 }
3870 }
3871 //
3872 // This simple emit switch works, but does not take advantage of the
3873 // `switch' opcode.
3874 // TODO: remove non-string logic from here
3875 // TODO: binary search strings?
3876 //
3878 {
3890 //
3891 // Special processing for strings: we cant compare
3892 // against null.
3893 //
3906 }
3922 }
3923 //
3924 // If we are the default target
3925 //
3938 }
3946 else
3954 else
3956 }
3957 }
3958 }
3974 }
3976 }
3980 }
3985 }
3988 {
3997 }
3999 // Validate switch.
4015 else
4020 }
4030 }
4033 {
4034 // Store variable for comparission purposes
4043 //
4044 // Setup the codegen context
4045 //
4052 // Emit Code.
4056 else
4059 // Restore context state.
4062 //
4063 // Restore the previous context
4064 //
4069 }
4070 }
4073 Expression expr;
4074 Statement Statement;
4077 {
4081 }
4084 {
4087 }
4090 {
4099 }
4109 // try
4116 // ig.Emit (OpCodes.Leave, finish);
4120 // finally
4127 }
4128 }
4134 {
4136 }
4139 {
4141 }
4144 {
4156 }
4157 }
4163 {
4165 }
4168 {
4179 }
4182 {
4194 }
4195 }
4201 {
4203 }
4206 {
4215 }
4218 {
4227 }
4228 }
4230 //
4231 // Fixed statement
4232 //
4234 Expression type;
4235 ArrayList declarators;
4236 Statement statement;
4237 Type expr_type;
4245 }
4248 {
4253 }
4256 {
4270 //
4271 // The rules for the possible declarators are pretty wise,
4272 // but the production on the grammar is more concise.
4273 //
4274 // So we have to enforce these rules here.
4275 //
4276 // We do not resolve before doing the case 1 test,
4277 // because the grammar is explicit in that the token &
4278 // is present, so we need to test for this particular case.
4279 //
4281 //
4282 // Case 1: & object.
4283 //
4295 }
4310 i++;
4313 }
4319 //
4320 // Case 2: Array
4321 //
4326 //
4327 // Provided that array_type is unmanaged,
4328 //
4332 //
4333 // and T* is implicitly convertible to the
4334 // pointer type given in the fixed statement.
4335 //
4347 i++;
4350 }
4352 //
4353 // Case 3: string
4354 //
4360 i++;
4361 }
4362 }
4365 }
4368 {
4376 //
4377 // Case 1: & object.
4378 //
4380 //
4381 // Store pointer in pinned location
4382 //
4388 // Clear the pinned variable.
4394 }
4396 //
4397 // Case 2: Array
4398 //
4400 //
4401 // Store pointer in pinned location
4402 //
4409 // Clear the pinned variable.
4415 }
4417 //
4418 // Case 3: string
4419 //
4439 // Clear the pinned variable
4442 }
4443 }
4446 }
4447 }
4455 Expression type_expr;
4456 //Expression clus_expr;
4457 Type type;
4460 {
4466 }
4471 }
4472 }
4477 }
4478 }
4481 {
4492 }
4500 }
4501 }
4507 }
4508 }
4515 //
4516 // specific, general and fini might all be null.
4517 //
4519 {
4522 }
4529 }
4532 {
4561 }
4575 }
4595 }
4610 }
4620 }
4627 }
4630 {
4632 Label end;
4643 //
4644 // System.Reflection.Emit provides this automatically:
4645 // ig.Emit (OpCodes.Leave, finish);
4652 VariableInfo vi;
4665 //
4666 // if when clause is there
4667 //
4679 }
4683 }
4699 }
4703 }
4714 }
4722 // Unfortunately, System.Reflection.Emit automatically emits a leave
4723 // to the end of the finally block. This is a problem if `returns'
4724 // is true since we may jump to a point after the end of the method.
4725 // As a workaround, emit an explicit ret here.
4732 }
4733 }
4737 Statement Statement;
4738 ArrayList var_list;
4739 Expression expr;
4740 Type expr_type;
4741 Expression conv;
4746 {
4750 }
4752 //
4753 // Resolves for the case of using using a local variable declaration.
4754 //
4756 {
4764 //
4765 // The type must be an IDisposable or an implicit conversion
4766 // must exist.
4767 //
4783 i++;
4784 }
4786 }
4792 Expression a;
4802 i++;
4803 }
4806 }
4809 {
4816 }
4819 }
4821 //
4822 // Emits the code for the case of using using a local variable declaration.
4823 //
4825 {
4835 }
4845 i--;
4855 }
4859 }
4862 {
4863 //
4864 // Make a copy of the expression and operate on that.
4865 //
4870 else
4892 }
4895 {
4914 }
4917 }
4920 {
4927 }
4928 }
4930 /// <summary>
4931 /// Implementation of the foreach C# statement
4932 /// </summary>
4934 Expression type;
4935 LocalVariableReference variable;
4936 Expression expr;
4937 Statement statement;
4938 ForeachHelperMethods hm;
4941 Type var_type;
4945 {
4948 }
4949 else
4950 {
4953 }
4958 }
4961 {
4970 //
4971 // We need an instance variable. Not sure this is the best
4972 // way of doing this.
4973 //
4974 // FIXME: When we implement propertyaccess, will those turn
4975 // out to return values in ExprClass? I think they should.
4976 //
4981 }
4993 }
4999 }
5004 //
5005 //
5006 // FIXME: maybe we can apply the same trick we do in the
5007 // array handling to avoid creating empty and conv in some cases.
5008 //
5009 // Although it is not as important in this case, as the type
5010 // will not likely be object (what the enumerator will return).
5011 //
5025 }
5027 //
5028 // Retrieves a `public bool MoveNext ()' method from the Type `t'
5029 //
5031 {
5032 MemberList move_next_list;
5049 }
5050 }
5052 }
5054 //
5055 // Retrieves a `public T get_Current ()' method from the Type `t'
5056 //
5058 {
5059 MemberList move_next_list;
5075 }
5077 }
5079 //
5080 // This struct records the helper methods used by the Foreach construct
5081 //
5092 {
5097 }
5098 }
5101 {
5116 }
5120 //
5121 // Check whether GetEnumerator is accessible to us
5122 //
5130 // If from a different assembly, false
5133 //
5134 // Are we being invoked from the same class, or from a derived method?
5135 //
5139 }
5149 }
5151 //
5152 // Ok, we can access it, now make sure that we can do something
5153 // with this `GetEnumerator'
5154 //
5158 (!RootContext.StdLib && TypeManager.ImplementsInterface (mi.ReturnType, TypeManager.ienumerator_type))) {
5162 }
5164 //
5165 // Ok, so they dont return an IEnumerable, we will have to
5166 // find if they support the GetEnumerator pattern.
5167 //
5183 }
5185 /// <summary>
5186 /// This filter is used to find the GetEnumerator method
5187 /// on which IEnumerator operates
5188 /// </summary>
5192 {
5194 }
5197 {
5202 }
5205 {
5206 MemberList mi;
5218 }
5220 //
5221 // Looks for a usable GetEnumerator in the Type, and if found returns
5222 // the three methods that participate: GetEnumerator, MoveNext and get_Current
5223 //
5225 {
5231 //
5232 // Now try to find the method in the interfaces
5233 //
5240 }
5242 //
5243 // Since TypeBuilder.GetInterfaces only returns the interface
5244 // types for this type, we have to keep looping, but once
5245 // we hit a non-TypeBuilder (ie, a Type), then we know we are
5246 // done, because it returns all the types
5247 //
5250 else
5252 }
5255 }
5257 //
5258 // FIXME: possible optimization.
5259 // We might be able to avoid creating `empty' if the type is the sam
5260 //
5262 {
5269 else
5272 //
5273 // Instantiate the enumerator
5274 //
5287 }
5290 //
5291 // Protect the code in a try/finalize block, so that
5292 // if the beast implement IDisposable, we get rid of it
5293 //
5294 Label l;
5300 }
5316 // The runtime provides this for us.
5317 // ig.Emit (OpCodes.Leave, end);
5319 //
5320 // Now the finally block
5321 //
5338 // The runtime generates this anyways.
5339 // ig.Emit (OpCodes.Endfinally);
5342 }
5346 }
5348 //
5349 // FIXME: possible optimization.
5350 // We might be able to avoid creating `empty' if the type is the sam
5351 //
5353 {
5359 //
5360 // Make our copy of the array
5361 //
5410 }
5417 }
5424 }
5430 //
5431 // FIXME: Maybe we can cache the computation of `get'?
5432 //
5458 }
5459 }
5463 }
5466 {
5481 else
5490 }
5491 }
5493 /// <summary>
5494 /// AddHandler statement
5495 /// </summary>
5497 Expression EvtId;
5498 Expression EvtHandler;
5500 //
5501 // keeps track whether EvtId is already resolved
5502 //
5506 {
5511 //Console.WriteLine ("Adding handler '" + evt_handler + "' for Event '" + evt_id +"'");
5512 }
5515 {
5516 //
5517 // if EvetId is of EventExpr type that means
5518 // this is already resolved
5519 //
5523 }
5530 }
5533 {
5536 }
5539 }
5542 {
5543 //
5544 // Already resolved and emitted don't do anything
5545 //
5556 // The even type was already resolved to a delegate, so
5557 // we must un-resolve its name to generate a type expression
5561 // which we can use to declare a new event handler
5562 // of the same type
5567 // we resolve it all and emit the code
5570 {
5573 }
5576 }
5577 }
5579 /// <summary>
5580 /// RemoveHandler statement
5581 /// </summary>
5583 {
5584 Expression EvtId;
5585 Expression EvtHandler;
5588 {
5592 }
5595 {
5599 {
5602 }
5605 {
5608 }
5610 }
5613 {
5619 // The even type was already resolved to a delegate, so
5620 // we must un-resolve its name to generate a type expression
5624 // which we can use to declare a new event handler
5625 // of the same type
5628 // detach the event
5631 // we resolve it all and emit the code
5634 {
5637 }
5640 }
5641 }
5648 {
5651 }
5652 }
5655 ArrayList RedimTargets;
5656 Type BaseType;
5662 {
5666 }
5669 {
5670 Expression RedimTarget;
5671 ArrayList NewIndexes;
5685 }
5690 }
5697 Expression BaseTypeExpr = MonoBASIC.Parser.DecomposeQI(BaseType.FullName.ToString(), Location.Null);
5699 // TODO: we are in a foreach we probably can't reuse ReDimExpr, must turn it into an array(list)
5701 {
5702 // TODO: Generate call to copying code, which has to make lots of verifications
5703 //PreserveExpr = (ExpressionStatement) new Preserve(RedimTarget, acExpr, loc);
5704 //ReDimExpr = (StatementExpression) new StatementExpression ((ExpressionStatement) new Assign (RedimTarget, PreserveExpr, loc), loc);
5705 ReDimExpr = (StatementExpression) new StatementExpression ((ExpressionStatement) new Assign (RedimTarget, acExpr, loc), loc);
5706 }
5707 else
5708 ReDimExpr = (StatementExpression) new StatementExpression ((ExpressionStatement) new Assign (RedimTarget, acExpr, loc), loc);
5710 }
5712 }
5715 {
5718 }
5720 }
5723 Expression EraseTarget;
5728 {
5731 }
5734 {
5739 EraseExpr = (StatementExpression) new StatementExpression ((ExpressionStatement) new Assign (EraseTarget, NullLiteral.Null, loc), loc);
5743 }
5746 {
5749 }
5751 }
5754 }