public class EmbeddingTest {
	private static int foo() {
		return <% one %>;
	}

	public static void main(String[] args) {
		System.out.println(foo());
	}
}

1

	protected class ScannerAdaptor playedBy Scanner {

		// access fields from Scanner ("callout bindings"):
		int getCurrentPosition() 	             -> get int currentPosition;
		void setCurrentPosition(int currentPosition) -> set int currentPosition;
		char[] getSource()                           -> get char[] source;

		// intercept this method from Scanner ("callin binding"):
		int getNextToken() <- replace int getNextToken();

		callin int getNextToken() throws InvalidInputException {
			// invoke the original method:
			int token = base.getNextToken();
			if (token == TerminalTokens.TokenNameLESS) {
				char[] source = getSource();
				int pos = getCurrentPosition();
				int start = pos+1; 
				if (source[pos] == '%') {
					try {
						while (source[++pos] != '%' || source[++pos] != '>') 
							; // empty
					} catch (ArrayIndexOutOfBoundsException aioobe) {
						return token;
					}
					int end = pos-1;
					char[] fragment = CharOperation.subarray(source, start, end);
					setCurrentPosition(pos + 1);
					// prepare an inner adaptor to intercept the expected parser action
					new InnerAdaptor(fragment, start, end).activate();
					return TerminalTokens.TokenNamenull;
				}
			}
			return token;
		}
	}

protected team class InnerAdaptor {		
	char[] source;
	int start, end;
	protected InnerAdaptor(char[] source, int start, int end) {
		this.source = source;
		this.start = start;
		this.end = end;
	}
	
	/** This inner role does the real work of the InnerAdaptor. */
	protected class ParserAdaptor playedBy Parser {
		// import methods from Parser ("callout bindings"):
		@SuppressWarnings("decapsulation")
		void pushOnExpressionStack(Expression expr) -> void pushOnExpressionStack(Expression expr);
			
		// intercept this method from Parser ("callin binding"):
		void consumeToken(int type) <- replace void consumeToken(int type);
		
		@SuppressWarnings("basecall")
		callin void consumeToken(int type) {
			if (type == TerminalTokens.TokenNamenull) {
				InnerAdaptor.this.deactivate(); // this inner adaptor has done its job, no longer intercept
				// TODO analyse source to find what AST should be created
				Expression replacement = new CustomIntLiteral(source, start, end);
				// feed custom AST into the parser:
				this.pushOnExpressionStack(replacement);
				return;
			}
			// shouldn't happen: only activated when scanner returns TokenNamenull
			base.consumeToken(type);
		}
	}		
}

<extension
         point="org.objectteams.otequinox.aspectBindings">
      <aspectBinding
            icon="platform:/plugin/org.objectteams.otdt.ui/icons/ot/calloutbinding_obj.gif">
         <basePlugin
               icon="platform:/plugin/org.eclipse.pde.ui/icons/obj16/plugin_obj.gif"
               id="org.eclipse.jdt.core">
         </basePlugin>
         <team
               activation="ALL_THREADS"
               class="embedding.jdt.SyntaxAdaptor"
               icon="platform:/plugin/org.objectteams.otdt.ui/icons/ot/team_obj.gif">
         </team>
         <team
               activation="NONE"
               class="embedding.jdt.SyntaxAdaptor$__OT__InnerAdaptor"
               icon="platform:/plugin/org.objectteams.otdt.ui/icons/ot/team_obj.gif">
         </team>
      </aspectBinding>
   </extension>

	protected class DomConverterAdaptor playedBy ASTConverter {
		/*
		 * Callout
		 */
		void removeLeadingAndTrailingCommentsFromLiteral(
				DomCustomIntLiteral node)
		->
		void removeLeadingAndTrailingCommentsFromLiteral(ASTNode node);
		void recordNodes(DomCustomIntLiteral node,
				org.eclipse.jdt.internal.compiler.ast.ASTNode oldASTNode)		->
		void recordNodes(ASTNode node,
				org.eclipse.jdt.internal.compiler.ast.ASTNode oldASTNode);
		boolean getResolveBindings() -> get boolean resolveBindings;
		char[] getCompilationUnitSource() -> get char[] compilationUnitSource;
		AST getAst() -> get AST ast;

		Expression convert(org.eclipse.jdt.internal.compiler.ast.Expression expression) <- replace Expression convert(org.eclipse.jdt.internal.compiler.ast.Expression expression);
		
		callin Expression convert(org.eclipse.jdt.internal.compiler.ast.Expression expression){
			if (expression instanceof CustomIntLiteral) {
				return convertCustomIntLiteral((CustomIntLiteral) expression);
			}
			return base.convert(expression);
		}
		
                // HERE IS THE INTERESTING PART
		private DomCustomIntLiteral convertCustomIntLiteral(CustomIntLiteral expression){
			int length = expression.sourceEnd - expression.sourceStart + 1;	
			int sourceStart = expression.sourceStart;
			final DomCustomIntLiteral literal = new DomCustomIntLiteral(this.getAst());
			literal.internalSetToken(new String(this.getCompilationUnitSource(), sourceStart, length));
			if (this.getResolveBindings()) {
				this.recordNodes(literal, expression);
			}
			literal.setSourceRange(sourceStart, length);
			removeLeadingAndTrailingCommentsFromLiteral(literal);
			return literal;			
		}
	}

	protected class DomCustomIntLiteral playedBy NumberLiteral {
		
		/*
		 * Callout
		 */
		internalSetToken -> internalSetToken;
		setSourceRange -> setSourceRange;
		
		public DomCustomIntLiteral(AST ast){
			base(ast);
		}
			
		protected abstract void internalSetToken(String string);
		protected abstract void setSourceRange(int sourceStart, int length);
	}