Changeset 21763

Timestamp:

08/04/08 10:39:26 (4 months ago)

Author:

lwall

Message:

s/q:code/quasi/ plus various t/ buglets

Files:

• src/Pugs/Eval.hs (modified) (1 diff)
• src/Pugs/Parser.hs (modified) (1 diff)
• src/perl6/Cursor.pmc (modified) (1 diff)
• src/perl6/STD.pm (modified) (9 diffs)
• t/examples/99problems/problem91.t (modified) (3 diffs)
• t/examples/all_parse.t (modified) (1 diff)
• t/macros/caller.t (modified) (1 diff)
• t/macros/macro_code_test.t (modified) (8 diffs)
• t/macros/opaque_ast_macros.t (modified) (3 diffs)

src/Pugs/Eval.hs

@@ -899 +899 @@
         evalExp $ Syn "=" [Val lhs, App (_Var op) Nothing [Val val, rhsExp]]
 
-reduceSyn "q:code" [ body ] = expToEvalVal body
+reduceSyn "quasi" [ body ] = expToEvalVal body
 
 reduceSyn "CCallDyn" (Val (VStr quant):methExp:invExp:args) = do

src/Pugs/Parser.hs

@@ -984 +984 @@
             _ -> fail "no caller env to install pragma in"
 
-{-| Match a @q:code { ... }@ quotation -}
+{-| Match a @quasi { ... }@ quotation -}
 ruleCodeQuotation :: RuleParser Exp
 ruleCodeQuotation = rule "code quotation" $ do
     -- XXX - This is entirely kluge; it drops traits in the body too
-    symbol "q:code" >> optional (symbol "(:COMPILING)")
+    symbol "quasi" >> optional (symbol ":COMPILING")
     block <- ruleBlockBody
-    return (Syn "q:code" [bi_body block])
+    return (Syn "quasi" [bi_body block])
     
 -- | If we've executed code like @BEGIN { exit }@, we've to run all @\@*END@

src/perl6/Cursor.pmc

@@ -202 +202 @@
         return { PATS => ['(?#::)'] };  # (but if we advanced just assume a :: here)
     }
+    $key = 'termish' if $key eq 'EXPR';
     return $self->lexers->{$key} = $self->_AUTOLEXgen($key, $retree);
 }

src/perl6/STD.pm

@@ -1757 +1757 @@
 }
 
+token quasiquibble ($l) {
+    :my $lang = $l;
+    :my $start;
+    :my $stop;
+
+    <.ws>
+    [ <quotepair> <.ws>
+        {
+            my $kv = $<quotepair>[*-1];
+            $lang = $lang.tweak($kv.<k>, $kv.<v>)
+                or self.panic("Unrecognized adverb :" ~ $kv.<k> ~ '(' ~ $kv.<v> ~ ')');
+        }
+    ]*
+
+    {
+        ($start,$stop) = $¢.peek_delimiters();
+        $lang = $start ne $stop ?? $lang.balanced($start,$stop)
+                                !! $lang.unbalanced($stop);
+    }
+
+    [
+    || <?{ $start eq '{' }> [ :lang($lang) <block> ]
+    || $start [ :lang($lang) <statementlist> ] $stop
+    ]
+}
+
 # note: polymorphic over many quote languages, we hope
 token nibbler {
@@ -1863 +1889 @@
 token quote:tr {
     <sym> » <!before '('> <pat=tribble( $¢.cursor_fresh( ::STD::Q ).tweak(:q))>
+}
+
+token quote:quasi {
+    <sym> » <!before '('> <pat=quasiquibble($¢.cursor_fresh( ::STD::Quasi ))>
 }
 
@@ -2224 +2254 @@
     }
 
-    multi method tweak (:$code) {
-        return ::RegexCode;
-    }
-
     multi method tweak (*%x) {
         my @k = keys(%x);
@@ -2235 +2261 @@
 
 
+} # end grammar
+
+grammar Quasi is STD {
+    token term:unquote {
+        <starter><starter><starter> :: <statementlist> <stopper><stopper><stopper>
+    }
 } # end grammar
 
@@ -2381 +2413 @@
     [
         # Is it a longname declaration?
-    || <?{ $<sigil> eq '&' }> <?ident> ::
+    || <?{ $<sigil>.text eq '&' }> <?ident> ::
         <ident=sublongname>
 
     ||  # Is it a shaped array or hash declaration?
-        <?{ $<sigil> eq '@' || $<sigil> eq '%' }>
+        <?{ $<sigil>.text eq '@' || $<sigil>.text eq '%' }>
         <ident>?
         <.ws>
@@ -2905 +2937 @@
     { <sym> }
 
-token term:sym<...> ( --> List_prefix)
+token prefix:sym<...> ( --> List_prefix)
 {
     '...'
 }
 
-token term:sym<???> ( --> List_prefix)
+token prefix:sym<???> ( --> List_prefix)
 {
     '???'
 }
 
-token term:sym<!!!> ( --> List_prefix)
+token prefix:sym<!!!> ( --> List_prefix)
 {
     '!!!'
@@ -2929 +2961 @@
 #     { <typename> <?spacey> <arglist> { $<sym> = $<typename>.item; } }
 
-# unrecognized identifiers are assumed to be post-declared listops.
+# force ident(), ident.(), etc. to be a function call always
 token term:ident ( --> Term )
 {
     <ident>
     [
-    | '.(' <in: ')', 'semilist', 'argument list'> {*}                               #= func args
-    | '(' <in: ')', 'semilist', 'argument list'> {*}                                #= func args
-    | <.unsp> '.'? '(' <in: ')', 'semilist', 'argument list'> {*}                   #= func args
-    ]
-}
-
+    | '.(' <in: ')', 'semilist', 'argument list'> {*}             #= func args
+    | '(' <in: ')', 'semilist', 'argument list'> {*}              #= func args
+    | <.unsp> '.'? '(' <in: ')', 'semilist', 'argument list'> {*} #= func args
+    ]
+
+    [
+    || ':' <?before \s> <arglist>    # either switch to listopiness
+    || {{ $+prevop = $<O> = {}; }}   # or allow adverbs
+    ]
+}
+
+# names containing :: may or may not be function calls
+# bare ident without parens also handled here if no other rule parses it
 token term:name ( --> Term)
 {
@@ -2945 +2984 @@
     [
     ||  <?{
-            $¢.is_type($<longname>.text)
+            $¢.is_type($<longname>.text) or substr($<longname>.text,0,2) eq '::'
         }> ::
         # parametric type?
@@ -2955 +2994 @@
         ]?
         {*}                                                     #= typename
+
+    # unrecognized names are assumed to be post-declared listops.
+    || <?before \s> <arglist>
+        {*}                                                     #= listop args
     ||
         [
-        | '.(' <in: ')', 'semilist', 'argument list'> {*}                               #= func args
-        | '(' <in: ')', 'semilist', 'argument list'> {*}                                #= func args
-        | <?before \s> <?{ substr($<longname>.text,0,2) ne '::' }> <arglist> {*}                            #= listop args
-        | <.unsp> '.'? '(' <in: ')', 'semilist', 'argument list'> {*}                   #= func args
-        | :: {*}                                                #= listop noarg
+        | '.(' <in: ')', 'semilist', 'argument list'>
+            {*}                                                 #= func args
+
+        | '(' <in: ')', 'semilist', 'argument list'>
+            {*}                                                 #= func args
+
+        | <.unsp> '.'? '(' <in: ')', 'semilist', 'argument list'>
+            {*}                                                 #= func args
+
+
+        | ::  {*}                                               #= listop noarg
+        ]
+
+        [
+        || ':' <?before \s> <arglist>    # either switch to listopiness
+        || {{ $+prevop = $<O> = {}; }}   # or allow adverbs
         ]
     ]

t/examples/99problems/problem91.t

@@ -36 +36 @@
     }
     
-    method toStr() {
+    method Str() {
         $.x ~ "/" ~ $.y;
     }
 }
-
-# Stringify a case
-multi sub *prefix:<~> (Case $c) { $c.toStr }
 
 # All the moves a Knight can do
@@ -110 +107 @@
     }
     my Bool @chessboard[$n][$n];
-    for ( 0..$n-1 ) -> $i {
+    for 0..$n-1 -> $i {
         @chessboard[$i] = [True xx $n];
     }
@@ -120 +117 @@
 my $n = 8;
 my @result = searchFrom( Case.new(:x(0),:y(0)), $n );
-# @result.map:{.toStr}.join(", ").say;
+# @result.map:{.Str}.join(", ").say;
 ok check_tour($n, @result), "This knight's tour is valid.";

t/examples/all_parse.t

@@ -49 +49 @@
 # $! instead of this yucky workaround
 for sort(@files) -> $ex {
-    my $out = `$*EXECUTABLE_NAME -c -Iblib6/lib $ex`;
+    my $out = qqx[$*EXECUTABLE_NAME -c -Iblib6/lib $ex];
 
     if $out ~~ m:P5/syntax OK\s*$/ {

t/macros/caller.t

@@ -19 +19 @@
 
 macro ast_compiling_current_line () {
-    return q:code(:COMPILING) { current_line() };
+    return quasi :COMPILING { current_line() };
 }
 
 macro ast_current_line () {
-    return q:code { current_line() };
+    return quasi { current_line() };
 }
 

t/macros/macro_code_test.t

@@ -19 +19 @@
 # is Eager
 macro max ($x is CST, $y is CST) {
-    return q:code { ($x > $y) ?? $x !! $y };
+    return quasi { ($x > $y) ?? $x !! $y };
 }
 
@@ -37 +37 @@
 =begin pod
 
-=head1 q:code & AST splicing options
+=head1 quasi & AST splicing options
 
 =head2 Splicing Problem
 
-The contents of q:code blocks need to be able to refer to values
+The contents of quasi blocks need to be able to refer to values
 as any other closure does, but also define graft points for
 other asts.
@@ -47 +47 @@
 =head2 Solution Space
 
-First principle, adding q:code before a block doesn't change things
+First principle, adding quasi before a block doesn't change things
   - it's still a closure
   - if you mention $var it means the $var in the surrounding lexical scope
     (mentioning new vars may bind at the macro use)
   - subs continue to be bound to the local definitions
-  - macros continue to be expanded at parse time (q:code parse time)
+  - macros continue to be expanded at parse time (quasi parse time)
 
 Second principle, to do something special, say something special.
@@ -62 +62 @@
 the point is to wrap or warp them into the returned AST|string.
 We want an easy way to splice the input AST into the output AST
-The output AST is usually a q:code block somehow using the macro arg asts:
+The output AST is usually a quasi block somehow using the macro arg asts:
 
-  q:code { my $x; $x; $input_ast; $captured_var; $var_at_call }
+  quasi { my $x; $x; $input_ast; $captured_var; $var_at_call }
 
 =head2 Some Suggested Solutions
@@ -72 +72 @@
    literal($ast) macro to talk about an ast as a value
  
- * signature such as q:code ($ast) { $var; $ast }
+ * signature such as quasi ($ast) { $var; $ast }
    (idea--: duplicates macro's param list, violates sig -> application w/ args 
     expectation with subs)
@@ -79 +79 @@
 
  * escape meta-syntax (lisp's solution)  
-    q:code { say "Exp (\qq[~$package]) = ", \qq[$package] }
+    quasi { say "Exp (\qq[~$package]) = ", \qq[$package] }
  
- * set of escape macros which only apply in q:code blocks glue($ast)
+ * set of escape macros which only apply in quasi blocks glue($ast)
 
 More complex restructuring of the input AST would require walking
@@ -94 +94 @@
 =head2 Current Solution
 
-q:code { } is the quoter and {{{ }}} is the default antiquote
+quasi { } is the quoter and {{{ }}} is the default antiquote
 (the rule is actually the delimiter repeated thrice).
-The use of {{{ ... }}} in a q:code is just like an inline macro.
-Pretending that the body of you program is within a q:code{ }
+The use of {{{ ... }}} in a quasi is just like an inline macro.
+Pretending that the body of you program is within a quasi{ }
 then {{{ }}} can be used for inline macros, compile time
 generation of ASTs which are spliced immediately.
@@ -138 +138 @@
 $Larry "I don't see why not"
 
- q:code { sub x { ... }; macro y { ... }; use force; }
+ quasi { sub x { ... }; macro y { ... }; use force; }
 
 The AST needs to be rescanned anyway, so perform the appropriate

t/macros/opaque_ast_macros.t

@@ -6 +6 @@
 =head1 DESCRIPTION
 
-Tests for macros which return q:code but do not do splicing
+Tests for macros which return quasi but do not do splicing
 
 See L<S06/"Macros">.
@@ -15 +15 @@
 
 # L<S06/Macros>
-macro four () { q:code { 2+2 } } 
+macro four () { quasi { 2+2 } } 
 
-is(four, 4, "macro returning q:code");
+is(four, 4, "macro returning quasi");
 
-macro hi () { q:code(:COMPILING) { "hello $s" } } 
+macro hi () { quasi :COMPILING { "hello $s" } } 
 
 macro hey () { ({ "hello $^s" }.body) } 
@@ -31 +31 @@
 
 my $x;
-macro noop ()  { $x = "Nothing happened"; q:code { } } 
+macro noop ()  { $x = "Nothing happened"; quasi { } } 
 noop();
 #macro noop2 () { $x ~= ", twice"; return } # unspecced