Changeset 808


Ignore:
Timestamp:
Jul 19, 2012 7:01:58 PM (12 years ago)
Author:
biz002
Message:

test program for magnolia pretty printing

For printing Magnolia. Does just about as good a job as possible
without semantic tokens and groupings. I.e. with a single annot
attached to each actual token, otherwise free of context.

desugared test progs pp'ing ok

sugared test progs pp'ing ok

most C style syntax now displays reasonably,
to the extent exercised by magnolia-tests project .mg files

but renaming and doc block syntaxes are unusual and unpretty

LINECOMMENT category

spacer table building now works better when no category set
is given to make func

deal with Skip combination in table construction already

could only create usable parser for one .mg file - fix

now in-memory caching parser classes instead of parser objects

token annots and spacing table for Magnolia

improve support for Sequence(list[Decision] ds) decisions in spacer

add module for rascal-based test utils

clojure.core -> testutil.core

Location:
trunk/magnolia-eclipse
Files:
1 added
8 edited
1 copied
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/magnolia-eclipse/project.clj

    r807 r808  
    8282  :compile-path "clj-bin"
    8383  :library-path "clj-lib"
    84   :repl-init org.magnolialang.clojure.core
    85   :aot [org.magnolialang.clojure.core
    86         org.magnolialang.clojure.rascal-shell]
     84  :repl-init org.magnolialang.testutil.core
     85  :aot [org.magnolialang.testutil.core
     86        org.magnolialang.testutil.rascal-shell]
    8787  ;; Time-consuming, but shows what classes loaded from where.
    8888  ;;:jvm-opts ["-verbose:class"]

  • trunk/magnolia-eclipse/src/org/magnolialang/infra/ConsoleInfra.java

    r807 r808  
    111111
    112112        // cache of generated parsers
    113         private final Map<String, IGTD> parsers                         = new HashMap<String, IGTD>();
     113        private final Map<String, Class<IGTD>>  parserClasses           = new HashMap<String, Class<IGTD>>();
    114114
    115         private final IRascalMonitor    rm                                      = new NullRascalMonitor();
     115        private final IRascalMonitor                    rm                                      = new NullRascalMonitor();
    116116
    117         protected static final String   parserPackageName       = "org.rascalmpl.java.parser.object";
     117        protected static final String                   parserPackageName       = "org.rascalmpl.java.parser.object";
    118118
    119119
    … …  
    125125        @Override
    126126        public IGTD getParser(String moduleName) {
    127                 IGTD parser = parsers.get(moduleName);
    128                 if(parser != null)
    129                         return parser;
    130                 //System.out.println("generating parser for " + moduleName);
    131                 /*
    132                 String moduleBaseName;
    133                 if(moduleName.contains("::"))
    134                         moduleBaseName = moduleName.substring(moduleName.lastIndexOf(':') + 1, moduleName.length());
    135                 else
    136                         moduleBaseName = moduleName;
    137                         */
    138                 String parserName = moduleName.replaceAll("::", ".");
    139                 String normName = parserName.replaceAll("\\.", "_");
    140                 final Evaluator evaluator = newEvaluator();
    141                 final IValueFactory vf = evaluator.getValueFactory();
    142                 final JavaBridge bridge = new JavaBridge(evaluator.getClassLoaders(), vf);
    143                 evaluator.doImport(rm, "lang::rascal::grammar::ParserGenerator");
    144                 evaluator.doImport(rm, "lang::rascal::grammar::definition::Modules");
    145                 evaluator.doImport(rm, moduleName);
    146                 URI uri = evaluator.getHeap().getModuleURI(moduleName);
    147                 IMap prodmap = evaluator.getCurrentModuleEnvironment().getSyntaxDefinition();
    148                 IConstructor grammar = (IConstructor) evaluator.call(rm, "modules2grammar", vf.string(moduleName), prodmap);
    149                 IString classString = (IString) evaluator.call(rm, "generateObjectParser", vf.string(parserPackageName), vf.string(normName), grammar);
    150                 Class<IGTD> parserClass = bridge.compileJava(uri, parserPackageName + "." + normName, classString.getValue());
     127                //System.err.println("ConsoleInfra.getParser for " + moduleName);
     128                Class<IGTD> parserClass = parserClasses.get(moduleName);
     129                if(parserClass == null) {
     130                        System.err.println("generating parser for " + moduleName);
     131                        /*
     132                        String moduleBaseName;
     133                        if(moduleName.contains("::"))
     134                                moduleBaseName = moduleName.substring(moduleName.lastIndexOf(':') + 1, moduleName.length());
     135                        else
     136                                moduleBaseName = moduleName;
     137                                */
     138                        String parserName = moduleName.replaceAll("::", ".");
     139                        String normName = parserName.replaceAll("\\.", "_");
     140                        final Evaluator evaluator = newEvaluator();
     141                        final IValueFactory vf = evaluator.getValueFactory();
     142                        final JavaBridge bridge = new JavaBridge(evaluator.getClassLoaders(), vf);
     143                        evaluator.doImport(rm, "lang::rascal::grammar::ParserGenerator");
     144                        evaluator.doImport(rm, "lang::rascal::grammar::definition::Modules");
     145                        evaluator.doImport(rm, moduleName);
     146                        URI uri = evaluator.getHeap().getModuleURI(moduleName);
     147                        IMap prodmap = evaluator.getCurrentModuleEnvironment().getSyntaxDefinition();
     148                        IConstructor grammar = (IConstructor) evaluator.call(rm, "modules2grammar", vf.string(moduleName), prodmap);
     149                        IString classString = (IString) evaluator.call(rm, "generateObjectParser", vf.string(parserPackageName), vf.string(normName), grammar);
     150                        parserClass = bridge.compileJava(uri, parserPackageName + "." + normName, classString.getValue());
     151                        parserClasses.put(moduleName, parserClass);
     152                }
     153                // We cannot store IGTD objects in our cache, as SGTDBF.parse may only be invoked _once_ per instance.
     154                // Hence we are storing classes, and creating a new instance every time.
     155                // If we stored IGTD objects we could only parse _one_ Magnolia module per runtime.
    151156                try {
    152                         parser = parserClass.newInstance();
     157                        return parserClass.newInstance();
    153158                }
    154159                catch(Exception e) {
    155160                        throw new ImplementationError("failed to create parser for " + moduleName, e);
    156161                }
    157                 parsers.put(moduleName, parser);
    158                 return parser;
    159162        }
    160163

  • trunk/magnolia-eclipse/src/org/magnolialang/pgf/TableBuilder.rsc

    r755 r808  
    1111        = Nothing()
    1212        | Sequence(list[Decision] todo)
     13        | Skip()
    1314        ;
    1415       
    … …  
    4243                return addDecisionNoLookBehind(current, decision, tbl);
    4344        else
    44                 return tbl[table = tbl.table + (<current, lastSeen> : decision)];
     45        return addDecisionLookAtBoth(current, lastSeen, decision, tbl);
     46}
     47
     48public TableBuilder addDecisionLookAtBoth(TokenCat current, TokenCat lastSeen, Decision decision, TableBuilder tbl) {
     49  tbl = tbl[cats = tbl.cats + {current, lastSeen}];
     50  return tbl[table = tbl.table + (<current, lastSeen> : decision)];
    4551}
    4652
    … …  
    6268        DecisionTable newTbl = ();
    6369       
    64        
     70    // look behind only entries
    6571        for(k <- tbl.lookTable) {
    6672                for(c <- tbl.cats) {
    … …  
    6975        }
    7076
     77    // look at current only entries
    7178        for(k <- tbl.noLookTable) {
     79        // "" is the initial value for lastSeen
    7280                newTbl[<k,"">] = tbl.noLookTable[k];
    7381                for(c <- tbl.cats) {
    … …  
    7987        }
    8088
     89    // specific entries
     90    newTbl += tbl.table;
     91
     92    // fill in the rest with defaults
    8193        for(c1 <- tbl.cats) {
    8294                if(<c1,""> notin newTbl)
    … …  
    88100        }
    89101       
    90         return newTbl + tbl.table;
     102        return newTbl;
    91103}
    92104
     105// Note that a Skip() stays as such even if combined with
     106// something else.
    93107Decision combine(Decision old, Decision new) {
    94108        switch(<old,new>) {
    … …  
    97111                case <_, Nothing()>:
    98112                        return old;
     113                case <Skip(),_>:
     114            return old;
     115                case <_, Skip()>:
     116            return new;
    99117                case <Sequence(ds1), Sequence(ds2)>:
    100118                        return Sequence(ds1 + ds2);
    … …  
    108126}
    109127
    110 
    111128public DecisionTable makeTable(map[tuple[TokenCat current, TokenCat lastSeen], Decision] decisions) {
    112129        return makeTable(decisions, {});
    113130}
     131
    114132public DecisionTable makeTable(map[tuple[TokenCat current, TokenCat lastSeen], Decision] decisions, set[TokenCat] cats) {
    115133        tbl = newTable();

  • trunk/magnolia-eclipse/src/org/magnolialang/pgf/Token.rsc

    r792 r808  
    2727  | Space(str s)
    2828  | Width(num w)
     29  | NilToken()
    2930  | Eof();
    3031
    … …  
    177178}   
    178179
     180public list[Token] toList(Tseq ts) {
     181  list[Token] lst = [];
     182  while (true) {
     183    <t, ts> = tseqGet(ts);
     184    if (t == Eof())
     185      return lst;
     186    lst += [t];
     187  }
     188}
     189
    179190// deprecated (use emptyTseq)
    180191public Tseq newTokenStream() {

  • trunk/magnolia-eclipse/src/org/magnolialang/pgf/engines/Spacer.rsc

    r792 r808  
    2929        | EnterContext(rel[TokenCat, TokenCat, Decision] newTable)
    3030        | ExitContext()
    31         | Sequence(list[Decision] todo)
     31    | Sequence(list[Decision] todo)
    3232        | ModeChoice(map[SpacerMode,Decision] choiceMap, Decision choiceDefault)
    3333        | Nothing()
    … …  
    6060
    6161public tuple[Tseq outToks, SpacerContext ctx] processToken(Token tok, Tseq outToks, SpacerContext ctx) {
     62  if (NilToken() := tok)
     63    return <outToks, ctx>;
    6264  if(getCategory(tok) == ".")
    6365        return <put(tok, outToks), ctx>;
    6466       
    6567  decision = ctx.table[<getCategory(tok), ctx.lastSeen>] ? Nothing();
    66 //      println("<getCategory(tok)>, <ctx.lastSeen> =\> <decision>");
    67   decisions = [decision];
     68  //println("<getCategory(tok)>, <ctx.lastSeen> =\> <decision>");
     69  list[Decision] decisions;
    6870  if(Sequence(ds) := decision)
    6971    decisions = ds;
     72  else
     73    decisions = [decision];
    7074 
    7175  for(d <- decisions) {
    … …  
    139143                        case Text(t):
    140144                                print("[<t>]");
    141                         case Space(s): {
     145                        case Space(_): {
    142146                print("_");
    143147                        }

  • trunk/magnolia-eclipse/src/org/magnolialang/pgf/tests/RunTestSpacer.rsc

    r792 r808  
    66import org::magnolialang::pgf::engines::FmtEngine;
    77import org::magnolialang::pgf::engines::Spacer;
     8import org::magnolialang::pgf::TableBuilder;
    89import org::magnolialang::pgf::Token;
    910
    … …  
    1314// not even if made 'public'
    1415alias DecisionTable = map[tuple[TokenCat current, TokenCat lastSeen], Decision];
     16
     17set[TokenCat] myCategories = {"TOKEN", "SPC", "BINOP"};
     18
     19public DecisionTable binOpTable = makeTable((
     20    //<"BINOP","*"> : Insert(Text("xxx")),
     21    <"BINOP","*"> : Sequence([Insert(Text("x")), Insert(Text("y")), Insert(Text("z"))]),
     22    <"*","*"> : Nothing()
     23        ), myCategories);
    1524
    1625void printFormatted(Tseq ts) {
    … …  
    3241                                alwaysSpaceTable,
    3342                                spaceTable,
    34                                 reSpaceTable
     43                                reSpaceTable,
     44                                binOpTable
    3545                                ];
    3646  i = 0;

  • trunk/magnolia-eclipse/src/org/magnolialang/pgf/tests/TestWithMgModules.rsc

    r807 r808  
    1 // run with rascal-src-with-magnolia
    2 
    31module org::magnolialang::pgf::tests::TestWithMgModules
    42
    5 import org::magnolialang::pgf::PrettyParseTree;
     3import org::magnolialang::pgf::engines::Spacer;
     4
     5import org::magnolialang::pgf::engines::FmtEngine;
     6import org::magnolialang::pgf::TableBuilder;
    67import org::magnolialang::pgf::Token;
    78
     9import org::magnolialang::magnolia::lib::Names;
    810import org::magnolialang::magnolia::MagnoliaFacts;
    9 import org::magnolialang::magnolia::lib::Names;
     11import org::magnolialang::terms::Terms;
     12
    1013import util::tasks::Manager;
    1114
    1215import IO;
    1316import List;
    14 
    15 public void main(list[str] args) {
    16   name = strToName("basic.Basic");
     17import Node;
     18import ParseTree;
     19import String;
     20
     21void printFormatted(Tseq ts) {
     22  prettyPrintFlush(newFmtSt(80, ts));
     23}
     24
     25set[TokenCat] mgCategories = {
     26  "TOKEN", "SPC", "LPAREN", "RPAREN", "LBRACE", "RBRACE",
     27  "LBRACKET", "RBRACKET", "BINOP", "PREOP", "COMMA",
     28  "KEYWORD", "SEMICOLON", "COLON", "DOT", "WORD"
     29};
     30
     31Token mgCat(t:Text(s), str defCat) {
     32        switch(s) {
     33                case "(":       return t[@cat="LPAREN"];
     34                case ")":       return t[@cat="RPAREN"];
     35                case "[":       return t[@cat="LBRACKET"];
     36                case "]":       return t[@cat="RBRACKET"];
     37                case "{":       return t[@cat="LBRACE"];
     38                case "}":       return t[@cat="RBRACE"];
     39                case ",":       return t[@cat="COMMA"];
     40                case ";":       return t[@cat="SEMICOLON"];
     41                case ":":       return t[@cat="COLON"];
     42                case ".":       return t[@cat="DOT"];
     43        }
     44        if(s in ["+", "-", "*", "/", "%", "=",
     45             "\<=", "\>=", "\<", "\>", "==", "!=",
     46             "&&", "||", "^^", "&", "|", "^", "\<\<", "\>\>", "in",
     47             "=\>", "\<=\>", "\<-\>"])
     48                return t[@cat="BINOP"];
     49        if(s in ["!", "~"])
     50                return t[@cat="PREOP"];
     51    if (/^\/\// := s) {
     52      return Text(trim(s))[@cat="LINECOMMENT"];
     53    }
     54        return t[@cat=defCat];
     55}
     56
     57str treeToStr(Tree t) {
     58  return yieldTerm(t, false);
     59}
     60
     61Tseq treeToTseq(Tseq outStream, Tree t) {
     62        void addLex(Tree a) {
     63      str s = unparse(a);
     64      if (/\/\*/ := s) {
     65        for (s <- split("\n", s)) {
     66          s = trim(s);
     67          if(s != "")
     68            outStream = put(Text(s)[@cat="BLOCKCOMMENT"], outStream);
     69        }
     70      } else if (/^\s*$/ !:= s) {
     71        outStream = put(mgCat(Text(s), "WORD"), outStream);
     72      }
     73    }
     74        void addLit(Tree l) {
     75      outStream = put(mgCat(Text(unparse(l)), "KEYWORD"), outStream);
     76    }
     77        void addLayouts(Tree l) {
     78      str s = unparse(l);
     79      if(s != "")
     80        outStream = put(Space(s), outStream);
     81        }
     82
     83    /* We appear to sometimes be getting duplicates of tokens (such as ";" or "_+_"). Are there dupes in parse tree as well? Due to ambiguity? xxx
     84
     85TOKENLEX1(_+_ : appl(prod(lex("OperatorIdentifier"), [lit("_"), sort("TOPBINOP"), lit("_")], {}), [appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)]), appl(prod(sort("TOPBINOP"), [keywords("TOPADDOP")], {}), [appl(prod(keywords("TOPADDOP"), [lit("+")], {}), [appl(prod(lit("+"), [char-class([range(43, 43)])], {}), [char(43)])])]), appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)])]))
     86TOKENLEX1(_+_ : appl(prod(lex("OperatorIdentifier"), [lit("_"), lex("BINOP"), lit("_")], {}), [appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)]), appl(prod(lex("BINOP"), [lex("ADDOP")], {}), [appl(prod(lex("ADDOP"), [char-class([range(43, 43), range(45, 45)])], {}), [char(43)])]), appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)])]))
     87
     88Indeed it is an ambiguity issue.
     89
     90amb({appl(prod(lex("OperatorIdentifier"), [lit("_"), sort("TOPBINOP"), lit("_")], {}), [appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)]), appl(prod(sort("TOPBINOP"), [keywords("TOPADDOP")], {}), [appl(prod(keywords("TOPADDOP"), [lit("+")], {}), [appl(prod(lit("+"), [char-class([range(43, 43)])], {}), [char(43)])])]), appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)])]), appl(prod(lex("OperatorIdentifier"), [lit("_"), lex("BINOP"), lit("_")], {}), [appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)]), appl(prod(lex("BINOP"), [lex("ADDOP")], {}), [appl(prod(lex("ADDOP"), [char-class([range(43, 43), range(45, 45)])], {}), [char(43)])]), appl(prod(lit("_"), [char-class([range(95, 95)])], {}), [char(95)])])})
     91
     92     */
     93    if (false) {
     94        top-down-break visit(t) {
     95                case a:appl(prod(lex(_),_,_), _):
     96          println("TOKENLEX1(<a> : <treeToStr(a)>)");
     97                case a:appl(prod(label(_, lex(_)),_,_), _):
     98          println("TOKENLEX2(<a> : <treeToStr(a)>)");
     99                case a:appl(prod(layouts(_),_,_), _):
     100          println("TOKENLAY3(<a> : <treeToStr(a)>)");
     101                case a:appl(prod(label(_, layouts(_)),_,_), _):
     102          println("TOKENLAY4(<a> : <treeToStr(a)>)");
     103                case a:appl(prod(lit(_),_,_), _):
     104          println("TOKENLIT5(<a> : <treeToStr(a)>)");
     105                case a:appl(prod(label(_,lit(_)),_,_), _):
     106          println("TOKENLIT6(<a> : <treeToStr(a)>)");
     107                case a:appl(prod(cilit(_),_,_), _):
     108          println("TOKENLIT7(<a> : <treeToStr(a)>)");
     109                case a:appl(prod(label(_,cilit(_)),_,_), _):
     110          println("TOKENLIT8(<a> : <treeToStr(a)>)");
     111        }
     112    }
     113               
     114        top-down-break visit(t) {
     115                case a:appl(prod(lex(_),_,_), _):
     116                        addLex(a);
     117                case a:appl(prod(label(_, lex(_)),_,_), _):
     118                        addLex(a);
     119            /*
     120                case l:appl(prod(layouts(_),_,_), _):
     121                        addLayouts(l);
     122                case l:appl(prod(label(_, layouts(_)),_,_), _):
     123                        addLayouts(l);
     124            */
     125                case l:appl(prod(lit(_),_,_), _):
     126                        addLit(l);
     127                case l:appl(prod(label(_,lit(_)),_,_), _):
     128                        addLit(l);
     129                case l:appl(prod(cilit(_),_,_), _):
     130                        addLit(l);
     131                case l:appl(prod(label(_,cilit(_)),_,_), _):
     132                        addLit(l);
     133        }
     134
     135        return outStream;
     136}
     137
     138// In the second arg we need only list categories not appearing
     139// in the rules, or otherwise we get Nothing() as the Decision
     140// for anything involving that category.
     141DecisionTable mgSpaceTable = makeTable((
     142  <"SPC", "*"> : Skip(),
     143  <"*", "COMMA"> : Insert(Space(" ")),
     144  <"WORD", "WORD"> : Insert(Space(" ")),
     145  <"WORD", "KEYWORD"> : Insert(Space(" ")),
     146  <"KEYWORD", "WORD"> : Insert(Space(" ")),
     147  <"KEYWORD", "KEYWORD"> : Insert(Space(" ")),
     148  <"KEYWORD", "RBRACKET"> : Insert(Space(" ")),
     149  <"PREOP", "KEYWORD"> : Insert(Space(" ")),
     150  <"LPAREN", "KEYWORD"> : Insert(Space(" ")),
     151  <"*", "BINOP"> : Insert(Space(" ")),
     152  <"BINOP", "*"> : Insert(Space(" ")),
     153  <"*", "COLON"> : Insert(Space(" ")),
     154  <"COLON", "*"> : Insert(Space(" ")),
     155  <"LBRACE", "KEYWORD"> : Insert(Space(" ")),
     156  <"LBRACE", "RPAREN"> : Insert(Space(" ")),
     157  <"KEYWORD", "RPAREN"> : Insert(Space(" ")),
     158  <"*", "LBRACE"> : Sequence([Insert(Nest(LvInc(2))), Insert(Line())]),
     159  <"RBRACE", "*"> : Sequence([Insert(Nest(LvPop())), Insert(Line())]),
     160  <"*", "RBRACE"> : Insert(Line()),
     161  <"*", "SEMICOLON"> : Insert(Line()),
     162  <"*", "LINECOMMENT"> : Insert(Line()),
     163  <"*", "BLOCKCOMMENT"> : Insert(Line()),
     164  <"*", "*"> : Nothing()), {"LBRACKET"});
     165
     166/*
     167  E.g.
     168
     169  (init-compiler)
     170  (rimport "org::magnolialang::pgf::tests::TestWithMgModules")
     171  (rcall "testMgSpacer" (rstring "basic.Basic"))
     172
     173  (rreload "org::magnolialang::pgf::tests::TestWithMgModules")
     174  (rcall "testMgSpacer" (rstring "basic.Basic"))
     175
     176  Note to reload a dependency you may also have to reload this
     177  module to get the reloaded dependency re-imported here.
     178*/
     179public void testMgSpacer(str modName) {
     180  /*
     181    parsing
     182  */
     183  name = strToName(modName);
    17184  tr = startTransaction();
    18   println(getFact(tr, #DefInfo, name));
     185  //println(getFact(tr, #DefInfo, name));
     186  // for printing the ParseTree 'val', 'unparse' is used?
     187  println(getFact(tr, #ParseTree, name).val);
     188  //println(getFact(tr, #ParseTree, name)); // huge
     189  //println(getFact(tr, #ImplodedTree, name)); // smaller
    19190  pt = getFact(tr, #ParseTree, name).val;
    20   println(pt);
    21   ts = prettyParseTree(emptyTseq(), pt);
     191  //println(yieldTerm(implode(pt), false));
     192  //println(pt);
     193  ts = treeToTseq(emptyTseq(), pt);
    22194  println(ts);
     195  printlnTokenStream(ts);
    23196  endTransaction(tr);
    24 }
     197
     198  /*
     199    spacing
     200  */
     201  println("SPACED:");
     202  ctx = SpacerContext(mgSpaceTable);
     203  out = emptyTseq();
     204  info = <ts, out, ctx>;
     205  info = processTokens(info);
     206  out = info[1];
     207  printlnTokenStream(out);
     208
     209  /*
     210    pretty printing
     211  */
     212  printFormatted(out);
     213}

  • trunk/magnolia-eclipse/src/org/magnolialang/testutil/RascalEval.java

    r807 r808  
    7575
    7676
     77        /*
    7778        public IValue call(String name, IValue[] args) {
    7879                // Note about Java varargs: IValue... is sugar for IValue[], so this is okay.
    7980                return evaluator.call(name, args);
    80         }
    81 
     81        }*/
    8282
    8383        public IValue call(String name, Collection<IValue> args) {

  • trunk/magnolia-eclipse/src/org/magnolialang/testutil/TestUtil.rsc

    r807 r808  
    1 // run with rascal-src-with-magnolia
    2 
    3 module org::magnolialang::pgf::tests::TestWithMgModules
     1module org::magnolialang::testutil::TestUtil
    42
    53import org::magnolialang::pgf::PrettyParseTree;
    … …  
    1311import List;
    1412
    15 public void main(list[str] args) {
    16   name = strToName("basic.Basic");
     13/** Dumps test data (token streams of Magnolia) as Rascal data
     14    structures. */
     15public Tseq mgModuleToTokens(str modName) {
     16  name = strToName(modName);
    1717  tr = startTransaction();
    18   println(getFact(tr, #DefInfo, name));
     18  //println(getFact(tr, #DefInfo, name));
    1919  pt = getFact(tr, #ParseTree, name).val;
    20   println(pt);
     20  //println(pt);
    2121  ts = prettyParseTree(emptyTseq(), pt);
    22   println(ts);
     22  //println(ts);
    2323  endTransaction(tr);
     24  return ts;
    2425}

  • trunk/magnolia-eclipse/src/org/magnolialang/testutil/core.clj

    r807 r808  
    1 ;; E.g. (use 'org.magnolialang.clojure.core :reload-all)
    2 (ns org.magnolialang.clojure.core
     1;; E.g. (use 'org.magnolialang.testutil.core :reload-all)
     2(ns org.magnolialang.testutil.core
    33  (:import
    44   (org.magnolialang.testutil RascalEval TestUtil)
    … …  
    7777  (def rsc-evaluator (get-ric)))
    7878       
     79(defn rtostring [r]
     80  (RascalEval/resultToString r))
     81
     82;; Evaluate Rascal expression in an Evaluator.
     83;; E.g. (reval "registerCompiler")
     84(defn reval [s]
     85  (.eval rsc-evaluator s))
     86
     87(defn reval-str [s]
     88  (rtostring (reval s)))
     89
     90;; E.g. (reval-more "import util::tasks::Manager; getFact; 5;")
     91(defn reval-more [s]
     92  (.evalMore rsc-evaluator s))
     93
     94;; E.g. (rimport "util::tasks::Manager")
     95(defn rimport [s]
     96  (.doImport rsc-evaluator s))
     97
     98(defn rapply [s as]
     99  (.call rsc-evaluator s as))
     100
     101(defn rcall [s & as]
     102  (rapply s as))
     103
     104;; For reloading Rascal modules individually.
     105;; E.g. (rreload "org::magnolialang::pgf::Token")
     106(defn rreload [& s]
     107  (let [evaluator (.getEvaluator rsc-evaluator)
     108        errorLoc (java.net.URI/create "clojure:///")
     109        mods (java.util.HashSet. s)]
     110    (.reloadModules evaluator rascal-monitor mods errorLoc)))
     111
    79112;; You can do things like "pure" Rascal use without this, but
    80113;; this (time-consuming) initialization is required (once) to use
    … …  
    90123  (let [parser (.getParser mg-lang)]
    91124    (.initialize parser))
    92   (def rsc-evaluator (get-ric)))
     125  (def rsc-evaluator (get-ric))
     126  (rimport "org::magnolialang::testutil::TestUtil"))
    93127
    94128(defn get-parser [s]
    … …  
    120154  (.getNameAST mg-lang s))
    121155
     156;; E.g. (spit "/tmp/foo" (with-out-str (println (get-parse-tree "toplevel.Predicates"))))
    122157(defn get-parse-tree [s]
    123158  (let [state tu-state
    … …  
    139174    (.getOptionStringFact state (rstring s))))
    140175
    141 (defn rtostring [r]
    142   (RascalEval/resultToString r))
    143 
    144 ;; Evaluate Rascal expression in an Evaluator.
    145 ;; E.g. (reval "registerCompiler")
    146 (defn reval [s]
    147   (.eval rsc-evaluator s))
    148 
    149 (defn reval-str [s]
    150   (rtostring (reval s)))
    151 
    152 ;; E.g. (reval-more "import util::tasks::Manager; getFact; 5;")
    153 (defn reval-more [s]
    154   (.evalMore rsc-evaluator s))
    155 
    156 ;; E.g. (rimport "util::tasks::Manager")
    157 (defn rimport [s]
    158   (.doImport rsc-evaluator s))
    159 
    160 (defn rcall
    161   ;; Clojure does not (yet) appear to support optional positional
    162   ;; arguments with default values, so we do it like this
    163   ([s as] (.call rsc-evaluator s as))
    164   ([s] (rcall s [])))
    165 
    166 (defn rapply [s & as]
    167   (rcall s as))
    168 
    169 ;; For reloading Rascal modules individually.
    170 ;; E.g. (rreload "org::magnolialang::pgf::Token")
    171 (defn rreload [& s]
    172   (let [evaluator (.getEvaluator rsc-evaluator)
    173         errorLoc (java.net.URI/create "clojure:///")
    174         mods (java.util.HashSet. s)]
    175     (.reloadModules evaluator rascal-monitor mods errorLoc)))
     176(defn mg-module-to-tokens [s]
     177  (rcall "mgModuleToTokens" (rstring s)))
    176178
    177179(defn get-fact [type name]
    … …  
    197199  (get-fact MagnoliaFacts/Type_Simplified ast))
    198200
     201;; E.g. (spit "/tmp/foo" (yield-term (ctor-get-val (get-parse-tree "basic.Basic"))))
    199202(defn yield-term
    200203  ([v a?] (org.magnolialang.terms.TermAdapter/yieldTerm v a?))
    … …  
    218221(defn view-flattened-module [s]
    219222  (println (.getValue
    220             (rapply "prettyMagnolia"
    221                     (ctor-get-val (get-type-checked s))))))
    222 
     223            (rcall "prettyMagnolia"
     224                   (ctor-get-val (get-type-checked s))))))
     225
     226(defn run-pretty-magnolia [s]
     227  (rcall "runPrettyMagnolia" (rstring s)))

  • trunk/magnolia-eclipse/src/org/magnolialang/testutil/rascal_shell.clj

    r807 r808  
    1 ;; E.g. (use 'org.magnolialang.clojure.rascal-shell :reload-all)
    2 (ns org.magnolialang.clojure.rascal-shell
    3   (:use org.magnolialang.clojure.core)
     1;; E.g. (use 'org.magnolialang.testutil.rascal-shell :reload-all)
     2(ns org.magnolialang.testutil.rascal-shell
     3  (:use org.magnolialang.testutil.core)
    44  (:import
    55   (org.magnolialang.testutil RascalShell))
    66  (:gen-class))
    77
    8 ;; E.g. lein run -m org.magnolialang.clojure.rascal-shell --z x y
     8;; E.g. lein run -m org.magnolialang.testutil.rascal-shell --z x y
    99;; or rather
    10 ;;   lein run -m org.magnolialang.clojure.rascal-shell org::magnolialang::pgf::tests::TestFmtEngine
     10;;   lein run -m org.magnolialang.testutil.rascal-shell org::magnolialang::pgf::tests::TestFmtEngine
    1111(defn -main [& args]
    1212  (init-compiler)
    … …  
    2020      ;; E.g.
    2121      ;; lein compile
    22       ;; java -cp ./clj-bin:`lein classpath` org.magnolialang.clojure.rascal_shell
     22      ;; java -cp ./clj-bin:`lein classpath` org.magnolialang.testutil.rascal_shell
    2323      (RascalShell/runRepl compiler)
    2424      (let [[mod args] [(first args) (or (rest args) ())]
Note: See TracChangeset for help on using the changeset viewer.