plugins/org.eclipse.gymnast.generators.ecore/src/org/eclipse/gymnast/generators/ecore/convert/Grammar2Ecore.java - emfatic/org.eclipse.emfatic - Git at Google

 package org.eclipse.gymnast.generators.ecore.convert;

 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EAnnotation;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EEnum;
 import org.eclipse.emf.ecore.EEnumLiteral;
 import org.eclipse.emf.ecore.EModelElement;
 import org.eclipse.emf.ecore.EOperation;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EParameter;
 import org.eclipse.emf.ecore.EcoreFactory;
 import org.eclipse.emf.ecore.EcorePackage;
 import org.eclipse.gymnast.generators.ecore.cst.AltRuleAltsKind;
 import org.eclipse.gymnast.generators.ecore.cst.AltRuleCS;
 import org.eclipse.gymnast.generators.ecore.cst.RootCS;
 import org.eclipse.gymnast.generators.ecore.cst.RuleCS;
 import org.eclipse.gymnast.generators.ecore.cst.SeqRuleCS;
 import org.eclipse.gymnast.generators.ecore.cst.TokenRuleAltsKind;
 import org.eclipse.gymnast.generators.ecore.cst.TokenRuleCS;

 import sun.security.action.GetLongAction;

 public class Grammar2Ecore {

 	public RootCS c;
 	public final EPackage eP;

 	private static final String newLine = System.getProperty("line.separator");

 	private String unparseMethodBody = "";
 	private EClass ecorizer = null;
 	boolean genEcorizer = true;
 	boolean genUnparser = true;
 	boolean genPrettyPrinter = true;
 	private boolean addUmbrellaType;
 	private String umbrellaTypeName;

 	public Grammar2Ecore(RootCS c) {
 		assert c.isWellFormed();
 		this.c = c;
 		eP = EcoreFactory.eINSTANCE.createEPackage();
 		eP.setName(c.languageName);
 		eP.setNsPrefix(c.languageName);
 		eP.setNsURI(c.languageName);
 	}

 	private void createEnumsForTokenRulesWithFixedKeywords(EClass ecorizer) {
 		for (TokenRuleCS trCS : c.tokenRules) {
 			if (trCS.getKindOfAlts() == TokenRuleAltsKind.FIXED_KEYWORDS && !trCS.canBeRegardedAsBoolean()) {
 				List<String> enumLits = trCS.explodeTerminalAlternatives();
 				enumLits = unquote(enumLits);
 				EEnum enu = MyEcoreUtil.newEnum(eP, trCS.name, enumLits);
 				/* assign built textual representation for tokens */
 				for (EEnumLiteral eL : enu.getELiterals()) {
 					if (c.isBuiltInToken(eL.getName())) {
 						eL.setLiteral(RootCS.getValueOfBuiltInToken(eL.getName()));
 					}
 				}
 				/* notice that enu.name may differ from trCS.name */
 				trCS.enu = enu;
 				if (genEcorizer) {
 					new EcorizeOperation(trCS, enu, ecorizer, c);
 				}
 			}
 		}
 	}

 	public List<String> getTokenRulesWithFixedKeywords() {
 		List<String> res = new ArrayList<String>();
 		for (TokenRuleCS trCS : c.tokenRules) {
 			if (trCS.getKindOfAlts() == TokenRuleAltsKind.FIXED_KEYWORDS) {
 				res.add(trCS.name);
 			}
 		}
 		return res;
 	}

 	private void createEnumsForAltRulesWithFixedKeywords(EClass ecorizer) {
 		for (AltRuleCS arCS : c.altRules) {
 			if (arCS.getKindOfAlts() == AltRuleAltsKind.FIXED_KEYWORDS && !arCS.canBeRegardedAsBoolean()) {
 				List<String> enumLits = arCS.explodeTerminalAlternatives();
 				enumLits = unquote(enumLits);
 				EEnum enu = MyEcoreUtil.newEnum(eP, arCS.name, enumLits);
 				/* notice that enu.name may differ from arCS.name */
 				arCS.enu = enu;
 				if (genEcorizer) {
 					new EcorizeOperation(arCS, enu, ecorizer, c);
 				}
 			}
 		}
 	}

 	public List<String> getAltRulesWithFixedKeywords() {
 		List<String> res = new ArrayList<String>();
 		for (AltRuleCS arCS : c.altRules) {
 			if (arCS.getKindOfAlts() == AltRuleAltsKind.FIXED_KEYWORDS) {
 				res.add(arCS.name);
 			}
 		}
 		return res;
 	}

 	private List<String> unquote(List<String> enumLits) {
 		List<String> res = new ArrayList<String>();
 		for (String s : enumLits) {
 			if (s.startsWith("\"") && s.endsWith("\"")) {
 				s = s.substring(1, s.length() - 1);
 			}
 			res.add(s);
 		}
 		return res;
 	}

 	private String unquote(String s) {
 		String res = s.substring(1, s.length() - 1);
 		return res;
 	}

 	public void convert() {
 		convert(c.getOption_ecorizer(), c.getOption_unparser(), c.getOption_prettyPrinter(), c
 				.getOption_addUmbrellaType(), c.getOption_umbrellaTypeName());
 	}

 	public void convert(boolean genEcorizer, boolean genUnparser, boolean genPrettyPrinter, boolean addUmbrellaType,
 			String umbrellaTypeName) {

 		this.genEcorizer = genEcorizer;
 		this.genUnparser = genUnparser;
 		this.genPrettyPrinter = genPrettyPrinter;
 		this.addUmbrellaType = addUmbrellaType;
 		this.umbrellaTypeName = umbrellaTypeName;

 		/*
 		 * Before code generation proper, some in-memory maps are filled. As an
 		 * exception to the above, a few Java methods (ecorizers returning
 		 * enums) are generated while populating those maps.
 		 */
 		if (genEcorizer) {
 			ecorizer = MyEcoreUtil.newClass(eP, "Ecorizer", false, null);
 		}

 		createEnumsForTokenRulesWithFixedKeywords(ecorizer);
 		createEnumsForAltRulesWithFixedKeywords(ecorizer);

 		createEmptyClassesForSeqRules();
 		createEmptyClassesForAltRulesWithSeqItemsOnly();

 		/*
 		 * Most of the Java code generation is done from now on.
 		 *
 		 * For each SeqRule, an unparse() method (returning String) is added to
 		 * its Ecore-based counterpart.
 		 *
 		 * Along the way, the method body for an ecorizer method is also
 		 * generated (such method takes a Gymnast AST node as input, and
 		 * instantiates, populates and returns its Ecore-based counterpart).
 		 *
 		 */
 		new GenUnparseInhaleAndMMForSeqRules(ecorizer, c, this);

 		/*
 		 * The "big switch" is generated: a method that returns an instantiated
 		 * Ecore-based class given an AST node (i.e. given an instance of the
 		 * Gymnast-generated <languageName>ASTNode). This big switch invokes the
 		 * type-specific ecorizers generated before.
 		 *
 		 */
 		if (this.genEcorizer) {
 			new EcorizeOperation(ecorizer, c);
 		}

 		if (this.addUmbrellaType) {
 			String typeName = "umbrella" + c.languageName;
 			if (!c.getOption_umbrellaTypeName().equals("")) {
 				typeName = c.getOption_umbrellaTypeName();
 			}
 			addUmbrellaType(typeName);
 		}

 	}

 	/**
 	 *
 	 * add umbrella type over all productions (well, except enums). That
 	 * simplifies later writing an instanceof or adding a single method that all
 	 * AST nodes should support (e.g., prettyPrint() ).
 	 *
 	 */
 	private void addUmbrellaType(String typeName) {

 		EClassifier superType = null;
 		if (c.getOption_prettyPrinter()) {
 			/*
 			 * FIXME should make the umbrella type implement the interface
 			 * below. But en Ecore class (the created umbrella type) cannot have
 			 * an EDataType amongs its supertypes ...
 			 */
 			superType = EcorizeOperation.getEDataTypeForJavaClass(eP,
 					GenUnparseInhaleAndMMForSeqRules.jPPPrettyPrintable);
 		}

 		EClass umbrellaType = MyEcoreUtil.newClass(eP, typeName, true, null);
 		EList<EClassifier> cs = eP.getEClassifiers();
 		for (EClassifier classifier : cs) {
 			if (classifier instanceof EClass && classifier != ecorizer && classifier != umbrellaType) {
 				EClass clz = (EClass) classifier;
 				if (clz.getESuperTypes().isEmpty()) {
 					clz.getESuperTypes().add(umbrellaType);
 					assert MyEcoreUtil.isWellFormed(eP);
 				}
 			}
 		}
 	}

 	public static void newUnparseOperation(EClass eC, String unparseMethodBody) {
 		EOperation uOp = MyEcoreUtil.newOperation("unparse", eC, EcorePackage.eINSTANCE.getEString());
 		if (unparseMethodBody != null) {
 			/*
 			 * No method body is needed when adding just the signature of
 			 * unparse() to an abstract EClass (for example, those resulting
 			 * from AltRuleCS with kind CONTAINSSEQONLY
 			 */
 			MyEcoreUtil.newAnnotation(uOp, "http://www.eclipse.org/emf/2002/GenModel", "body", unparseMethodBody);
 		}
 	}

 	/**
 	 * Precondition: createEmptyClassesForSeqRules() has been called already.
 	 */
 	private void createEmptyClassesForAltRulesWithSeqItemsOnly() {
 		for (AltRuleCS arCS : c.altRules) {
 			if (arCS.getKindOfAlts() == AltRuleAltsKind.CONTAINSSEQ) {
 				EClass ecForAltRule = MyEcoreUtil.newClass(eP, arCS.name, true, null);
 				arCS.eClass = ecForAltRule;
 				// comment: the AltRule production
 				newGrammarRuleAnnotation(ecForAltRule, "AltRule", arCS.toString());
 				// unparse method signature
 				if (genUnparser) {
 					newUnparseOperation(ecForAltRule, null);
 				}
 				// classes for all SeqRule are available
 				List<String> constituentSeqs = arCS.alts;
 				for (String srName : constituentSeqs) {
 					EClass ecOfRefedSeqRule = c.getETypeForSeqRuleName(srName);
 					EList<EClass> ecRefedSupertypes = ecOfRefedSeqRule.getESuperTypes();
 					if (!ecRefedSupertypes.contains(ecForAltRule)) {
 						ecRefedSupertypes.add(ecForAltRule);
 					}
 				}
 			}
 		}
 	}

 	/**
 	 * Adds an annotation with source "gymnast" as a comment to ease tracing the
 	 * correspondence between grammar productions and the EClassifiers generated
 	 * for them.
 	 *
 	 * @param eAnnotated
 	 * @param ruleKind
 	 * @param ruleDefinition
 	 */
 	public static void newGrammarRuleAnnotation(EModelElement eAnnotated, String ruleKind, String ruleDefinition) {
 		MyEcoreUtil.newAnnotation(eAnnotated, "gymnast", ruleKind, ruleDefinition);
 	}

 	private void createEmptyClassesForSeqRules() {
 		for (SeqRuleCS srCS : c.seqRules) {
 			EClass ec = MyEcoreUtil.newClass(eP, srCS.name, false, null);
 			srCS.eClass = ec;
 			newGrammarRuleAnnotation(ec, "SeqRule", srCS.toString());
 		}
 	}

 	public static EOperation newEcorizeOperation(EClass ecorizer, RuleCS seqOrAltRule, EClass seqOrAltRuleEClass) {

 		// ------ operation ----------------------------------------------
 		EOperation eOp = MyEcoreUtil.newOperation("ecorize" + RootCS.camelCase(seqOrAltRule.name), ecorizer,
 				seqOrAltRuleEClass);

 		String inputArgJavaType = seqOrAltRule.getJavaFQNInGymnast();

 		// ------ parameter ----------------------------------------------
 		EParameter param = EcoreFactory.eINSTANCE.createEParameter();
 		param.setName("astNode");
 		EClassifier gymGenClass = EcorizeOperation.getEDataTypeForJavaClass(ecorizer.getEPackage(), inputArgJavaType);
 		param.setEType(gymGenClass);
 		eOp.getEParameters().add(param);

 		return eOp;
 	}

 	public static EAnnotation newMethodBodyAnnotation(EOperation eOp, String methodBody) {
 		EAnnotation res = MyEcoreUtil
 				.newAnnotation(eOp, "http://www.eclipse.org/emf/2002/GenModel", "body", methodBody);
 		return res;
 	}

 	public static EOperation newPrettyPrintOperation(EClass eC, String ppMethodBody) {
 		EClassifier gymPPBoxClass = EcorizeOperation.getEDataTypeForJavaClass(eC.getEPackage(), GenUnparseInhaleAndMMForSeqRules.jPPBox);
 		EOperation ppEOp = MyEcoreUtil.newOperation("prettyPrint", eC, gymPPBoxClass);
 		MyEcoreUtil.newAnnotation(ppEOp, "http://www.eclipse.org/emf/2002/GenModel", "body", ppMethodBody);
 		return ppEOp;
 	}

 }
	package org.eclipse.gymnast.generators.ecore.convert;

	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.ecore.EAnnotation;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EClassifier;
	import org.eclipse.emf.ecore.EEnum;
	import org.eclipse.emf.ecore.EEnumLiteral;
	import org.eclipse.emf.ecore.EModelElement;
	import org.eclipse.emf.ecore.EOperation;
	import org.eclipse.emf.ecore.EPackage;
	import org.eclipse.emf.ecore.EParameter;
	import org.eclipse.emf.ecore.EcoreFactory;
	import org.eclipse.emf.ecore.EcorePackage;
	import org.eclipse.gymnast.generators.ecore.cst.AltRuleAltsKind;
	import org.eclipse.gymnast.generators.ecore.cst.AltRuleCS;
	import org.eclipse.gymnast.generators.ecore.cst.RootCS;
	import org.eclipse.gymnast.generators.ecore.cst.RuleCS;
	import org.eclipse.gymnast.generators.ecore.cst.SeqRuleCS;
	import org.eclipse.gymnast.generators.ecore.cst.TokenRuleAltsKind;
	import org.eclipse.gymnast.generators.ecore.cst.TokenRuleCS;

	import sun.security.action.GetLongAction;

	public class Grammar2Ecore {

	public RootCS c;
	public final EPackage eP;

	private static final String newLine = System.getProperty("line.separator");

	private String unparseMethodBody = "";
	private EClass ecorizer = null;
	boolean genEcorizer = true;
	boolean genUnparser = true;
	boolean genPrettyPrinter = true;
	private boolean addUmbrellaType;
	private String umbrellaTypeName;

	public Grammar2Ecore(RootCS c) {
	assert c.isWellFormed();
	this.c = c;
	eP = EcoreFactory.eINSTANCE.createEPackage();
	eP.setName(c.languageName);
	eP.setNsPrefix(c.languageName);
	eP.setNsURI(c.languageName);
	}

	private void createEnumsForTokenRulesWithFixedKeywords(EClass ecorizer) {
	for (TokenRuleCS trCS : c.tokenRules) {
	if (trCS.getKindOfAlts() == TokenRuleAltsKind.FIXED_KEYWORDS && !trCS.canBeRegardedAsBoolean()) {
	List<String> enumLits = trCS.explodeTerminalAlternatives();
	enumLits = unquote(enumLits);
	EEnum enu = MyEcoreUtil.newEnum(eP, trCS.name, enumLits);
	/* assign built textual representation for tokens */
	for (EEnumLiteral eL : enu.getELiterals()) {
	if (c.isBuiltInToken(eL.getName())) {
	eL.setLiteral(RootCS.getValueOfBuiltInToken(eL.getName()));
	}
	}
	/* notice that enu.name may differ from trCS.name */
	trCS.enu = enu;
	if (genEcorizer) {
	new EcorizeOperation(trCS, enu, ecorizer, c);
	}
	}
	}
	}

	public List<String> getTokenRulesWithFixedKeywords() {
	List<String> res = new ArrayList<String>();
	for (TokenRuleCS trCS : c.tokenRules) {
	if (trCS.getKindOfAlts() == TokenRuleAltsKind.FIXED_KEYWORDS) {
	res.add(trCS.name);
	}
	}
	return res;
	}

	private void createEnumsForAltRulesWithFixedKeywords(EClass ecorizer) {
	for (AltRuleCS arCS : c.altRules) {
	if (arCS.getKindOfAlts() == AltRuleAltsKind.FIXED_KEYWORDS && !arCS.canBeRegardedAsBoolean()) {
	List<String> enumLits = arCS.explodeTerminalAlternatives();
	enumLits = unquote(enumLits);
	EEnum enu = MyEcoreUtil.newEnum(eP, arCS.name, enumLits);
	/* notice that enu.name may differ from arCS.name */
	arCS.enu = enu;
	if (genEcorizer) {
	new EcorizeOperation(arCS, enu, ecorizer, c);
	}
	}
	}
	}

	public List<String> getAltRulesWithFixedKeywords() {
	List<String> res = new ArrayList<String>();
	for (AltRuleCS arCS : c.altRules) {
	if (arCS.getKindOfAlts() == AltRuleAltsKind.FIXED_KEYWORDS) {
	res.add(arCS.name);
	}
	}
	return res;
	}

	private List<String> unquote(List<String> enumLits) {
	List<String> res = new ArrayList<String>();
	for (String s : enumLits) {
	if (s.startsWith("\"") && s.endsWith("\"")) {
	s = s.substring(1, s.length() - 1);
	}
	res.add(s);
	}
	return res;
	}

	private String unquote(String s) {
	String res = s.substring(1, s.length() - 1);
	return res;
	}

	public void convert() {
	convert(c.getOption_ecorizer(), c.getOption_unparser(), c.getOption_prettyPrinter(), c
	.getOption_addUmbrellaType(), c.getOption_umbrellaTypeName());
	}

	public void convert(boolean genEcorizer, boolean genUnparser, boolean genPrettyPrinter, boolean addUmbrellaType,
	String umbrellaTypeName) {

	this.genEcorizer = genEcorizer;
	this.genUnparser = genUnparser;
	this.genPrettyPrinter = genPrettyPrinter;
	this.addUmbrellaType = addUmbrellaType;
	this.umbrellaTypeName = umbrellaTypeName;

	/*
	* Before code generation proper, some in-memory maps are filled. As an
	* exception to the above, a few Java methods (ecorizers returning
	* enums) are generated while populating those maps.
	*/
	if (genEcorizer) {
	ecorizer = MyEcoreUtil.newClass(eP, "Ecorizer", false, null);
	}

	createEnumsForTokenRulesWithFixedKeywords(ecorizer);
	createEnumsForAltRulesWithFixedKeywords(ecorizer);

	createEmptyClassesForSeqRules();
	createEmptyClassesForAltRulesWithSeqItemsOnly();

	/*
	* Most of the Java code generation is done from now on.
	*
	* For each SeqRule, an unparse() method (returning String) is added to
	* its Ecore-based counterpart.
	*
	* Along the way, the method body for an ecorizer method is also
	* generated (such method takes a Gymnast AST node as input, and
	* instantiates, populates and returns its Ecore-based counterpart).
	*
	*/
	new GenUnparseInhaleAndMMForSeqRules(ecorizer, c, this);

	/*
	* The "big switch" is generated: a method that returns an instantiated
	* Ecore-based class given an AST node (i.e. given an instance of the
	* Gymnast-generated <languageName>ASTNode). This big switch invokes the
	* type-specific ecorizers generated before.
	*
	*/
	if (this.genEcorizer) {
	new EcorizeOperation(ecorizer, c);
	}

	if (this.addUmbrellaType) {
	String typeName = "umbrella" + c.languageName;
	if (!c.getOption_umbrellaTypeName().equals("")) {
	typeName = c.getOption_umbrellaTypeName();
	}
	addUmbrellaType(typeName);
	}

	}

	/**
	*
	* add umbrella type over all productions (well, except enums). That
	* simplifies later writing an instanceof or adding a single method that all
	* AST nodes should support (e.g., prettyPrint() ).
	*
	*/
	private void addUmbrellaType(String typeName) {

	EClassifier superType = null;
	if (c.getOption_prettyPrinter()) {
	/*
	* FIXME should make the umbrella type implement the interface
	* below. But en Ecore class (the created umbrella type) cannot have
	* an EDataType amongs its supertypes ...
	*/
	superType = EcorizeOperation.getEDataTypeForJavaClass(eP,
	GenUnparseInhaleAndMMForSeqRules.jPPPrettyPrintable);
	}

	EClass umbrellaType = MyEcoreUtil.newClass(eP, typeName, true, null);
	EList<EClassifier> cs = eP.getEClassifiers();
	for (EClassifier classifier : cs) {
	if (classifier instanceof EClass && classifier != ecorizer && classifier != umbrellaType) {
	EClass clz = (EClass) classifier;
	if (clz.getESuperTypes().isEmpty()) {
	clz.getESuperTypes().add(umbrellaType);
	assert MyEcoreUtil.isWellFormed(eP);
	}
	}
	}
	}

	public static void newUnparseOperation(EClass eC, String unparseMethodBody) {
	EOperation uOp = MyEcoreUtil.newOperation("unparse", eC, EcorePackage.eINSTANCE.getEString());
	if (unparseMethodBody != null) {
	/*
	* No method body is needed when adding just the signature of
	* unparse() to an abstract EClass (for example, those resulting
	* from AltRuleCS with kind CONTAINSSEQONLY
	*/
	MyEcoreUtil.newAnnotation(uOp, "http://www.eclipse.org/emf/2002/GenModel", "body", unparseMethodBody);
	}
	}

	/**
	* Precondition: createEmptyClassesForSeqRules() has been called already.
	*/
	private void createEmptyClassesForAltRulesWithSeqItemsOnly() {
	for (AltRuleCS arCS : c.altRules) {
	if (arCS.getKindOfAlts() == AltRuleAltsKind.CONTAINSSEQ) {
	EClass ecForAltRule = MyEcoreUtil.newClass(eP, arCS.name, true, null);
	arCS.eClass = ecForAltRule;
	// comment: the AltRule production
	newGrammarRuleAnnotation(ecForAltRule, "AltRule", arCS.toString());
	// unparse method signature
	if (genUnparser) {
	newUnparseOperation(ecForAltRule, null);
	}
	// classes for all SeqRule are available
	List<String> constituentSeqs = arCS.alts;
	for (String srName : constituentSeqs) {
	EClass ecOfRefedSeqRule = c.getETypeForSeqRuleName(srName);
	EList<EClass> ecRefedSupertypes = ecOfRefedSeqRule.getESuperTypes();
	if (!ecRefedSupertypes.contains(ecForAltRule)) {
	ecRefedSupertypes.add(ecForAltRule);
	}
	}
	}
	}
	}

	/**
	* Adds an annotation with source "gymnast" as a comment to ease tracing the
	* correspondence between grammar productions and the EClassifiers generated
	* for them.
	*
	* @param eAnnotated
	* @param ruleKind
	* @param ruleDefinition
	*/
	public static void newGrammarRuleAnnotation(EModelElement eAnnotated, String ruleKind, String ruleDefinition) {
	MyEcoreUtil.newAnnotation(eAnnotated, "gymnast", ruleKind, ruleDefinition);
	}

	private void createEmptyClassesForSeqRules() {
	for (SeqRuleCS srCS : c.seqRules) {
	EClass ec = MyEcoreUtil.newClass(eP, srCS.name, false, null);
	srCS.eClass = ec;
	newGrammarRuleAnnotation(ec, "SeqRule", srCS.toString());
	}
	}

	public static EOperation newEcorizeOperation(EClass ecorizer, RuleCS seqOrAltRule, EClass seqOrAltRuleEClass) {

	// ------ operation ----------------------------------------------
	EOperation eOp = MyEcoreUtil.newOperation("ecorize" + RootCS.camelCase(seqOrAltRule.name), ecorizer,
	seqOrAltRuleEClass);

	String inputArgJavaType = seqOrAltRule.getJavaFQNInGymnast();

	// ------ parameter ----------------------------------------------
	EParameter param = EcoreFactory.eINSTANCE.createEParameter();
	param.setName("astNode");
	EClassifier gymGenClass = EcorizeOperation.getEDataTypeForJavaClass(ecorizer.getEPackage(), inputArgJavaType);
	param.setEType(gymGenClass);
	eOp.getEParameters().add(param);

	return eOp;
	}

	public static EAnnotation newMethodBodyAnnotation(EOperation eOp, String methodBody) {
	EAnnotation res = MyEcoreUtil
	.newAnnotation(eOp, "http://www.eclipse.org/emf/2002/GenModel", "body", methodBody);
	return res;
	}

	public static EOperation newPrettyPrintOperation(EClass eC, String ppMethodBody) {
	EClassifier gymPPBoxClass = EcorizeOperation.getEDataTypeForJavaClass(eC.getEPackage(), GenUnparseInhaleAndMMForSeqRules.jPPBox);
	EOperation ppEOp = MyEcoreUtil.newOperation("prettyPrint", eC, gymPPBoxClass);
	MyEcoreUtil.newAnnotation(ppEOp, "http://www.eclipse.org/emf/2002/GenModel", "body", ppMethodBody);
	return ppEOp;
	}

	}