我是Rascal的新手并正在尝试其转换/术语重写能力。
我想编写一个分割声明的脚本，如：
int x = 5;
进入声明/初始化，如：
int x; x = 5;
我怎么能这样做？假设我正在尝试转换的语言是Java。
感谢您的帮助。
答案 0 :(得分：2)
好问题。有几种方法可以做到这一点，我将展示最简单的方法。请注意，您的示例不是最简单的示例，因为它需要从单个语句转换为语句列表（即，它不是类型保留）。
以下是一个完整的例子，解释如下。
collectionData主要部分是简单语言的完整语法。实际转换由module Decl
import IO;
import ParseTree;
// Decl, a trivial language, to demo simple program trafo
lexical Id = [a-z][a-z0-9]* !>> [a-z0-9] \ Reserved;
lexical Natural = [0-9]+ ;
lexical String = "\"" ![\"]* "\"";
layout Layout = WhitespaceAndComment* !>> [\ \t\n];
lexical WhitespaceAndComment
= [\ \t\n\r]
;
keyword Reserved = "int" | "str" | "if" | "then" | "else" | "fi" | "while" | "do" | "od";
start syntax Program
= {Statement ";"}* body
;
syntax Type
= "int"
| "str"
;
syntax Statement
= Type tp Id var
| Type tp Id var ":=" Expression exp
| Id var ":=" Expression val
| "if" Expression cond "then" {Statement ";"}* thenPart "else" {Statement ";"}* elsePart "fi"
| "while" Expression cond "do" {Statement ";"}* body "od"
;
syntax Expression
= Id name
| String string
| Natural natcon
| bracket "(" Expression e ")"
> left ( Expression lhs "+" Expression rhs
| Expression lhs "-" Expression rhs
)
;
str trafo1 () {
p = parse(#start[Program], "int x := 1").top;
newBody = "";
for(stat <- p.body){
if((Statement) `<Type tp> <Id var> := <Expression exp>` := stat){
newBody += "<tp> <var>; <var> := <exp>";
} else {
newBody += "<stat>";
}
}
return newBody;
}
完成，其中包括：
trafo1（用于构建结果）。解决方案风格很大取决于您的目标。这里我们只是构建一个字符串。如果需要，您可以返回解析后的字符串作为结果。
备选方案：
希望这有助于您开始使用。
答案 1 :(得分：1)
我在这里有一些代码示例，它们使用具体的语法匹配和替换来得到你想要的东西：
module JavaMatch
import lang::java::\syntax::Java15;
// this just replaces exactly these specific kinds of declarations, as the only statement in a block:
CompilationUnit splitInitializersSimple(CompilationUnit u) = visit(u) {
case (Block) `{ int i = 0; }` => (Block) `{int i; i = 0;}`
};
// the next generalizes over any type, variable name or expression, but still one statement in a block:
CompilationUnit splitInitializersSingle(CompilationUnit u) = visit(u) {
case (Block) `{ <Type t> <Id i> = <Expr e>; }`
=> (Block) `{<Type t> <Id i>; <Id i> = <Expr e>;}`
};
// Now we allow more statements around the declaration, and we simply leave them where they are
CompilationUnit splitInitializersInContext(CompilationUnit u) = visit(u) {
case (Block) `{ <BlockStm* pre>
' <Type t> <Id i> = <Expr e>;
' <BlockStm* post>
'}`
=> (Block) `{ <BlockStm* pre>
' <Type t> <Id i>;
' <Id i> = <Expr e>;
' <BlockStm* post>
'}`
};
// But there could be more initializers in the same decl as well, as in int i, j = 0, k; :
CompilationUnit splitInitializersInContext2(CompilationUnit u) = visit(u) {
case (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>= <Expr e>, <{VarDec ","}+ b>;
' <BlockStm* post>
'}`
=> (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>, <{VarDec ","}+ b>;
' <Id i> = <Expr e>;
' <BlockStm* post>
'}`
};
// and now we add `innermost` such that not only the first but all occurrences are replaced:
CompilationUnit splitInitializersInContext2(CompilationUnit u) = innermost visit(u) {
case (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>= <Expr e>, <{VarDec ","}+ b>;
' <BlockStm* post>
'}`
=> (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>, <{VarDec ","}+ b>;
' <Id i> = <Expr e>;
' <BlockStm* post>
'}`
};
void doIt(loc file) {
start[CompilationUnit] unit = parse(#start[CompilationUnit], file);
unit.top = splitInitializersInContext(unit.top);
writeFile(file, "<unit>");
}
最后的评论，因为这仍然不完全一般：