Exemplo n.º 1
0
 public void visitWhileStatement(GNode n) {
   add(getIndent());
   add("while (");
   dispatch((Node) n.get(0)); // while condition
   add(")");
   dispatch((Node) n.get(1)); // attached block
 }
  protected void onInstantiate(GNode n) {
    JavaType t1, t2;
    expressions = new JavaExpression[3];
    expressions[0] = (JavaExpression) this.dispatch((GNode) n.get(0));
    expressions[1] = (JavaExpression) this.dispatch((GNode) n.get(1));
    expressions[2] = (JavaExpression) this.dispatch((GNode) n.get(2));

    if (expressions[1].getType().isChildOf(expressions[2].getType())) {
      this.setType(expressions[2].getType());
    } else {
      this.setType(expressions[1].getType());
    }
  }
  /**
   * Constructs the package using a GNode.
   *
   * @param n The package or import declaration node.
   */
  public JavaPackage(GNode n) {
    // Parse the package name
    pkg = new ArrayList<String>();
    int size;
    if (n.hasName("ImportDeclaration")) {
      if (null == n.get(2)) size = n.getNode(1).size() - 1;
      else size = n.getNode(1).size();
    } else {
      size = n.getNode(1).size();
    }
    for (int i = 0; i < size; i++) {
      pkg.add(n.getNode(1).getString(i));
    }

    // Initialize the file list
    files = new ArrayList<JavaFile>();
  }
  public CreateCplusplusHeader(GNode n) {

    classTree = n;

    /*Debug**/
    // p1.println(classTree.size());
    final PrintWriter p1;
    final GNode[] containsRelevantClasses;
    final ArrayList<String> stringClasses = new ArrayList<String>();
    final ArrayList<Integer> countClasses = new ArrayList<Integer>();
    final ArrayList<Integer> countChildren = new ArrayList<Integer>();
    final GNode stac = GNode.create("Holder");

    File headerFile;

    File newDirectory;

    try {

      newDirectory = new File("cplusplusfiles");
      newDirectory.mkdir();
      headerFile = new File("cplusplusfiles", "Header.h");
      headerFile.createNewFile();
      p1 = new PrintWriter(headerFile);

      /*Remove comments below to Debug**/
      // p1.println(classTree.size());
      // p1.println(containsRelevantClasses.size());
      // p1.println(countClasses);
      //  p1.println(countChildren);

      p1.println("// Ankit Goel's Header");
      p1.println("#pragma once");
      p1.println();
      p1.println("#include <stdint.h>");
      p1.println("#include <string>");
      p1.println();
      p1.println("using namespace java::lang;");
      p1.println("// Foward Declarations ");
      p1.println();

      /* Remove comments below to Debug**/
      //  String s = classTree.getNode(1).getNode(0).getNode(0).getName();
      //  p1.println(s);
      //  p1.flush();
      //  p1.close();

      new Visitor() {
        int counter22 = 0;

        public void visitClass(GNode n) {
          counter22++;

          countChildren.add(n.size());
          countClasses.add(counter22);

          visit(n);
        }

        public void visitClassHeaderDeclaration(GNode n) {

          stac.add(n);

          /*Remove comments below to Debug**/
          // p1.println(n.getNode(0).getName());
          // containsRelevantClasses[counter22] = (GNode) n;

        }

        public void visit(Node n) {
          for (Object o : n) if (o instanceof Node) dispatch((Node) o);
        }
      }.dispatch(classTree);

      /*Remove comments below to Debug**/
      // p1.println(stac.size());

      String globalVariableArrayCheck;
      for (int b = 4; b < stac.size(); b++) {

        createCplusplusHeader = (GNode) stac.getNode(b);
        GNode vMethods = (GNode) createCplusplusHeader.getNode(0);
        // p1.println(createCplusplusHeader.getName());
        /*Remove comments below to Debug**/
        // p1.println(vMethods.getName());
        // We need a mapping of methodName to accessibility

        final HashMap<String, String> mNAccess = new HashMap<String, String>();

        /*Remove comments below to Debug**/
        // We need a mapping to methodName to whetherItsStatic
        // p1.println(mNAccess);
        // p1.println(mNAccess.get("goel"));

        final GNode constructorPrinter = GNode.create("ConstructorPrinter");

        final ArrayList<Integer> getCounter = new ArrayList<Integer>();

        new Visitor() {
          int counter2 = 0;

          public void visitVirtualMethodDeclaration(GNode n) {
            counter2++;
            getCounter.add(counter2);
          }

          public void visit(Node n) {
            for (Object o : n) if (o instanceof Node) dispatch((Node) o);
          }
        }.dispatch(vMethods);

        int startHere = getCounter.get(getCounter.size() - 1) + 1;

        /*Remove comments below to Debug**/
        // p1.println(startHere);

        final String className = vMethods.getNode(startHere).getNode(4).getNode(0).getString(0);

        final String plainClassName = className.substring(2, className.length());

        final GNode ARRAYTRACKER = GNode.create("ArrayTracker");

        // Need another dispatch for constructor heeader node
        new Visitor() {
          public void visitConstructorHeader(GNode n) {

            // Add each node
            if (n.getString(0).equals(plainClassName)) constructorPrinter.add(n);
          }

          public void visitCustomArrayDeclaration(GNode n) {
            ARRAYTRACKER.add(n);
          }

          public void visit(Node n) {
            for (Object o : n) if (o instanceof Node) dispatch((Node) o);
          }
        }.dispatch(createCplusplusHeader);
        // p1.println(constructorPrinter.size());
        // Find out when the virtual method declarations ends

        /*Remove comments below to Debug**/
        // p1.println(getCounter);

        p1.println("struct __" + plainClassName + ";");
        p1.println();
        p1.println("struct __" + plainClassName + "_VT;");
        p1.println();
        p1.println("typedef __rt::Ptr<" + "__" + plainClassName + "> " + plainClassName + ";");
        p1.println();
        p1.println("struct __" + plainClassName + " { ");
        p1.println();
        p1.println("    // The data layout for java.lang.plainClassName");
        p1.println("      " + "__" + plainClassName + "_VT* __vptr;");

        // Get the Field Decl in this

        final GNode fields = GNode.create("Fields");
        new Visitor() {
          public void visitDataLayoutDeclaration(GNode n) {
            visit(n);
          }

          public void visitDataFieldList(GNode n) {

            fields.add(n);
          }

          public void visit(Node n) {
            for (Object o : n) if (o instanceof Node) dispatch((Node) o);
          }
        }.dispatch(createCplusplusHeader);
        // p1.println(fields.size());

        final ArrayList<String> privateOrpublic = new ArrayList<String>();
        final ArrayList<String> PrimitiveType = new ArrayList<String>();
        final ArrayList<String> Decl = new ArrayList<String>();

        new Visitor() {
          public void visitDataFieldList(GNode n) {
            visit(n);
          }

          public void visitFieldDeclaration(GNode n) {

            // if (n.getNode(0).size() > 0 )
            // privateOrpublic.add(n.getNode(0).getNode(0).getString(0));
            /*
            if (n.getNode(0).getNode(0).getString(0).equals("static") && n.getNode(1).getNode(0).getString(0).equals("int") )
                PrimitiveType.add("static const int32_t ");
            **/
            if (n.getNode(1).getNode(0).getString(0).equals("int")
                && n.toString().contains("static")) PrimitiveType.add(" static int32_t");
            else PrimitiveType.add(n.getNode(1).getNode(0).getString(0));

            Decl.add(n.getNode(2).getNode(0).getString(0));

            /*
            else
                Decl.add(n.getNode(2).getNode(0).getString(0) + "  = " +  n.getNode(2).getNode(0).getNode(2).getString(0));
             **/
          }

          public void visit(Node n) {
            for (Object o : n) if (o instanceof Node) dispatch((Node) o);
          }
        }.dispatch(fields);

        // Print out the Data Fields
        for (int c = 0; c < Decl.size(); c++) {

          p1.println();
          p1.println("     " + PrimitiveType.get(c) + " " + Decl.get(c) + ";");
        }

        List<String> typeOfParameter = new ArrayList<String>();
        List<String> DECLARATOR = new ArrayList<String>();

        // p1.println(constructorPrinter);

        for (int ccd = 0; ccd < constructorPrinter.size(); ccd++) {

          // There is more than one parameter
          if (constructorPrinter.getNode(ccd).getNode(1).size() >= 1) {

            GNode GETPARAMS = GNode.create("GETPARAMS");

            GETPARAMS.add(constructorPrinter.getNode(ccd).getNode(1));
            // p1.println(GETPARAMS);
            // Now Go through the Formal Parameters

            for (int dcc = 0; dcc < GETPARAMS.size(); dcc++) {

              typeOfParameter.add(
                  GETPARAMS.getNode(0).getNode(dcc).getNode(1).getNode(0).getString(0));

              DECLARATOR.add(GETPARAMS.getNode(0).getNode(dcc).getString(3));
            }
          } else {

            p1.println();

            p1.println("      " + className + "();");
          }
        }

        if (DECLARATOR.size() >= 1 && typeOfParameter.size() >= 1) {
          p1.print(className + "( ");
          for (int goela = 0; goela < typeOfParameter.size(); goela++) {

            if (goela != typeOfParameter.size() - 1)
              p1.print(typeOfParameter.get(goela) + "   " + DECLARATOR.get(goela) + ",");
            else p1.print(typeOfParameter.get(goela) + "   " + DECLARATOR.get(goela) + ");");
          }
        }

        p1.println();

        if ((constructorPrinter.size() == 0)) {
          p1.println();
          p1.println("     " + "// The Constructor");
          p1.println();
          p1.println("          " + "__" + plainClassName + "(); ");
        }

        // Find Instance Methods of the class Basically go through vtMethodPointersList and
        //  go through its children and check if the qualified identifier is the same as the clas
        // name

        // Store the names in a Arraylist type
        final List<String> names = new ArrayList<String>();

        List<String> types2 = new ArrayList<String>();

        final List<Integer> indexx = new ArrayList<Integer>();

        final HashMap<Integer, String> checkForOtherSuperClass = new HashMap<Integer, String>();

        // final HashMap<String,String> checkForPredefinedMethods = new HashMap<String,String>();
        // Basically You need to consider this fact there will be however so many Constructors and
        // you need to keep a tally to start it like that and
        // Ignore those indices

        final List<Integer> constuctorIndex = new ArrayList<Integer>();
        final GNode constructors = GNode.create("CONSTRUCTOR");
        final String constructorNameGetter = plainClassName;
        //  p1.println(constructors.size());
        // p1.println(constructorNameGetter);
        // Lets find out which methods are unique

        new Visitor() {
          public int counter = 0;

          public void visitVTConstructorDeclaration(GNode n) {
            visit(n);
          }

          public void visitvtMethodPointersList(GNode n) {

            visit(n);
          }

          public void visitvtMethodPointer(GNode n) {

            counter++;

            if (!(n.getNode(1).getString(1).equals("__Object"))
                && !(n.getString(0).equals("main_String"))) {

              //  constructorIndex.add(counter);

              //  p1.println(n.getString(0));

              indexx.add(counter);
              names.add(n.getString(0));
              // There needs to be a check for the other than __Object && __SuperClass
              checkForOtherSuperClass.put(counter, n.getNode(1).getString(1));

              //  checkForPredefinedMethods.put(n.getString(0), n.getNode(1).getString(1));

            } else {

              checkForOtherSuperClass.put(counter, n.getNode(1).getString(1));
              // constructors.add(n);
            }
          }

          public void visit(Node n) {
            for (Object o : n) if (o instanceof Node) dispatch((Node) o);
          }
        }.dispatch(vMethods);

        // p1.println(names);
        //  p1.println("Constructors" + constructors.size());
        //  p1.println(checkForOtherSuperClass);
        // System.out.println("ARRAY CONTENTS" + names);
        // Now lets get the type of the method and store it in Types arraylist

        // Visit the Method Declarations of the Java AST and store the types in order into an array.
        // Then
        // store the corresponding names of the methods in another array then do matching to
        // determine the
        // the types of the method
        // p1.println(checkForOtherSuperClass);

        for (int i = 0; i < indexx.size(); i++) {

          if (vMethods.getNode(indexx.get(i)).getGeneric(0) != null) {

            if (vMethods.getNode(indexx.get(i)).getNode(0).getName().equals("Type")) {

              // I think there only needs to be one check for a bool value the rest translate as is
              if (vMethods
                  .getNode(indexx.get(i))
                  .getNode(0)
                  .getNode(0)
                  .getString(0)
                  .equals("boolean")) types2.add("bool");
              else types2.add(vMethods.getNode(indexx.get(i)).getNode(0).getNode(0).getString(0));

            } else types2.add("void");

          } else {

            types2.add(" ");
          }
        }
        // p1.println(types2);
        // p1.println(names);
        // params are appended to the methods name
        List<String> specialnames = new ArrayList<String>();

        // A single method name which is a string could essential map to however many Strings
        Map<String, String> parameters = new HashMap<String, String>();

        // Remove anything after _ in the method these are the parameters that are appended to it
        for (int i = 0; i < names.size(); i++) {

          Pattern p = Pattern.compile("_");

          Matcher m = p.matcher(names.get(i));

          if (m.find()) {
            // p1.println("FOUND");

            // p1.println(m.start());

            // ****** Changed
            //  specialnames.add(names.get(i).substring(0,m.start()));

            specialnames.add(names.get(i));
            // Money.add(names.get(i));

            parameters.put(
                specialnames.get(i), names.get(i).substring(m.start(), names.get(i).length()));
          } else {

            specialnames.add(names.get(i));
            // The hashmap needs to be consistent
            parameters.put(names.get(i), "ZeroParams");
          }
        }
        // p1.println(names);
        // p1.println(parameters);
        // p1.println(types2);
        // p1.println(parameters);
        // Now print the instance methods using the types and names
        p1.println("    // The instance methods of java.lang.plainClassName");
        // p1.println(specialnames);

        // Constructor Initializeer
        p1.println("    static " + plainClassName + " init_Construct( " + plainClassName + "); ");

        for (int i = 0; i < types2.size(); i++) {

          if (parameters.get(specialnames.get(i)).equals("ZeroParams")
              && !(specialnames.get(i).equals(plainClassName)))
            p1.println(
                "    "
                    + "static "
                    + types2.get(i)
                    + " "
                    + specialnames.get(i)
                    + "( "
                    + plainClassName
                    + ")"
                    + ";");
          else {

            if (!(specialnames.get(i).equals(plainClassName))) {

              ArrayList<Integer> getTheParameters = new ArrayList<Integer>();

              p1.print(
                  "    "
                      + "static "
                      + types2.get(i)
                      + " "
                      + specialnames.get(i)
                      + "( "
                      + plainClassName
                      + " , ");

              Pattern pp = Pattern.compile("_");

              Matcher mm = pp.matcher(parameters.get(specialnames.get(i)));

              while (mm.find()) {

                getTheParameters.add(mm.start());
              }

              for (int cc = 0; cc < getTheParameters.size(); cc++) {

                if (cc != getTheParameters.size() - 1) {

                  p1.print(
                      parameters
                              .get(specialnames.get(i))
                              .substring(getTheParameters.get(cc) + 1, getTheParameters.get(cc + 1))
                          + " , ");

                } else {
                  int length = parameters.get(specialnames.get(i)).length();
                  p1.print(
                      parameters
                              .get(specialnames.get(i))
                              .substring(getTheParameters.get(cc) + 1, length)
                          + ");");
                }
              }

              p1.println();
            }
          }
        }

        p1.println();
        p1.println(
            "    // The Function returning the class Object representing java.lang.plainClassName ");
        p1.println("    static Class __class(); ");
        p1.println("    static void init(  " + "__" + plainClassName + "*" + "  );");
        p1.println();

        // Changes for Command line arguements
        if (plainClassName.contains("Test")) {

          p1.println("    static void main(__rt::Ptr<__rt::Array<String> > args);");
        }
        p1.println("    static __" + plainClassName + "_" + "VT " + "__vtable;");
        p1.println();
        p1.println(" };");
        p1.println();

        // Now print the Constructor taking into account which ones are implemented by the given
        // class
        p1.println("struct __" + plainClassName + "_" + "VT" + "{");
        p1.println("    Class __isa;");

        // Introduce some logic to differentiate between new methods and predefined inherited method
        // from Object
        List<String> arr1 = new ArrayList<String>();
        arr1.add("hashcode");
        arr1.add("equals");
        arr1.add("getClass");
        arr1.add("toString");
        arr1.add("getName");
        arr1.add("getSuperClass");
        arr1.add("isInstance");

        // Basically iterate through map and add any methods that have a type not equal to the

        // You need to add the inherited types
        p1.println("    void (*__delete)(__" + plainClassName + "*);");
        p1.println("    int32_t (*hashCode)(" + plainClassName + ");");
        p1.println("    bool (*equals)(" + plainClassName + " , " + "Object);");
        p1.println("    Class (*getClass)(" + plainClassName + ");");
        p1.println("    String (*toString) (" + plainClassName + ");");

        for (int i = 0; i < names.size(); i++) {

          if (!(arr1.contains(names.get(i)))) {

            p1.println();

            ArrayList<Integer> getTheParameters = new ArrayList<Integer>();

            if (parameters.get(specialnames.get(i)).equals("ZeroParams")
                && !(specialnames.get(i).equals(plainClassName)))
              p1.println(
                  "    "
                      + types2.get(i)
                      + " (*"
                      + specialnames.get(i)
                      + ") ("
                      + plainClassName
                      + ");");
            else {

              if (!(specialnames.get(i).equals(plainClassName))) {

                Pattern pp = Pattern.compile("_");

                Matcher mm = pp.matcher(parameters.get(specialnames.get(i)));

                while (mm.find()) {

                  getTheParameters.add(mm.start());
                }
                p1.print(
                    "    "
                        + types2.get(i)
                        + " (*"
                        + specialnames.get(i)
                        + ") ("
                        + plainClassName
                        + " , ");

                for (int cc = 0; cc < getTheParameters.size(); cc++) {

                  if (cc != getTheParameters.size() - 1) {

                    p1.print(
                        parameters
                                .get(specialnames.get(i))
                                .substring(
                                    getTheParameters.get(cc) + 1, getTheParameters.get(cc + 1))
                            + " , ");

                  } else {
                    int length = parameters.get(specialnames.get(i)).length();
                    p1.print(
                        parameters
                                .get(specialnames.get(i))
                                .substring(getTheParameters.get(cc) + 1, length)
                            + ");");
                  }
                }
              }

              // p1.println(getTheParameters);
            }
          }
        }

        p1.println();
        p1.println();
        // Now the constructor initilization inlined in the header
        p1.println("    __" + plainClassName + "_VT()");
        p1.println("    : __isa(__" + plainClassName + "::__class()),");

        List<String> getImplementation = new ArrayList<String>();

        int COUNT = 0;

        // Are there any instance methods
        for (int i = 0; i < specialnames.size(); i++) {
          if (!(specialnames.equals(plainClassName))) COUNT++;
        }
        // p1.println(COUNT);
        for (int i = 0; i < arr1.size(); i++) {

          if (names.contains(arr1.get(i))) {

            // Suppose a super class defines an Object method then this is wrong  so add an
            // additional check
            // if(checkForPredefinedMethods.get(arr1.get(i)).equals("__" + plainClassName))
            getImplementation.add(plainClassName);
            // else
            //  getImplementation.add(checkForPredefinedMethods.get(arr1.get(i)));

          } else {

            getImplementation.add("Object");
          }
        }
        // Remove comment to Debug
        // p1.println(getImplementation);

        p1.println("    __delete(&__rt::__delete<__" + plainClassName + ">),");

        // Hardcoded May Need to Change in the final Phase
        if (getImplementation.get(0).equals("Object"))
          p1.println(
              "      hashCode((int32_t(*)("
                  + plainClassName
                  + "))"
                  + "&__"
                  + getImplementation.get(0)
                  + "::hashCode),");
        else p1.println("      hashCode(&__" + plainClassName + "::hashCode),");

        if (getImplementation.get(1).equals("Object"))
          p1.println(
              "      equals((bool(*)("
                  + plainClassName
                  + " , Object)) &__"
                  + getImplementation.get(1)
                  + "::equals), ");
        else p1.println("      equals(&__" + plainClassName + "::equals");

        if (getImplementation.get(2).equals("Object"))
          p1.println(
              "      getClass((Class(*)("
                  + plainClassName
                  + ")) &__"
                  + getImplementation.get(2)
                  + "::getClass), ");
        else p1.println("      getClass(&__" + plainClassName + ")");

        // Remember to Take care of the comma issue
        if (getImplementation
            .get(3)
            .equals("Object") /*|| !(getImplementation.get(3).equals("__" + plainClassName))**/) {

          if (COUNT != 0)
            p1.println(
                "      toString((String(*)("
                    + plainClassName
                    + ")) &__"
                    + getImplementation.get(3)
                    + "::toString), ");
          else
            p1.println(
                "      toString((String(*)("
                    + plainClassName
                    + ")) &__"
                    + getImplementation.get(3)
                    + "::toString) { ");

        } else {
          int x = names.size();
          boolean bat = false;
          if ((x == 1) && (names.get(0).equals("toString"))) bat = true;
          if (COUNT != 0 && !(bat))
            p1.println("      toString(&__" + getImplementation.get(3) + "::toString),");
          else p1.println("      toString(&__" + getImplementation.get(3) + "::toString) {");
        }
        // p1.println(names);

        //

        for (int uniqueNames = 0; uniqueNames < names.size(); uniqueNames++) {

          // Remove Unnecessary Methods
          if (arr1.contains(names.get(uniqueNames))) {
            names.remove(uniqueNames);
            specialnames.remove(uniqueNames);
            types2.remove(uniqueNames);
          }
        }

        // p1.println(types2);
        // p1.println(names);
        // ADD Remaining Methods to implementation
        for (int i = 0; i < names.size(); i++) {

          if (!(arr1.contains(specialnames.get(i)))
              && checkForOtherSuperClass.get(i + 6).equals(className)
              && (i == names.size() - 1)
              && !(specialnames.get(i).equals(plainClassName))) {
            // Remember to Fix this later

            p1.println();
            p1.println(
                "      "
                    + specialnames.get(i)
                    + "(&__"
                    + plainClassName
                    + "::"
                    + specialnames.get(i)
                    + ") {");

          }

          // Finally Add Parameters Here
          else {
            if (parameters.get(specialnames.get(i)).equals("ZeroParams")
                && !(specialnames.get(i).equals(plainClassName))
                && !(arr1.contains(specialnames.get(i)))) {

              if (i != names.size() - 1)
                p1.println(
                    "      "
                        + specialnames.get(i)
                        + "(("
                        + types2.get(i)
                        + "(*)"
                        + "("
                        + plainClassName
                        + "))"
                        + "&"
                        + checkForOtherSuperClass.get(i + 6)
                        + "::"
                        + specialnames.get(i)
                        + "),");
              else
                p1.println(
                    "      "
                        + specialnames.get(i)
                        + "(("
                        + types2.get(i)
                        + "(*)"
                        + "("
                        + plainClassName
                        + "))"
                        + "&"
                        + checkForOtherSuperClass.get(i + 6)
                        + "::"
                        + specialnames.get(i)
                        + ") {");

              p1.println();

            } else {

              if (!(specialnames.get(i).equals(plainClassName))
                  && !(arr1.contains(specialnames.get(i)))) {

                ArrayList<Integer> getTheParameters = new ArrayList<Integer>();

                p1.print(
                    "      "
                        + specialnames.get(i)
                        + "(("
                        + types2.get(i)
                        + "(*)"
                        + "("
                        + plainClassName
                        + " , ");

                Pattern pp = Pattern.compile("_");

                Matcher mm = pp.matcher(parameters.get(specialnames.get(i)));

                while (mm.find()) {

                  getTheParameters.add(mm.start());
                }

                for (int cc = 0; cc < getTheParameters.size(); cc++) {

                  if (cc != getTheParameters.size() - 1) {

                    p1.print(
                        parameters
                                .get(specialnames.get(i))
                                .substring(
                                    getTheParameters.get(cc) + 1, getTheParameters.get(cc + 1))
                            + " , ");

                  } else {
                    int length = parameters.get(specialnames.get(i)).length();
                    p1.print(
                        parameters
                            .get(specialnames.get(i))
                            .substring(getTheParameters.get(cc) + 1, length));
                    if (i != names.size() - 1)
                      p1.print(
                          "))"
                              + "&"
                              + checkForOtherSuperClass.get(i + 6)
                              + "::"
                              + specialnames.get(i)
                              + "),");
                    else
                      p1.print(
                          "))"
                              + "&"
                              + checkForOtherSuperClass.get(i + 6)
                              + "::"
                              + specialnames.get(i)
                              + ") {");

                    p1.println();
                  }
                }

                // p1.println(getTheParameters);
              }
            }
          }
        }

        p1.println("    }");
        p1.println("};");
        p1.println();
        p1.println();
        p1.println();
        /*Remove comments below to Debug**/

      }
      // p1.println(names);

      p1.flush();
      p1.close();
    } catch (Exception e) {
    }
  }
Exemplo n.º 5
0
 public void visitLogicalOrExpression(GNode n) {
   dispatch((Node) n.get(0));
   add(" || ");
   dispatch((Node) n.get(1));
 }
Exemplo n.º 6
0
 public void visitIntegerLiteral(GNode n) {
   add((String) n.get(0));
 }
Exemplo n.º 7
0
 public void visitDeclarator(GNode n) {
   String declaratorName = n.getString(0);
   add(declaratorName);
   add(" = ");
   visit(n);
 }
Exemplo n.º 8
0
 public void visitPrimitiveType(GNode n) {
   add((String) n.get(0) + " ");
 }
Exemplo n.º 9
0
 public void visitPrimaryIdentifier(GNode n) {
   String word = (String) n.get(0);
   add(word);
   visit(n);
 }
Exemplo n.º 10
0
 public void visitSelectionExpression(GNode n) {
   // Visits the first part, prints it, puts the dot, then prints the rest
   visit(n);
   add(".");
   add((String) n.get(1));
 }