Python_CodeGen.jrag

aspect Python_CodeGenEnv {

  // Environment wrapper for Python code generation
  // handles qualid nesting, indentation, file writing and
  // prefix propagation

  public class Python_env {

    final private class Python_printer {
      
      private boolean newline = true;
      private PrintStream out;

      public Python_printer(PrintStream out) {
        this.out = out;
      }

      public void print(Python_env env, String s) {
        if (newline) {
          newline = false;
          for (int i = 0 ; i < env.indent ; i++) {
            out.print("    ");
          }
        }
        out.print(s);
      }

      public void println(Python_env env, String s) {
        print(env, s);
        out.println();
        newline = true;
      }

      public void println(Python_env env) {
        out.println();
        newline = true;
      }

    }

    private int indent;
    private Python_printer printer;

    public Python_env(PrintStream out) {
      this.indent = 0;
      this.printer = new Python_printer(out);
    }

    public void indent() {
      indent++;
    }

    public void unindent() {
      indent--;
    }

    public void print(String s) {
      printer.print(this, s);
    }

    public void println(String s) {
      printer.println(this, s);
    }

    public void println() {
      printer.println(this);
    }

  }

}

aspect Python_CodeGen {

  public void Specification.Python_gen(PrintStream out, String baseName, int version) {
    Python_env env = new Python_env(out);
    env.println("#!/usr/bin/python");
    env.println("# Auto generated " + baseName);
    env.println();
    env.println("import labcomm2014");
    env.println();
    Python_genTypes(env);
    env.println("typedef = tuple([");
    env.indent();
    for (int i = 0 ; i < getNumDecl() ; i++) {
      getDecl(i).Python_genTypedefListEntry(env);
    }
    env.unindent();
    env.println("])");
    env.println("sample = tuple([");
    env.indent();
    for (int i = 0 ; i < getNumDecl() ; i++) {
      getDecl(i).Python_genSampleListEntry(env);
    }
    env.unindent();
    env.println("])");
  }

}

aspect PythonTypes {
  
  public void Specification.Python_genTypes(Python_env env) {
    for (int i = 0 ; i < getNumDecl() ; i++) {
      getDecl(i).Python_genSignatureAndTypedef(env);
    }
  }

  public void Decl.Python_genSignatureAndTypedef(Python_env env) {
    throw new Error(this.getClass().getName() + 
                    ".Python_genSignatureAndTypedef(Python_env env)" + 
                    " not declared");
  }

  public void TypeDecl.Python_genSignatureAndTypedef(Python_env env) {
    env.println("class " + getName() + "(object):");
    env.indent();
    env.println("typedef = labcomm2014.typedef('" + getName() + "',");
    env.indent();
    getDataType().Python_genTypedef(env);
    env.unindent();
    env.println(")");
    env.unindent();
    env.println();
  }

  public void SampleDecl.Python_genSignatureAndTypedef(Python_env env) {
    env.println("class " + getName() + "(object):");
    env.indent();
    env.println("signature = labcomm2014.sample('" + getName() + "', ");
    env.indent();
    getDataType().Python_genSignature(env);
    env.unindent();
    env.println(")");
    env.println("typedef = labcomm2014.sample('" + getName() + "', ");
    env.indent();
    getDataType().Python_genTypedef(env);
    env.unindent();
    env.println(")");
    env.unindent();
    env.println();
  }

  public void UserType.Python_genSignature(Python_env env) {
    lookupType(getName()).getDataType().Python_genSignature(env);
  }

  public void DataType.Python_genSignature(Python_env env) {
    throw new Error(this.getClass().getName() + 
                    ".Python_genSignature(Python_env env)" + 
                    " not declared");
  }

  public void PrimType.Python_genSignature(Python_env env) {
    switch (getToken()) {
      case LABCOMM_BOOLEAN: { env.print("labcomm2014.BOOLEAN()"); } break;
      case LABCOMM_BYTE: { env.print("labcomm2014.BYTE()"); } break;
      case LABCOMM_SHORT: { env.print("labcomm2014.SHORT()"); } break;
      case LABCOMM_INT: { env.print("labcomm2014.INTEGER()"); } break;
      case LABCOMM_LONG: { env.print("labcomm2014.LONG()"); } break;
      case LABCOMM_FLOAT: { env.print("labcomm2014.FLOAT()"); } break;
      case LABCOMM_DOUBLE: { env.print("labcomm2014.DOUBLE()"); } break;
      case LABCOMM_STRING: { env.print("labcomm2014.STRING()"); } break;
      case LABCOMM_SAMPLE: { env.print("labcomm2014.SAMPLE()"); } break;
    }
  }

  public void ArrayType.Python_genSignature(Python_env env) {
    env.print("labcomm2014.array([");
    for (int i = 0 ; i < getNumExp() ; i++) {
      if (i > 0) { env.print(", "); }
      env.print(getExp(i).Python_getValue());
    }
    env.println("],");
    env.indent();
    getDataType().Python_genSignature(env);
    env.print(")");
    env.unindent();
  }

  public void StructType.Python_genSignature(Python_env env) {
    env.println("labcomm2014.struct([");
    env.indent();
    for (int i = 0 ; i < getNumField() ; i++) {
      if (i > 0) { env.println(","); }
      getField(i).Python_genSignature(env);
    }
    env.print("])");
    env.unindent();
  }

  public void VoidType.Python_genSignature(Python_env env) {
    env.println("labcomm2014.struct([])");
  }

  public void Field.Python_genSignature(Python_env env) {
    env.print("('" + getName() + "', ");
    getDataType().Python_genSignature(env);
    env.print(")");
  }

  public void UserType.Python_genTypedef(Python_env env) {
    env.println(getName() + ".typedef");
  }

  public void DataType.Python_genTypedef(Python_env env) {
    throw new Error(this.getClass().getName() + 
                    ".Python_genTypedef(Python_env env)" + 
                    " not declared");
  }

  public void PrimType.Python_genTypedef(Python_env env) {
    switch (getToken()) {
      case LABCOMM_BOOLEAN: { env.print("labcomm2014.BOOLEAN()"); } break;
      case LABCOMM_BYTE: { env.print("labcomm2014.BYTE()"); } break;
      case LABCOMM_SHORT: { env.print("labcomm2014.SHORT()"); } break;
      case LABCOMM_INT: { env.print("labcomm2014.INTEGER()"); } break;
      case LABCOMM_LONG: { env.print("labcomm2014.LONG()"); } break;
      case LABCOMM_FLOAT: { env.print("labcomm2014.FLOAT()"); } break;
      case LABCOMM_DOUBLE: { env.print("labcomm2014.DOUBLE()"); } break;
      case LABCOMM_STRING: { env.print("labcomm2014.STRING()"); } break;
      case LABCOMM_SAMPLE: { env.print("labcomm2014.SAMPLE()"); } break;
    }
  }

  public void ArrayType.Python_genTypedef(Python_env env) {
    env.print("labcomm2014.array([");
    for (int i = 0 ; i < getNumExp() ; i++) {
      if (i > 0) { env.print(", "); }
      env.print(getExp(i).Python_getValue());
    }
    env.println("],");
    env.indent();
    getDataType().Python_genTypedef(env);
    env.print(")");
    env.unindent();
  }

  public void StructType.Python_genTypedef(Python_env env) {
    env.println("labcomm2014.struct([");
    env.indent();
    for (int i = 0 ; i < getNumField() ; i++) {
      if (i > 0) { env.println(","); }
      getField(i).Python_genTypedef(env);
    }
    env.print("])");
    env.unindent();
  }

  public void VoidType.Python_genTypedef(Python_env env) {
    env.println("labcomm2014.struct([])");
  }

  public void Field.Python_genTypedef(Python_env env) {
    env.print("('" + getName() + "', ");
    getDataType().Python_genTypedef(env);
    env.print(")");
  }

  public void Decl.Python_genTypedefListEntry(Python_env env) {
  }

  public void TypeDecl.Python_genTypedefListEntry(Python_env env) {
    env.println(getName() + ",");
  }

  public void Decl.Python_genSampleListEntry(Python_env env) {
  }

  public void SampleDecl.Python_genSampleListEntry(Python_env env) {
    env.println(getName()+ ",");
  }

  public String Exp.Python_getValue() {
   throw new Error(this.getClass().getName() + 
                    ".Python_getValue()" + 
                    " not declared");
  }

  public String IntegerLiteral.Python_getValue() {
    return getValue();
  }

  public String VariableSize.Python_getValue() {
    return "0";
  }

}