//-*-java-*-

/*
 *  Public Methods
 */

Weaver {

  public static Vector weave(String[] args) throws ParseException {{
    /*
     *  Updates internal weaver state - does no code generation.
     */
    // parse input files
    args = processFlags(args);
    if(args.length == 0) {
      parsed_input = new Weaver[1];
      try {
        parsed_input[0] = Weaver.parse(System.in);
      } catch(ParseException e) {
        Err.err("Trouble parsing System.in:");
        throw e;
      }
      args = new String[1];
      args[0] = "System.in";
    }
    else try {
      parsed_input = new Weaver[args.length];
      for(int i=0;i<args.length;i++) {
        FileInputStream infile = new FileInputStream(args[i]);
        try {
          parsed_input[i] = Weaver.parse(infile);
        } catch(ParseException e) {
          Err.err("Trouble parsing "+args[i]+":");
          throw e;
        }
      }
    } catch(FileNotFoundException e) {
      throw new RuntimeException(e.toString());
    }
    
    // this should disappear soon - the demeterj front end will deal
    // with aspect prioritization
    AspectSorter v_aspsort = new AspectSorter(parsed_input.length);
    v_aspsort.current_aspect = "core";
    for(int i=0;i<parsed_input.length;i++) parsed_input[i].toWeaver(v_aspsort);
    v_aspsort.current_aspect = "cool";
    for(int i=0;i<parsed_input.length;i++) parsed_input[i].toWeaver(v_aspsort);
    v_aspsort.current_aspect = "ridl";
    for(int i=0;i<parsed_input.length;i++) parsed_input[i].toWeaver(v_aspsort);
    parsed_input = v_aspsort.sorted_aspects;
    
    for(int i=0;i<parsed_input.length;i++) {
      Vector imports = new Vector();
      Pack[] pack = { null };
      Enumeration codefrag_enum = parsed_input[i].get_codefrags().elements();
      while(codefrag_enum.hasMoreElements()) {
        CodeFrag codefrag = (CodeFrag)codefrag_enum.nextElement();
        codefrag.arrayTypeStuff();
        codefrag.resolveVars(the_BIG_one);
        build(codefrag, imports, pack);
      }
    }
    
    if(!Err.report()) return null;
    
    return the_BIG_one.fileList();
  }}

  public static void generate() {{
    File outdir = new File(outputdir);
    if(!outdir.exists()) outdir.mkdirs();
    OutputVisitor v_output = new OutputVisitor();
    the_BIG_one.toSimples(v_output);
  }}

  public static void reset() {{
    the_BIG_one = Weaver.parse("gen:");
    Err.reset();
  }}

  public static boolean exists(String thing) {{
    /*
     *  Argument is a classname, interfacename, or qualified methodname.
     *  No packages yet.
     */
    if(thing.indexOf('.') == -1) return the_BIG_one.getCI(thing) != null;
    else
      return !the_BIG_one.findCIParts(FullMethodName.parse(thing)).isEmpty();
  }}

  public static int getModifiers(String meth) {{
    /*
     *  Test return val with java.lang.reflect.Modifier.
     *  Returns -1 if meth isn't found or multiple methods are found with
     *  non-matching modifers.  Be aware that passing -1 to the static
     *  methods of java.lang.reflect.Modifier always returns true.
     */
    Enumeration meth_enum;
    meth_enum = the_BIG_one.findCIParts(FullMethodName.parse(meth)).elements();
    int ret = -1;
    while(meth_enum.hasMoreElements()) {
      ClassMethod m = (ClassMethod)meth_enum.nextElement();
      int cur = m.getModifiers();
      if(ret == -1) ret = cur;
      else if(ret != cur) {
	ret = -1;
	break;
      }
    }
    return ret;
  }}

  public static String getSuperclass(String clazz) {{
    /*
     *  Returns null if "clazz" isn't an added class or if it has no superclass
     */
    AddClass addc;
    try {
      addc = (AddClass)the_BIG_one.getCI(clazz);
      if(addc == null) {
	System.err.println("getCI(\""+clazz+"\") returned null.");
	return null;
      }
    } catch(ClassCastException e) {
      System.err.println("getCI(\""+clazz+"\") didn't return an AddClass.");
      return null;
    }
    String ret = addc.parentClassString();
    if(ret == null) System.err.println("parentClassString() returned null.");
    return ret;
  }}
}

/*
 *  ...
 */

Weaver {
  {{
   private static Weaver[] parsed_input;
   private static Weaver the_BIG_one = Weaver.parse("gen:");
   static String outputdir = "gen";
   }}

  private static String[] processFlags(String[] args) {{
    for(int i=0;i<args.length;i++) {
      if(!args[i].startsWith("-")) {
        String[] ret = new String[args.length-i];
        System.arraycopy(args, i, ret, 0, args.length-i);
        return ret;
      }
      if(args[i].equals("-outputdir")) {
	try {
          outputdir = args[++i];
	} catch(ArrayIndexOutOfBoundsException e) {
          Err.err("Option \"-outputdir\" needs an argument.");
	}
      }
      else if(args[i].equals("-quiet")) Err.beQuiet();
      else Err.warn("Unknown option: "+args[i]+".");
    }
    return new String[0]; // dummy
  }}
    
  private static void build(CodeFrag frag, Vector imports, Pack[] pack) {{
    AdjustItem item = frag.get_adjustitem();
    if(item instanceof AddClass || item instanceof AddInterface)
      the_BIG_one.addCI(frag, imports, pack[0]);
    else if(item instanceof AddAttribute)
      the_BIG_one.addAtt((AddAttribute)item);
    else if(item instanceof AugmentMethod)
      the_BIG_one.augMeth((AugmentMethod)item);
    else if(item instanceof ImplementInterface)
      the_BIG_one.impInt((ImplementInterface)item);
    else if(item instanceof RenameMethod)
      the_BIG_one.renMeth((RenameMethod)item);
    else if(item instanceof PackageSpec)
      pack[0] = ((PackageSpec)item).get_pack();
    else if(item instanceof ImportStatement) {
      String imp = ((ImportStatement)item).toString();
      if(!imports.contains(imp)) imports.addElement(imp);
    }
    else if(item instanceof VarAssignment) {}
    else Err.bug("Uninterpretable (but parsed) command.");
  }}

}

/*
 *  Array Type Manipulation
 */

CodeFrag {
  void arrayTypeStuff() to Argument {
    before Argument {{
      int dim = host.get_varname().getArrayDimensionAndNullify();
      host.get_argtype().increaseArrayDimension(dim);
    }}
  }
}

VarName {
  int getArrayDimensionAndNullify() {{
    if(get_bracks()==null) return 0;
    int ret = 0;
    for(Enumeration e = get_bracks().elements();
	e.hasMoreElements(); e.nextElement()) ret++;
    set_bracks(null);
    return ret;
  }}
}

FixDataType {
  void increaseArrayDimension(int more) {{
    for(int i=0;i<more;i++) {
      if(get_bracks()==null) set_bracks(SquareBracketses.parse("[]"));
      else get_bracks().addElement(SquareBrackets.parse("[]"));
    }
  }}
}

/*
 *  Weaving Routines
 */

Weaver {

  traversal toWeaver(AspectSorter) { to Weaver; }

  void addCI(CodeFrag frag, Vector imports, Pack pack) to CodeFrags {
    start {{
      AdjustItem item = frag.get_adjustitem();
      if(item instanceof AddClass) {
	AddClass ac = (AddClass)item;
	ac.imports = (Vector)imports.clone();
	if(ac.get_pack() == null) ac.set_pack(pack);
      } else {
	AddInterface ai = (AddInterface)item;
	ai.imports = (Vector)imports.clone();
	if(ai.get_pack() == null) ai.set_pack(pack);
      }
    }}
    before CodeFrags {{ host.addElement(frag); }} // test for killing
  }

  void addAtt(AddAttribute item) via AddClass to ClassParts {
    around AddClass {{
      if(host.get_name().get_ident().equals(item.get_classname().get_ident()))
	subtraversal.apply();
    }}
    around ClassParts {{
      Enumeration newparts_enum = item.get_classparts().elements();
      while(newparts_enum.hasMoreElements())
	host.addElement((ClassPart)newparts_enum.nextElement());
    }}
  }

  void augMeth(AugmentMethod item) via ClassMethod to JavaCode {
    {{
     boolean found_class = false;
     boolean found_method = false;
     }}
    
    around AddClass {{
      if(host.get_name().get_ident().equals(item.long_get_classident())) {
	found_class = true;
	subtraversal.apply();
      }
    }}
    around ClassMethod {{
      if(host.matches(item.get_name())) {
	found_method = true;
	subtraversal.apply();
      }
    }}
    around JavaCode {{
      StringBuffer prev_method = new StringBuffer(host.get_text().toString());
      StringBuffer new_code =
	new StringBuffer(item.get_javacode().get_text().toString());
      if(item.get_insertplace() instanceof InsertBefore) {
	String meth = new String(new_code.append(prev_method));
	host.set_text(new Text(meth));
      }
      else { // InsertAfter
	String meth =
	  "\n    try { "+prev_method+"} finally { "+new_code+" }\n";
	host.set_text(new Text(meth));
      }
    }}
    finish {{
      if(!found_class) {
	StringBuffer sb = new StringBuffer();
	sb.append("Class "+item.long_get_classident()+" not found when trying"+
		  " to insert code ");
	if(item.get_insertplace() instanceof InsertBefore)
	  sb.append("before ");
	else sb.append("after ");
	sb.append(item.get_name()+".");
	Err.warn(sb.toString());
      }
      else if(!found_method) {
	StringBuffer sb = new StringBuffer();
	sb.append("Method not found when trying to insert code ");
	if(item.get_insertplace() instanceof InsertBefore)
          sb.append("before ");
        else sb.append("after ");
	sb.append(item.get_name()+".");
	Err.warn(sb.toString());
      }
    }}

  }

  void impInt(ImplementInterface item) via AddClass to ClassParentFeature {
    {{
     boolean found_class = false;
     }}
    around AddClass {{
      // check correct class;
      if(host.get_name().get_ident().
	 equals(item.get_classname().get_ident())) {
	found_class = true;
        subtraversal.apply();
      }
    }}

    before ClassParentFeature {{
      if(host.get_interfaces() == null) {
	host.set_interfaces(new Interfaces());
	host.get_interfaces().set_interfacenames(new ComListOfDotList());
      }
      host.get_interfaces().get_interfacenames().addElement(item.get_interfacename());
    }}

    finish {{
      if(!found_class) {
        Err.warn("Class "+item.get_classname()+" not found when trying"+
		 " to make it implement "+item.get_interfacename()+".");
      }
    }}
  }

  void renMeth(RenameMethod item) to ClassMethod {
    {{
     boolean found_class = false;
     boolean found_method = false;
     }}

    around AddClass {{
      if(host.get_name().get_ident().
	 equals(item.get_original().long_get_classident())) {
	found_class = true;
        subtraversal.apply();
      }
    }}

    before ClassMethod {{
      if(host.matches(item.get_original())) {
	found_method = true;
	if(item.get_renamed().get_vis() != null)
	  host.set_vis(item.get_renamed().get_vis());
	if(item.get_renamed().get_mods() != null)
	  host.set_mods(item.get_renamed().get_mods());
	if(item.get_renamed().get_type() != null)
	  host.set_type(item.get_renamed().get_type());
	host.set_name(item.get_renamed().get_name());
	if(item.get_renamed().get_args() != null)
	  host.long_set_args(item.get_renamed().get_args().get_arguments());
      }
    }}

    finish {{
      if(!found_class) Err.warn("Class "+item.long_get_classident()+
				" not found when trying to rename "+
				item.get_original()+" to "+
				item.get_renamed()+".");
      else
	if(!found_method) Err.warn("Method not found when trying to rename "+
				   item.get_original()+" to "+
				   item.get_renamed()+".");
    }}

  }

  traversal toSimples(OutputVisitor) {
    bypassing {AugmentMethod,AddAttribute,ImplementInterface,
	       RenameMethod,PackageSpec,ImportStatement,VarAssignment} to *;
  }

}

Weaver {
  Vector findCIParts(FullMethodName fmn) to {ParsableClassPart,InterfacePart} {
    // does not currently find interface parts
    {{Vector ret = new Vector();}}
    around AddClass {{
      if(host.get_name().get_ident().equals(fmn.long_get_classident()))
        subtraversal.apply();
    }}
    before ClassMethod {{
      if(host.matches(fmn)) ret.addElement(host);
    }}
    return {{ ret }}
  }

  AdjustItem getCI(String ci) to {AddClass,AddInterface} {
    before {AddClass,AddInterface} {{
      if(host.get_name().toString().equals(ci)) return_val = host;
    }}
  }
}

AddClass {
  String parentClassString() to ParentClass {
    before ParentClass {{ return_val = host.get_dottedname().toString(); }}
  }
}

ClassPart {
  void set_arguments(Arguments new_args) to ClassMethod {
    before ClassMethod {{ host.set_args(new_args); }}
  }
}

Arguments {
  void removeArgnames() to Argument {
    before Argument {{ host.set_varname(null); }}
  }
}

Argument {
  boolean matches(ArgumentType type) {{
    try {
      EqualVisitor eqv = new EqualVisitor(type.get_argtype());
      this.get_argtype().toAll(eqv);
      if(!eqv.get_is_equal()) return false;
      
      eqv = new EqualVisitor(this.get_argtype());
      type.get_argtype().toAll(eqv);
      if(!eqv.get_is_equal()) return false;
    } catch(NullPointerException e) {
      return false;
    }
    return true;
  }}
}

{MemberType,MethodArgTypes,FixVisibility,ArgumentTypes} {
  traversal toAll(EqualVisitor) { to *; }
}

{Visibility,Modifiers,MemberType,MethodName,Arguments,MethodThrows,
   MethodBody,ParentClass,Interfaces,FieldNameOptInit,FieldNameInit} {
  traversal toAllOut(OutputVisitor) { to *; }
}

{AugmentMethod,FullMethodName} {
  Ident long_get_methodident() to MethodName {
    {{ Ident return_val = null; }}
    before MethodName {{ return_val = host.get_ident(); }}
    return {{ return_val }}
  }
}

{AugmentMethod,FullMethodName,RenameMethod} {
  Ident long_get_classident() to ClassName {
    {{ Ident return_val = null; }}
    before ClassName {{ return_val = host.get_ident(); }}
    return {{ return_val }}
  }
}

ParsableClassPart {
  void long_set_args(Arguments new_args) to ClassMethod {
    before ClassMethod {{ host.set_arguments(new_args); }}
  }
  void long_set_body(JavaCode body) to ClassMethod {
    before ClassMethod {{
      host.set_body((MethodBody)FixMethodBody.
		    parse("("+"@"+body.get_text().toString()+"@"+")"));
    }}
  }
}

ClassMethod {
  boolean matches(FullMethodName name) {{
    if(name.get_genmethodname() instanceof MethodName &&
       !get_name().get_ident().equals(name.long_get_methodident())) {
      return false;
    }
    if(!isMethod()) return false;
    if(name.get_args() != null) {
      Enumeration pcp_enum = long_get_argEnum();
      Enumeration fmn_enum = name.long_get_argEnum();
      if(pcp_enum == null && fmn_enum == null) return true;
      if(pcp_enum == null || fmn_enum == null) {
	return false;
      }
      while(pcp_enum.hasMoreElements() && fmn_enum.hasMoreElements()) {
	Argument pcp_arg = (Argument)pcp_enum.nextElement();
	ArgumentType fmn_arg = (ArgumentType)fmn_enum.nextElement();
	if(!pcp_arg.matches(fmn_arg)) {
	  return false;
	}
      }
      if(pcp_enum.hasMoreElements() || fmn_enum.hasMoreElements()) {
	return false;
      }
    } 
    return true;
  }}

  int getModifiers() to {Visword,AModifier} {
    before PubOpt    {{ return_val |= Modifier.PUBLIC; }}
    before PrivOpt   {{ return_val |= Modifier.PRIVATE; }}
    before ProtOpt   {{ return_val |= Modifier.PROTECTED; }}
    before StaticOpt {{ return_val |= Modifier.STATIC; }}
    before FinalOpt  {{ return_val |= Modifier.FINAL; }}
    before SynchOpt  {{ return_val |= Modifier.SYNCHRONIZED; }}
    before TransOpt  {{ return_val |= Modifier.TRANSIENT; }}
    before VolOpt    {{ return_val |= Modifier.VOLATILE; }}
    before AbsOpt    {{ return_val |= Modifier.ABSTRACT; }}
    before NativeOpt {{ return_val |= Modifier.NATIVE; }}
  }
}

ParsableClassPart {
  Enumeration long_get_argEnum() to ClassMethod {
    {{Enumeration ret = null;}}
    before ClassMethod {{
      if(host.get_args() != null)
	ret = host.get_args().elements();
    }}
    return {{ ret }}
  }
  FixDataType long_get_return() via MemberType to FixDataType {
    {{FixDataType ret = null;}}
    before FixDataType {{ ret = host; }}
    return {{ ret }}
  }
  JavaCode long_get_body() to FixMethodBody {
    {{JavaCode ret = null;}}
    before FixMethodBody {{ ret = host.get_javacode(); }}
    return {{ ret }}
  }
}

FullMethodName {
  Enumeration long_get_argEnum() {{
    if(get_args() == null ||
       get_args().get_argumenttypes() == null) return null;
    return get_args().get_argumenttypes().elements();
  }}
}

{Arguments,ImportStatement,Pack,FullMethodName,FullMethodProto} {
  public String toString() {{
    StringWriter sw = new StringWriter();
    this.universal_trv0(new PrintVisitor(new PrintWriter(sw)));
    return sw.toString();
  }}
}

{ParsableClassPart,ParsableInterfacePart} {
  FixVisibility long_get_vis() to FixVisibility {
    before FixVisibility {{ return_val = host; }}
  }
  FixModifiers long_get_mods() to FixModifiers {
    before FixModifiers {{ return_val = host; }}
  }
  boolean isMethod() {{
    if((Object)this instanceof ClassMethod ||
       (Object)this instanceof InterfaceMethod) return true;
    return false;
  }}
}

FixVisibility {
  boolean equals(FixVisibility other) {{
    Visword this_vis = this.get_visword();
    Visword other_vis = other.get_visword();
    if(this_vis == null && other_vis == null) return true;
    if(this_vis == null || other_vis == null) return false;
    return this_vis.getClass().equals(other_vis.getClass());
  }}
}

FixDataType {
  public boolean equals(FixDataType other) {{
    StringWriter this_sw = new StringWriter();
    this.universal_trv0(new PrintVisitor(new PrintWriter(this_sw)));
    StringWriter that_sw = new StringWriter();
    other.universal_trv0(new PrintVisitor(new PrintWriter(that_sw)));
    return this_sw.toString().equals(that_sw.toString());
  }}
}

FixModifiers {
  boolean hasSubset(FixModifiers other) {{
    Enumeration subset_enum = other.elements();
    while(subset_enum.hasMoreElements())
      if(!this.contains((AModifier)subset_enum.nextElement()))
	return false;
    return true;
  }}
}

AModifier {
  public boolean equals(AModifier other) {{
    return this.getClass().equals(other.getClass());
  }}
}

AspectSorter {

  {{
  Weaver[] sorted_aspects;
  int current_aspect_num;
  String current_aspect;

  AspectSorter(int num) {
    this.sorted_aspects = new Weaver[num];
    this.current_aspect_num = 0;
  }
  }}

  before Weaver {{
    if(host.get_aspect().get_ident().toString().equals(current_aspect))
      sorted_aspects[current_aspect_num++] = host;
  }}

}

{AddClass,AddInterface} {
  {{Vector imports = null;}}
}

/*
 *  List o' Files
 */

Weaver {
  Vector fileList() { Weaver -> AddClass
		      AddClass -> AddClassName
		      Weaver -> AddInterface
		      AddInterface -> InterfaceName }
		      source: Weaver
		      target: {AddClassName,InterfaceName} {

    {{Vector ret = new Vector();}}

    before {AddClassName,InterfaceName} {{
      ret.addElement(new File(Weaver.outputdir, host.toString() + ".java"));
    }}

    return {{ ret}}
  }
}