protected static transient Logger logger = LoggerFactory.getLogger(KnowledgeBuilderImpl.class);

    private final Map<String, PackageRegistry> pkgRegistryMap;

    private List<KnowledgeBuilderResult>                   results;

    private final KnowledgeBuilderConfigurationImpl configuration;

    public static final RuleBuilder ruleBuilder        = new RuleBuilder();

    /**

     * Optional RuleBase for incremental live building

     */

    private InternalKnowledgeBase kBase;

    /**

     * default dialect

     */

    private final String                                   defaultDialect;

    private ClassLoader                                    rootClassLoader;

    private final Map<String, Class<?>>                    globals  = new HashMap<String, Class<?>>();

    private Resource                                       resource;

    private List<DSLTokenizedMappingFile>                  dslFiles;

    protected DateFormats dateFormats;

    private final org.drools.compiler.compiler.ProcessBuilder processBuilder;

    private IllegalArgumentException                       processBuilderCreationFailure;

    private PMMLCompiler                                   pmmlCompiler;

    //This list of package level attributes is initialised with the PackageDescr's attributes added to the builder.

    //The package level attributes are inherited by individual rules not containing explicit overriding parameters.

    //The map is keyed on the PackageDescr's namespace and contains a map of AttributeDescr's keyed on the

    //AttributeDescr's name.

    private final Map<String, Map<String, AttributeDescr>> packageAttributes  = new HashMap<String, Map<String, AttributeDescr>>();

    //PackageDescrs' list of ImportDescrs are kept identical as subsequent PackageDescrs are added.

    private final Map<String, List<PackageDescr>>          packages           = new HashMap<String, List<PackageDescr>>();

    private final Stack<List<Resource>> buildResources     = new Stack<List<Resource>>();

    private int                                            currentRulePackage = 0;

    private AssetFilter                                    assetFilter        = null;

    private final TypeDeclarationBuilder                   typeBuilder;

    /**

     * Use this when package is starting from scratch.

     */

    public KnowledgeBuilderImpl() {

        this((InternalKnowledgeBase) null,

             null);

    }

    /**

     * This will allow you to merge rules into this pre existing package.

     */

    public KnowledgeBuilderImpl(final InternalKnowledgePackage pkg) {

        this(pkg,

             null);

    }

    public KnowledgeBuilderImpl(final InternalKnowledgeBase kBase) {

        this(kBase,

             null);

    }

    /**

     * Pass a specific configuration for the PackageBuilder

     *

     * PackageBuilderConfiguration is not thread safe and it also contains

     * state. Once it is created and used in one or more PackageBuilders it

     * should be considered immutable. Do not modify its properties while it is

     * being used by a PackageBuilder.

     */

    public KnowledgeBuilderImpl(final KnowledgeBuilderConfigurationImpl configuration) {

        this((InternalKnowledgeBase) null,

             configuration);

    }

    public KnowledgeBuilderImpl(InternalKnowledgePackage pkg,

                                KnowledgeBuilderConfigurationImpl configuration) {

        if (configuration == null) {

            this.configuration = new KnowledgeBuilderConfigurationImpl();

        } else {

            this.configuration = configuration;

        }

        this.dateFormats = null;//(DateFormats) this.environment.get( EnvironmentName.DATE_FORMATS );

        if (this.dateFormats == null) {

            this.dateFormats = new DateFormatsImpl();

            //this.environment.set( EnvironmentName.DATE_FORMATS , this.dateFormats );

        }

        this.rootClassLoader = this.configuration.getClassLoader();

        this.defaultDialect = this.configuration.getDefaultDialect();

        this.pkgRegistryMap = new LinkedHashMap<String, PackageRegistry>();

        this.results = new ArrayList<KnowledgeBuilderResult>();

        PackageRegistry pkgRegistry = new PackageRegistry(rootClassLoader, this.configuration, pkg);

        pkgRegistry.setDialect(this.defaultDialect);

        this.pkgRegistryMap.put(pkg.getName(),

                                pkgRegistry);

        // add imports to pkg registry

        for (final ImportDeclaration implDecl : pkg.getImports().values()) {

            pkgRegistry.addImport(new ImportDescr(implDecl.getTarget()));

        }

        processBuilder = createProcessBuilder();

        typeBuilder = new TypeDeclarationBuilder(this);

    }

    public KnowledgeBuilderImpl(InternalKnowledgeBase kBase,

                                KnowledgeBuilderConfigurationImpl configuration) {

        if (configuration == null) {

            this.configuration = new KnowledgeBuilderConfigurationImpl();

        } else {

            this.configuration = configuration;

        }

        if (kBase != null) {

            this.rootClassLoader = kBase.getRootClassLoader();

        } else {

            this.rootClassLoader = this.configuration.getClassLoader();

        }

        this.dateFormats = null;//(DateFormats) this.environment.get( EnvironmentName.DATE_FORMATS );

        if (this.dateFormats == null) {

            this.dateFormats = new DateFormatsImpl();

            //this.environment.set( EnvironmentName.DATE_FORMATS , this.dateFormats );

        }

        // FIXME, we need to get drools to support "default" namespace.

        //this.defaultNamespace = pkg.getName();

        this.defaultDialect = this.configuration.getDefaultDialect();

        this.pkgRegistryMap = new LinkedHashMap<String, PackageRegistry>();

        this.results = new ArrayList<KnowledgeBuilderResult>();

        this.kBase = kBase;

        processBuilder = createProcessBuilder();

        typeBuilder = new TypeDeclarationBuilder(this);

    }

    private ProcessBuilder createProcessBuilder() {

        try {

            return ProcessBuilderFactory.newProcessBuilder(this);

        } catch (IllegalArgumentException e) {

            processBuilderCreationFailure = e;

            return null;

        }

    }

    private PMMLCompiler getPMMLCompiler() {

        if (this.pmmlCompiler == null) {

            this.pmmlCompiler = PMMLCompilerFactory.getPMMLCompiler();

        }

        return this.pmmlCompiler;

    }

    Resource getCurrentResource() {

        return resource;

    }

    InternalKnowledgeBase getKnowledgeBase() {

        return kBase;

    }

    TypeDeclarationBuilder getTypeBuilder() {

        return typeBuilder;

    }

    /**

     * Load a rule package from DRL source.

     *

     * @throws DroolsParserException

     * @throws java.io.IOException

     */

    public void addPackageFromDrl(final Reader reader) throws DroolsParserException,

                                                              IOException {

        addPackageFromDrl(reader, new ReaderResource(reader, ResourceType.DRL));

    }

    /**

     * Load a rule package from DRL source and associate all loaded artifacts

     * with the given resource.

     *

     * @param reader

     * @param sourceResource the source resource for the read artifacts

     * @throws DroolsParserException

     * @throws IOException

     */

    public void addPackageFromDrl(final Reader reader,

                                  final Resource sourceResource) throws DroolsParserException,

                                                                        IOException {

        this.resource = sourceResource;

        final DrlParser parser = new DrlParser(configuration.getLanguageLevel());

        final PackageDescr pkg = parser.parse(sourceResource, reader);

        this.results.addAll(parser.getErrors());

        if (pkg == null) {

            addBuilderResult(new ParserError(sourceResource, "Parser returned a null Package", 0, 0));

        }

        if (!parser.hasErrors()) {

            addPackage(pkg);

        }

        this.resource = null;

    }

    public void addPackageFromDecisionTable(Resource resource,

                                            ResourceConfiguration configuration) throws DroolsParserException,

                                                                                        IOException {

        this.resource = resource;

        addPackage(decisionTableToPackageDescr(resource, configuration));

        this.resource = null;

    }

    PackageDescr decisionTableToPackageDescr(Resource resource,

                                             ResourceConfiguration configuration) throws DroolsParserException,

                                                                                         IOException {

        DecisionTableConfiguration dtableConfiguration = configuration instanceof DecisionTableConfiguration ?

                                                         (DecisionTableConfiguration) configuration :

                                                         null;

        String string = DecisionTableFactory.loadFromInputStream(resource.getInputStream(), dtableConfiguration);

        DrlParser parser = new DrlParser(this.configuration.getLanguageLevel());

        PackageDescr pkg = parser.parse(resource, new StringReader(string));

        this.results.addAll(parser.getErrors());

        if (pkg == null) {

            addBuilderResult(new ParserError(resource, "Parser returned a null Package", 0, 0));

        }

        return parser.hasErrors() ? null : pkg;

    }

    public void addPackageFromScoreCard(Resource resource,

                                        ResourceConfiguration configuration) throws DroolsParserException,

                                                                                    IOException {

        this.resource = resource;

        addPackage(scoreCardToPackageDescr(resource, configuration));

        this.resource = null;

    }

    PackageDescr scoreCardToPackageDescr(Resource resource,

                                         ResourceConfiguration configuration) throws DroolsParserException,

                                                                                     IOException {

        ScoreCardConfiguration scardConfiguration = configuration instanceof ScoreCardConfiguration ?

                                                    (ScoreCardConfiguration) configuration :

                                                    null;

        String string = ScoreCardFactory.loadFromInputStream(resource.getInputStream(), scardConfiguration);

        DrlParser parser = new DrlParser(this.configuration.getLanguageLevel());

        PackageDescr pkg = parser.parse(resource, new StringReader(string));

        this.results.addAll(parser.getErrors());

        if (pkg == null) {

            addBuilderResult(new ParserError(resource, "Parser returned a null Package", 0, 0));

        }

        return parser.hasErrors() ? null : pkg;

    }

    public void addPackageFromDrl(Resource resource) throws DroolsParserException,

                                                            IOException {

        this.resource = resource;

        addPackage(drlToPackageDescr(resource));

        this.resource = null;

    }

    PackageDescr drlToPackageDescr(Resource resource) throws DroolsParserException,

                                                             IOException {

        PackageDescr pkg;

        boolean hasErrors = false;

        if (resource instanceof DescrResource) {

            pkg = (PackageDescr) ((DescrResource) resource).getDescr();

        } else {

            final DrlParser parser = new DrlParser(configuration.getLanguageLevel());

            pkg = parser.parse(resource);

            this.results.addAll(parser.getErrors());

            if (pkg == null) {

                addBuilderResult(new ParserError(resource, "Parser returned a null Package", 0, 0));

            }

            hasErrors = parser.hasErrors();

        }

        if (pkg != null) {

            pkg.setResource(resource);

        }

        return hasErrors ? null : pkg;

    }

    /**

     * Load a rule package from XML source.

     *

     * @param reader

     * @throws DroolsParserException

     * @throws IOException

     */

    public void addPackageFromXml(final Reader reader) throws DroolsParserException,

                                                              IOException {

        this.resource = new ReaderResource(reader, ResourceType.XDRL);

        final XmlPackageReader xmlReader = new XmlPackageReader(this.configuration.getSemanticModules());

        xmlReader.getParser().setClassLoader(this.rootClassLoader);

        try {

            xmlReader.read(reader);

        } catch (final SAXException e) {

            throw new DroolsParserException(e.toString(),

                                            e.getCause());

        }

        addPackage(xmlReader.getPackageDescr());

        this.resource = null;

    }

    public void addPackageFromXml(final Resource resource) throws DroolsParserException,

                                                                  IOException {

        this.resource = resource;

        addPackage(xmlToPackageDescr(resource));

        this.resource = null;

    }

    PackageDescr xmlToPackageDescr(Resource resource) throws DroolsParserException,

                                                             IOException {

        final XmlPackageReader xmlReader = new XmlPackageReader(this.configuration.getSemanticModules());

        xmlReader.getParser().setClassLoader(this.rootClassLoader);

        Reader reader = null;

        try {

            reader = resource.getReader();

            xmlReader.read(reader);

        } catch (final SAXException e) {

            throw new DroolsParserException(e.toString(),

                                            e.getCause());

        } finally {

            if (reader != null) {

                reader.close();

            }

        }

        return xmlReader.getPackageDescr();

    }

    /**

     * Load a rule package from DRL source using the supplied DSL configuration.

     *

     * @param source

     *            The source of the rules.

     * @param dsl

     *            The source of the domain specific language configuration.

     * @throws DroolsParserException

     * @throws IOException

     */

    public void addPackageFromDrl(final Reader source,

                                  final Reader dsl) throws DroolsParserException,

                                                           IOException {

        this.resource = new ReaderResource(source, ResourceType.DSLR);

        final DrlParser parser = new DrlParser(configuration.getLanguageLevel());

        final PackageDescr pkg = parser.parse(source, dsl);

        this.results.addAll(parser.getErrors());

        if (!parser.hasErrors()) {

            addPackage(pkg);

        }

        this.resource = null;

    }

    public void addPackageFromDslr(final Resource resource) throws DroolsParserException,

                                                                   IOException {

        this.resource = resource;

        addPackage(dslrToPackageDescr(resource));

        this.resource = null;

    }

    PackageDescr dslrToPackageDescr(Resource resource) throws DroolsParserException {

        boolean hasErrors;

        PackageDescr pkg;

        DrlParser parser = new DrlParser(configuration.getLanguageLevel());

        DefaultExpander expander = getDslExpander();

        Reader reader = null;

        try {

            if (expander == null) {

                expander = new DefaultExpander();

            }

            reader = resource.getReader();

            String str = expander.expand(reader);

            if (expander.hasErrors()) {

                for (ExpanderException error : expander.getErrors()) {

                    error.setResource(resource);

                    addBuilderResult(error);

                }

            }

            pkg = parser.parse(resource, str);

            this.results.addAll(parser.getErrors());

            hasErrors = parser.hasErrors();

        } catch (IOException e) {

            throw new RuntimeException(e);

        } finally {

            if (reader != null) {

                try {

                    reader.close();

                } catch (IOException e) {

                }

            }

        }

        return hasErrors ? null : pkg;

    }

    public void addDsl(Resource resource) throws IOException {

        this.resource = resource;

        DSLTokenizedMappingFile file = new DSLTokenizedMappingFile();

        Reader reader = null;

        try {

            reader = resource.getReader();

            if (!file.parseAndLoad(reader)) {

                this.results.addAll(file.getErrors());

            }

            if (this.dslFiles == null) {

                this.dslFiles = new ArrayList<DSLTokenizedMappingFile>();

            }

            this.dslFiles.add(file);

        } finally {

            if (reader != null) {

                reader.close();

            }

            this.resource = null;

        }

    }

    /**

     * Add a ruleflow (.rfm) asset to this package.

     */

    public void addRuleFlow(Reader processSource) {

        addProcessFromXml(processSource);

    }

    public void addProcessFromXml(Resource resource) {

        if (processBuilder == null) {

            throw new RuntimeException("Unable to instantiate a process builder", processBuilderCreationFailure);

        }

        if (ResourceType.DRF.equals(resource.getResourceType())) {

            addBuilderResult(new DeprecatedResourceTypeWarning(resource, "RF"));

        }

        this.resource = resource;

        try {

            this.results.addAll(processBuilder.addProcessFromXml(resource));

            processBuilder.getErrors().clear();

        } catch (Exception e) {

            if (e instanceof RuntimeException) {

                throw (RuntimeException) e;

            }

            addBuilderResult(new ProcessLoadError(resource, "Unable to load process.", e));

        }

        this.results = getResults(this.results);

        this.resource = null;

    }

    public void addProcessFromXml(Reader processSource) {

        addProcessFromXml(new ReaderResource(processSource, ResourceType.DRF));

    }

    public void addKnowledgeResource(Resource resource,

                                     ResourceType type,

                                     ResourceConfiguration configuration) {

        try {

            ((InternalResource) resource).setResourceType(type);

            if (ResourceType.DRL.equals(type)) {

                addPackageFromDrl(resource);

            } else if (ResourceType.GDRL.equals(type)) {

                addPackageFromDrl(resource);

            } else if (ResourceType.RDRL.equals(type)) {

                addPackageFromDrl(resource);

            } else if (ResourceType.DESCR.equals(type)) {

                addPackageFromDrl(resource);

            } else if (ResourceType.DSLR.equals(type)) {

                addPackageFromDslr(resource);

            } else if (ResourceType.RDSLR.equals(type)) {

                addPackageFromDslr(resource);

            } else if (ResourceType.DSL.equals(type)) {

                addDsl(resource);

            } else if (ResourceType.XDRL.equals(type)) {

                addPackageFromXml(resource);

            } else if (ResourceType.DRF.equals(type)) {

                addProcessFromXml(resource);

            } else if (ResourceType.BPMN2.equals(type)) {

                BPMN2ProcessFactory.configurePackageBuilder(this);

                addProcessFromXml(resource);

            } else if (ResourceType.DTABLE.equals(type)) {

                addPackageFromDecisionTable(resource, configuration);

            } else if (ResourceType.PKG.equals(type)) {

                addPackageFromInputStream(resource);

            } else if (ResourceType.CHANGE_SET.equals(type)) {

                addPackageFromChangeSet(resource);

            } else if (ResourceType.XSD.equals(type)) {

                addPackageFromXSD(resource, (JaxbConfigurationImpl) configuration);

            } else if (ResourceType.PMML.equals(type)) {

                addPackageFromPMML(resource, type, configuration);

            } else if (ResourceType.SCARD.equals(type)) {

                addPackageFromScoreCard(resource, configuration);

            } else {

                addPackageForExternalType(resource, type, configuration);

            }

        } catch (RuntimeException e) {

            throw e;

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

    }

    void addPackageForExternalType(Resource resource,

                                   ResourceType type,

                                   ResourceConfiguration configuration) throws Exception {

        ResourceTypeBuilder builder = ResourceTypeBuilderRegistry.getInstance().getResourceTypeBuilder(type);

        if (builder != null) {

            builder.setPackageBuilder(this);

            builder.addKnowledgeResource(resource,

                                         type,

                                         configuration);

        } else {

            throw new RuntimeException("Unknown resource type: " + type);

        }

    }

    public void addPackageFromPMML(Resource resource,

                                   ResourceType type,

                                   ResourceConfiguration configuration) throws Exception {

        PMMLCompiler compiler = getPMMLCompiler();

        if (compiler != null) {

            if (compiler.getResults().isEmpty()) {

                this.resource = resource;

                PackageDescr descr = pmmlModelToPackageDescr(compiler, resource);

                if (descr != null) {

                    addPackage(descr);

                }

                this.resource = null;

            } else {

                this.results.addAll(compiler.getResults());

            }

            compiler.clearResults();

        } else {

            addPackageForExternalType(resource, type, configuration);

        }

    }

    PackageDescr pmmlModelToPackageDescr(PMMLCompiler compiler,

                                         Resource resource) throws DroolsParserException,

                                                                   IOException {

        String theory = compiler.compile(resource.getInputStream(),

                                         rootClassLoader);

        if (!compiler.getResults().isEmpty()) {

            this.results.addAll(compiler.getResults());

            return null;

        }

        DrlParser parser = new DrlParser(configuration.getLanguageLevel());

        PackageDescr pkg = parser.parse(resource, new StringReader(theory));

        this.results.addAll(parser.getErrors());

        if (pkg == null) {

            addBuilderResult(new ParserError(resource, "Parser returned a null Package", 0, 0));

            return pkg;

        } else {

            return parser.hasErrors() ? null : pkg;

        }

    }

    void addPackageFromXSD(Resource resource,

                           JaxbConfigurationImpl configuration) throws IOException {

        String[] classes = DroolsJaxbHelperProviderImpl.addXsdModel(resource,

                                                                    this,

                                                                    configuration.getXjcOpts(),

                                                                    configuration.getSystemId());

        for (String cls : classes) {

            configuration.getClasses().add(cls);

        }

    }

    void addPackageFromChangeSet(Resource resource) throws SAXException,

                                                           IOException {

        XmlChangeSetReader reader = new XmlChangeSetReader(this.configuration.getSemanticModules());

        if (resource instanceof ClassPathResource) {

            reader.setClassLoader(((ClassPathResource) resource).getClassLoader(),

                                  ((ClassPathResource) resource).getClazz());

        } else {

            reader.setClassLoader(this.configuration.getClassLoader(),

                                  null);

        }

        Reader resourceReader = null;

        try {

            resourceReader = resource.getReader();

            ChangeSet changeSet = reader.read(resourceReader);

            if (changeSet == null) {

                // @TODO should log an error

            }

            for (Resource nestedResource : changeSet.getResourcesAdded()) {

                InternalResource iNestedResourceResource = (InternalResource) nestedResource;

                if (iNestedResourceResource.isDirectory()) {

                    for (Resource childResource : iNestedResourceResource.listResources()) {

                        if (((InternalResource) childResource).isDirectory()) {

                            continue; // ignore sub directories

                        }

                        ((InternalResource) childResource).setResourceType(iNestedResourceResource.getResourceType());

                        addKnowledgeResource(childResource,

                                             iNestedResourceResource.getResourceType(),

                                             iNestedResourceResource.getConfiguration());

                    }

                } else {

                    addKnowledgeResource(iNestedResourceResource,

                                         iNestedResourceResource.getResourceType(),

                                         iNestedResourceResource.getConfiguration());

                }

            }

        } finally {

            if (resourceReader != null) {

                resourceReader.close();

            }

        }

    }

    void addPackageFromInputStream(final Resource resource) throws IOException,

                                                                   ClassNotFoundException {

        InputStream is = resource.getInputStream();

        Object object = DroolsStreamUtils.streamIn(is, this.configuration.getClassLoader());

        is.close();

        if (object instanceof Collection) {

            // KnowledgeBuilder API

            @SuppressWarnings("unchecked")

            Collection<KnowledgePackage> pkgs = (Collection<KnowledgePackage>) object;

            for (KnowledgePackage kpkg : pkgs) {

                overrideReSource((KnowledgePackageImpl) kpkg, resource);

                addPackage((KnowledgePackageImpl) kpkg);

            }

        } else if (object instanceof KnowledgePackageImpl) {

            // KnowledgeBuilder API

            KnowledgePackageImpl kpkg = (KnowledgePackageImpl) object;

            overrideReSource(kpkg, resource);

            addPackage(kpkg);

        } else {

            results.add(new DroolsError(resource) {

                @Override

                public String getMessage() {

                    return "Unknown binary format trying to load resource " + resource.toString();

                }

                @Override

                public int[] getLines() {

                    return new int[0];

                }

            });

        }

    }

    private void overrideReSource(InternalKnowledgePackage pkg,

                                  Resource res) {

        for (org.kie.api.definition.rule.Rule r : pkg.getRules()) {

            if (isSwappable(((RuleImpl)r).getResource(), res)) {

                ((RuleImpl)r).setResource(res);

            }

        }

        for (TypeDeclaration d : pkg.getTypeDeclarations().values()) {

            if (isSwappable(d.getResource(), res)) {

                d.setResource(res);

            }

        }

        for (Function f : pkg.getFunctions().values()) {

            if (isSwappable(f.getResource(), res)) {

                f.setResource(res);

            }

        }

        for (org.kie.api.definition.process.Process p : pkg.getRuleFlows().values()) {

            if (isSwappable(p.getResource(), res)) {

                p.setResource(res);

            }

        }

    }

    private boolean isSwappable(Resource original,

                                Resource source) {

        return original == null

               || (original instanceof ReaderResource && ((ReaderResource) original).getReader() == null);

    }

    /**

     * This adds a package from a Descr/AST This will also trigger a compile, if

     * there are any generated classes to compile of course.

     */

    public void addPackage(final PackageDescr packageDescr) {

        PackageRegistry pkgRegistry = initPackageRegistry(packageDescr);

        if (pkgRegistry == null) {

            return;

        }

        currentRulePackage = pkgRegistryMap.size() - 1;

        // merge into existing package

        mergePackage(pkgRegistry, packageDescr);

        compileAllRules(packageDescr, pkgRegistry);

    }

    void compileAllRules(PackageDescr packageDescr, PackageRegistry pkgRegistry) {

        pkgRegistry.setDialect(getPackageDialect(packageDescr));

        compileRules(packageDescr, pkgRegistry);

        compileAll();

        try {

            reloadAll();

        } catch (Exception e) {

            addBuilderResult(new DialectError(null, "Unable to wire compiled classes, probably related to compilation failures:" + e.getMessage()));

        }

        updateResults();

        // iterate and compile

        if (!hasErrors() && this.kBase != null) {

            for (RuleDescr ruleDescr : packageDescr.getRules()) {

                if( filterAccepts( ruleDescr.getNamespace(), ruleDescr.getName() ) ) {

                    pkgRegistry = this.pkgRegistryMap.get(ruleDescr.getNamespace());

                    this.kBase.addRule(pkgRegistry.getPackage(), pkgRegistry.getPackage().getRule(ruleDescr.getName()));

                }

            }

        }

    }

    void addBuilderResult(KnowledgeBuilderResult result) {

        this.results.add(result);

    }

    PackageRegistry createPackageRegistry(PackageDescr packageDescr) {

        PackageRegistry pkgRegistry = initPackageRegistry(packageDescr);

        if (pkgRegistry == null) {

            return null;

        }

        for (ImportDescr importDescr : packageDescr.getImports()) {

            pkgRegistry.registerImport( importDescr.getTarget() );

        }

        return pkgRegistry;

    }

    private PackageRegistry initPackageRegistry(PackageDescr packageDescr) {

        if (packageDescr == null) {

            return null;

        }

        //Derive namespace

        if (isEmpty(packageDescr.getNamespace())) {

            packageDescr.setNamespace(this.configuration.getDefaultPackageName());

        }

        validateUniqueRuleNames(packageDescr);

        if (!checkNamespace(packageDescr.getNamespace())) {

            return null;

        }

        initPackage(packageDescr);

        PackageRegistry pkgRegistry = this.pkgRegistryMap.get(packageDescr.getNamespace());

        if (pkgRegistry == null) {

            // initialise the package and namespace if it hasn't been used before

            pkgRegistry = newPackage(packageDescr);

        }

        return pkgRegistry;

    }

    private void compileRules(PackageDescr packageDescr, PackageRegistry pkgRegistry) {

        List<FunctionDescr> functions = packageDescr.getFunctions();

        if (!functions.isEmpty()) {

            for (FunctionDescr functionDescr : functions) {

                if (filterAccepts(functionDescr.getNamespace(), functionDescr.getName()) ) {

                    if (isEmpty(functionDescr.getNamespace())) {

                        // make sure namespace is set on components

                        functionDescr.setNamespace(packageDescr.getNamespace());

                    }

                    // make sure functions are compiled using java dialect

                    functionDescr.setDialect("java");

                    preCompileAddFunction(functionDescr);

                }

            }

            // iterate and compile