diff options
Diffstat (limited to 'Chalice/src/main/scala/ChaliceToCSharp.scala')
| -rw-r--r-- | Chalice/src/main/scala/ChaliceToCSharp.scala | 266 |
1 files changed, 0 insertions, 266 deletions
diff --git a/Chalice/src/main/scala/ChaliceToCSharp.scala b/Chalice/src/main/scala/ChaliceToCSharp.scala deleted file mode 100644 index 0df6fe6e..00000000 --- a/Chalice/src/main/scala/ChaliceToCSharp.scala +++ /dev/null @@ -1,266 +0,0 @@ -//-----------------------------------------------------------------------------
-//
-// Copyright (C) Microsoft Corporation. All Rights Reserved.
-//
-//-----------------------------------------------------------------------------
-package chalice;
-class ChaliceToCSharp {
-
- def convertProgram(decls: List[TopLevelDecl]): String = {
- "using Chalice;" + nl + nl +
- rep(decls map convertTopLevelDecl)
- }
-
- def convertTopLevelDecl(decl: TopLevelDecl): String = {
- decl match {
- case cl: Class => convertClass(cl)
- case ch: Channel => convertChannel(ch)
- }
- }
-
- def convertChannel(ch: Channel): String = {
- "public class " + ch.channelId + " {" + nl +
- indentMore {
- indent + "class " + ch.channelId + "_args " + "{" + nl +
- indentMore {
- repsep(ch.parameters map { variable => indent + "internal " + convertType(variable.t) + " " + variable.id + ";"}, nl)
- } + nl + indent + "}" + nl +
- indent + "ChannelBuffer<" + ch.channelId + "_args" + ">" + " buffer = new ChannelBuffer<" + ch.channelId + "_args" + ">();" + nl +
- indent + "public void Send(" + repsep(ch.parameters map { variable => convertType(variable.t) + " " + variable.id }, ", ") + ") {" + nl +
- indentMore {
- indent + ch.channelId + "_args " + "entry = new " + ch.channelId + "_args" + "();" + nl +
- repsep(ch.parameters map { p => indent + "entry." + p.id + " = " + p.id + ";"}, nl) + nl +
- indent + "buffer.Add(entry);" + nl
- } +
- indent + "}" + nl +
- indent + "public void Receive(" + repsep(ch.parameters map { variable => "out " + convertType(variable.t) + " " + variable.id }, ", ") + ") {" + nl +
- indentMore {
- indent + ch.channelId + "_args " + "entry = buffer.Remove();" + nl +
- repsep(ch.parameters map { p => indent + p.id + " = entry." + p.id + ";"}, nl) + nl
- } +
- indent + "}" + nl
- } +
- "}" + nl + nl
- }
-
- def convertClass(cl: Class): String = if (cl.IsExternal) "" else {
- "public class " + cl.id + " {" + nl +
- indentMore { indent + "public " + cl.id + "() " + "{" + nl + indent + "}" } + nl + nl +
- (if(0 < cl.Fields.length) {
- indentMore { indent + "public " + cl.id + "(" + repsep(cl.Fields map { f => convertType(f.typ) + " " + f.Id }, ", ") + ") " + "{" + nl +
- indentMore { rep(cl.Fields map { f => indent + "this." + f.Id + " = " + f.Id + ";" + nl}) } +
- indent + "}" } + nl + nl
- } else "") +
- indentMore { repsep(cl.members map convertMember, nl) } +
- "}" + nl + nl
- }
-
- def convertMember(member: Member): String = {
- member match {
- case Field(id, tp, false) =>
- indent + "public " + convertType(tp) + " " + id + ";" + nl
- case meth@Method(id, ins, outs, spec, body) =>
- var csharpmain = if(id.equals("Start") && ins.length == 0 && outs.length == 0) {
- indent + "public static void Main() { " + nl +
- indentMore {
- indent + meth.Parent.id + " newObject = new " + meth.Parent.id + "();" + nl +
- indent + "newObject.Start();" + nl
- } +
- indent + "}" + nl + nl
- } else { "" };
- var params = repsep(ins map { variable => convertType(variable.t) + " " + variable.id }, ", ") + (if(ins.length > 0 && outs.length > 0) ", " else "") +
- repsep(outs map { variable => "out " + convertType(variable.t) + " " + variable.id }, ", ");
- csharpmain +
- indent + "public " + "void " + id + "(" + params + ") " + "{" + nl +
- indentMore {
- rep(outs map { x => indent + x.id + " = " + defaultValue(x.t) + ";" + nl } ) +
- rep(body map convertStatement)
- } +
- indent + "}" + nl + nl +
- indent + "public delegate " + "void " + id + "_delegate" + "(" + params + ");" + nl + nl +
- indent + "public class " + "Token_" + id + " { " + nl +
- (indentMore {
- indent + "public " + id + "_delegate " + "del;" + nl +
- indent + "public " + "System.IAsyncResult " + "async;" + nl +
- (rep(outs map { o: Variable => indent + "public " + convertType(o.t) + " " + o.id + ";" + nl }))
- }) +
- indent + "}" + nl
- case Function(id, ins, out, spec, definition) if definition.isDefined =>
- indent + "public " + convertType(out) + " " + id + "(" +
- repsep(ins map { variable => convertType(variable.t) + " " + variable.id }, ", ") +
- ") " + "{" + nl +
- indentMore { indent + "return " + convertExpression(definition.get) + ";" + nl } +
- indent + "}" + nl
- case MonitorInvariant(_) => indent + "// monitor invariant" + nl
- case Predicate(_, _) => indent + "//predicate" + nl
- case _ => throw new NotSupportedException("unsupportet construct")
- }
- }
-
- def convertStatement(statement: Statement): String = {
- statement match {
- case Assert(e) => indent + "// assert" + nl
- case Assume(e) => indent + {e match {
- case BoolLiteral(false) => "assert false;" + nl // abort since we made a wrong choice...
- case _ => // TODO: what to do with assume expressions that contain old, result, ghost variables, etc.
- "// assume" + nl}}
- case BlockStmt(ss) => indent + "{" + nl + (indentMore { rep(ss map convertStatement) }) + indent + "}" + nl
- case IfStmt(guard, thn, els) => indent + "if (" + convertExpression(guard) + ")" + nl + convertStatement(thn) +
- (if(els.isDefined) (indent + "else" + nl + convertStatement(els.get)) else { "" }) + nl
- case LocalVar(v, rhs) =>
- indent + convertType(v.t) + " " + v.id + " = " +
- (if(rhs.isDefined) convertExpression(rhs.get) else defaultValue(v.t)) +
- ";" + nl
- case FieldUpdate(MemberAccess(target, f), rhs) =>
- indent + convertExpression(target) + "." + f + " = " + convertExpression(rhs) + ";" + nl
- case Assign(VariableExpr(x), rhs) =>
- indent + x + " = " + convertExpression(rhs) + ";" + nl
- case WhileStmt(guard, _, _, _, body) =>
- indent + "while (" + convertExpression(guard) + ")" + nl + convertStatement(body) + nl
- case c@Call(_, lhs, target, id, args) =>
- declareLocals(c.locals) +
- indent + convertExpression(target) + "." + id + "(" +
- repsep(args map convertExpression, ", ") +
- (if(args.length > 0 && lhs.length > 0) ", " else "") +
- repsep(lhs map { l => "out " + convertExpression(l) }, ", ") +
- ")" + ";" + nl
- case Install(_, _, _) => indent + "// install" + nl
- case Share(_, _, _) => indent + "// share" + nl
- case Unshare(_) => indent + "// unshare" + nl
- case Downgrade(_) => indent + "// downgrade" + nl
- case Acquire(obj) => indent + "System.Threading.Monitor.Enter(" + convertExpression(obj) + ")" + ";" + nl
- case Release(obj) => indent + "System.Threading.Monitor.Exit(" + convertExpression(obj) + ")" + ";" + nl
- case Lock(obj, body, false) => indent + "lock(" + convertExpression(obj) + ") " + nl + convertStatement(body) + nl
- case Free(_) => indent + "// free" + nl
- case Fold(_) => indent + "// fold" + nl
- case Unfold(_) => indent + "// unfold" + nl
- case RdAcquire(obj) => assert(false); ""
- case RdRelease(obj) => assert(false); ""
- case Lock(_, _, true) => assert(false); ""
- case ca@CallAsync(declaresLocal, lhs, obj, id, args) =>
- val tokenName = if(declaresLocal) lhs.id else { uniqueInt += 1; "tok_" + uniqueInt };
- val call = convertExpression(obj) + "." + id;
- val tokenClass = ca.m.Parent.id + ".Token_" + id;
- val delegateName = ca.m.Parent.id + "." + id + "_delegate";
- indent + tokenClass + " " + tokenName + " = new " + tokenClass + "();" + nl +
- indent + tokenName + "." + "del" + " = new " + delegateName + "(" + call + ");" + nl +
- indent + tokenName + "." + "async" + " = " + tokenName + "." + "del" + "." + "BeginInvoke(" + repsep(args map convertExpression, ", ") +
- (if(args.length > 0 && ca.m.outs.length > 0) ", " else "") + repsep(ca.m.outs map { o => "out " + tokenName + "." + o.id }, ", ") +
- (if(args.length > 0 || ca.m.outs.length > 0) ", " else "") + "null, null" +
- ");" + nl
- case ja@JoinAsync(lhs, token) =>
- indent + convertExpression(token) + "." + "del.EndInvoke(" +
- repsep(lhs map { x => "out " + x.id}, ", ") +
- (if(lhs.length > 0) ", " else "") + convertExpression(token) + "." + "async" + ");" + nl
- case s@Send(ch, args) =>
- indent + convertExpression(ch) + ".Send(" + repsep(args map convertExpression, ", ") + ")" + ";" + nl
- case r@Receive(_, ch, outs) =>
- declareLocals(r.locals) +
- indent + convertExpression(ch) + ".Receive(" + repsep(outs map { out => "out " + convertExpression(out)}, ", ") + ")" + ";" + nl
- case _ => throw new NotSupportedException("unsupportet construct")
- }
- }
-
- def declareLocals(locals: List[Variable]) = {
- var s = ""
- for (v <- locals)
- s = s + indent + convertType(v.t) + " " + v.id + ";" + nl
- s
- }
-
- def convertExpression(expression: RValue): String = {
- expression match {
- case IntLiteral(n) => "" + n
- case BoolLiteral(b) => "" + b
- case NullLiteral() => "null"
- case StringLiteral(s) => "\"" + s + "\""
- case th: ThisExpr => "this"
- case VariableExpr(id) => id
- case MemberAccess(target, f) => convertExpression(target) + "." + f
- case newrhs@NewRhs(c, initialization, lower, upper) =>
- if(initialization.length == 0) { "new " + c + "()" } else {
- val init = repsep(newrhs.typ.Fields map { f => (initialization.find { i => i.f == f}) match {
- case None => defaultValue(f.typ)
- case Some(init) => convertExpression(init.e);
- }
- }, ", ");
- "new " + c + "(" + init + ")";
- }
- case At(s, i) => convertExpression(s) + ".At(" + convertExpression(i) + ")"
- case Append(s1, s2) => convertExpression(s1) + ".Append(" + convertExpression(s2) + ")"
- case Take(s, i) => convertExpression(s) + ".Take(" + convertExpression(i) + ")"
- case Drop(s, i) => convertExpression(s) + ".Drop(" + convertExpression(i) + ")"
- case LockBelow(_, _) => "true"
- case bin: BinaryExpr => "(" + convertExpression(bin.E0) + " " + bin.OpName + " " + convertExpression(bin.E1) + ")"// todo: <==> and ==>
- case Unfolding(p, e) => convertExpression(e)
- case FunctionApplication(target, id, args) => convertExpression(target) + "." + id + "(" + repsep(args map convertExpression, ", ") + ")"
- case Not(e) => "(! " + convertExpression(e) + ")"
- case EmptySeq(tp) => "new Chalice.ImmutableList<" + convertType(tp) + ">()"
- case es@ExplicitSeq(elems) =>
- val elemType = new Type(es.typ.asInstanceOf[SeqClass].parameter);
- "new Chalice.ImmutableList<" + convertType(elemType) + ">(" +
- "new " + convertType(elemType) + "[] {" + repsep(elems map convertExpression, ", ") + "}" +
- ")"
- case Range(min, max) => "Chalice.ImmutableList.Range(" + convertExpression(min) + ", " + convertExpression(max) + ")"
- case Length(s) => convertExpression(s) + ".Length"
- case IfThenElse(c, thn, els) => "(" + convertExpression(c) + " ? " + convertExpression(thn) + " : " + convertExpression(els) + ")"
- case _ => throw new NotSupportedException("Expression not supported yet!");
- }
- }
-
- def convertType(tp: Type): String = {
- tp.typ match {
- case t: TokenClass => t.c.FullName + ".Token_" + t.m
- case s: SeqClass => "Chalice.ImmutableList<" + convertType(new Type(s.parameter)) + ">"
- case IntClass => "int"
- case BoolClass => "bool"
- case NullClass => "object"
- case StringClass => "string"
- case Class(id, _, _, _) => id
- }
- }
-
- def defaultValue(tp: Type) = {
- tp.typ match {
- case t: TokenClass => "null"
- case s: SeqClass => "new Chalice.ImmutableList<" + convertType(new Type(s.parameter)) + ">()"
- case IntClass => "0"
- case BoolClass => "false"
- case NullClass => "null"
- case Class(id, _, _, _) => "null"
- }
- }
-
- // utility methods below
-
- var uniqueInt: Int = 0;
- val nl = System.getProperty("line.separator");
- var indentLevel = 0
-
- def rep(strings: List[String]): String = {
- strings.foldLeft("")({ (a, b) => a + b })
- }
-
- def repsep(strings: List[String], separator: String): String = {
- if(strings.length == 0) {
- ""
- } else {
- strings.reduceLeft({ (a, b) => a + separator + b })
- }
- }
-
- def indent: String = {
- def doIndent(i: Int): String = {
- if(i==0) { "" } else { " " + doIndent(i-1) }
- }
- doIndent(indentLevel);
- }
-
- def indentMore(what: => String) = {
- val prev = indentLevel
- indentLevel = indentLevel + 1
- val result = what
- indentLevel = prev
- result
- }
-}
|