code: /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements. See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership. The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the  "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /*
   * $Id$
   */
  
  package org.apache.xalan.xsltc.compiler;
  
  import java.util.Enumeration;
  
  import org.apache.xalan.xsltc.compiler.util.ClassGenerator;
  import org.apache.xalan.xsltc.compiler.util.ErrorMsg;
  import org.apache.xalan.xsltc.compiler.util.MethodGenerator;
  import org.apache.xalan.xsltc.compiler.util.Type;
  import org.apache.xalan.xsltc.compiler.util.TypeCheckError;
  import org.apache.xml.utils.SystemIDResolver;
  import org.xml.sax.InputSource;
  import org.xml.sax.XMLReader;
  
  /**
   * @author Jacek Ambroziak
   * @author Morten Jorgensen
   * @author Erwin Bolwidt <ejb@klomp.org>
   * @author Gunnlaugur Briem <gthb@dimon.is>
   */
  final class Include extends TopLevelElement {
  
      private Stylesheet _included = null;
  
      public Stylesheet getIncludedStylesheet() {
  	return _included;
      }
  
      public void parseContents(final Parser parser) {
  	XSLTC xsltc = parser.getXSLTC();
  	Stylesheet context = parser.getCurrentStylesheet();
          
  	String docToLoad = getAttribute("href");
  	try {
  	    if (context.checkForLoop(docToLoad)) {
  		final ErrorMsg msg = new ErrorMsg(ErrorMsg.CIRCULAR_INCLUDE_ERR,
                                                    docToLoad, this);
  		parser.reportError(Constants.FATAL, msg);
  		return;
  	    }
  
  	    InputSource input = null;
  	    XMLReader reader = null;
  	    String currLoadedDoc = context.getSystemId();
  	    SourceLoader loader = context.getSourceLoader();
              
              // Use SourceLoader if available
  	    if (loader != null) {
  		input = loader.loadSource(docToLoad, currLoadedDoc, xsltc);
                  if (input != null) {
                      docToLoad = input.getSystemId();
                      reader = xsltc.getXMLReader();
                  }
  	    }
  
              // No SourceLoader or not resolved by SourceLoader
              if (input == null) {
                  docToLoad = SystemIDResolver.getAbsoluteURI(docToLoad, currLoadedDoc);
                  input = new InputSource(docToLoad);
  	    }
  
  	    // Return if we could not resolve the URL
  	    if (input == null) {
  		final ErrorMsg msg = 
  		    new ErrorMsg(ErrorMsg.FILE_NOT_FOUND_ERR, docToLoad, this);
  		parser.reportError(Constants.FATAL, msg);
  		return;
  	    }
  
  	    final SyntaxTreeNode root;
              if (reader != null) {
                  root = parser.parse(reader,input);
              }
              else {
                  root = parser.parse(input);
              }
                
  	    if (root == null) return;
  	    _included = parser.makeStylesheet(root);
  	    if (_included == null) return;
  
  	    _included.setSourceLoader(loader);
  	    _included.setSystemId(docToLoad);
  	    _included.setParentStylesheet(context);
  	    _included.setIncludingStylesheet(context);
  	    _included.setTemplateInlining(context.getTemplateInlining());
  
  	    // An included stylesheet gets the same import precedence
  	    // as the stylesheet that included it.
  	    final int precedence = context.getImportPrecedence();
  	    _included.setImportPrecedence(precedence);
  	    parser.setCurrentStylesheet(_included);
  	    _included.parseContents(parser);
  
  	    final Enumeration elements = _included.elements();
  	    final Stylesheet topStylesheet = parser.getTopLevelStylesheet();
  	    while (elements.hasMoreElements()) {
  		final Object element = elements.nextElement();
  		if (element instanceof TopLevelElement) {
  		    if (element instanceof Variable) {
  			topStylesheet.addVariable((Variable) element);
  		    }
  		    else if (element instanceof Param) {
  			topStylesheet.addParam((Param) element);
  		    }
  		    else {
  			topStylesheet.addElement((TopLevelElement) element);
  		    }
  		}
  	    }
  	}
  	catch (Exception e) {
  	    e.printStackTrace();
  	}
  	finally {
  	    parser.setCurrentStylesheet(context);
  	}
      }
      
      public Type typeCheck(SymbolTable stable) throws TypeCheckError {
  	return Type.Void;
      }
      
      public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
  	// do nothing
      }
  }
  