public class XMLErrorResources_tr extends ListResourceBundle
{

/*
 * This file contains error and warning messages related to Xalan Error
 * Handling.
 *
 *  General notes to translators:
 *
 *  1) Xalan (or more properly, Xalan-interpretive) and XSLTC are names of
 *     components.
 *     XSLT is an acronym for "XML Stylesheet Language: Transformations".
 *     XSLTC is an acronym for XSLT Compiler.
 *
 *  2) A stylesheet is a description of how to transform an input XML document
 *     into a resultant XML document (or HTML document or text).  The
 *     stylesheet itself is described in the form of an XML document.
 *
 *  3) A template is a component of a stylesheet that is used to match a
 *     particular portion of an input document and specifies the form of the
 *     corresponding portion of the output document.
 *
 *  4) An element is a mark-up tag in an XML document; an attribute is a
 *     modifier on the tag.  For example, in <elem attr='val' attr2='val2'>
 *     "elem" is an element name, "attr" and "attr2" are attribute names with
 *     the values "val" and "val2", respectively.
 *
 *  5) A namespace declaration is a special attribute that is used to associate
 *     a prefix with a URI (the namespace).  The meanings of element names and
 *     attribute names that use that prefix are defined with respect to that
 *     namespace.
 *
 *  6) "Translet" is an invented term that describes the class file that
 *     results from compiling an XML stylesheet into a Java class.
 *
 *  7) XPath is a specification that describes a notation for identifying
 *     nodes in a tree-structured representation of an XML document.  An
 *     instance of that notation is referred to as an XPath expression.
 *
 */

  /** Maximum error messages, this is needed to keep track of the number of messages.    */
  public static final int MAX_CODE = 61;

  /** Maximum warnings, this is needed to keep track of the number of warnings.          */
  public static final int MAX_WARNING = 0;

  /** Maximum misc strings.   */
  public static final int MAX_OTHERS = 4;

  /** Maximum total warnings and error messages.          */
  public static final int MAX_MESSAGES = MAX_CODE + MAX_WARNING + 1;

  /*
   * Message keys
   */
  public static final String ER_FUNCTION_NOT_SUPPORTED = "ER_FUNCTION_NOT_SUPPORTED";
  public static final String ER_CANNOT_OVERWRITE_CAUSE = "ER_CANNOT_OVERWRITE_CAUSE";
  public static final String ER_NO_DEFAULT_IMPL = "ER_NO_DEFAULT_IMPL";
  public static final String ER_CHUNKEDINTARRAY_NOT_SUPPORTED = "ER_CHUNKEDINTARRAY_NOT_SUPPORTED";
  public static final String ER_OFFSET_BIGGER_THAN_SLOT = "ER_OFFSET_BIGGER_THAN_SLOT";
  public static final String ER_COROUTINE_NOT_AVAIL = "ER_COROUTINE_NOT_AVAIL";
  public static final String ER_COROUTINE_CO_EXIT = "ER_COROUTINE_CO_EXIT";
  public static final String ER_COJOINROUTINESET_FAILED = "ER_COJOINROUTINESET_FAILED";
  public static final String ER_COROUTINE_PARAM = "ER_COROUTINE_PARAM";
  public static final String ER_PARSER_DOTERMINATE_ANSWERS = "ER_PARSER_DOTERMINATE_ANSWERS";
  public static final String ER_NO_PARSE_CALL_WHILE_PARSING = "ER_NO_PARSE_CALL_WHILE_PARSING";
  public static final String ER_TYPED_ITERATOR_AXIS_NOT_IMPLEMENTED = "ER_TYPED_ITERATOR_AXIS_NOT_IMPLEMENTED";
  public static final String ER_ITERATOR_AXIS_NOT_IMPLEMENTED = "ER_ITERATOR_AXIS_NOT_IMPLEMENTED";
  public static final String ER_ITERATOR_CLONE_NOT_SUPPORTED = "ER_ITERATOR_CLONE_NOT_SUPPORTED";
  public static final String ER_UNKNOWN_AXIS_TYPE = "ER_UNKNOWN_AXIS_TYPE";
  public static final String ER_AXIS_NOT_SUPPORTED = "ER_AXIS_NOT_SUPPORTED";
  public static final String ER_NO_DTMIDS_AVAIL = "ER_NO_DTMIDS_AVAIL";
  public static final String ER_NOT_SUPPORTED = "ER_NOT_SUPPORTED";
  public static final String ER_NODE_NON_NULL = "ER_NODE_NON_NULL";
  public static final String ER_COULD_NOT_RESOLVE_NODE = "ER_COULD_NOT_RESOLVE_NODE";
  public static final String ER_STARTPARSE_WHILE_PARSING = "ER_STARTPARSE_WHILE_PARSING";
  public static final String ER_STARTPARSE_NEEDS_SAXPARSER = "ER_STARTPARSE_NEEDS_SAXPARSER";
  public static final String ER_COULD_NOT_INIT_PARSER = "ER_COULD_NOT_INIT_PARSER";
  public static final String ER_EXCEPTION_CREATING_POOL = "ER_EXCEPTION_CREATING_POOL";
  public static final String ER_PATH_CONTAINS_INVALID_ESCAPE_SEQUENCE = "ER_PATH_CONTAINS_INVALID_ESCAPE_SEQUENCE";
  public static final String ER_SCHEME_REQUIRED = "ER_SCHEME_REQUIRED";
  public static final String ER_NO_SCHEME_IN_URI = "ER_NO_SCHEME_IN_URI";
  public static final String ER_NO_SCHEME_INURI = "ER_NO_SCHEME_INURI";
  public static final String ER_PATH_INVALID_CHAR = "ER_PATH_INVALID_CHAR";
  public static final String ER_SCHEME_FROM_NULL_STRING = "ER_SCHEME_FROM_NULL_STRING";
  public static final String ER_SCHEME_NOT_CONFORMANT = "ER_SCHEME_NOT_CONFORMANT";
  public static final String ER_HOST_ADDRESS_NOT_WELLFORMED = "ER_HOST_ADDRESS_NOT_WELLFORMED";
  public static final String ER_PORT_WHEN_HOST_NULL = "ER_PORT_WHEN_HOST_NULL";
  public static final String ER_INVALID_PORT = "ER_INVALID_PORT";
  public static final String ER_FRAG_FOR_GENERIC_URI ="ER_FRAG_FOR_GENERIC_URI";
  public static final String ER_FRAG_WHEN_PATH_NULL = "ER_FRAG_WHEN_PATH_NULL";
  public static final String ER_FRAG_INVALID_CHAR = "ER_FRAG_INVALID_CHAR";
  public static final String ER_PARSER_IN_USE = "ER_PARSER_IN_USE";
  public static final String ER_CANNOT_CHANGE_WHILE_PARSING = "ER_CANNOT_CHANGE_WHILE_PARSING";
  public static final String ER_SELF_CAUSATION_NOT_PERMITTED = "ER_SELF_CAUSATION_NOT_PERMITTED";
  public static final String ER_NO_USERINFO_IF_NO_HOST = "ER_NO_USERINFO_IF_NO_HOST";
  public static final String ER_NO_PORT_IF_NO_HOST = "ER_NO_PORT_IF_NO_HOST";
  public static final String ER_NO_QUERY_STRING_IN_PATH = "ER_NO_QUERY_STRING_IN_PATH";
  public static final String ER_NO_FRAGMENT_STRING_IN_PATH = "ER_NO_FRAGMENT_STRING_IN_PATH";
  public static final String ER_CANNOT_INIT_URI_EMPTY_PARMS = "ER_CANNOT_INIT_URI_EMPTY_PARMS";
  public static final String ER_METHOD_NOT_SUPPORTED ="ER_METHOD_NOT_SUPPORTED";
  public static final String ER_INCRSAXSRCFILTER_NOT_RESTARTABLE = "ER_INCRSAXSRCFILTER_NOT_RESTARTABLE";
  public static final String ER_XMLRDR_NOT_BEFORE_STARTPARSE = "ER_XMLRDR_NOT_BEFORE_STARTPARSE";
  public static final String ER_AXIS_TRAVERSER_NOT_SUPPORTED = "ER_AXIS_TRAVERSER_NOT_SUPPORTED";
  public static final String ER_ERRORHANDLER_CREATED_WITH_NULL_PRINTWRITER = "ER_ERRORHANDLER_CREATED_WITH_NULL_PRINTWRITER";
  public static final String ER_SYSTEMID_UNKNOWN = "ER_SYSTEMID_UNKNOWN";
  public static final String ER_LOCATION_UNKNOWN = "ER_LOCATION_UNKNOWN";
  public static final String ER_PREFIX_MUST_RESOLVE = "ER_PREFIX_MUST_RESOLVE";
  public static final String ER_CREATEDOCUMENT_NOT_SUPPORTED = "ER_CREATEDOCUMENT_NOT_SUPPORTED";
  public static final String ER_CHILD_HAS_NO_OWNER_DOCUMENT = "ER_CHILD_HAS_NO_OWNER_DOCUMENT";
  public static final String ER_CHILD_HAS_NO_OWNER_DOCUMENT_ELEMENT = "ER_CHILD_HAS_NO_OWNER_DOCUMENT_ELEMENT";
  public static final String ER_CANT_OUTPUT_TEXT_BEFORE_DOC = "ER_CANT_OUTPUT_TEXT_BEFORE_DOC";
  public static final String ER_CANT_HAVE_MORE_THAN_ONE_ROOT = "ER_CANT_HAVE_MORE_THAN_ONE_ROOT";
  public static final String ER_ARG_LOCALNAME_NULL = "ER_ARG_LOCALNAME_NULL";
  public static final String ER_ARG_LOCALNAME_INVALID = "ER_ARG_LOCALNAME_INVALID";
  public static final String ER_ARG_PREFIX_INVALID = "ER_ARG_PREFIX_INVALID";

  public static final String ER_RESOURCE_COULD_NOT_FIND = "ER_RESOURCE_COULD_NOT_FIND";
  public static final String ER_RESOURCE_COULD_NOT_LOAD = "ER_RESOURCE_COULD_NOT_LOAD";
  public static final String ER_BUFFER_SIZE_LESSTHAN_ZERO = "ER_BUFFER_SIZE_LESSTHAN_ZERO";
  public static final String ER_INVALID_UTF16_SURROGATE = "ER_INVALID_UTF16_SURROGATE";
  public static final String ER_OIERROR = "ER_OIERROR";
  public static final String ER_NAMESPACE_PREFIX = "ER_NAMESPACE_PREFIX";
  public static final String ER_STRAY_ATTRIBUTE = "ER_STRAY_ATTIRBUTE";
  public static final String ER_STRAY_NAMESPACE = "ER_STRAY_NAMESPACE";
  public static final String ER_COULD_NOT_LOAD_RESOURCE = "ER_COULD_NOT_LOAD_RESOURCE";
  public static final String ER_COULD_NOT_LOAD_METHOD_PROPERTY = "ER_COULD_NOT_LOAD_METHOD_PROPERTY";
  public static final String ER_SERIALIZER_NOT_CONTENTHANDLER = "ER_SERIALIZER_NOT_CONTENTHANDLER";
  public static final String ER_ILLEGAL_ATTRIBUTE_POSITION = "ER_ILLEGAL_ATTRIBUTE_POSITION";

  /*
   * Now fill in the message text.
   * Then fill in the message text for that message code in the
   * array. Use the new error code as the index into the array.
   */

  /**
   * Get the lookup table for error messages
   *
   * @return The association list.
   */
  public Object[][] getContents()
  {
    return new Object[][] {

  /** Error message ID that has a null message, but takes in a single object.    */
    {"ER0000" , "{0}" },

    { ER_FUNCTION_NOT_SUPPORTED,
      "\u0130\u015flev desteklenmiyor!"},

    { ER_CANNOT_OVERWRITE_CAUSE,
      "Nedenin \u00fczerine yaz\u0131lamaz"},

    { ER_NO_DEFAULT_IMPL,
      "Varsay\u0131lan uygulama bulunamad\u0131"},

    { ER_CHUNKEDINTARRAY_NOT_SUPPORTED,
      "ChunkedIntArray({0}) \u015fu an desteklenmiyor"},

    { ER_OFFSET_BIGGER_THAN_SLOT,
      "G\u00f6reli konum yuvadan b\u00fcy\u00fck"},

    { ER_COROUTINE_NOT_AVAIL,
      "Coroutine kullan\u0131lam\u0131yor, id={0}"},

    { ER_COROUTINE_CO_EXIT,
      "CoroutineManager co_exit() iste\u011fi ald\u0131"},

    { ER_COJOINROUTINESET_FAILED,
      "co_joinCoroutineSet() ba\u015far\u0131s\u0131z oldu"},

    { ER_COROUTINE_PARAM,
      "Coroutine de\u011fi\u015ftirgesi hatas\u0131 ({0})"},

    { ER_PARSER_DOTERMINATE_ANSWERS,
      "\nBEKLENMEYEN: Parser doTerminate yan\u0131t\u0131 {0}"},

    { ER_NO_PARSE_CALL_WHILE_PARSING,
      "Ayr\u0131\u015ft\u0131rma s\u0131ras\u0131nda parse \u00e7a\u011fr\u0131lamaz"},

    { ER_TYPED_ITERATOR_AXIS_NOT_IMPLEMENTED,
      "Hata: {0} ekseni i\u00e7in tip atanm\u0131\u015f yineleyici ger\u00e7ekle\u015ftirilmedi"},

    { ER_ITERATOR_AXIS_NOT_IMPLEMENTED,
      "Hata: {0} ekseni i\u00e7in yineleyici ger\u00e7ekle\u015ftirilmedi"},

    { ER_ITERATOR_CLONE_NOT_SUPPORTED,
      "Yineleyici e\u015fkopyas\u0131 desteklenmiyor"},

    { ER_UNKNOWN_AXIS_TYPE,
      "Bilinmeyen eksen dola\u015fma tipi: {0}"},

    { ER_AXIS_NOT_SUPPORTED,
      "Eksen dola\u015f\u0131c\u0131 desteklenmiyor: {0}"},

    { ER_NO_DTMIDS_AVAIL,
      "Kullan\u0131labilecek ba\u015fka DTM tan\u0131t\u0131c\u0131s\u0131 yok"},

    { ER_NOT_SUPPORTED,
      "Desteklenmiyor: {0}"},

    { ER_NODE_NON_NULL,
      "getDTMHandleFromNode i\u00e7in d\u00fc\u011f\u00fcm bo\u015f de\u011ferli olmamal\u0131d\u0131r"},

    { ER_COULD_NOT_RESOLVE_NODE,
      "D\u00fc\u011f\u00fcm tan\u0131t\u0131c\u0131 de\u011fere \u00e7\u00f6z\u00fclemedi"},

    { ER_STARTPARSE_WHILE_PARSING,
       "Ayr\u0131\u015ft\u0131rma s\u0131ras\u0131nda startParse \u00e7a\u011fr\u0131lamaz"},

    { ER_STARTPARSE_NEEDS_SAXPARSER,
       "startParse i\u00e7in bo\u015f de\u011ferli olmayan SAXParser gerekiyor"},

    { ER_COULD_NOT_INIT_PARSER,
       "Ayr\u0131\u015ft\u0131r\u0131c\u0131 bununla kullan\u0131ma haz\u0131rlanamad\u0131"},

    { ER_EXCEPTION_CREATING_POOL,
       "Havuz i\u00e7in yeni \u00f6rnek yarat\u0131l\u0131rken kural d\u0131\u015f\u0131 durum"},

    { ER_PATH_CONTAINS_INVALID_ESCAPE_SEQUENCE,
       "Yol ge\u00e7ersiz ka\u00e7\u0131\u015f dizisi i\u00e7eriyor"},

    { ER_SCHEME_REQUIRED,
       "\u015eema gerekli!"},

    { ER_NO_SCHEME_IN_URI,
       "URI i\u00e7inde \u015fema bulunamad\u0131: {0}"},

    { ER_NO_SCHEME_INURI,
       "URI i\u00e7inde \u015fema bulunamad\u0131"},

    { ER_PATH_INVALID_CHAR,
       "Yol ge\u00e7ersiz karakter i\u00e7eriyor: {0}"},

    { ER_SCHEME_FROM_NULL_STRING,
       "Bo\u015f de\u011ferli dizgiden \u015fema tan\u0131mlanamaz"},

    { ER_SCHEME_NOT_CONFORMANT,
       "\u015eema uyumlu de\u011fil."},

    { ER_HOST_ADDRESS_NOT_WELLFORMED,
       "Anasistem do\u011fru bi\u00e7imli bir adres de\u011fil"},

    { ER_PORT_WHEN_HOST_NULL,
       "Anasistem bo\u015f de\u011ferliyken kap\u0131 tan\u0131mlanamaz"},

    { ER_INVALID_PORT,
       "Kap\u0131 numaras\u0131 ge\u00e7ersiz"},

    { ER_FRAG_FOR_GENERIC_URI,
       "Par\u00e7a yaln\u0131zca soysal URI i\u00e7in tan\u0131mlanabilir"},

    { ER_FRAG_WHEN_PATH_NULL,
       "Yol bo\u015f de\u011ferliyken par\u00e7a tan\u0131mlanamaz"},

    { ER_FRAG_INVALID_CHAR,
       "Par\u00e7a ge\u00e7ersiz karakter i\u00e7eriyor"},

    { ER_PARSER_IN_USE,
      "Ayr\u0131\u015ft\u0131r\u0131c\u0131 kullan\u0131mda"},

    { ER_CANNOT_CHANGE_WHILE_PARSING,
      "Ayr\u0131\u015ft\u0131rma s\u0131ras\u0131nda {0} {1} de\u011fi\u015ftirilemez"},

    { ER_SELF_CAUSATION_NOT_PERMITTED,
      "\u00d6znedenselli\u011fe izin verilmez"},

    { ER_NO_USERINFO_IF_NO_HOST,
      "Anasistem belirtilmediyse kullan\u0131c\u0131 bilgisi belirtilemez"},

    { ER_NO_PORT_IF_NO_HOST,
      "Anasistem belirtilmediyse kap\u0131 belirtilemez"},

    { ER_NO_QUERY_STRING_IN_PATH,
      "Yol ve sorgu dizgisinde sorgu dizgisi belirtilemez"},

    { ER_NO_FRAGMENT_STRING_IN_PATH,
      "Par\u00e7a hem yolda, hem de par\u00e7ada belirtilemez"},

    { ER_CANNOT_INIT_URI_EMPTY_PARMS,
      "Bo\u015f de\u011fi\u015ftirgelerle URI kullan\u0131ma haz\u0131rlanamaz"},

    { ER_METHOD_NOT_SUPPORTED,
      "Y\u00f6ntem hen\u00fcz desteklenmiyor"},

    { ER_INCRSAXSRCFILTER_NOT_RESTARTABLE,
      "IncrementalSAXSource_Filter \u015fu an yeniden ba\u015flat\u0131labilir durumda de\u011fil"},

    { ER_XMLRDR_NOT_BEFORE_STARTPARSE,
      "XMLReader, startParse iste\u011finden \u00f6nce olmaz"},

    { ER_AXIS_TRAVERSER_NOT_SUPPORTED,
      "Eksen dola\u015f\u0131c\u0131 desteklenmiyor: {0}"},

    { ER_ERRORHANDLER_CREATED_WITH_NULL_PRINTWRITER,
      "ListingErrorHandler bo\u015f de\u011ferli PrintWriter ile yarat\u0131ld\u0131!"},

    { ER_SYSTEMID_UNKNOWN,
      "SystemId bilinmiyor"},

    { ER_LOCATION_UNKNOWN,
      "Hata yeri bilinmiyor"},

    { ER_PREFIX_MUST_RESOLVE,
      "\u00d6nek bir ad alan\u0131na \u00e7\u00f6z\u00fclmelidir: {0}"},

    { ER_CREATEDOCUMENT_NOT_SUPPORTED,
      "XPathContext i\u00e7inde createDocument() desteklenmiyor!"},

    { ER_CHILD_HAS_NO_OWNER_DOCUMENT,
      "\u00d6zniteli\u011fin alt \u00f6\u011fesinin iye belgesi yok!"},

    { ER_CHILD_HAS_NO_OWNER_DOCUMENT_ELEMENT,
      "\u00d6zniteli\u011fin alt \u00f6\u011fesinin iye belge \u00f6\u011fesi yok!"},

    { ER_CANT_OUTPUT_TEXT_BEFORE_DOC,
      "Uyar\u0131: Belge \u00f6\u011fesinden \u00f6nce metin \u00e7\u0131k\u0131\u015f\u0131 olamaz!  Yoksay\u0131l\u0131yor..."},

    { ER_CANT_HAVE_MORE_THAN_ONE_ROOT,
      "DOM \u00fczerinde birden fazla k\u00f6k olamaz!"},

    { ER_ARG_LOCALNAME_NULL,
       "'localName' ba\u011f\u0131ms\u0131z de\u011fi\u015ftirgesi bo\u015f de\u011ferli"},

    { ER_ARG_LOCALNAME_INVALID,
       "QNAME i\u00e7indeki yerel ad (localname) ge\u00e7erli bir NCName olmal\u0131d\u0131r"},

    { ER_ARG_PREFIX_INVALID,
       "QNAME i\u00e7indeki \u00f6nek ge\u00e7erli bir NCName olmal\u0131d\u0131r"},

    { "BAD_CODE", "createMessage i\u00e7in kullan\u0131lan de\u011fi\u015ftirge s\u0131n\u0131rlar\u0131n d\u0131\u015f\u0131nda"},
    { "FORMAT_FAILED", "messageFormat \u00e7a\u011fr\u0131s\u0131 s\u0131ras\u0131nda kural d\u0131\u015f\u0131 durum yay\u0131nland\u0131"},
    { "line", "Sat\u0131r #"},
    { "column","Kolon #"},

    {ER_SERIALIZER_NOT_CONTENTHANDLER,
      "Diziselle\u015ftirici s\u0131n\u0131f\u0131 ''{0}'' org.xml.sax.ContentHandler i\u015flevini uygulam\u0131yor."},

    {ER_RESOURCE_COULD_NOT_FIND,
      "Kaynak [ {0} ] bulunamad\u0131.\n {1}" },

    {ER_RESOURCE_COULD_NOT_LOAD,
      "Kaynak [ {0} ] y\u00fckleyemedi: {1} \n {2} \t {3}" },

    {ER_BUFFER_SIZE_LESSTHAN_ZERO,
      "Arabellek b\u00fcy\u00fckl\u00fc\u011f\u00fc <=0" },

    {ER_INVALID_UTF16_SURROGATE,
      "UTF-16 yerine kullan\u0131lan de\u011fer ge\u00e7ersiz: {0} ?" },

    {ER_OIERROR,
      "G\u00c7 hatas\u0131" },

    {ER_ILLEGAL_ATTRIBUTE_POSITION,
      "Alt d\u00fc\u011f\u00fcmlerden sonra ya da bir \u00f6\u011fe \u00fcretilmeden \u00f6nce {0} \u00f6zniteli\u011fi eklenemez. \u00d6znitelik yoksay\u0131lacak."},

      /*
       * Note to translators:  The stylesheet contained a reference to a
       * namespace prefix that was undefined.  The value of the substitution
       * text is the name of the prefix.
       */
    {ER_NAMESPACE_PREFIX,
      "''{0}'' \u00f6nekine ili\u015fkin ad alan\u0131 bildirilmedi." },
      /*
       * Note to translators:  This message is reported if the stylesheet
       * being processed attempted to construct an XML document with an
       * attribute in a place other than on an element.  The substitution text
       * specifies the name of the attribute.
       */
    {ER_STRAY_ATTRIBUTE,
      "''{0}'' \u00f6zniteli\u011fi \u00f6\u011fenin d\u0131\u015f\u0131nda." },

      /*
       * Note to translators:  As with the preceding message, a namespace
       * declaration has the form of an attribute and is only permitted to
       * appear on an element.  The substitution text {0} is the namespace
       * prefix and {1} is the URI that was being used in the erroneous
       * namespace declaration.
       */
    {ER_STRAY_NAMESPACE,
      "''{0}''=''{1}'' ad alan\u0131 bildirimi \u00f6\u011fenin d\u0131\u015f\u0131nda." },

    {ER_COULD_NOT_LOAD_RESOURCE,
      "''{0}'' y\u00fcklenemedi (CLASSPATH de\u011fi\u015fkeninizi inceleyin), yaln\u0131zca varsay\u0131lanlar kullan\u0131l\u0131yor"},

    {ER_COULD_NOT_LOAD_METHOD_PROPERTY,
      "''{1}'' \u00e7\u0131k\u0131\u015f y\u00f6ntemi i\u00e7in ''{0}'' \u00f6zellik dosyas\u0131 y\u00fcklenemedi (CLASSPATH de\u011fi\u015fkenini inceleyin)" }

  };
  }

  /**
   *   Return a named ResourceBundle for a particular locale.  This method mimics the behavior
   *   of ResourceBundle.getBundle().
   *
   *   @param className the name of the class that implements the resource bundle.
   *   @return the ResourceBundle
   *   @throws MissingResourceException
   */
  public static final XMLErrorResources loadResourceBundle(String className)
          throws MissingResourceException
  {

    Locale locale = Locale.getDefault();
    String suffix = getResourceSuffix(locale);

    try
    {

      return (XMLErrorResources) ResourceBundle.getBundle(className
              + suffix, locale);
    }
    catch (MissingResourceException e)
    {
      try{

        return (XMLErrorResources) ResourceBundle.getBundle(className,
                new Locale("tr", "TR"));
      }
      catch (MissingResourceException e2)
      {

        throw new MissingResourceException(
          "Could not load any resource bundles.", className, "");
      }
    }
  }

  /**
   * Return the resource file suffic for the indicated locale
   * For most locales, this will be based the language code.  However
   * for Chinese, we do distinguish between Taiwan and PRC
   *
   * @param locale the locale
   * @return an String suffix which canbe appended to a resource name
   */
  private static final String getResourceSuffix(Locale locale)
  {

    String suffix = "_" + locale.getLanguage();
    String country = locale.getCountry();

    if (country.equals("TW"))
      suffix += "_" + country;

    return suffix;


org.apache.xml.dtm.DTMAxisTraverser

public abstract class DTMAxisTraverser
{

  /**
   * By the nature of the stateless traversal, the context node can not be
   * returned or the iteration will go into an infinate loop.  So to traverse
   * an axis, the first function must be used to get the first node.
   *
   *
This method needs to be overloaded only by those axis that process
   * the self node. <\p>
   *
   * @param context The context node of this traversal. This is the point
   * that the traversal starts from.
   * @return the first node in the traversal.
   */
  public int first(int context)
  {
    return next(context, context);
  }

  /**
   * By the nature of the stateless traversal, the context node can not be
   * returned or the iteration will go into an infinate loop.  So to traverse
   * an axis, the first function must be used to get the first node.
   *
   *
This method needs to be overloaded only by those axis that process
   * the self node. <\p>
   *
   * @param context The context node of this traversal. This is the point
   * of origin for the traversal -- its "root node" or starting point.
   * @param extendedTypeID The extended type ID that must match.
   *
   * @return the first node in the traversal.
   */
  public int first(int context, int extendedTypeID)
  {
    return next(context, context, extendedTypeID);
  }

  /**
   * Traverse to the next node after the current node.
   *
   * @param context The context node of this traversal. This is the point
   * of origin for the traversal -- its "root node" or starting point.
   * @param current The current node of the traversal. This is the last known
   * location in the traversal, typically the node-handle returned by the
   * previous traversal step. For the first traversal step, context
   * should be set equal to current. Note that in order to test whether
   * context is in the set, you must use the first() method instead.
   *
   * @return the next node in the iteration, or DTM.NULL.
   * @see first(int)
   */
  public abstract int next(int context, int current);

  /**
   * Traverse to the next node after the current node that is matched
   * by the extended type ID.
   *
   * @param context The context node of this traversal. This is the point
   * of origin for the traversal -- its "root node" or starting point.
   * @param current The current node of the traversal. This is the last known
   * location in the traversal, typically the node-handle returned by the
   * previous traversal step. For the first traversal step, context
   * should be set equal to current. Note that in order to test whether
   * context is in the set, you must use the first() method instead.
   * @param extendedTypeID The extended type ID that must match.
   *
   * @return the next node in the iteration, or DTM.NULL.
   * @see first(int,int)
   */
  public abstract int next(int context, int current, int extendedTypeID);


public class SmallBlockTableWriter
    implements BlockWritable, BATManaged
{
    private BlockAllocationTableWriter _sbat;
    private List                       _small_blocks;
    private int                        _big_block_count;
    private RootProperty               _root;

    /**
     * Creates new SmallBlockTable
     *
     * @param documents a List of POIFSDocument instances
     * @param root the Filesystem's root property
     */

    public SmallBlockTableWriter(final List documents,
                                 final RootProperty root)
    {
        _sbat         = new BlockAllocationTableWriter();
        _small_blocks = new ArrayList();
        _root         = root;
        Iterator iter = documents.iterator();

        while (iter.hasNext())
        {
            POIFSDocument   doc    = ( POIFSDocument ) iter.next();
            BlockWritable[] blocks = doc.getSmallBlocks();

            if (blocks.length != 0)
            {
                doc.setStartBlock(_sbat.allocateSpace(blocks.length));
                for (int j = 0; j < blocks.length; j++)
                {
                    _small_blocks.add(blocks[ j ]);
                }
            }
        }
        _sbat.simpleCreateBlocks();
        _root.setSize(_small_blocks.size());
        _big_block_count = SmallDocumentBlock.fill(_small_blocks);
    }

    /**
     * Get the number of SBAT blocks
     *
     * @return number of SBAT big blocks
     */

    public int getSBATBlockCount()
    {
	return (_big_block_count + 15) / 16;
    }

    /**
     * Get the SBAT
     *
     * @return the Small Block Allocation Table
     */

    public BlockAllocationTableWriter getSBAT()
    {
        return _sbat;
    }

    /* ********** START implementation of BATManaged ********** */

    /**
     * Return the number of BigBlock's this instance uses
     *
     * @return count of BigBlock instances
     */

    public int countBlocks()
    {
        return _big_block_count;
    }

    /**
     * Set the start block for this instance
     *
     * @param start_block
     */

    public void setStartBlock(int start_block)
    {
        _root.setStartBlock(start_block);
    }

    /* **********  END  implementation of BATManaged ********** */
    /* ********** START implementation of BlockWritable ********** */

    /**
     * Write the storage to an OutputStream
     *
     * @param stream the OutputStream to which the stored data should
     *               be written
     *
     * @exception IOException on problems writing to the specified
     *            stream
     */

    public void writeBlocks(final OutputStream stream)
        throws IOException
    {
        Iterator iter = _small_blocks.iterator();

        while (iter.hasNext())
        {
            (( BlockWritable ) iter.next()).writeBlocks(stream);

FUNC_DECL LOOP VAR_DECL PARAM CALL CALL CALL

FUNC_DECL LOOP VAR_DECL PARAM PARAM ASSIGN CALL CALL CALL ASSIGN ASSIGN ASSIGN CALL CALL IF VAR_DECL VAR_DECL CALL CALL CALL BINARY_OP LOOP LITERAL_ANCHOR CALL BINARY_OP CALL CALL CALL CALL LITERAL_ANCHOR


public final class ResolverHelper {
    private ResolverHelper() {
    }

    // lists all the values a token can take in a pattern, as listed by a given url lister
    public static String[] listTokenValues(Repository rep, String pattern, String token) {
        String fileSep = rep.getFileSeparator();
        pattern = rep.standardize(pattern);
        String tokenString = IvyPatternHelper.getTokenString(token);
        int index = pattern.indexOf(tokenString);
        if (index == -1) {
            Message.verbose("unable to list " + token + " in " + pattern
                    + ": token not found in pattern");
            return null;
        }
        if (((pattern.length() <= index + tokenString.length()) || fileSep.equals(pattern
                .substring(index + tokenString.length(), index + tokenString.length() + 1)))
                && (index == 0 || fileSep.equals(pattern.substring(index - 1, index)))) {
            // the searched token is a whole name
            String root = pattern.substring(0, index);
            return listAll(rep, root);
        } else {
            int slashIndex = pattern.substring(0, index).lastIndexOf(fileSep);
            String root = slashIndex == -1 ? "" : pattern.substring(0, slashIndex);

            try {
                Message.debug("\tusing " + rep + " to list all in " + root);
                List all = rep.list(root);
                if (all != null) {
                    Message.debug("\t\tfound " + all.size() + " urls");
                    List ret = new ArrayList(all.size());
                    int endNameIndex = pattern.indexOf(fileSep, slashIndex + 1);
                    String namePattern;
                    if (endNameIndex != -1) {
                        namePattern = pattern.substring(slashIndex + 1, endNameIndex);
                    } else {
                        namePattern = pattern.substring(slashIndex + 1);
                    }
                    String acceptNamePattern = ".*"
                            + IvyPatternHelper.substituteToken(namePattern, token, "([^" + fileSep
                                    + "]+)") + ".*";
                    Pattern p = Pattern.compile(acceptNamePattern.toString());
                    for (Iterator iter = all.iterator(); iter.hasNext();) {
                        String path = (String) iter.next();
                        Matcher m = p.matcher(path);
                        if (m.matches()) {
                            String value = m.group(1);
                            ret.add(value);
                        }
                    }
                    Message.debug("\t\t" + ret.size() + " matched " + pattern);
                    return (String[]) ret.toArray(new String[ret.size()]);
                } else {
                    return null;
                }
            } catch (IOException e) {
                Message.verbose(
                    "problem while listing resources in " + root + " with " + rep + ":");
                Message.verbose("  " + e.getClass().getName() + " " + e.getMessage());
                return null;
            } catch (Exception e) {
                Message.warn("problem while listing resources in " + root + " with " + rep + ":");
                Message.warn("  " + e.getClass().getName() + " " + e.getMessage());
                return null;
            }
        }
    }

    public static String[] listAll(Repository rep, String parent) {
        try {
            String fileSep = rep.getFileSeparator();
            Message.debug("\tusing " + rep + " to list all in " + parent);
            List all = rep.list(parent);
            if (all != null) {
                Message.debug("\t\tfound " + all.size() + " resources");
                List names = new ArrayList(all.size());
                for (Iterator iter = all.iterator(); iter.hasNext();) {
                    String path = (String) iter.next();
                    if (path.endsWith(fileSep)) {
                        path = path.substring(0, path.length() - 1);
                    }
                    int slashIndex = path.lastIndexOf(fileSep);
                    names.add(path.substring(slashIndex + 1));
                }
                return (String[]) names.toArray(new String[names.size()]);
            } else {
                Message.debug("\t\tno resources found");
                return null;
            }
        } catch (IOException e) {
            Message.verbose("problem while listing resources in " + parent + " with " + rep + ":");
            Message.verbose("  " + e.getClass().getName() + " " + e.getMessage());
            return null;
        } catch (Exception e) {
            Message.warn("problem while listing resources in " + parent + " with " + rep + ":");
            Message.warn("  " + e.getClass().getName() + " " + e.getMessage());
            return null;
        }
    }

    public static ResolvedResource[] findAll(Repository rep, ModuleRevisionId mrid, String pattern,
            Artifact artifact) {
        // substitute all but revision
        String partiallyResolvedPattern = IvyPatternHelper.substitute(pattern, ModuleRevisionId
                .newInstance(mrid, IvyPatternHelper.getTokenString(IvyPatternHelper.REVISION_KEY)),
            artifact);
        Message.debug("\tlisting all in " + partiallyResolvedPattern);

        String[] revs = listTokenValues(rep, partiallyResolvedPattern,
            IvyPatternHelper.REVISION_KEY);
        if (revs != null) {
            Message.debug("\tfound revs: " + Arrays.asList(revs));
            List ret = new ArrayList(revs.length);
            for (int i = 0; i < revs.length; i++) {
                String rres = IvyPatternHelper.substituteToken(partiallyResolvedPattern,
                    IvyPatternHelper.REVISION_KEY, revs[i]);
                try {
                    Resource res = rep.getResource(rres);
                    if ((res != null) && res.exists()) {
                        ret.add(new ResolvedResource(res, revs[i]));
                    }
                } catch (IOException e) {
                    Message.warn("impossible to get resource from name listed by repository: "
                            + rres + ": " + e.getMessage());
                }
            }
            if (revs.length != ret.size()) {
                Message.debug("\tfound resolved res: " + ret);
            }
            return (ResolvedResource[]) ret.toArray(new ResolvedResource[ret.size()]);
        } else if (partiallyResolvedPattern.indexOf(
                "[" + IvyPatternHelper.REVISION_KEY + "]") == -1) {
            // the partially resolved pattern is completely resolved, check the resource
            try {
                Resource res = rep.getResource(partiallyResolvedPattern);
                if (res.exists()) {
                    Message.debug("\tonly one resource found without real listing: "
                                    + "using and defining it as working@"
                                    + rep.getName() + " revision: " + res.getName());
                    return new ResolvedResource[] {new ResolvedResource(res, "working@"
                            + rep.getName())};
                }
            } catch (IOException e) {
                Message.debug("\timpossible to get resource from name listed by repository: "
                        + partiallyResolvedPattern + ": " + e.getMessage());
            }
            Message.debug("\tno revision found");
        }
        return null;
    }

    // public static ResolvedResource[] findAll(Repository rep, ModuleRevisionId mrid, String
    // pattern, Artifact artifact, VersionMatcher versionMatcher, ResourceMDParser mdParser) {
    // // substitute all but revision
    // String partiallyResolvedPattern = IvyPatternHelper.substitute(pattern, new
    // ModuleRevisionId(mrid.getModuleId(),
    // IvyPatternHelper.getTokenString(IvyPatternHelper.REVISION_KEY), mrid.getExtraAttributes()),
    // artifact);
    // Message.debug("\tlisting all in "+partiallyResolvedPattern);
    //
    // String[] revs = listTokenValues(rep, partiallyResolvedPattern,
    // IvyPatternHelper.REVISION_KEY);
    // if (revs != null) {
    // Message.debug("\tfound revs: "+Arrays.asList(revs));
    // List ret = new ArrayList(revs.length);
    // String rres = null;
    // for (int i = 0; i < revs.length; i++) {
    // ModuleRevisionId foundMrid = new ModuleRevisionId(mrid.getModuleId(), revs[i],
    // mrid.getExtraAttributes());
    // if (versionMatcher.accept(mrid, foundMrid)) {
    // rres = IvyPatternHelper.substituteToken(partiallyResolvedPattern,
    // IvyPatternHelper.REVISION_KEY, revs[i]);
    // try {
    // ResolvedResource resolvedResource;
    // if (versionMatcher.needModuleDescriptor(mrid, foundMrid)) {
    // resolvedResource = mdParser.parse(rep.getResource(rres), revs[i]);
    // if (!versionMatcher.accept(mrid,
    // ((MDResolvedResource)resolvedResource).getResolvedModuleRevision().getDescriptor())) {
    // continue;
    // }
    // } else {
    // resolvedResource = new ResolvedResource(rep.getResource(rres), revs[i]);
    // }
    // ret.add(resolvedResource);
    // } catch (IOException e) {
    // Message.warn("impossible to get resource from name listed by repository: "+rres+":
    // "+e.getMessage());
    // }
    // }
    // }
    // if (revs.length != ret.size()) {
    // Message.debug("\tfound resolved res: "+ret);
    // }
    // return (ResolvedResource[])ret.toArray(new ResolvedResource[ret.size()]);
    // } else {
    // // maybe the partially resolved pattern is completely resolved ?
    // try {
    // Resource res = rep.getResource(partiallyResolvedPattern);
    // if (res.exists()) {
    // Message.debug("\tonly one resource found without real listing: using and defining it as
    // working@"+rep.getName()+" revision: "+res.getName());
    // return new ResolvedResource[] {new ResolvedResource(res, "working@"+rep.getName())};
    // }
    // } catch (IOException e) {
    // Message.debug("\timpossible to get resource from name listed by repository:
    // "+partiallyResolvedPattern+": "+e.getMessage());
    // }
    // Message.debug("\tno revision found");
    // }
    // return null;
    // }

    // lists all the values a token can take in a pattern, as listed by a given url lister
    public static String[] listTokenValues(URLLister lister, String pattern, String token) {
        pattern = standardize(pattern);
        if (lister.accept(pattern)) {
            String tokenString = IvyPatternHelper.getTokenString(token);
            int index = pattern.indexOf(tokenString);
            if (index == -1) {
                Message.verbose("unable to list " + token + " in " + pattern
                        + ": token not found in pattern");
                return null;
            }
            if (((pattern.length() <= index + tokenString.length()) || "/".equals(pattern
                    .substring(index + tokenString.length(), index + tokenString.length() + 1)))
                    && (index == 0 || "/".equals(pattern.substring(index - 1, index)))) {
                // the searched token is a whole name
                String root = pattern.substring(0, index);
                try {
                    return listAll(lister, new URL(root));
                } catch (MalformedURLException e) {
                    Message
                            .warn("malformed url from pattern root: " + root + ": "
                                    + e.getMessage());
                    return null;
                }
            } else {
                int slashIndex = pattern.substring(0, index).lastIndexOf('/');
                String root = slashIndex == -1 ? "" : pattern.substring(0, slashIndex);

                try {
                    Message.debug("\tusing " + lister + " to list all in " + root);
                    List all = lister.listAll(new URL(root));
                    Message.debug("\t\tfound " + all.size() + " urls");
                    List ret = new ArrayList(all.size());
                    int endNameIndex = pattern.indexOf('/', slashIndex + 1);
                    String namePattern;
                    if (endNameIndex != -1) {
                        namePattern = pattern.substring(slashIndex + 1, endNameIndex);
                    } else {
                        namePattern = pattern.substring(slashIndex + 1);
                    }
                    String acceptNamePattern = ".*"
                            + IvyPatternHelper.substituteToken(namePattern, token, "([^/]+)")
                            + ".*";
                    Pattern p = Pattern.compile(acceptNamePattern.toString());
                    for (Iterator iter = all.iterator(); iter.hasNext();) {
                        URL url = (URL) iter.next();
                        String path = standardize(url.getPath());
                        Matcher m = p.matcher(path);
                        if (m.matches()) {
                            String value = m.group(1);
                            ret.add(value);
                        }
                    }
                    Message.debug("\t\t" + ret.size() + " matched " + pattern);
                    return (String[]) ret.toArray(new String[ret.size()]);
                } catch (Exception e) {
                    Message.warn("problem while listing files in " + root + ": " + e.getClass()
                            + " " + e.getMessage());
                    return null;
                }
            }
        }
        return null;
    }

    private static String standardize(String path) {
        return path.replace('\\', '/');
    }

    public static String[] listAll(URLLister lister, URL root) {
        try {
            if (lister.accept(root.toExternalForm())) {
                Message.debug("\tusing " + lister + " to list all in " + root);
                List all = lister.listAll(root);
                Message.debug("\t\tfound " + all.size() + " urls");
                List names = new ArrayList(all.size());
                for (Iterator iter = all.iterator(); iter.hasNext();) {
                    URL dir = (URL) iter.next();
                    String path = dir.getPath();
                    if (path.endsWith("/")) {
                        path = path.substring(0, path.length() - 1);
                    }
                    int slashIndex = path.lastIndexOf('/');
                    names.add(path.substring(slashIndex + 1));
                }
                return (String[]) names.toArray(new String[names.size()]);
            }
            return null;
        } catch (Exception e) {
            Message.warn("problem while listing directories in " + root + ": " + e.getClass() + " "
                    + e.getMessage());
            return null;


public class TypeCheckError extends Exception {
    ErrorMsg _error = null;
    SyntaxTreeNode _node = null;

    public TypeCheckError(SyntaxTreeNode node) {
	super();
	_node = node;
    }

    public TypeCheckError(ErrorMsg error) {
	super();
	_error = error;
    }

    public TypeCheckError(String code, Object param) {
	super();
	_error = new ErrorMsg(code, param);
    }

    public TypeCheckError(String code, Object param1, Object param2) {
	super();
	_error = new ErrorMsg(code, param1, param2);
    }

    public ErrorMsg getErrorMsg() {
        return _error;
    }

    public String getMessage() {
        return toString();
    }

    public String toString() {
	String result;

	if (_error == null) {
            if (_node != null) {
                _error = new ErrorMsg(ErrorMsg.TYPE_CHECK_ERR,
                                      _node.toString());
	    } else {
	        _error = new ErrorMsg(ErrorMsg.TYPE_CHECK_UNK_LOC_ERR);
	    }
        }

	return _error.toString();


public abstract class PatternConverter {
  public PatternConverter next;
  int min = -1;
  int max = 0x7FFFFFFF;
  boolean leftAlign = false;

  protected
  PatternConverter() {  }

  protected
  PatternConverter(FormattingInfo fi) {
    min = fi.min;
    max = fi.max;
    leftAlign = fi.leftAlign;
  }

  /**
     Derived pattern converters must override this method in order to
     convert conversion specifiers in the correct way.
  */
  abstract
  protected
  String convert(LoggingEvent event);

  /**
     A template method for formatting in a converter specific way.
   */
  public
  void format(StringBuffer sbuf, LoggingEvent e) {
    String s = convert(e);

    if(s == null) {
      if(0 < min)
	spacePad(sbuf, min);
      return;
    }

    int len = s.length();

    if(len > max)
      sbuf.append(s.substring(len-max));
    else if(len < min) {
      if(leftAlign) {
	sbuf.append(s);
	spacePad(sbuf, min-len);
      }
      else {
	spacePad(sbuf, min-len);
	sbuf.append(s);
      }
    }
    else
      sbuf.append(s);
  }

  static String[] SPACES = {" ", "  ", "    ", "        ", //1,2,4,8 spaces
			    "                ", // 16 spaces
			    "                                " }; // 32 spaces

  /**
     Fast space padding method.
  */
  public
  void spacePad(StringBuffer sbuf, int length) {
    while(length >= 32) {
      sbuf.append(SPACES[5]);
      length -= 32;
    }

    for(int i = 4; i >= 0; i--) {
      if((length & (1<<i)) != 0) {
	sbuf.append(SPACES[i]);


public class SectionIDMap extends HashMap
{

    /**
     *
The SummaryInformation's section's format ID.

     */
    public static final byte[] SUMMARY_INFORMATION_ID = new byte[]
    {
        (byte) 0xF2, (byte) 0x9F, (byte) 0x85, (byte) 0xE0,
        (byte) 0x4F, (byte) 0xF9, (byte) 0x10, (byte) 0x68,
        (byte) 0xAB, (byte) 0x91, (byte) 0x08, (byte) 0x00,
        (byte) 0x2B, (byte) 0x27, (byte) 0xB3, (byte) 0xD9
    };

    /**
     *
The DocumentSummaryInformation's first and second sections' format
     * ID.

     */
    public static final byte[][] DOCUMENT_SUMMARY_INFORMATION_ID = new byte[][]
    {
        {
            (byte) 0xD5, (byte) 0xCD, (byte) 0xD5, (byte) 0x02,
            (byte) 0x2E, (byte) 0x9C, (byte) 0x10, (byte) 0x1B,
            (byte) 0x93, (byte) 0x97, (byte) 0x08, (byte) 0x00,
            (byte) 0x2B, (byte) 0x2C, (byte) 0xF9, (byte) 0xAE
        },
        {
            (byte) 0xD5, (byte) 0xCD, (byte) 0xD5, (byte) 0x05,
            (byte) 0x2E, (byte) 0x9C, (byte) 0x10, (byte) 0x1B,
            (byte) 0x93, (byte) 0x97, (byte) 0x08, (byte) 0x00,
            (byte) 0x2B, (byte) 0x2C, (byte) 0xF9, (byte) 0xAE
        }
    };

    /**
     *
A property without a known name is described by this string.

     */
    public static final String UNDEFINED = "[undefined]";

    /**
     *
The default section ID map. It maps section format IDs to
     * {@link PropertyIDMap}s.

     */
    private static SectionIDMap defaultMap;

    /**
     *
Returns the singleton instance of the default {@link
     * SectionIDMap}.

     *
     * @return The instance value
     */
    public static SectionIDMap getInstance()
    {
        if (defaultMap == null)
        {
            final SectionIDMap m = new SectionIDMap();
            m.put(SUMMARY_INFORMATION_ID,
                  PropertyIDMap.getSummaryInformationProperties());
            m.put(DOCUMENT_SUMMARY_INFORMATION_ID[0],
                  PropertyIDMap.getDocumentSummaryInformationProperties());
            defaultMap = m;
        }
        return defaultMap;
    }

    /**
     *
Returns the property ID string that is associated with a
     * given property ID in a section format ID's namespace.

     *
     * @param sectionFormatID Each section format ID has its own name
     * space of property ID strings and thus must be specified.
     * @param  pid The property ID
     * @return The well-known property ID string associated with the
     * property ID <var>pid</var> in the name space spanned by <var>
     * sectionFormatID</var> . If the <var>pid</var>
     * /<var>sectionFormatID </var> combination is not well-known, the
     * string "[undefined]" is returned.
     */
    public static String getPIDString(final byte[] sectionFormatID,
                                      final long pid)
    {
        final PropertyIDMap m = getInstance().get(sectionFormatID);
        if (m == null)
            return UNDEFINED;
        else
        {
            final String s = (String) m.get(pid);
            if (s == null)
                return UNDEFINED;
            return s;
        }
    }

    /**
     *
Returns the {@link PropertyIDMap} for a given section format
     * ID.

     *
     * @param sectionFormatID the section format ID
     * @return the property ID map
     */
    public PropertyIDMap get(final byte[] sectionFormatID)
    {
        return (PropertyIDMap) super.get(new String(sectionFormatID));
    }

    /**
     *
Returns the {@link PropertyIDMap} for a given section format
     * ID.

     *
     * @param sectionFormatID A section format ID as a <tt>byte[]</tt> .
     * @deprecated Use {@link #get(byte[])} instead!
     * @return the property ID map
     */
    public Object get(final Object sectionFormatID)
    {
        return get((byte[]) sectionFormatID);
    }

    /**
     *
Associates a section format ID with a {@link
     * PropertyIDMap}.

     *
     * @param sectionFormatID the section format ID
     * @param propertyIDMap the property ID map
     * @return as defined by {@link java.util.Map#put}
     */
    public Object put(final byte[] sectionFormatID,
                      final PropertyIDMap propertyIDMap)
    {
        return super.put(new String(sectionFormatID), propertyIDMap);
    }

    /**
     * @deprecated Use {@link #put(byte[], PropertyIDMap)} instead!
     *
     * @see #put(byte[], PropertyIDMap)
     *
     * @param key This parameter remains undocumented since the method is
     * deprecated.
     * @param value This parameter remains undocumented since the method is
     * deprecated.
     * @return The return value remains undocumented since the method is
     * deprecated.
     */
    public Object put(final Object key, final Object value)
    {
        return put((byte[]) key, (PropertyIDMap) value);


public class JMXMessage extends DefaultMessage {

    private Notification notification;

    public JMXMessage() {
        this(null);
    }

    public JMXMessage(Notification notification) {
        this.notification = notification;
    }

    @Override
    public String toString() {
        return "JMXMessage: " + notification;
    }

    @Override
    public JMXExchange getExchange() {
        return (JMXExchange)super.getExchange();
    }

    @Override
    public JMXMessage newInstance() {
        return new JMXMessage();
    }

    public Notification getNotification() {
        return notification;

    public JMXMessage() {
        this(null);


public class IvyNodeEviction {
    /**
     * This class contains data about the eviction of an {@link IvyNode}.
     */
    public static class EvictionData {
        /**
         * Can be null in case of transitive eviction.
         */
        private IvyNode parent;

        /**
         * Can be null in case of transitive eviction.
         */
        private ConflictManager conflictManager;

        /**
         * Can be null in case of transitive eviction.
         */
        private Collection selected; // Collection(IvyNode)

        private String rootModuleConf;

        private String detail;

        /**
         * Creates a new object containing the eviction data of an {@link IvyNode}.
         *
         * @param rootModuleConf
         *            the root module configuration
         * @param parent
         *            the parent node (or <tt>null</tt> in case of transitive eviction)
         * @param conflictManager
         *            the conflict manager which evicted the node (or <tt>null</tt> in case of
         *            transitive eviction)
         * @param selected
         *            a collection of {@link IvyNode}s which evict the evicted node (or
         *            <tt>null</tt> in case of transitive eviction)
         */
        public EvictionData(String rootModuleConf, IvyNode parent, ConflictManager conflictManager,
                Collection selected) {
            this(rootModuleConf, parent, conflictManager, selected, null);
        }

        /**
         * Creates a new object containing the eviction data of an {@link IvyNode}.
         *
         * @param rootModuleConf
         *            the root module configuration
         * @param parent
         *            the parent node (or <tt>null</tt> in case of transitive eviction)
         * @param conflictManager
         *            the conflict manager which evicted the node (or <tt>null</tt> in case of
         *            transitive eviction)
         * @param selected
         *            a collection of {@link IvyNode}s which evict the evicted node (or
         *            <tt>null</tt> in case of transitive eviction)
         * @param detail
         *            a String detailing the reason why the node was evicted
         */
        public EvictionData(String rootModuleConf, IvyNode parent, ConflictManager conflictManager,
                Collection selected, String detail) {
            this.rootModuleConf = rootModuleConf;
            this.parent = parent;
            this.conflictManager = conflictManager;
            this.selected = selected;
            this.detail = detail;
        }

        public String toString() {
            if (selected != null) {
                return selected + " in " + parent
                    + (detail == null ? "" : " " + detail)
                    + " (" + conflictManager + ") [" + rootModuleConf + "]";
            } else {
                return "transitively [" + rootModuleConf + "]";
            }
        }

        public ConflictManager getConflictManager() {
            return conflictManager;
        }

        public IvyNode getParent() {
            return parent;
        }

        public Collection getSelected() {
            return selected;
        }

        public String getRootModuleConf() {
            return rootModuleConf;
        }

        public boolean isTransitivelyEvicted() {
            return parent == null;
        }

        public String getDetail() {
            return detail;
        }
    }

    private static final class ModuleIdConf {
        private ModuleId moduleId;

        private String conf;

        public ModuleIdConf(ModuleId mid, String conf) {
            if (mid == null) {
                throw new NullPointerException("mid cannot be null");
            }
            if (conf == null) {
                throw new NullPointerException("conf cannot be null");
            }
            moduleId = mid;
            this.conf = conf;
        }

        public final String getConf() {
            return conf;
        }

        public final ModuleId getModuleId() {
            return moduleId;
        }

        public boolean equals(Object obj) {
            if (!(obj instanceof ModuleIdConf)) {
                return false;
            }
            return getModuleId().equals(((ModuleIdConf) obj).getModuleId())
                    && getConf().equals(((ModuleIdConf) obj).getConf());
        }

        public int hashCode() {
            //CheckStyle:MagicNumber| OFF
            int hash = 33;
            hash += getModuleId().hashCode() * 17;
            hash += getConf().hashCode() * 17;
            //CheckStyle:MagicNumber| ON
            return hash;
        }
    }

    private IvyNode node;

    private Map selectedDeps = new HashMap(); // Map (ModuleIdConf -> Set(Node)) // map indicating

    // for each dependency which node has been selected

    private Map pendingConflicts = new HashMap(); // Map (ModuleIdConf -> Set(Node)) // map

    // indicating for each dependency which nodes
    // are in pending conflict (conflict detected
    // but not yet resolved)

    private Map evictedDeps = new HashMap(); // Map (ModuleIdConf -> Set(Node)) // map indicating

    // for each dependency which node has been evicted

    private Map evictedRevs = new HashMap(); // Map (ModuleIdConf -> Set(ModuleRevisionId)) //

    // map indicating for each dependency which revision
    // has been evicted

    private Map evicted = new HashMap(); // Map (root module conf -> EvictionData) // indicates

    // if the node is evicted in each root module conf

    public IvyNodeEviction(IvyNode node) {
        if (node == null) {
            throw new NullPointerException("node must not be null");
        }
        this.node = node;
    }

    /**
     * @return A copy of the set of resolved nodes (real nodes)
     */
    public Set getResolvedNodes(ModuleId mid, String rootModuleConf) {
        Collection resolved = (Collection) selectedDeps.get(new ModuleIdConf(mid, rootModuleConf));
        Set ret = new HashSet();
        if (resolved != null) {
            for (Iterator iter = resolved.iterator(); iter.hasNext();) {
                IvyNode node = (IvyNode) iter.next();
                ret.add(node.getRealNode());
            }
        }
        return ret;
    }

    public Collection getResolvedRevisions(ModuleId mid, String rootModuleConf) {
        Collection resolved = (Collection) selectedDeps.get(new ModuleIdConf(mid, rootModuleConf));
        if (resolved == null) {
            return new HashSet();
        } else {
            Collection resolvedRevs = new HashSet();
            for (Iterator iter = resolved.iterator(); iter.hasNext();) {
                IvyNode node = (IvyNode) iter.next();
                resolvedRevs.add(node.getId());
                resolvedRevs.add(node.getResolvedId());
            }
            return resolvedRevs;
        }
    }

    public void setResolvedNodes(ModuleId moduleId, String rootModuleConf, Collection resolved) {
        ModuleIdConf moduleIdConf = new ModuleIdConf(moduleId, rootModuleConf);
        selectedDeps.put(moduleIdConf, new HashSet(resolved));
    }

    public Collection getEvictedNodes(ModuleId mid, String rootModuleConf) {
        Collection resolved = (Collection) evictedDeps.get(new ModuleIdConf(mid, rootModuleConf));
        Set ret = new HashSet();
        if (resolved != null) {
            for (Iterator iter = resolved.iterator(); iter.hasNext();) {
                IvyNode node = (IvyNode) iter.next();
                ret.add(node.getRealNode());
            }
        }
        return ret;
    }

    public Collection getEvictedRevisions(ModuleId mid, String rootModuleConf) {
        Collection evicted = (Collection) evictedRevs.get(new ModuleIdConf(mid, rootModuleConf));
        if (evicted == null) {
            return new HashSet();
        } else {
            return new HashSet(evicted);
        }
    }

    public void setEvictedNodes(ModuleId moduleId, String rootModuleConf, Collection evicted) {
        ModuleIdConf moduleIdConf = new ModuleIdConf(moduleId, rootModuleConf);
        evictedDeps.put(moduleIdConf, new HashSet(evicted));
        Collection evictedRevs = new HashSet();
        for (Iterator iter = evicted.iterator(); iter.hasNext();) {
            IvyNode node = (IvyNode) iter.next();
            evictedRevs.add(node.getId());
            evictedRevs.add(node.getResolvedId());
        }
        this.evictedRevs.put(moduleIdConf, evictedRevs);
    }

    public boolean isEvicted(String rootModuleConf) {
        cleanEvicted();
        IvyNode root = node.getRoot();
        ModuleId moduleId = node.getId().getModuleId();
        Collection resolvedRevisions = root.getResolvedRevisions(moduleId, rootModuleConf);
        EvictionData evictedData = getEvictedData(rootModuleConf);
        return root != node && evictedData != null
            && (!resolvedRevisions.contains(node.getResolvedId())
                || evictedData.isTransitivelyEvicted()
               );
    }

    public boolean isCompletelyEvicted() {
        cleanEvicted();
        if (node.isRoot()) {
            return false;
        }
        String[] rootModuleConfigurations = node.getRootModuleConfigurations();
        for (int i = 0; i < rootModuleConfigurations.length; i++) {
            if (!isEvicted(rootModuleConfigurations[i])) {
                return false;
            }
        }
        return true;
    }

    private void cleanEvicted() {
        // check if it was evicted by a node that we are now the real node for
        for (Iterator iter = evicted.keySet().iterator(); iter.hasNext();) {
            String rootModuleConf = (String) iter.next();
            EvictionData ed = (EvictionData) evicted.get(rootModuleConf);
            Collection sel = ed.getSelected();
            if (sel != null) {
                for (Iterator iterator = sel.iterator(); iterator.hasNext();) {
                    IvyNode n = (IvyNode) iterator.next();
                    if (n.getRealNode().equals(this)) {
                        // yes, we are the real node for a selected one !
                        // we are no more evicted in this conf !
                        iter.remove();
                    }
                }
            }
        }
    }

    public void markEvicted(EvictionData evictionData) {
        evicted.put(evictionData.getRootModuleConf(), evictionData);
    }

    public EvictionData getEvictedData(String rootModuleConf) {
        cleanEvicted();
        return (EvictionData) evicted.get(rootModuleConf);
    }

    public String[] getEvictedConfs() {
        cleanEvicted();
        return (String[]) evicted.keySet().toArray(new String[evicted.keySet().size()]);
    }

    /**
     * Returns null if this node has only be evicted transitively, or the the collection of selected
     * nodes if it has been evicted by other selected nodes
     *
     * @return
     */
    public Collection getAllEvictingNodes() {
        Collection allEvictingNodes = null;
        for (Iterator iter = evicted.values().iterator(); iter.hasNext();) {
            EvictionData ed = (EvictionData) iter.next();
            Collection selected = ed.getSelected();
            if (selected != null) {
                if (allEvictingNodes == null) {
                    allEvictingNodes = new HashSet();
                }
                allEvictingNodes.addAll(selected);
            }
        }
        return allEvictingNodes;
    }

    public Collection/*<String>*/ getAllEvictingNodesDetails() {
        Collection ret = null;
        for (Iterator iter = evicted.values().iterator(); iter.hasNext();) {
            EvictionData ed = (EvictionData) iter.next();
            Collection selected = ed.getSelected();
            if (selected != null) {
                if (ret == null) {
                    ret = new HashSet();
                }
                if (selected.size() == 1) {
                    ret.add(selected.iterator().next()
                        + (ed.getDetail() == null ? "" : " " + ed.getDetail()));
                } else if (selected.size() > 1) {
                    ret.add(selected
                        + (ed.getDetail() == null ? "" : " " + ed.getDetail()));
                }
            }
        }
        return ret;
    }

    public Collection getAllEvictingConflictManagers() {
        Collection ret = new HashSet();
        for (Iterator iter = evicted.values().iterator(); iter.hasNext();) {
            EvictionData ed = (EvictionData) iter.next();
            ret.add(ed.getConflictManager());
        }
        return ret;
    }

    /**
     * Returns the eviction data for this node if it has been previously evicted in the root, null
     * otherwise (if it hasn't been evicted in root) for the given rootModuleConf. Note that this
     * method only works if conflict resolution has already be done in all the ancestors.
     *
     * @param rootModuleConf
     * @param ancestor
     * @return
     */
    public EvictionData getEvictionDataInRoot(String rootModuleConf, IvyNode ancestor) {
        Collection selectedNodes = node.getRoot().getResolvedNodes(node.getModuleId(),
            rootModuleConf);
        for (Iterator iter = selectedNodes.iterator(); iter.hasNext();) {
            IvyNode node = (IvyNode) iter.next();
            if (node.getResolvedId().equals(this.node.getResolvedId())) {
                // the node is part of the selected ones for the root: no eviction data to return
                return null;
            }
        }
        // we didn't find this mrid in the selected ones for the root: it has been previously
        // evicted
        return new EvictionData(rootModuleConf, ancestor, node.getRoot().getConflictManager(
            node.getModuleId()), selectedNodes);
    }

    public Collection getPendingConflicts(String rootModuleConf, ModuleId mid) {
        Collection resolved = (Collection) pendingConflicts.get(new ModuleIdConf(mid,
                rootModuleConf));
        Set ret = new HashSet();
        if (resolved != null) {
            for (Iterator iter = resolved.iterator(); iter.hasNext();) {
                IvyNode node = (IvyNode) iter.next();
                ret.add(node.getRealNode());
            }
        }
        return ret;
    }

    public void setPendingConflicts(ModuleId moduleId, String rootModuleConf,
            Collection conflicts) {
        ModuleIdConf moduleIdConf = new ModuleIdConf(moduleId, rootModuleConf);
        pendingConflicts.put(moduleIdConf, new HashSet(conflicts));

FUNC_DECL RETURN IF VAR_DECL VAR_DECL PARAM PARAM BINARY_OP LOOP LITERAL_ANCHOR CALL CALL CALL VAR_DECL CALL CALL CALL CALL CALL

FUNC_DECL IF VAR_DECL PARAM PARAM BINARY_OP RETURN LOOP VAR_DECL RETURN LITERAL_ANCHOR CALL CALL CALL VAR_DECL CALL CALL CALL CALL CALL CALL CALL CALL

FUNC_DECL VAR_DECL PARAM PARAM PARAM CALL CALL CALL

FUNC_DECL IF VAR_DECL PARAM PARAM BINARY_OP RETURN RETURN LITERAL_ANCHOR CALL CALL CALL CALL

FUNC_DECL LOOP VAR_DECL VAR_DECL PARAM PARAM PARAM CALL CALL CALL VAR_DECL CALL CALL CALL CALL CALL CALL CALL CALL CALL

FUNC_DECL LOOP CALL IF VAR_DECL VAR_DECL VAR_DECL BINARY_OP CALL LOOP LITERAL_ANCHOR CALL CALL CALL CALL CALL IF VAR_DECL CALL CALL CALL CALL CALL

FUNC_DECL RETURN CALL CALL CALL CALL CALL

FUNC_DECL RETURN LOOP VAR_DECL CALL VAR_DECL CALL CALL CALL CALL CALL CALL

FUNC_DECL RETURN LOOP VAR_DECL PARAM PARAM CALL CALL CALL IF VAR_DECL CALL CALL CALL CALL CALL CALL RETURN CALL CALL LITERAL_ANCHOR CALL CALL


public class ModelFactory implements ERFListener
{

    List listeners;
    Model currentmodel;
    boolean lastEOF;

    /**
     * Constructor for ModelFactory.  Does practically nothing.
     */
    public ModelFactory()
    {
        super();
        listeners = new ArrayList(1);
    }

    /**
     * register a ModelFactoryListener so that it can receive
     * Models as they are created.
     */
    public void registerListener(ModelFactoryListener listener) {
        listeners.add(listener);
    }

    /**
     * Start processing the Workbook stream into Model events.
     */
    public void run(InputStream stream) {
        EventRecordFactory factory = new EventRecordFactory(true);
        factory.registerListener(this,null);
        lastEOF = true;
        factory.processRecords(stream);
    }

    public boolean processRecord(Record rec)
    {
       if (rec.getSid() == BOFRecord.sid) {
             if (lastEOF != true) {
              throw new RuntimeException("Not yet handled embedded models");
             } else {
              BOFRecord bof = (BOFRecord)rec;
              switch (bof.getType()) {
               case BOFRecord.TYPE_WORKBOOK:
                 currentmodel = new Workbook();
               break;
               case BOFRecord.TYPE_WORKSHEET:
                 currentmodel = new Sheet();
               break;
              default:
                   throw new RuntimeException("Unsupported model type "+bof.getType());
              }

             }
        }

        if (rec.getSid() == EOFRecord.sid) {
            lastEOF = true;
            throwEvent(currentmodel);
        } else {
            lastEOF = false;
        }

        return true;
    }

    /**
     * Throws the model as an event to the listeners
     * @param model to be thrown
     */
    private void throwEvent(Model model)
    {
        Iterator i = listeners.iterator();
        while (i.hasNext()) {
          ModelFactoryListener mfl = (ModelFactoryListener) i.next();
          mfl.process(model);

FUNC_DECL LOOP VAR_DECL PARAM CALL VAR_DECL CALL CALL CALL


public class FormatterElement {

    private String classname;
    private String extension;
    private OutputStream out = System.out;
    private File outFile;
    private boolean useFile = true;
    private String ifProperty;
    private String unlessProperty;

    /** xml formatter class */
    public static final String XML_FORMATTER_CLASS_NAME =
        "org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter";
    /** brief formatter class */
    public static final String BRIEF_FORMATTER_CLASS_NAME =
        "org.apache.tools.ant.taskdefs.optional.junit.BriefJUnitResultFormatter";
    /** plain formatter class */
    public static final String PLAIN_FORMATTER_CLASS_NAME =
        "org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter";

    /**
     *
 Quick way to use a standard formatter.
     *
     *
 At the moment, there are three supported standard formatters.
     *

     *
 The xml type uses a XMLJUnitResultFormatter.
     *
 The brief type uses a BriefJUnitResultFormatter.
     *
 The plain type (the default) uses a PlainJUnitResultFormatter.
     *

     *
     *
 Sets classname attribute - so you can't use that
     * attribute if you use this one.
     * @param type the enumerated value to use.
     */
    public void setType(TypeAttribute type) {
        if ("xml".equals(type.getValue())) {
            setClassname(XML_FORMATTER_CLASS_NAME);
        } else {
            if ("brief".equals(type.getValue())) {
                setClassname(BRIEF_FORMATTER_CLASS_NAME);
                setClassname(PLAIN_FORMATTER_CLASS_NAME);
            }
        }
    }

    /**
     *
 Set name of class to be used as the formatter.
     *
     *
 This class must implement JUnitResultFormatter
     * @param classname the name of the formatter class.
     */
    public void setClassname(String classname) {
        this.classname = classname;
        if (XML_FORMATTER_CLASS_NAME.equals(classname)) {
           setExtension(".xml");
        } else if (PLAIN_FORMATTER_CLASS_NAME.equals(classname)) {
           setExtension(".txt");
        } else if (BRIEF_FORMATTER_CLASS_NAME.equals(classname)) {
           setExtension(".txt");
        }
    }

    /**
     * Get name of class to be used as the formatter.
     * @return the name of the class.
     */
    public String getClassname() {
        return classname;
    }

    /**
     * Set the extension to use for the report file.
     * @param ext the extension to use.
     */
    public void setExtension(String ext) {
        this.extension = ext;
    }

    /**
     * Get the extension used for the report file.
     * @return the extension.
     */
    public String getExtension() {
        return extension;
    }

    /**
     *
 Set the file which the formatte should log to.
     *
     *
 Note that logging to file must be enabled .
     */
    void setOutfile(File out) {
        this.outFile = out;
    }

    /**
     *
 Set output stream for formatter to use.
     *
     *
 Defaults to standard out.
     * @param out the output stream to use.
     */
    public void setOutput(OutputStream out) {
        this.out = out;
    }

    /**
     * Set whether the formatter should log to file.
     * @param useFile if true use a file, if false send
     *                to standard out.
     */
    public void setUseFile(boolean useFile) {
        this.useFile = useFile;
    }

    /**
     * Get whether the formatter should log to file.
     */
    boolean getUseFile() {
        return useFile;
    }

    /**
     * Set whether this formatter should be used.  It will be
     * used if the property has been set, otherwise it won't.
     * @param ifProperty name of property
     */
    public void setIf(String ifProperty) {
        this.ifProperty = ifProperty;
    }

    /**
     * Set whether this formatter should NOT be used. It
     * will not be used if the property has been set, orthwise it
     * will be used.
     * @param unlessProperty name of property
     */
    public void setUnless(String unlessProperty) {
        this.unlessProperty = unlessProperty;
    }

    /**
     * Ensures that the selector passes the conditions placed
     * on it with if and unless properties.
     * @param t the task the this formatter is used in.
     * @return true if the formatter should be used.
     */
    public boolean shouldUse(Task t) {
        if (ifProperty != null && t.getProject().getProperty(ifProperty) == null) {
            return false;
        } else if (unlessProperty != null
                    && t.getProject().getProperty(unlessProperty) != null) {
            return false;
        }

        return true;
    }

    /**
     * @since Ant 1.2
     */
    JUnitTaskMirror.JUnitResultFormatterMirror createFormatter() throws BuildException {
        return createFormatter(null);
    }

    /**
     * @since Ant 1.6
     */
    JUnitTaskMirror.JUnitResultFormatterMirror createFormatter(ClassLoader loader)
        throws BuildException {

        if (classname == null) {
            throw new BuildException("you must specify type or classname");
        }
        Class f = null;
        try {
            if (loader == null) {
                f = Class.forName(classname);
            } else {
                f = Class.forName(classname, true, loader);
            }
        } catch (ClassNotFoundException e) {
            throw new BuildException(
                "Using loader " + loader + " on class " + classname
                + ": " + e, e);
        } catch (NoClassDefFoundError e) {
            throw new BuildException(
                "Using loader " + loader + " on class " + classname
                + ": " + e, e);
        }

        Object o = null;
        try {
            o = f.newInstance();
        } catch (InstantiationException e) {
            throw new BuildException(e);
        } catch (IllegalAccessException e) {
            throw new BuildException(e);
        }

        if (!(o instanceof JUnitTaskMirror.JUnitResultFormatterMirror)) {
            throw new BuildException(classname
                + " is not a JUnitResultFormatter");
        }
        JUnitTaskMirror.JUnitResultFormatterMirror r =
            (JUnitTaskMirror.JUnitResultFormatterMirror) o;
        if (useFile && outFile != null) {
            try {
                out = new BufferedOutputStream(new FileOutputStream(outFile));
            } catch (java.io.IOException e) {
                throw new BuildException("Unable to open file " + outFile, e);
            }
        }
        r.setOutput(out);
        return r;
    }

    /**
     *
 Enumerated attribute with the values "plain", "xml" and "brief".
     *
     *
 Use to enumerate options for type attribute.
     */
    public static class TypeAttribute extends EnumeratedAttribute {
        /** {@inheritDoc}. */
        public String[] getValues() {
            return new String[] {"plain", "xml", "brief"};

FUNC_DECL IF PARAM LITERAL_ANCHOR IF CALL LITERAL_ANCHOR CALL CALL CALL CALL CALL CALL

FUNC_DECL IF PARAM IF CALL ASSIGN IF CALL CALL CALL CALL LITERAL_ANCHOR CALL LITERAL_ANCHOR LITERAL_ANCHOR

    boolean getUseFile() {
        return useFile;


public class ApplicationContextRegistry implements Registry {
    private ApplicationContext applicationContext;

    public ApplicationContextRegistry(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    public <T> T lookup(String name, Class<T> type) {
        try {
            Object value = applicationContext.getBean(name, type);
            return type.cast(value);
        } catch (NoSuchBeanDefinitionException e) {
            return null;
        }
    }

    public Object lookup(String name) {
        try {
            return applicationContext.getBean(name);
        } catch (NoSuchBeanDefinitionException e) {
            return null;

FUNC_DECL TRY PARAM PARAM CATCH RETURN VAR_DECL RETURN CALL LITERAL_ANCHOR CALL

FUNC_DECL TRY PARAM CATCH RETURN RETURN CALL LITERAL_ANCHOR


org.apache.xml.dtm.DTMIterator

public interface DTMIterator
{

  /**
   * Accept the node.
   */
  public static final short FILTER_ACCEPT = 1;

  /**
   * Reject the node. Same behavior as FILTER_SKIP. (In the DOM these
   * differ when applied to a TreeWalker but have the same result when
   * applied to a NodeIterator).
   */
  public static final short FILTER_REJECT = 2;

  /**
   * Skip this single node.
   */
  public static final short FILTER_SKIP = 3;

  /**
   * Get an instance of a DTM that "owns" a node handle.  Since a node
   * iterator may be passed without a DTMManager, this allows the
   * caller to easily get the DTM using just the iterator.
   *
   * @param nodeHandle the nodeHandle.
   *
   * @return a non-null DTM reference.
   */
  public DTM getDTM(int nodeHandle);

  /**
   * Get an instance of the DTMManager.  Since a node
   * iterator may be passed without a DTMManager, this allows the
   * caller to easily get the DTMManager using just the iterator.
   *
   * @return a non-null DTMManager reference.
   */
  public DTMManager getDTMManager();

  /**
   * The root node of the DTMIterator, as specified when it
   * was created.  Note the root node is not the root node of the
   * document tree, but the context node from where the iteration
   * begins and ends.
   *
   * @return nodeHandle int Handle of the context node.
   */
  public int getRoot();

  /**
   * Reset the root node of the DTMIterator, overriding
   * the value specified when it was created.  Note the root node is
   * not the root node of the document tree, but the context node from
   * where the iteration begins.
   *
   * @param nodeHandle int Handle of the context node.
   * @param environment The environment object.
   * The environment in which this iterator operates, which should provide:
   *

   *
a node (the context node... same value as "root" defined below)

   *
a pair of non-zero positive integers (the context position and the context size)

   *
a set of variable bindings

   *
a function library

   *
the set of namespace declarations in scope for the expression.

   *

   *
   *
At this time the exact implementation of this environment is application
   * dependent.  Probably a proper interface will be created fairly soon.

   *
   */
  public void setRoot(int nodeHandle, Object environment);

  /**
   * Reset the iterator to the start. After resetting, the next node returned
   * will be the root node -- or, if that's filtered out, the first node
   * within the root's subtree which is _not_ skipped by the filters.
   */
  public void reset();

  /**
   * This attribute determines which node types are presented via the
   * iterator. The available set of constants is defined above.
   * Nodes not accepted by
   * whatToShow will be skipped, but their children may still
   * be considered.
   *
   * @return one of the SHOW_XXX constants, or several ORed together.
   */
  public int getWhatToShow();

  /**
   *
The value of this flag determines whether the children of entity
   * reference nodes are visible to the iterator. If false, they  and
   * their descendants will be rejected. Note that this rejection takes
   * precedence over whatToShow and the filter.

   *
   *
 To produce a view of the document that has entity references
   * expanded and does not expose the entity reference node itself, use
   * the whatToShow flags to hide the entity reference node
   * and set expandEntityReferences to true when creating the
   * iterator. To produce a view of the document that has entity reference
   * nodes but no entity expansion, use the whatToShow flags
   * to show the entity reference node and set
   * expandEntityReferences to false.

   *
   *
NOTE: In Xalan's use of DTM we will generally have fully expanded
   * entity references when the document tree was built, and thus this
   * flag will have no effect.

   *
   * @return true if entity references will be expanded.  */
  public boolean getExpandEntityReferences();

  /**
   * Returns the next node in the set and advances the position of the
   * iterator in the set. After a DTMIterator has setRoot called,
   * the first call to nextNode() returns that root or (if it
   * is rejected by the filters) the first node within its subtree which is
   * not filtered out.
   * @return The next node handle in the set being iterated over, or
   *  DTM.NULL if there are no more members in that set.
   */
  public int nextNode();

  /**
   * Returns the previous node in the set and moves the position of the
   * DTMIterator backwards in the set.
   * @return The previous node handle in the set being iterated over,
   *   or DTM.NULL if there are no more members in that set.
   */
  public int previousNode();

  /**
   * Detaches the DTMIterator from the set which it iterated
   * over, releasing any computational resources and placing the iterator
   * in the INVALID state. After detach has been invoked,
   * calls to nextNode or previousNode will
   * raise a runtime exception.
   */
  public void detach();

  /**
   * Specify if it's OK for detach to release the iterator for reuse.
   *
   * @param allowRelease true if it is OK for detach to release this iterator
   * for pooling.
   */
  public void allowDetachToRelease(boolean allowRelease);

  /**
   * Get the current node in the iterator. Note that this differs from
   * the DOM's NodeIterator, where the current position lies between two
   * nodes (as part of the maintain-relative-position semantic).
   *
   * @return The current node handle, or -1.
   */
  public int getCurrentNode();

  /**
   * Tells if this NodeSetDTM is "fresh", in other words, if
   * the first nextNode() that is called will return the
   * first node in the set.
   *
   * @return true if the iteration of this list has not yet begun.
   */
  public boolean isFresh();

  /**
   * If setShouldCacheNodes(true) is called, then nodes will
   * be cached, enabling random access, and giving the ability to do
   * sorts and the like.  They are not cached by default.
   *
   * %REVIEW% Shouldn't the other random-access methods throw an exception
   * if they're called on a DTMIterator with this flag set false?
   *
   * @param b true if the nodes should be cached.
   */
  public void setShouldCacheNodes(boolean b);

  /**
   * Tells if this iterator can have nodes added to it or set via
   * the setItem(int node, int index) method.
   *
   * @return True if the nodelist can be mutated.
   */
  public boolean isMutable();

  /** Get the current position within the cached list, which is one
   * less than the next nextNode() call will retrieve.  i.e. if you
   * call getCurrentPos() and the return is 0, the next fetch will
   * take place at index 1.
   *
   * @return The position of the iteration.
   */
  public int getCurrentPos();

  /**
   * If an index is requested, NodeSetDTM will call this method
   * to run the iterator to the index.  By default this sets
   * m_next to the index.  If the index argument is -1, this
   * signals that the iterator should be run to the end and
   * completely fill the cache.
   *
   * @param index The index to run to, or -1 if the iterator should be run
   *              to the end.
   */
  public void runTo(int index);

  /**
   * Set the current position in the node set.
   *
   * @param i Must be a valid index.
   */
  public void setCurrentPos(int i);

  /**
   * Returns the node handle of an item in the collection. If
   * index is greater than or equal to the number of nodes in
   * the list, this returns null.
   *
   * @param index of the item.
   * @return The node handle at the indexth position in the
   *   DTMIterator, or -1 if that is not a valid
   *   index.
   */
  public int item(int index);

  /**
   * Sets the node at the specified index of this vector to be the
   * specified node. The previous component at that position is discarded.
   *
   *
The index must be a value greater than or equal to 0 and less
   * than the current size of the vector.
   * The iterator must be in cached mode.

   *
   *
Meant to be used for sorted iterators.

   *
   * @param node Node to set
   * @param index Index of where to set the node
   */
  public void setItem(int node, int index);

  /**
   * The number of nodes in the list. The range of valid child node indices
   * is 0 to length-1 inclusive. Note that this requires running
   * the iterator to completion, and presumably filling the cache.
   *
   * @return The number of nodes in the list.
   */
  public int getLength();

  /**
   * Get a cloned Iterator that is reset to the start of the iteration.
   *
   * @return A clone of this iteration that has been reset.
   *
   * @throws CloneNotSupportedException
   */
  public DTMIterator cloneWithReset() throws CloneNotSupportedException;

  /**
   * Get a clone of this iterator, but don't reset the iteration in the
   * process, so that it may be used from the current position.
   *
   * @return A clone of this object.
   *
   * @throws CloneNotSupportedException
   */
  public Object clone() throws CloneNotSupportedException;

  /**
   * Returns true if all the nodes in the iteration well be returned in document
   * order.
   *
   * @return true if all the nodes in the iteration well be returned in document
   * order.
   */
  public boolean isDocOrdered();

  /**
   * Returns the axis being iterated, if it is known.
   *
   * @return Axis.CHILD, etc., or -1 if the axis is not known or is of multiple
   * types.
   */
  public int getAxis();


org.apache.xalan.xsltc.compiler.IntExpr

final class IntExpr extends Expression {
    private final int _value;

    public IntExpr(int value) {
        _value = value;
    }

    public Type typeCheck(SymbolTable stable) throws TypeCheckError {
	return _type = Type.Int;
    }

    public String toString() {
	return "int-expr(" + _value + ')';
    }

    public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
	ConstantPoolGen cpg = classGen.getConstantPool();
	InstructionList il = methodGen.getInstructionList();
	il.append(new PUSH(cpg, _value));

FUNC_DECL VAR_DECL VAR_DECL PARAM PARAM CALL CALL CALL CALL


org.apache.camel.model.LoadBalanceType

@XmlRootElement(name = "loadBalance")
@XmlAccessorType(XmlAccessType.FIELD)
public class LoadBalanceType extends ProcessorType<LoadBalanceType> {
    @XmlAttribute(required = false)
    private String ref;

    @XmlElements({
        @XmlElement(required = false, name = "roundRobin", type = RoundRobinLoadBalanceStrategy.class),
        @XmlElement(required = false, name = "random", type = RandomLoadBalanceStrategy.class),
        @XmlElement(required = false, name = "sticky", type = StickyLoadBalanceStrategy.class),
        @XmlElement(required = false, name = "topic", type = TopicLoadBalanceStrategy.class)}
        )
    private LoadBalancerType loadBalancerType;

    @XmlElementRef
    private List<ProcessorType<?>> outputs = new ArrayList<ProcessorType<?>>();

    public LoadBalanceType() {
    }

    @Override
    public String getShortName() {
        return "loadbalance";
    }

    public List<ProcessorType<?>> getOutputs() {
        return outputs;
    }

    public void setOutputs(List<ProcessorType<?>> outputs) {
        this.outputs = outputs;
        if (outputs != null) {
            for (ProcessorType output : outputs) {
                configureChild(output);
            }
        }
    }

    @Override
    protected void configureChild(ProcessorType output) {
        super.configureChild(output);
        if (isInheritErrorHandler()) {
            output.setErrorHandlerBuilder(getErrorHandlerBuilder());
        }
    }

    public String getRef() {
        return ref;
    }

    public void setRef(String ref) {
        this.ref = ref;
    }

    public LoadBalancerType getLoadBalancerType() {
        return loadBalancerType;
    }

    public void setLoadBalancerType(LoadBalancerType loadbalancer) {
        loadBalancerType = loadbalancer;
    }

    protected Processor createOutputsProcessor(RouteContext routeContext, Collection<ProcessorType<?>> outputs)
        throws Exception {
        LoadBalancer loadBalancer = LoadBalancerType.getLoadBalancer(routeContext, loadBalancerType, ref);
        for (ProcessorType processorType : outputs) {
            SendProcessor processor = (SendProcessor) processorType.createProcessor(routeContext);
            loadBalancer.addProcessor(processor);
        }
        return loadBalancer;
    }

    @Override
    public Processor createProcessor(RouteContext routeContext) throws Exception {
        LoadBalancer loadBalancer = LoadBalancerType.getLoadBalancer(routeContext, loadBalancerType, ref);
        for (ProcessorType processorType : getOutputs()) {
            Processor processor = processorType.createProcessor(routeContext);
            processor = processorType.wrapProcessorInInterceptors(routeContext, processor);
            loadBalancer.addProcessor(processor);
        }

        return loadBalancer;
    }

    public LoadBalanceType setLoadBalancer(LoadBalancer loadBalancer) {
        loadBalancerType = new LoadBalancerType(loadBalancer);
        return this;
    }

    public LoadBalanceType roundRobin() {
        loadBalancerType = new LoadBalancerType(new RoundRobinLoadBalancer());
        return this;
    }

    public LoadBalanceType random() {
        loadBalancerType = new LoadBalancerType(new RandomLoadBalancer());
        return this;
    }

    public LoadBalanceType sticky(Expression<Exchange> correlationExpression) {
        loadBalancerType = new LoadBalancerType(new StickyLoadBalancer(correlationExpression));
        return this;
    }

    /**
     * @deprecated will be removed in Camel 2.0, use multicast instead
     */
    public LoadBalanceType topic() {
        loadBalancerType = new LoadBalancerType(new TopicLoadBalancer());
        return this;
    }

    @Override
    public String getLabel() {
        CollectionStringBuffer buffer = new CollectionStringBuffer();
        List<ProcessorType<?>> list = getOutputs();
        for (ProcessorType<?> processorType : list) {
            buffer.append(processorType.getLabel());
        }
        return buffer.toString();
    }

    @Override
    public String toString() {
        if (loadBalancerType != null) {
            return "LoadBalanceType[" + loadBalancerType + ", " + getOutputs() + "]";
        } else {
            return "LoadBalanceType[ref: " + ref + ", " + getOutputs() + "]";

    public String getRef() {
        return ref;

FUNC_DECL RETURN LOOP VAR_DECL PARAM PARAM VAR_DECL CALL CALL CALL

FUNC_DECL RETURN LOOP VAR_DECL PARAM VAR_DECL CALL CALL CALL ASSIGN CALL CALL

FUNC_DECL RETURN LOOP VAR_DECL VAR_DECL CALL CALL CALL CALL CALL


public class KeyIterator extends OneStepIteratorForward
{

  /** Key name.
   *  @serial           */
  private QName m_name;

  /**
   * Get the key name from a key declaration this iterator will process
   *
   *
   * @return Key name
   */
  public QName getName()
  {
    return m_name;
  }

  /** Vector of Key declarations in the stylesheet.
   *  @serial          */
  private Vector m_keyDeclarations;

  /**
   * Get the key declarations from the stylesheet
   *
   *
   * @return Vector containing the key declarations from the stylesheet
   */
  public Vector getKeyDeclarations()
  {
    return m_keyDeclarations;
  }

  /**
    * Create a KeyIterator object.
    *
    * @param compiler A reference to the Compiler that contains the op map.
    * @param opPos The position within the op map, which contains the
    * location path expression for this itterator.
    *
    * @throws javax.xml.transform.TransformerException
    */
  KeyIterator(QName name, Vector keyDeclarations)
  {
    super(Axis.ALL);
    m_keyDeclarations = keyDeclarations;
    m_name = name;
  }

  /**
   *  Test whether a specified node is visible in the logical view of a
   * TreeWalker or NodeIterator. This function will be called by the
   * implementation of TreeWalker and NodeIterator; it is not intended to
   * be called directly from user code.
   *
   * @param testnode  The node to check to see if it passes the filter or not.
   *
   * @return  a constant to determine whether the node is accepted,
   *   rejected, or skipped, as defined  above .
   */
  public short acceptNode(int testNode)
  {
    boolean foundKey = false;
    KeyIterator ki = (KeyIterator) m_lpi;
    org.apache.xpath.XPathContext xctxt = ki.getXPathContext();
    Vector keys = ki.getKeyDeclarations();

    QName name = ki.getName();
    try
    {
      int nDeclarations = keys.size();

      for (int i = 0; i < nDeclarations; i++)
      {
        KeyDeclaration kd = (KeyDeclaration) keys.elementAt(i);

        if (!kd.getName().equals(name))
          continue;

        foundKey = true;

        XPath matchExpr = kd.getMatch();
        double score = matchExpr.getMatchScore(xctxt, testNode);

        if (score == kd.getMatch().MATCH_SCORE_NONE)
          continue;

        return DTMIterator.FILTER_ACCEPT;
	  }
    }
    catch (TransformerException se)
    {

    }

    if (!foundKey)
      throw new RuntimeException(
        XSLMessages.createMessage(
          XSLTErrorResources.ER_NO_XSLKEY_DECLARATION,
          new Object[] { name.getLocalName()}));

    return DTMIterator.FILTER_REJECT;

  public QName getName()
  {
    return m_name;