Changeset 809


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

adopt new token annotation and spacing table for Pretty library

fix: no pp'ing of function param modifiers

Location:
trunk/magnolia-eclipse/src/org/magnolialang
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/magnolia-eclipse/src/org/magnolialang/magnolia/lib/Pretty.rsc

    r796 r809  
    11module org::magnolialang::magnolia::lib::Pretty
     2
     3import org::magnolialang::magnolia::AbstractSyntax;
     4import org::magnolialang::magnolia::lib::MagnoliaCompileLib;
     5import org::magnolialang::magnolia::lib::Names;
     6import org::magnolialang::pgf::AstToStream;
     7import org::magnolialang::pgf::TableBuilder;
    28import org::magnolialang::pgf::Token;
    39import org::magnolialang::pgf::engines::FmtEngine;
    410import org::magnolialang::pgf::engines::Spacer;
    5 import org::magnolialang::pgf::AstToStream;
    6 import org::magnolialang::magnolia::AbstractSyntax;
    711import org::magnolialang::terms::Terms;
    8 import org::magnolialang::magnolia::AbstractSyntax;
    9 import org::magnolialang::magnolia::lib::Names;
    10 import org::magnolialang::magnolia::lib::MagnoliaCompileLib;
    11 import org::magnolialang::pgf::TableBuilder;
     12
    1213import IO;
    1314import String;
     15import Type; // for typeOf
    1416
    1517public str prettyMagnolia(AST tree) {
    1618        ctx = SpacerContext(mgSpaceTable);
    1719        stream = pp(tree, newTokenStream());
    18         //println(stream);
    1920        <_, stream, _> = processTokens(<stream, newTokenStream(), ctx>);
    20         //println(stream);
    21         //printlnTokenStream(stream);
    22         /*
    23         result = "";
    24         while(true) {
    25                 <tok, stream> = tseqGet(stream);
    26                 switch(tok) {
    27                         case Text(t):
    28                                 result += t;
    29                         case Space(s): {
    30                                 result += s;
    31                         }
    32             case Eof():
    33                 return result;
    34                         default:
    35                                 throw "Unknown token <tok>";
    36                 }
    37         }
    38         */
    39         return pretty(120, stream);
     21        return pretty(80, stream);
    4022}
    4123 
    … …  
    4527
    4628Token SemiColon = Text(";")[@cat="SEMICOLON"];
     29Token Colon = Text(":")[@cat="COLON"];
    4730Token Comma = Text(",")[@cat="COMMA"];
    4831Token LParen = Text("(")[@cat="LPAREN"];
    … …  
    5336Token RBracket = Text("]")[@cat="RBRACKET"];
    5437Token Keyword(str s) { return Text(s)[@cat="KEYWORD"]; }
     38Token PreOp(str s) { return Text(s)[@cat="PREOP"]; }
     39Token BinOp(str s) { return Text(s)[@cat="BINOP"]; }
     40
     41// These semantic tokens may be useful later.
     42Token Begin(str cat) { return NilToken(); }
     43Token End(str cat) { return NilToken(); }
     44
     45// For use in spacing table.
    5546Token BeginIndent = Nest(LvInc(4));
    5647Token EndIndent = Nest(LvPop());
    57 Token Begin(str cat) { return Nest(LvInc(0)); }
    58 Token End(str cat) { return Nest(LvPop()); }
    59 
    60 set[TokenCat] mgCategories = {"TOKEN", "SPC", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "BINOP", "PREOP", "COMMA", "KEYWORD", "SEMICOLON"};
    6148
    6249DecisionTable mgSpaceTable = makeTable((
    63                 <"SPC", "*"> : Skip(),
    64                 <"*", ""> : Nothing(),
    65                 <"*", "LPAREN"> : Nothing(),
    66                 <"*", "LBRACKET"> : Nothing(),
    67                 <"LPAREN", "*"> : Insert(Nest(LvRel(0))),
    68                 <"RPAREN", "*"> : Insert(Nest(LvPop())),
    69                 <"RBRACKET", "*"> : Nothing(),
    70                 <"*", "LBRACE"> : Sequence([Insert(BeginIndent), Insert(Line())]),
    71 //              <"LBRACE", "*"> : Insert(Line()),
    72                 <"*", "RBRACE"> : Insert(Line()),
    73                 <"RBRACE", "*"> : Sequence([Insert(EndIndent)]),
    74                 <"COMMA", "*"> : Nothing(),
    75                 <"*", "COMMA"> : Insert(Space(" ")),
    76                 <"*", "PREOP"> : Nothing(),
    77                 <"*", "SEMICOLON"> : Insert(Line()),
    78                 <"SEMICOLON", "*"> : Nothing(),
    79                 <"*", "DOT"> : Nothing(),
    80                 <"DOT", "*"> : Nothing(),
    81                 <"*", "*"> : Insert(Space(" "))
    82         ), mgCategories);
     50  <"SPC", "*"> : Skip(),
     51  <"*", "COMMA"> : Insert(Space(" ")),
     52  <"TOKEN", "TOKEN"> : Insert(Space(" ")),
     53  <"TOKEN", "KEYWORD"> : Insert(Space(" ")),
     54  <"KEYWORD", "TOKEN"> : Insert(Space(" ")),
     55  <"KEYWORD", "KEYWORD"> : Insert(Space(" ")),
     56  <"KEYWORD", "RBRACKET"> : Insert(Space(" ")),
     57  <"PREOP", "KEYWORD"> : Insert(Space(" ")),
     58  <"LPAREN", "KEYWORD"> : Insert(Space(" ")),
     59  <"*", "BINOP"> : Insert(Space(" ")),
     60  <"BINOP", "*"> : Insert(Space(" ")),
     61  <"*", "COLON"> : Insert(Space(" ")),
     62  <"COLON", "*"> : Insert(Space(" ")),
     63  <"LBRACE", "KEYWORD"> : Insert(Space(" ")),
     64  <"LBRACE", "RPAREN"> : Insert(Space(" ")),
     65  <"KEYWORD", "RPAREN"> : Insert(Space(" ")),
     66  <"*", "LBRACE"> : Sequence([Insert(BeginIndent), Insert(Line())]),
     67  <"RBRACE", "*"> : Sequence([Insert(EndIndent), Insert(Line())]),
     68  <"*", "RBRACE"> : Insert(Line()),
     69  <"*", "SEMICOLON"> : Insert(Line()),
     70  <"*", "LINECOMMENT"> : Insert(Line()),
     71  <"*", "BLOCKCOMMENT"> : Insert(Line()),
     72  <"*", "*"> : Nothing()), {"LBRACKET"});
    8373
    8474Tseq pp(leaf(s), Tseq stream) {
    … …  
    10999
    110100Tseq pp(Assign(arg0, arg1), Tseq stream) {
    111   return ast2stream(stream, pp, arg0, Text("="), arg1, SemiColon);
     101  return ast2stream(stream, pp, arg0, BinOp("="), arg1, SemiColon);
    112102}
    113103
    … …  
    132122}
    133123
    134 Tseq pp(BinOpSugar(arg0, arg1, arg2), Tseq stream) {
    135   return ast2stream(stream, pp, arg0, arg1, arg2);
     124Tseq pp(t : BinOpSugar(arg0, leaf(arg1), arg2), Tseq stream) {
     125  //println(typeOf(arg1)); // arg1 is of AST
     126  return ast2stream(stream, pp, arg0, BinOp(arg1), arg2);
    136127}
    137128
    … …  
    146137Tseq pp(Body(arg0), Tseq stream) {
    147138  if(Block(_) := arg0 || BlockExpr(_) := arg0)
    148         return ast2stream(stream, pp, Text("="), arg0);
     139        return ast2stream(stream, pp, BinOp("="), arg0);
    149140  else
    150         return ast2stream(stream, pp, Text("="), arg0, SemiColon);
     141        return ast2stream(stream, pp, BinOp("="), arg0, SemiColon);
    151142}
    152143
    … …  
    172163
    173164Tseq pp(ConceptDef(arg0, arg1, arg2, arg3), Tseq stream) {
    174   return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("concept"), arg1, arg2, Text("="), arg3, End("DEF"));
     165  return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("concept"), arg1, arg2, BinOp("="), arg3, End("DEF"));
    175166}
    176167
    … …  
    244235                        stream = ppFunParams(ps, stream);
    245236                        if(kind == "function") {
    246                                 stream = put(Text(":"), stream);
     237                                stream = put(Colon, stream);
    247238                                stream = pp(basename(t), stream);
    248239                        }
    … …  
    259250                        }
    260251                }
     252        case PredClause(n, ps): { //xxx can this have modifiers?
     253            stream = ast2stream(stream, pp, Keyword("predicate"), unqualify(basename(n)));
     254            stream = ppFunParams(ps, stream);
     255        }
     256        case AxiomClause(n, ps): { //xxx can this have modifiers? xxx print as axiom, theorem, or proof?
     257            stream = ast2stream(stream, pp, Keyword("axiom"), unqualify(basename(n)));
     258            stream = ppFunParams(ps, stream);
     259        }
     260        case TestClause(n, ps): { //xxx can this have modifiers?
     261            stream = ast2stream(stream, pp, Keyword("test"), unqualify(basename(n)));
     262            stream = ppFunParams(ps, stream);
     263        }
    261264                case TypeClause(n): {
    262265                        stream = ast2stream(stream, pp, Keyword("type"), unqualify(basename(n)));
    263266                }
    264267                case VarClause(n, t): {
    265                         stream = ast2stream(stream, pp, Keyword("var"), unqualify(basename(n)), Text(":"), t);
     268                        stream = ast2stream(stream, pp, Keyword("var"), unqualify(basename(n)), Colon, t);
    266269                }
    267270                default: {
    … …  
    342345  stream = ast2stream(stream, pp, Text("\\external"), LParen, arg0, Comma, basename(arg1), Comma, basename(arg2));
    343346  stream = ppFunParams(arg3, stream);
    344   stream = ast2stream(stream, pp, Text(":"), basename(arg4), RParen);
     347  stream = ast2stream(stream, pp, Colon, basename(arg4), RParen);
    345348  return stream;
    346349}
    … …  
    362365
    363366Tseq pp(Field(arg0, arg1), Tseq stream) {
    364   return ast2stream(stream, pp, arg0, Text("="), arg1);
     367  return ast2stream(stream, pp, arg0, BinOp("="), arg1);
    365368}
    366369
    … …  
    385388
    386389Tseq pp(FunName(arg0, arg1, arg2), Tseq stream) {
    387   return ast2stream(stream, pp, Keyword("function"), arg0, arg1, Text(":"), arg2);
     390  return ast2stream(stream, pp, Keyword("function"), arg0, arg1, Colon, arg2);
    388391}
    389392
    … …  
    429432
    430433Tseq pp(ImplDef(arg0, arg1, arg2, arg3), Tseq stream) {
    431   return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("implementation"), arg1, arg2, Text("="), arg3, End("DEF"));
     434  return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("implementation"), arg1, arg2, BinOp("="), arg3, End("DEF"));
    432435}
    433436
    … …  
    440443}
    441444
     445Tseq pp(IndexSugar(arg0, arg1), Tseq stream) {
     446  return ast2stream(stream, pp, arg0, LBracket, SepBy(arg1, Comma), RBracket);
     447}
     448
     449Tseq pp(InSugar(arg0, leaf(arg1), arg2), Tseq stream) {
     450  return ast2stream(stream, pp, arg0, BinOp(arg1), arg2);
     451}
     452
    442453Tseq pp(Lang(arg0), Tseq stream) {
    443454  return ast2stream(stream, pp, arg0);
    … …  
    453464
    454465Tseq pp(LibraryDef(arg0, arg1, arg2, arg3), Tseq stream) {
    455   return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("library"), arg1, arg2, Text("="), arg3, End("DEF"));
     466  return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("library"), arg1, arg2, BinOp("="), arg3, End("DEF"));
    456467}
    457468
    … …  
    509520
    510521Tseq ppProcParam(Param(arg0, arg1, arg2), Tseq stream) {
    511   return ast2stream(stream, pp, arg0, arg1, Text(":"), basename(arg2));
    512 }
    513 
     522  return ast2stream(stream, pp, arg0, arg1, Colon, basename(arg2));
     523}
     524
     525Tseq ppProcParam(ParamSugar(n, tn), Tseq stream) {
     526  return ast2stream(stream, pp, n, Colon, basename(tn));
     527}
     528
     529// a Param has name and type
     530Tseq ppFunParam(Param(arg1, arg2), Tseq stream) {
     531  return ast2stream(stream, pp, arg1, Colon, basename(arg2));
     532}
     533
     534// a Param has name and type, maybe also modifier (discarded)
    514535Tseq ppFunParam(Param(arg0, arg1, arg2), Tseq stream) {
    515   return ast2stream(stream, pp, arg1, Text(":"), basename(arg2));
    516 }
     536  return ast2stream(stream, pp, arg1, Colon, basename(arg2));
     537}
     538
     539Tseq ppFunParam(AST ast, Tseq stream) {
     540  throw "ppFunParam *****<yieldTerm(ast, false)>*****";
     541  }
    517542
    518543Tseq ppFunParams(ParamList(arg0), Tseq stream) {
    … …  
    530555Tseq pp(Predicate(), Tseq stream) {
    531556  return ast2stream(stream, pp, Text("\\predicate"));
     557}
     558
     559Tseq pp(t : PreOpSugar(leaf(arg0), arg1), Tseq stream) {
     560  //println(yieldTerm(t, false));
     561  return ast2stream(stream, pp, PreOp(arg0), arg1);
    532562}
    533563
    … …  
    607637
    608638Tseq pp(SatDef(arg0, arg1, arg2, arg3), Tseq stream) {
    609   return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("satisfaction"), arg1, arg2, Text("="), arg3, End("DEF"));
     639  return ast2stream(stream, pp, arg0, Begin("DEF"), Keyword("satisfaction"), arg1, arg2, BinOp("="), arg3, End("DEF"));
    610640}
    611641
    … …  
    638668}
    639669
     670Tseq pp(TopBinOp(arg0, leaf(arg1), arg2), Tseq stream) {
     671  return ast2stream(stream, pp, arg0, BinOp(arg1), arg2);
     672}
     673
    640674Tseq pp(TopExprTree(arg0), Tseq stream) {
    641675  return ast2stream(stream, pp, arg0);
    … …  
    646680}
    647681
     682Tseq pp(TopParen(arg0), Tseq stream) {
     683  return ast2stream(stream, pp, LParen, arg0, RParen);
     684}
     685
    648686Tseq pp(TopPreOp(arg0, arg1), Tseq stream) {
    649687  return ast2stream(stream, pp, arg0, arg1);
    … …  
    655693
    656694Tseq pp(TypeExpr(arg0), Tseq stream) {
    657   return ast2stream(stream, pp, Text(":"), arg0);
     695  return ast2stream(stream, pp, Colon, arg0);
    658696}
    659697
    … …  
    685723
    686724Tseq pp(VarDecl(arg0, arg1, arg2, arg3), Tseq stream) {
    687   return ast2stream(stream, pp, arg0, arg1, Text(":"), arg2, Text("="), arg3);
     725  return ast2stream(stream, pp, arg0, arg1, Colon, arg2, BinOp("="), arg3);
     726}
     727
     728Tseq pp(VarDeclSugarNoType(arg0, arg1), Tseq stream) {
     729  return ast2stream(stream, pp, Keyword("var"), arg0, BinOp("="), arg1);
     730}
     731
     732Tseq pp(VarDeclSugarNoExpr(arg0, arg1), Tseq stream) {
     733  return ast2stream(stream, pp, Keyword("var"), arg0, Colon, arg1);
    688734}
    689735
    690736Tseq pp(VarName(arg0, arg1), Tseq stream) {
    691   return ast2stream(stream, pp, Keyword("var"), arg0, Text(":"), arg1);
     737  return ast2stream(stream, pp, Keyword("var"), arg0, Colon, arg1);
    692738}
    693739
    … …  
    708754}
    709755
     756/*
     757set[TokenCat] mgCategories = {"TOKEN", "SPC", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACKET", "RBRACKET", "BINOP", "PREOP", "COMMA", "KEYWORD", "SEMICOLON"};
     758
     759DecisionTable mgSpaceTable = makeTable((
     760                <"SPC", "*"> : Skip(),
     761                <"*", ""> : Nothing(),
     762                <"*", "LPAREN"> : Nothing(),
     763                <"*", "LBRACKET"> : Nothing(),
     764                <"LPAREN", "*"> : Insert(Nest(LvRel(0))),
     765                <"RPAREN", "*"> : Insert(Nest(LvPop())),
     766                <"RBRACKET", "*"> : Nothing(),
     767                <"*", "LBRACE"> : Sequence([Insert(BeginIndent), Insert(Line())]),
     768                <"*", "RBRACE"> : Insert(Line()),
     769                <"RBRACE", "*"> : Sequence([Insert(EndIndent)]),
     770                <"COMMA", "*"> : Nothing(),
     771                <"*", "COMMA"> : Insert(Space(" ")),
     772                <"*", "PREOP"> : Nothing(),
     773                <"*", "SEMICOLON"> : Insert(Line()),
     774                <"SEMICOLON", "*"> : Nothing(),
     775                <"*", "DOT"> : Nothing(),
     776                <"DOT", "*"> : Nothing(),
     777                <"*", "*"> : Insert(Space(" "))
     778        ), mgCategories);
     779*/
     780

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

    r808 r809  
    580580}
    581581
    582 // a Param has name and type, maybe also modifier
     582// a Param has name and type, maybe also modifier,
     583// but modifiers are not suitable for function params
    583584Tseq ppFunParam(Param(arg0, arg1, arg2), Tseq stream) {
    584   return ast2stream(stream, pp, arg0, arg1, Colon, basename(arg2));
     585  return ast2stream(stream, pp, arg1, Colon, basename(arg2));
    585586}
    586587
Note: See TracChangeset for help on using the changeset viewer.