Planet Stratego

before · Nix package manager

p0
$ crap --new-project p0

src/xmpl.str
p0/
   Makefile.am
   README.Developer
   README
   AUTHORS
   bootstrap
   p0.spec.in
   NEWS
   p0.pc.in
   configure.ac
   ChangeLog
   xmpl/
        Makefile.am
   syn/
       Makefile.am
   tests/
         Makefile.am
   src/
       Makefile.am
       xmpl.str

$ ./bootstrap
$ ./configure
$ make all

$ make install

$ echo "foo" | /usr/local/bin/xmpl
"Hello, World!"

stdin
-i
"Hello, World!"
crap
crap
-------------------------------------------------------------------------
Dear author,

We are pleased to inform you that your paper entitled

     Building Program Optimizers with Rewriting [Strategies]

has been accepted for presentation at ICFP'98. In a next message, you
will receive reviews from the Program Committee that we hope you can
use to improve the final draft, which is due on July 14th. We will
also be sending you an ACM Copyright Release form, which must be
signed and returned by the same deadline.

Congratulations, and thank you for your submittal to ICFP'98.

  Paul Hudak
  Christian Queinnec
  co-Chairs, ICFP'98 Program Committee
-------------------------------------------------------------------------

EditorPart
ITextEditor.setHighlightRange()
markInNavigatorHistory()
AbstractTextEditor.markInNavigationHistory()
io-wrap
io-stream-wrap
io-wrap
  option-wrap(opts, usage, about, announce, s) =
    parse-options(opts, usage, about)
    ; announce
    ; (s; report-success + report-failure)

  report-failure =
      report-run-time
    ; <fprintnl> (stderr(), [ (), ": rewriting failed"])
    ; <exit> 1

exit
stacktrace-get-current-frame-name
stacktrace-get-all-frame-names
stacktrace-get-current-frame-index
io-wrap
  option-wrap(opts, usage, about, announce, s) =
    parse-options(opts, usage, about)
    ; announce
    ; (s; report-success + prim("SSL_stacktrace_get_all_frame_names") ; report-failure)

  report-failure =
      ?stacktrace
    ; report-run-time
    ; <fprintnl> (stderr(), [ <whoami> (), ": rewriting failed, trace:"])
    ; <reverse ; map(<fprintnl> (stderr(), ["\t", <id>]))> stacktrace
    ; <exit> 1

io-wrap

  main = io-wrap(my-wrap(foo))

  my-wrap(s) = s

  foo = debug(!"foo") ; bar

  bar = debug(!"bar") ; fap ; zap

  fap = debug(!"fap") ; id

  zap = debug(!"zap") ; debug ; fail

./prog: rewriting failed, trace:
        main_0_0
        io_wrap_1_0
        option_wrap_5_0
        lifted144
        input_1_0
        lifted145
        output_1_0
        lifted0
        my_wrap_1_0
        foo_0_0
        bar_0_0
        zap_0_0

lifted*
prog
  main = foo

  foo = bar

  bar = fap ; zap

  fap = id

  zap = fail

prog: rewriting failed, trace:
        main_0_0
        foo_0_0
        bar_0_0
        zap_0_0 

strc-java
main = !Foo(1,2)

public static class main_0_0 extends Strategy
{
    public final static main_0_0 instance = new main_0_0();
   public ATerm apply(ATerm term)
    {
      try
      {
        {
          ATerm[] b_0 = new ATerm[2];
          {
            ATerm c_0 = atermFactory.makeInt(1);
            b_0[0] = c_0;
          }
          {
            ATerm d_0 = atermFactory.makeInt(2);
            b_0[1] = d_0;
          }
          ATerm a_0 = atermFactory.makeAppl(atermFactory.makeAFun("Foo", 2, false), b_0);
          term = a_0;
        }
      }
      catch(Failure f)
      {
        return null;
      }
      return term;
    }
  }

apply
instance
ATerm apply(Strategy[] svars, ATerm[] tvars, ATerm currentTerm)
new
ATerm apply(Strategy s0, Strategy s1, ATerm t0, ATerm t0, ATerm currentTerm) 

s.apply()
ATerm apply(Strategy<x0,y0> s0, Strategy<x1,y1> s1, ATerm t0, ATerm t0, ATerm currentTerm)

x
y
N0
N31
  defined-functions-main =
    include-files-complex
  ; get-php-environment
  ; get-functions
  ; if ?[]
    then !"No functions defined."
    else  map(transform-to-message)
        ; lines                    
    end  
<?php
  echo addslashes(htmlentities($_GET['name']));
?>
function: addslashes       level: escaped-slashes
function: htmlentities     level: escaped-html
function: addslashes       level: escaped-slashes +
function: htmlentities     level: escaped-html +
<?php
 $foo = $_GET['asdf'];
 $bar = 1;
 $bar =& $foo;
 echo $bar;
?>
 add-php-simple-value(|val):
    t{a*} -> t{annos}
      where  b*    :=  a*
           ; annos := [PHPSimpleValue(val) | b*]
 add-php-simple-value(|val):
    t{a*} -> t{annos*}
      where  b*     :=  a*
           ; annos* := [PHPSimpleValue(val) | b*]
  define-inline =
    ?Function(f, xs, e)
    ; rules( Inline : Call(f, es) -> Let(xs, es, e)

  Inline2 : Call(f, es) -> Let(xs, es, e)

    x := <compute>
    ; rules( Foo : _ -> x )

    Foo := <compute>

    rules( Foo := <compute> )

  Desugar :
    |[ rules( dr := t ) ]| -> |[ where({y : !t; ?y; rules( dr : _ -> y )}) ]| 
    where y := <newname> "globvar"

    where({x : x := <compute>; rules( Foo : _ -> x )})

  Desugar :
    |[ rules( dr :+= t ) ]| -> |[ where({y : !t; ?y; rules( dr :+ _ -> y )}) ]| 
    where y := <newname> "globvar"

  $foo = array(1,2);
  $foo[] = $_GET['bar'];
  echo $foo[2];
  if ($is_upload && $file = fopen($fname, 'w')) { 
    ...
  }

  if(!$foo = getenv('BAR')){
    ...
  }

  @include_once 'Var/Renderer/' . $mode . '.php'

  E "*" E -> E > E "+" E -> E

  <E -> <E -> E + E> * E>
  <E -> E * <E -> E + E>>

  E "?" E ":" E -> E <0,4> > E "=" E

  <E -> <E -> E = E> ? E : E>
  <E -> E ? E : <E -> E = E>>

  "!" E -> E   > E "+" E -> E
  E "+" E -> E > V "=" E -> E

  "!" E -> E >  V "=" E -> E

  "!" E -> E .> E "+" E -> E

  <E -> <E -> E + E> * E>
  <E -> E * <E -> E + E>>

  E * E -> E <0> .> E + E -> E
  E * E -> E <2> .> E + E -> E

Planet Stratego

Martin Bravenboer: Dubious Conferences: How do they threat people?

Eelco Visser: The Nix Build Farm: A Declarative Approach to Continuous Integration

Karl Trygve Kalleberg: Create-a-Project: Creating Stratego/XT projects the simple way

Eelco Visser: OOPSLA'08 tutorial: Building Domain-Specific Languages for the Web

Eelco Visser: WebDSL: A Case Study in Domain-Specific Language Engineering

Eelco Visser: Stratego: 10 years

Eelco Visser: Declarative Access Control for WebDSL

Eelco Visser: Code Generation by Model Transformation

Eelco Visser: Attribute Grammars in Stratego II

Karl Trygve Kalleberg: Proper navigation support for Spoofax

Karl Trygve Kalleberg: Porting Eclipse IMP from Eclipse 3.2 to 3.3

Eelco Visser: Attribute Grammars in Stratego

Karl Trygve Kalleberg: Stack tracing improvements

Karl Trygve Kalleberg: Would you like a stack trace with your "rewriting failed"?

Eelco Visser: WebDSL in JastAdd

Karl Trygve Kalleberg: Visit to EPITA

Eelco Visser: WebDSL at Code Generation 2008

Eelco Visser: Pull Deployment of Services

Karl Trygve Kalleberg: FOSDEM 2008

Eelco Visser: Program Transformation & Generation

Eelco Visser: Generating Editors for Embedded Languages

Karl Trygve Kalleberg: New dissertation page and other Stratego updates

Martin Bravenboer: Ph.D. Thesis: Exercises in Free Syntax

Karl Trygve Kalleberg: Summer Job Hunting

Eelco Visser: www.webdsl.org online

Karl Trygve Kalleberg: Stratego Java backend in progress

Eric Bouwers: So much interesting to read ...

Eric Bouwers: A little migration helper

Karl Trygve Kalleberg: Post-Defense Redux

Eric Bouwers: It is getting noticed

Eelco Visser: Abstractions for Language Independent Transformations

Eric Bouwers: Where you at?

Eelco Visser: Domain-Specific Language Engineering (Mark I)

Eelco Visser: Scrap your Boilertemplate

Eelco Visser: Preventing Injection Attacks with Syntax Embeddings

Eric Bouwers: Some new features

Eric Bouwers: Merging fun

Karl Trygve Kalleberg: Spoofax seminar rescheduled

Eelco Visser: Global Variables

Karl Trygve Kalleberg: Upcoming Seminar: Spoofax: A Development Environment for Software Transformations

Eric Bouwers: Thinking of Merging

Martin Bravenboer: Migration of the YACC grammar for PHP to SDF

PHP precedence problems

Precedence rule recovery

Argument-specific priorities

Non-transitive priorities

Precedence rule migration

Future