| blob | ba18974baad3369aafe1b62bc19fdfc3381cad00 |
1 # Copyright (C) 2007-2008, The Perl Foundation.
2 # $Id$
6 method TOP($/) {
13 # Attach any initialization code.
21 )
22 );
27 }
29 # Make sure we have the interpinfo constants.
32 # Add code to load perl6.pbc if it's not already present
39 )
40 );
42 # convert the last operation of the block into a .return op
43 # so that :load block below isn't used as return value
45 # automatically invoke mainline on :load (but not :init)
53 )
54 ),
56 )
57 );
60 }
67 ## when entering a block, use any $?BLOCK_SIGNATURED if it exists,
68 ## otherwise create an empty block with an empty first child to
69 ## hold any parameters we might encounter inside the block.
75 }
78 }
80 }
86 }
87 }
90 method block($/) {
92 }
95 method statementlist($/) {
99 }
101 }
108 }
111 }
116 }
125 }
126 }
136 ),
137 $expr
138 ),
140 );
144 }
148 }
149 }
152 }
153 }
155 }
160 }
163 method if_statement($/) {
173 );
179 }
190 );
191 }
193 }
196 method unless_statement($/) {
204 );
206 }
209 method while_statement($/) {
215 }
217 method repeat_statement($/) {
221 # pasttype is 'repeat_while' or 'repeat_until'
224 }
226 method given_statement($/) {
230 ## call the block using the expression as an argument
235 );
237 }
239 method when_statement($/) {
243 # XXX TODO: push a control exception throw onto the end of the block so we
244 # exit the innermost block in which $_ was set.
246 # Invoke smartmatch of the expression.
253 );
255 # Use the smartmatch result as the condition.
260 );
262 }
264 method default_statement($/) {
265 # Always executed if reached, so just produce the block.
269 }
271 method loop_statement($/) {
277 }
281 }
283 }
285 method for_statement($/) {
294 );
296 }
298 method pblock($/) {
301 }
303 method use_statement($/) {
308 }
315 );
316 }
318 }
320 method begin_statement($/) {
325 # XXX - should emit BEGIN side-effects, and do a proper return()
327 }
329 method end_statement($/) {
337 }
339 method statement_mod_loop($/) {
346 );
349 );
354 }
360 );
362 }
368 );
369 }
370 }
372 method statement_mod_cond($/) {
379 );
382 );
389 );
391 }
397 );
398 }
399 }
402 method statement_prefix($/) {
407 # fall through, just use the statement itself
408 }
409 ## after the code in the try block is executed, bind $! to Failure,
410 ## and set up the code to catch an exception, in case one is thrown
414 ## Add a catch node to the try op that captures the
415 ## exception object into $!.
419 ## Add an 'else' node to the try op that clears $! if
420 ## no exception occurred.
423 }
427 }
430 }
431 # XXX Workaround for lexicals issue. rt #58854
434 }
437 }
439 }
445 # If we just got a routine_def, make it a sub.
448 }
450 # If it was multi, then emit a :multi and a type list.
452 # For now, if this is a multi we need to add code to transform the sub's
453 # multi container to a Perl6MultiSub.
461 )
462 )
463 );
465 # Flag the sub as multi, but it will get the signature from the
466 # signature object, so don't worry about that here.
470 }
472 }
480 }
484 # If it's got a name, only valid inside a class, role or grammar.
491 }
492 }
494 # Add declaration of leixcal self.
501 ),
503 ));
505 # Set up the block details.
510 }
513 }
515 }
521 }
524 }
526 }
533 # It's a named enumeration. First, we will get a mapping of all the names
534 # we will introduce with this enumeration to their values. We'll compute
535 # these at compile time, so then we can build as much of the enum as possible
536 # as PAST at compile time too. Note that means that, like a BEGIN block, we
537 # will compile, run and get the return value now.
544 $values
545 )
546 )
547 );
551 # Now we need to emit an role of the name of the enum containing:
552 # * One attribute with the same name as the enum
553 # * A method of the same name as the enum
554 # * Methods for each name introduced by the enum that compare the
555 # attribute with the value of that name.
562 ),
567 )
568 ),
575 ),
577 # XXX Set declared type here, when we parse that.
581 )
582 ),
589 ),
592 )
593 );
595 # Method for this value.
602 ),
614 ),
616 )
617 )
618 )
619 ));
620 }
622 # Now we emit code to create a class for the enum that does the role
623 # that we just defined. Note $def in the init code refers to this
624 # class from now on. Mark the class as an enum.
631 ),
638 )
639 )
640 ),
646 ),
650 )
651 )
652 );
654 # Want to give the class an invoke method that returns the enum value,
655 # and get_string, get_number and get_integer v-table overrides to we
656 # can get data from it..
663 ),
671 )
672 ),
676 )
677 ));
684 ),
695 )
696 )
697 ),
701 )
702 ));
709 ),
720 )
721 )
722 ),
726 )
727 ));
734 ),
745 )
746 )
747 ),
751 )
752 ));
754 # Now we need to create instances of each of these and install them
755 # in a package starting with the enum's name, plus an alias to them
756 # in the current package.
758 # Instantiate with value.
765 ),
772 ),
776 )
777 )
778 ));
780 # Add alias in current package.
781 # XXX Need to do collision detection, once we've a registry.
787 ),
792 )
793 ));
794 }
796 # Assemble all that we build into a statement list and then place it
797 # into the init code.
801 }
804 $class_past
805 ));
807 # Finally, since it's a decl, we don't have anything to emit at this
808 # point; just hand back empty statements block.
810 }
812 # Emit runtime call anonymous enum constructor.
816 $values
817 );
818 }
819 }
822 method routine_def($/) {
828 }
831 }
833 method method_def($/) {
837 }
840 }
843 method signature($/) {
844 # In here, we build a signature object and optionally some other things
845 # if $?SIG_BLOCK_NOT_NEEDED is not set to a true value.
846 # * $?BLOCK_SIGNATURED ends up containing the PAST tree for a block that
847 # takes and binds the parameters. This is used for generating subs,
848 # methods and so forth.
849 # * $?PARAM_TYPE_CHECK is used to export details of the types from here
850 # so that the multi plurality declarator can make use of them.
852 # Initialize PAST for the signatured block, if we're going to have it.
861 }
863 # Initialize PAST for constructing the signature object.
871 )
872 );
874 # Go through the parameters.
879 # Add parameter declaration to the block, if we're producing one.
881 # Register symbol and put parameter PAST into the node.
885 # If it is invocant, modify it to be just a lexical and bind self to it.
887 # Make sure it's first parameter.
890 }
892 # Modify.
896 # Bind self to it.
902 ),
904 ));
905 }
907 # Are we going to take the type of the thing we were passed and bind
908 # it to an abstraction parameter?
917 ),
924 )
925 )
926 ));
928 }
929 }
931 # Now start making a descriptor for the signature.
939 }
942 }
945 }
947 # See if we have any traits. For now, we just handle ro, rw and copy.
952 # Get name of the trait and see if it's one of the special
953 # traits we handle in the compiler.
957 }
961 }
965 }
968 }
969 }
972 }
973 }
975 # If we had is copy is rw or some other impossible combination, die.
978 }
980 # Add any type check that is needed. The scheme for this: $type_check
981 # is a statement block. We create a block for each parameter, which
982 # will be empty if there are no constraints for that parameter. This
983 # is so we can later generate a multi-sig from it.
989 # Just a type name?
998 )
999 );
1000 }
1003 }
1005 # Add it to the types list.
1007 }
1008 }
1010 # Add any post-constraints too.
1014 }
1016 # For blocks, we just collect the check into the list of all checks.
1019 }
1021 # For signatures, we build a list from the constraints and store it.
1025 ),
1029 )
1030 );
1032 # Just want the type, not the call to the checker.
1036 ));
1037 }
1040 # If we're making a block, emit code for trait types.
1043 # We just leave it as it is.
1044 }
1046 # Create a new container with ro set and bind the parameter to it.
1052 ),
1058 ),
1062 )
1063 )
1064 ));
1065 }
1067 # Create a new container and copy the value into it..
1073 ),
1078 ),
1082 )
1083 )
1084 ));
1085 }
1086 }
1087 }
1089 # Finish setting up the signatured block, if we're making one.
1095 }
1097 # Hand back the PAST to construct a signature object.
1099 }
1102 method parameter($/) {
1108 }
1114 }
1115 }
1119 }
1120 }
1121 }
1125 }
1128 }
1130 }
1132 }
1135 method param_var($/) {
1138 }
1143 );
1144 }
1147 method special_variable($/) {
1149 }
1155 # Whatever.
1165 )
1166 );
1167 }
1170 }
1181 # indirect call, invocant needs to be second arg
1185 }
1188 }
1189 }
1190 }
1192 }
1197 }
1204 # Just a normal method call.
1206 }
1208 # Private method call. Need to put ! on the start of the name
1209 # (unless it was call to a code object, in which case we don't do
1210 # anything more).
1214 }
1221 );
1222 }
1223 }
1230 }
1233 }
1236 }
1239 }
1240 }
1246 );
1247 }
1250 }
1258 }
1261 }
1267 }
1270 }
1273 }
1276 }
1287 );
1288 }
1292 }
1300 );
1301 }
1309 );
1310 }
1313 }
1315 }
1325 );
1326 }
1328 # Call on $_.
1335 ));
1336 }
1339 }
1341 }
1346 # Apply any "is" traits through MMD.
1356 ),
1360 )
1361 )
1362 );
1363 }
1365 # Role.
1373 ),
1377 )
1378 )
1379 );
1380 }
1383 }
1384 }
1385 }
1399 # Start of a new package. We create an empty PAST::Stmts node for the
1400 # package definition to be stored in and put it onto the current stack
1401 # of packages and the stack of its package type.
1408 }
1412 }
1416 }
1417 }
1419 # End of declaration. Our PAST will be that made by the package_def or
1420 # role_def.
1423 # Restore outer package.
1427 }
1430 }
1433 }
1436 }
1437 }
1448 # Start of package definition. Handle class and grammar specially.
1450 # Start of class definition; make PAST to create class object.
1456 ),
1460 )
1461 );
1463 # Add a name, if we have one.
1466 }
1469 }
1471 # Anonymous grammars not supported.
1474 }
1476 # Start of grammar definition. Create grammar class object.
1483 ),
1488 )
1489 )
1490 );
1491 }
1493 # Anonymous modules not supported.
1496 }
1497 }
1499 # Also store the current namespace, if we're not anonymous.
1502 }
1503 }
1505 # XXX For now, to work around the :load :init not being allowed to be
1506 # an outer bug, we will enclose the actual package block inside an
1507 # immediate block of its own.
1511 $inner_block
1512 );
1514 # Declare the namespace and that the result block holds things that we
1515 # do "on load".
1518 }
1523 # Apply traits.
1526 # It's a class. Make proto-object.
1535 ),
1539 ),
1543 )
1544 )
1545 );
1547 # If this is an anonymous class, the block doesn't want to be a
1548 # :init :load, and it's going to contain the class definition, so
1549 # we need to declare the lexical $def.
1557 ));
1558 }
1560 # Attatch any class initialization code to the init code;
1561 # note that we skip blocks, which are method accessors that
1562 # we want to put under this block so they get the correct
1563 # namespace. If it's an anonymous class, everything goes into
1564 # this block.
1567 }
1571 }
1574 }
1575 }
1576 }
1578 # Apply traits.
1581 # Make proto-object for grammar.
1590 ),
1594 ),
1598 )
1599 )
1600 );
1602 # Attatch grammar declaration to the init code.
1605 }
1608 # Clear namespace.
1610 }
1613 }
1614 }
1623 # Start of role definition. Push on code to create a role object.
1630 ),
1635 )
1636 )
1637 );
1639 # Also store the current namespace.
1641 }
1643 # Declare the namespace and that the result block holds things that we
1644 # do "on load".
1650 # Apply traits.
1653 # Attatch role declaration to the init code, skipping blocks since
1654 # those are accessors.
1657 }
1661 }
1664 }
1665 }
1667 # Clear namespace.
1671 }
1672 }
1678 }
1681 method variable_declarator($/) {
1684 # If it's an attribute declaration, we handle traits elsewhere.
1695 }
1698 }
1699 }
1702 }
1703 }
1709 }
1710 }
1711 }
1712 }
1715 }
1718 method scoped($/) {
1721 # Variable declaration?
1725 # Unless it's an attribute, emit code to set type and initialize it to
1726 # the correct proto.
1740 ),
1745 )
1746 ),
1747 $type
1748 )
1749 );
1750 }
1751 }
1753 # Variable declaration, but with a signature?
1757 }
1759 }
1761 # Routine declaration?
1765 # Don't support setting return type yet.
1768 }
1769 }
1771 }
1775 # Get the class or role we're in.
1783 }
1786 }
1790 );
1791 }
1793 # Is this a role-private or just a normal attribute?
1796 # These are only allowed inside a role.
1799 }
1801 # We need to name-manage this somehow. We'll do $!rolename!attrname
1802 # for now; long term, want some UUID. For the block entry, we enter it
1803 # as $!attrname, add the real name and set the scope as rpattribute,
1804 # then translate it to the right thing when we see it.
1810 }
1812 # Register name as attribute scope.
1815 }
1817 # Add attribute to class (always name it with ! twigil).
1826 ),
1829 )
1830 );
1831 }
1840 ),
1842 )
1843 );
1844 }
1846 # Is there any "handles" trait verb or an "is rw" or "is ro"?
1851 # Get the methods for the handles and add them to
1852 # the class
1854 $/,
1856 $name
1857 );
1860 }
1861 }
1863 # Just handle rw for now.
1866 }
1869 }
1870 }
1873 }
1874 }
1875 }
1877 # Twigil handling.
1879 # We have a . twigil, so we need to generate an accessor.
1882 }
1884 # Don't need to do anything.
1885 }
1887 # We have no twigil, make $name as an alias to $!name.
1890 );
1891 }
1893 # It's a twigil that you canny use in an attribute declaration.
1895 "invalid twigil "
1897 );
1898 }
1899 }
1901 method scope_declarator($/) {
1906 # What sort of thing are we scoping?
1912 # Variable. If it's declared with "has" it is always an attribute. If
1913 # it is declared with "my" inside a role and has the ! twigil, it is
1914 # a role private attribute.
1919 # Attribute declarations need special handling.
1925 # We don't have any PAST at the point of the declaration.
1927 }
1929 # If we're in a class and have something declared with a sigil, then
1930 # we need to generate an accessor method and emit that along with the
1931 # lexical declaration itself.
1933 # This node is just the variable declaration; also register it in
1934 # the symbol table.
1941 );
1944 # Now generate accessor, if it's public.
1947 }
1948 }
1950 # Otherwise, just a normal variable declaration.
1952 # Has this already been declared?
1955 # First declaration
1960 }
1963 "scope declarator '"
1965 );
1966 }
1968 # Add block entry.
1970 }
1971 }
1972 }
1974 # Signature.
1976 # We'll emit code to declare each of the parameters, then we'll have
1977 # the declaration evaluate to the signature object, thus allowing an
1978 # assignment to it.
1982 # Work out sigil and twigil.
1988 }
1992 }
1994 # Decide by declarator.
1996 # Add declaration code.
2000 }
2003 }
2009 ));
2011 # Add block entry.
2015 }
2018 }
2019 }
2020 }
2022 # Routine?
2024 # What declarator?
2026 # Default, nothing to do.
2027 }
2030 # Add ! to start of name.
2032 }
2035 }
2036 }
2039 }
2040 }
2042 # Something else we've not implemetned yet?
2045 }
2048 }
2055 }
2064 ),
2068 )
2069 );
2070 }
2077 ));
2078 }
2081 # Handle naming.
2100 }
2103 }
2105 }
2106 }
2111 }
2122 }
2124 }
2125 }
2127 # If it's $.x, it's a method call, not a variable.
2137 )
2138 );
2139 }
2141 # Variable. [!:^] twigil should be kept in the name.
2144 # All but subs should keep their sigils.
2148 }
2150 # If we have no twigil, but we see the name noted as an attribute in
2151 # an enclosing scope, add the ! twigil anyway; it's an alias.
2160 }
2161 }
2162 }
2163 }
2165 # If it's a role-private attribute, fix up the name.
2174 }
2175 }
2176 }
2177 }
2182 );
2186 }
2188 # If it has a ! twigil, give it attribute scope and add self.
2194 ));
2195 }
2197 # If we have something with an & sigil see if it has any entries
2198 # in the enclosing blocks; otherwise, default to package.
2207 }
2208 }
2209 }
2210 }
2213 }
2214 }
2216 }
2225 }
2229 }
2231 # If it is completely empty or consists of a single list, the first
2232 # element of which is either a hash or a pair, it's a hash constructor.
2237 # Empty block, so a hash.
2239 }
2242 # Block with just one pair in it, so a hash.
2244 }
2246 # List, but first elements must be...
2249 # ...a Pair
2251 }
2254 # ...or a hash.
2256 }
2257 }
2258 }
2259 }
2266 );
2269 }
2270 }
2273 }
2274 }
2282 );
2283 }
2288 $call_on
2289 );
2290 }
2292 }
2297 }
2302 }
2305 ## for a variety of reasons, this is easier in PIR than NQP for now.
2306 ## NQP doesn't have assign yet, and Perl6Str is lighter-weight than Str.
2307 method integer($/) {
2318 );
2319 }
2322 method dec_number($/) {
2324 }
2328 }
2330 method rad_number($/) {
2344 }
2352 );
2353 }
2354 }
2357 method quote($/) {
2359 }
2371 );
2372 }
2376 }
2382 );
2385 }
2386 }
2387 }
2389 }
2392 method quote_concat($/) {
2402 );
2404 }
2406 }
2415 );
2416 }
2419 }
2424 }
2425 }
2427 }
2430 method typename($/) {
2431 # Extract shortname part of identifier, if there is one.
2435 # Create default PAST node for package lookup of type.
2442 );
2444 # If there's no namespace, could be lexical abstraction type.
2446 # See if we got lexical with the right name.
2455 }
2456 }
2457 }
2458 }
2461 }
2469 }
2473 }
2476 }
2482 );
2483 }
2492 );
2493 }
2497 }
2500 method semilist($/) {
2505 }
2508 method arglist($/) {
2513 }
2519 }
2524 # Check that we have a sub call.
2527 }
2529 # Make a duplicate of the target node to receive result
2534 );
2536 # Change call node to a callmethod and add the invocant
2540 # and assign result to target
2545 $target
2546 );
2549 }
2556 );
2559 # Make sure we only have one initialization value.
2562 }
2563 # Push role name and argument onto infix:does or infix:but.
2566 }
2569 }
2571 }
2577 );
2581 }
2584 }
2585 }
2590 }
2593 method regex_declarator_regex($/) {
2597 }
2600 method regex_declarator_token($/) {
2605 }
2608 method regex_declarator_rule($/) {
2613 }
2616 method type_declarator($/) {
2617 # We need a block containing the constraint condition.
2620 # Make block with a smart match of the the expression as its contents.
2626 )
2627 ),
2636 )
2637 )
2638 )
2639 );
2640 }
2642 # Make sure it has a parameter and keep hold of it if found.
2649 }
2652 }
2653 }
2654 }
2659 }
2664 );
2666 }
2667 }
2669 # Do we have an existing constraint to check?
2681 )
2682 ),
2683 $new_cond
2684 )
2685 }
2687 # Set block details.
2690 # Now we need to create the block wrapper class.
2697 ),
2699 $past
2700 );
2703 }
2706 method fatarrow($/) {
2714 );
2716 }
2726 }
2733 }
2734 }
2737 }
2738 }
2744 );
2745 }
2748 }
2749 }
2752 }
2760 $pair_val
2761 );
2763 }
2766 method capterm($/) {
2767 # We will create the capture object, passing the things supplied.
2771 }
2774 method capture($/) {
2776 }
2779 method sigterm($/) {
2782 }
2785 # Used by all calling code to process arguments into the correct form.
2789 }
2797 }
2799 }
2802 }
2811 }
2816 );
2818 }
2821 }
2822 }
2830 }
2837 }
2841 ## Contextualizing is calling .item, .list, .hash, etc.
2842 ## on the expression in the brackets
2849 }
2850 $method
2851 }
2858 }
2861 # Processes a handles expression to produce the appropriate method(s).
2865 # What type of expression do we have?
2867 # Just a single string mapping.
2871 }
2873 # Single pair.
2876 }
2879 # List of something, but what is it?
2882 # String value.
2886 }
2888 # Pair.
2891 }
2894 'Only a list of constants or pairs can be used in handles'
2895 );
2896 }
2897 }
2898 }
2900 # Also a list, but constructed differently.
2903 # String value.
2907 }
2909 # Pair.
2912 }
2915 'Only a list of constants or pairs can be used in handles'
2916 );
2917 }
2918 }
2919 }
2922 }
2924 $past
2925 }
2928 # Produces a handles method.
2939 ),
2945 ),
2952 ),
2957 ),
2963 )
2964 )
2965 )
2966 }
2969 # Makes a handles method from a pair.
2973 # Single pair mapping. Check we have string name and value.
2980 }
2983 }
2985 $meth
2986 }
2989 # This takes an array of match objects of type constraints and builds a type
2990 # representation out of them.
2992 # Build the type constraints list for the variable.
2998 }
3000 # If there were none, it's Object.
3005 ));
3007 }
3009 # Now need to apply the type constraints. How many are there?
3011 # Just the first one.
3013 }
3015 # Many; make an and junction of types.
3018 }
3020 $type_cons
3021 }
3024 # Takes a block and turns it into a sub.
3030 }
3033 }
3034 }
3037 # Set the proto object type of a block.
3045 )
3046 );
3047 }
3050 # Associate a signature object with a block.
3057 $sig_obj
3058 )
3059 );
3060 }
3063 # Create an empty signautre object for subs with no signatures.
3072 )
3073 )
3074 }
3077 # Creates a signature descriptor (for now, just a hash).
3083 )
3084 }
3086 # Sets a given value in the signature descriptor.
3091 $value
3092 ));
3093 }
3095 # Returns a list of variables from a signature that we are to declare. Panics
3096 # if the signature is too complex to unpack.
3098 # Just make sure it's what we expect.
3102 }
3104 # Now go through what signature and extract what to declare.
3109 # Skip over invocant.
3111 }
3113 # If it has a name, we're fine; if not, it's something odd - give
3114 # it a miss for now.
3119 }
3120 }
3123 }
3126 }
3127 }
3128 }
3129 @result
3130 }
3132 # Generates a setter/getter method for an attribute in a class or role.
3137 }
3144 ),
3146 );
3147 }
3154 );
3155 $accessor
3156 }
3159 # Adds the given method to the current class. This just returns the method that
3160 # is passed to it if the current class is named; in the case that it is anonymous
3161 # we need instead to emit an add_method call and remove the methods name so it
3162 # doesn't pollute the namespace.
3167 # Create new PAST::Block - can't work out how to unset the name of an
3168 # existing one.
3172 );
3175 }
3177 # Put call to add method into the class definition.
3184 ),
3186 $new_method
3187 ));
3189 $new_method
3190 }
3192 $method
3193 }
3194 }
3196 # Creates an anonymous subset type.
3198 # We need a block containing the constraint condition.
3200 # Make block with the expression as its contents.
3204 );
3205 }
3207 # Make sure it has a parameter.
3214 }
3217 }
3218 }
3219 }
3224 }
3229 );
3231 }
3232 }
3234 # Now we'll just pass this block to the type checker,
3235 # since smart-matching a block invokes it.
3241 $past
3242 ),
3246 )
3247 );
3248 }
3250 # Local Variables:
3251 # mode: cperl
3252 # cperl-indent-level: 4
3253 # fill-column: 100
3254 # End:
3255 # vim: expandtab shiftwidth=4: