* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements.  See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

    private static final Pattern UNQUOTER = Pattern

            .compile("(<)|(>)|(')|(&)|(")|(\"\")|('')|(&#\\d+;)|(&#x(?:[A-Fa-f0-9])+;)");

    private final CompilerControlBlock ccb;

    private final StaticContext rootCtx;

    private StaticContext moduleCtx;

    private IVariableScope rootVarScope;

    private StaticContext currCtx;

    private int varCounter;

    private final ByteArrayAccessibleOutputStream baaos;

    private final DataOutput dOut;

    private final StringValueBuilder stringVB;

    public XMLQueryTranslator(CompilerControlBlock ccb) {

        this.ccb = ccb;

        varCounter = 0;

        rootCtx = ccb.getStaticContext();

        baaos = new ByteArrayAccessibleOutputStream();

        dOut = new DataOutputStream(baaos);

        stringVB = new StringValueBuilder();

    }

    private void pushContext() {

        currCtx = new ThinStaticContextImpl(currCtx);

    }

    private void popContext() {

        currCtx = currCtx.getParent();

    }

    public Module translateModule(ModuleNode moduleNode) throws SystemException {

        Module module = new Module();

        moduleCtx = new StaticContextImpl(rootCtx);

        moduleCtx.registerVariable(new XQueryVariable(XMLQueryCompilerConstants.DOT_VAR_NAME, SequenceType.create(

                AnyItemType.INSTANCE, Quantifier.QUANT_ONE), newLogicalVariable()));

        rootVarScope = new RootVariableScope();

        currCtx = moduleCtx;

        module.setModuleContext(moduleCtx);

        module.setCompilerControlBlock(ccb);

        VersionDeclNode ver = moduleNode.getVersion();

        if (ver != null) {

            if (!"1.0".equals(ver.getVersion())) {

                throw new SystemException(ErrorCode.XQST0031, ver.getSourceLocation());

            }

        }

        switch (moduleNode.getTag()) {

            case LIBRARY_MODULE: {

                module.setModuleType(ModuleType.LIBRARY);

                LibraryModuleNode lmNode = (LibraryModuleNode) moduleNode;

                String prefix = lmNode.getModuleDecl().getPrefix();

                String uri = unquote(lmNode.getModuleDecl().getTargetNS());

                if (prefix != null) {

                    currCtx.registerNamespaceUri(prefix, uri);

                }

                module.setNamespaceUri(uri);

                break;

            }

            case MAIN_MODULE: {

                module.setModuleType(ModuleType.MAIN);

                break;

            }

            default:

                throw new IllegalStateException("Unknown module type: " + moduleNode.getTag());

        }

        PrologNode prologNode = moduleNode.getProlog();

        parsePrologPass1(prologNode);

        parsePrologPass2(prologNode);

        ILogicalPlan plan = null;

        switch (moduleNode.getTag()) {

            case LIBRARY_MODULE:

                throw new SystemException(ErrorCode.TODO);

            case MAIN_MODULE:

                plan = translateMainModule((MainModuleNode) moduleNode);

        }

        module.setBody(plan);

        return module;

    }

    @SuppressWarnings("unchecked")

    private void parsePrologPass1(PrologNode prologNode) throws SystemException {

        if (prologNode != null) {

            List<ASTNode> decls = prologNode.getDecls();

            for (ASTNode d : decls) {

                switch (d.getTag()) {

                    case DEFAULT_ELEMENT_NAMESPACE_DECLARATION: {

                        DefaultElementNamespaceDeclNode node = (DefaultElementNamespaceDeclNode) d;

                        moduleCtx.setDefaultElementNamespaceUri(node.getUri());

                        break;

                    }

                    case DEFAULT_FUNCTION_NAMESPACE_DECLARATION: {

                        DefaultFunctionNamespaceDeclNode node = (DefaultFunctionNamespaceDeclNode) d;

                        moduleCtx.setDefaultFunctionNamespaceUri(node.getUri());

                        break;

                    }

                    case BOUNDARY_SPACE_DECLARATION: {

                        BoundarySpaceDeclNode node = (BoundarySpaceDeclNode) d;

                        moduleCtx.setBoundarySpaceProperty(node.getMode());

                        break;

                    }

                    case DEFAULT_COLLATION_DECLARATION: {

                        DefaultCollationDeclNode node = (DefaultCollationDeclNode) d;

                        moduleCtx.setDefaultCollation(node.getCollation());

                        break;

                    }

                    case BASE_URI_DECLARATION: {

                        BaseUriDeclNode node = (BaseUriDeclNode) d;

                        moduleCtx.setBaseUri(node.getUri());

                        break;

                    }

                    case CONSTRUCTION_DECLARATION: {

                        ConstructionDeclNode node = (ConstructionDeclNode) d;

                        moduleCtx.setConstructionModeProperty(node.getMode());

                        break;

                    }

                    case ORDERING_MODE_DECLARATION: {

                        OrderingModeDeclNode node = (OrderingModeDeclNode) d;

                        moduleCtx.setOrderingModeProperty(node.getMode());

                        break;

                    }

                    case EMPTY_ORDER_DECLARATION: {

                        EmptyOrderDeclNode node = (EmptyOrderDeclNode) d;

                        moduleCtx.setEmptyOrderProperty(node.getMode());

                        break;

                    }

                    case COPY_NAMESPACES_DECLARATION: {

                        CopyNamespacesDeclNode node = (CopyNamespacesDeclNode) d;

                        moduleCtx.setCopyNamespacesModeProperty(node.getMode());

                        break;

                    }

                    case NAMESPACE_DECLARATION: {

                        NamespaceDeclNode node = (NamespaceDeclNode) d;

                        moduleCtx.registerNamespaceUri(node.getPrefix(), unquote(node.getUri()));

                        break;

                    }

                    case SCHEMA_IMPORT: {

                        SchemaImportNode node = (SchemaImportNode) d;

                        if (node.isDefaultElementNamespace()) {

                            moduleCtx.setDefaultElementNamespaceUri(node.getTargetNS());

                        }

                        if (node.getPrefix() != null) {

                            moduleCtx.registerNamespaceUri(node.getPrefix(), unquote(node.getTargetNS()));

                        }

                        moduleCtx.registerSchemaImport(node.getTargetNS(), node.getLocations());

                        break;

                    }

                    case MODULE_IMPORT: {

                        ModuleImportNode node = (ModuleImportNode) d;

                        if (node.getPrefix() != null) {

                            moduleCtx.registerNamespaceUri(node.getPrefix(), unquote(node.getTargetNS()));

                        }

                        moduleCtx.registerModuleImport(node.getTargetNS(), node.getLocations());

                        break;

                    }

                    case VARIABLE_DECLARATION: {

                        VarDeclNode node = (VarDeclNode) d;

                        QName name = createQName(node.getName());

                        SequenceType type = SequenceType.create(AnyItemType.INSTANCE, Quantifier.QUANT_STAR);

                        if (node.getType() != null) {

                            type = createSequenceType(node.getType());

                        }

                        LogicalVariable lVar = newLogicalVariable();

                        XQueryVariable var = new XQueryVariable(name, type, lVar);

                        moduleCtx.registerVariable(var);

                        break;

                    }

                    case FUNCTION_DECLARATION: {

                        FunctionDeclNode node = (FunctionDeclNode) d;

                        boolean external = node.getBody() == null;

                        QName name = createQName(node.getName(), moduleCtx.getDefaultFunctionNamespaceUri());

                        String uri = name.getNamespaceURI();

                        if (XQueryConstants.FN_NSURI.equals(uri) || XQueryConstants.XS_NSURI.equals(uri)

                                || XQueryConstants.XSI_NSURI.equals(uri) || XQueryConstants.XML_NSURI.equals(uri)) {

                            throw new SystemException(ErrorCode.XQST0045, node.getSourceLocation());

                        }

                        SequenceType rType = SequenceType.create(AnyItemType.INSTANCE, Quantifier.QUANT_STAR);

                        if (node.getReturnType() != null) {

                            rType = createSequenceType(node.getReturnType());

                        }

                        Pair<QName, SequenceType> paramTypes[] = new Pair[node.getParameters().size()];

                        for (int i = 0; i < paramTypes.length; ++i) {

                            ParamNode pNode = node.getParameters().get(i);

                            QName pName = createQName(pNode.getName());

                            SequenceType pType = SequenceType.create(AnyItemType.INSTANCE, Quantifier.QUANT_STAR);

                            if (pNode.getType() != null) {

                                pType = createSequenceType(pNode.getType());

                            }

                            paramTypes[i] = Pair.<QName, SequenceType> of(pName, pType);

                        }

                        Signature sign = new Signature(rType, paramTypes);

                        Function f = external ? new ExternalFunction(name, sign) : new UserDefinedXQueryFunction(name,

                                sign, null);

                        moduleCtx.registerFunction(f);

                        break;

                    }

                    case OPTION_DECLARATION: {

                        OptionDeclNode node = (OptionDeclNode) d;

                        QName name = createQName(node.getName());

                        moduleCtx.setOption(name, node.getValue());

                        break;

                    }

                    default:

                        throw new IllegalStateException("Unknown node: " + d.getTag());

                }

            }

        }

    }

    private void parsePrologPass2(PrologNode prologNode) throws SystemException {

        if (prologNode != null) {

            List<ASTNode> decls = prologNode.getDecls();

            for (ASTNode d : decls) {

                switch (d.getTag()) {

                    case VARIABLE_DECLARATION: {

                        VarDeclNode node = (VarDeclNode) d;

                        // TODO Support Global variables

                        break;

                    }

                    case FUNCTION_DECLARATION: {

                        FunctionDeclNode node = (FunctionDeclNode) d;

                        boolean external = node.getBody() == null;

                        if (!external) {

                            QName name = createQName(node.getName(), moduleCtx.getDefaultFunctionNamespaceUri());

                            int arity = node.getParameters().size();

                            UserDefinedXQueryFunction f = (UserDefinedXQueryFunction) moduleCtx.lookupFunction(name,

                                    arity);

                            Signature sign = f.getSignature();

                            TranslationContext tCtx = new TranslationContext(null, new EmptyTupleSourceOperator());

                            XQueryVariable[] params = new XQueryVariable[arity];

                            for (int i = 0; i < arity; ++i) {

                                ParamNode pNode = node.getParameters().get(i);

                                QName pName = createQName(pNode.getName());

                                SequenceType pType = SequenceType.create(AnyItemType.INSTANCE, Quantifier.QUANT_STAR);

                                if (pNode.getType() != null) {

                                    pType = createSequenceType(pNode.getType());

                                }

                                XQueryVariable pVar = new XQueryVariable(pName, pType, newLogicalVariable());

                                params[i] = pVar;

                                tCtx.varScope.registerVariable(pVar);

                            }

                            f.setParameters(params);

                            LogicalVariable var = translateExpression(node.getBody(), tCtx);

                            ILogicalExpression expr = treat(vre(var), sign.getReturnType());

                            var = createAssignment(expr, tCtx);

                            f.setBody(new ALogicalPlanImpl(mutable(tCtx.op)));

                        }

                        break;

                    }

                }

            }

        }

    }

    private SequenceType createSequenceType(ASTNode type) throws SystemException {

        switch (type.getTag()) {

            case TYPE_DECLARATION: {

                TypeDeclNode tDecl = (TypeDeclNode) type;

                return createSequenceType(tDecl.getType());

            }

            case SEQUENCE_TYPE: {

                SequenceTypeNode sType = (SequenceTypeNode) type;

                if (sType.getItemType() == null) {

                    return SequenceType.create(AnyItemType.INSTANCE, Quantifier.QUANT_STAR);

                }

                TypeQuantifier tq = sType.getQuantifier();

                Quantifier q = Quantifier.QUANT_ONE;

                if (tq != null) {

                    switch (tq) {

                        case QUANT_QUESTION:

                            q = Quantifier.QUANT_QUESTION;

                            break;

                        case QUANT_PLUS:

                            q = Quantifier.QUANT_PLUS;

                            break;

                        case QUANT_STAR:

                            q = Quantifier.QUANT_STAR;

                            break;

                    }

                }

                ItemType iType = createItemType(sType.getItemType());

                return SequenceType.create(iType, q);

            }

            case EMPTY_SEQUENCE_TYPE: {

                return SequenceType.create(EmptySequenceType.INSTANCE, Quantifier.QUANT_ZERO);

            }

            case SINGLE_TYPE: {

                SingleTypeNode stNode = (SingleTypeNode) type;

                ItemType iType = createItemType(stNode.getAtomicType());

                return SequenceType.create(iType, stNode.isOptional() ? Quantifier.QUANT_QUESTION

                        : Quantifier.QUANT_ONE);

            }

            default:

                throw new IllegalStateException("Unknown node: " + type.getTag());

        }

    }

    private ItemType createItemType(ASTNode itemType) throws SystemException {

        switch (itemType.getTag()) {

            case ITEM_TYPE:

                return AnyItemType.INSTANCE;

            case ATOMIC_TYPE: {

                AtomicTypeNode atNode = (AtomicTypeNode) itemType;

                QName tName = createQName(atNode.getName());

                SchemaType sType = moduleCtx.lookupSchemaType(tName);

                if (sType == null || !sType.isAtomicType()) {

                    throw new SystemException(ErrorCode.XPST0051, atNode.getSourceLocation());

                }

                return (ItemType) sType;

            }

            case ANY_NODE_TEST:

                return AnyNodeType.INSTANCE;

            case DOCUMENT_TEST: {

                DocumentTestNode dt = (DocumentTestNode) itemType;

                if (dt.getElementTest() == null) {

                    return DocumentType.ANYDOCUMENT;

                }

                ElementType eType = (ElementType) createItemType(dt.getElementTest());

                return new DocumentType(eType);

            }

            case TEXT_TEST:

                return TextType.INSTANCE;

            case COMMENT_TEST:

                return CommentType.INSTANCE;

            case PI_TEST: {

                PITestNode pit = (PITestNode) itemType;

                if (pit.getTarget() == null) {

                    return ProcessingInstructionType.ANYPI;

                }

                return new ProcessingInstructionType(createUTF8String(pit.getTarget()));

            }

            case ATTRIBUTE_TEST: {

                AttributeTestNode at = (AttributeTestNode) itemType;

                if (at.getNameTest() == null) {

                    return AttributeType.ANYATTRIBUTE;

                }

                NameTestNode ntNode = at.getNameTest();

                NameTest nt = NameTest.STAR_NAMETEST;

                if (ntNode.getPrefix() == null && ntNode.getLocalName() == null) {

                    if (at.getTypeName() == null) {

                        return AttributeType.ANYATTRIBUTE;

                    }

                } else {

                    String uri;

                    if (!"".equals(ntNode.getPrefix())) {

                        uri = currCtx.lookupNamespaceUri(ntNode.getPrefix());

                        if (uri == null) {

                            throw new SystemException(ErrorCode.XPST0081, ntNode.getSourceLocation());

                        }

                    } else {

                        uri = "";

                    }

                    nt = new NameTest(createUTF8String(uri), createUTF8String(ntNode.getLocalName()));

                }

                SchemaType cType = BuiltinTypeRegistry.XS_ANY_ATOMIC;

                if (at.getTypeName() != null) {

                    cType = moduleCtx.lookupSchemaType(createQName(at.getTypeName()));

                    if (cType == null) {

                        throw new SystemException(ErrorCode.XPST0051, at.getSourceLocation());

                    }

                }

                return new AttributeType(nt, cType);

            }

            case SCHEMA_ATTRIBUTE_TEST: {

                throw new UnsupportedOperationException("schema-attribute(...) is not supported");

            }

            case ELEMENT_TEST: {

                ElementTestNode et = (ElementTestNode) itemType;

                if (et.getNameTest() == null) {

                    return ElementType.ANYELEMENT;

                }

                NameTestNode ntNode = et.getNameTest();

                NameTest nt = NameTest.STAR_NAMETEST;

                if (ntNode.getPrefix() == null && ntNode.getLocalName() == null) {

                    if (et.getTypeName() == null) {

                        return ElementType.ANYELEMENT;

                    }

                } else {

                    String uri;

                    if (!"".equals(ntNode.getPrefix())) {

                        uri = currCtx.lookupNamespaceUri(ntNode.getPrefix());

                        if (uri == null) {

                            throw new SystemException(ErrorCode.XPST0081, ntNode.getSourceLocation());

                        }

                    } else {

                        uri = "";

                    }

                    nt = new NameTest(createUTF8String(uri), createUTF8String(ntNode.getLocalName()));

                }

                SchemaType cType = AnyType.INSTANCE;

                if (et.getTypeName() != null) {

                    cType = moduleCtx.lookupSchemaType(createQName(et.getTypeName()));

                    if (cType == null) {

                        throw new SystemException(ErrorCode.XPST0051, et.getSourceLocation());

                    }

                }

                return new ElementType(nt, cType, et.isNillable());

            }

            case SCHEMA_ELEMENT_TEST: {

                throw new UnsupportedOperationException("schema-element(...) is not supported");

            }

            default:

                throw new IllegalStateException("Unknown node: " + itemType.getTag());

        }

    }

    private byte[] createUTF8String(String str) {

        ArrayBackedValueStorage abvs = new ArrayBackedValueStorage();

        StringValueBuilder svb = new StringValueBuilder();

        try {

            svb.write(str, abvs.getDataOutput());

        } catch (IOException e) {

            throw new IllegalStateException(e);

        }

        return Arrays.copyOf(abvs.getByteArray(), abvs.getLength());

    }

    private ILogicalPlan translateMainModule(MainModuleNode moduleNode) throws SystemException {

        QueryBodyNode qbn = moduleNode.getQueryBody();

        ASTNode queryBody = qbn.getExpression();

        TranslationContext tCtx = new TranslationContext(null, new EmptyTupleSourceOperator());

        LogicalVariable lVar = translateExpression(queryBody, tCtx);

        LogicalVariable iLVar = newLogicalVariable();

        UnnestOperator unnest = new UnnestOperator(iLVar, mutable(ufce(BuiltinOperators.ITERATE, vre(lVar))));

        unnest.getInputs().add(mutable(tCtx.op));

        List<Mutable<ILogicalExpression>> exprs = new ArrayList<Mutable<ILogicalExpression>>();

        exprs.add(mutable(vre(iLVar)));

        WriteOperator op = new WriteOperator(exprs, new QueryResultDataSink(ccb.getResultFileSplits()));

        op.getInputs().add(mutable(unnest));

        ALogicalPlanImpl lp = new ALogicalPlanImpl(mutable(op));

        return lp;

    }

    private LogicalVariable translateExpression(ASTNode value, TranslationContext tCtx) throws SystemException {

        switch (value.getTag()) {

            case EXPRESSION: {

                ExprNode node = (ExprNode) value;

                return translateExprNode(tCtx, node);

            }

            case UNARY_EXPRESSION: {

                UnaryExprNode ueNode = (UnaryExprNode) value;

                return translateUnaryExprNode(tCtx, ueNode);

            }

            case INFIX_EXPRESSION: {

                InfixExprNode ie = (InfixExprNode) value;

                return translateInfixExprNode(tCtx, ie);

            }

            case ENCLOSED_EXPRESSION: {

                EnclosedExprNode ee = (EnclosedExprNode) value;

                return translateEnclosedExprNode(tCtx, ee);

            }

            case PATH_EXPRESSION:

                return translatePathExpr((PathExprNode) value, tCtx);

            case FUNCTION_EXPRESSION: {

                FunctionExprNode fnNode = (FunctionExprNode) value;

                return translateFunctionExprNode(tCtx, fnNode);

            }

            case TYPE_EXPRESSION: {

                TypeExprNode teNode = (TypeExprNode) value;

                return translateTypeExprNode(tCtx, teNode);

            }

            case EXTENSION_EXPRESSION: {

                ExtensionExprNode eNode = (ExtensionExprNode) value;

                return translateExtensionExprNode(tCtx, eNode);

            }

            case PARENTHESIZED_EXPRESSION: {

                ParenthesizedExprNode peNode = (ParenthesizedExprNode) value;

                return translateParenthisizedExprNode(tCtx, peNode);

            }

            case LITERAL: {

                LiteralNode lNode = (LiteralNode) value;

                return translateLiteralNode(tCtx, lNode);

            }

            case DIRECT_PI_CONSTRUCTOR: {

                DirectPIConstructorNode dpicNode = (DirectPIConstructorNode) value;

                return translateDirectPIConstructorNode(tCtx, dpicNode);

            }

            case DIRECT_COMMENT_CONSTRUCTOR: {

                DirectCommentConstructorNode dccNode = (DirectCommentConstructorNode) value;

                return translateDirectCommentConstructorNode(tCtx, dccNode);

            }

            case DIRECT_ELEMENT_CONSTRUCTOR: {

                DirectElementConstructorNode decNode = (DirectElementConstructorNode) value;

                return translateDirectElementConstructorNode(tCtx, decNode);

            }

            case DIRECT_ATTRIBUTE_CONSTRUCTOR: {

                DirectAttributeConstructorNode dacNode = (DirectAttributeConstructorNode) value;

                return translateDirectAttributeConstructorNode(tCtx, dacNode);

            }

            case CONTEXT_ITEM:

                return tCtx.varScope.lookupVariable(XMLQueryCompilerConstants.DOT_VAR_NAME).getLogicalVariable();

            case IF_EXPRESSION: {

                IfExprNode ieNode = (IfExprNode) value;

                return translateIfExprNode(tCtx, ieNode);

            }

            case VARIABLE_REFERENCE: {

                VarRefNode vrNode = (VarRefNode) value;

                return translateVarRefNode(tCtx, vrNode);

            }

            case FLWOR_EXPRESSION: {

                FLWORExprNode fNode = (FLWORExprNode) value;

                return translateFLWORExprNode(tCtx, fNode);

            }

            case QUANTIFIED_EXPRESSION: {

                QuantifiedExprNode qeNode = (QuantifiedExprNode) value;

                return translateQuantifiedExprNode(tCtx, qeNode);

            }

            /*

                        case TYPESWITCH_EXPRESSION: {

                            TypeswitchExprNode teNode = (TypeswitchExprNode) value;

                            Expression sExpr = translateExpression(teNode.getSwitchExpr());

                            ForLetVariable tVar = new ForLetVariable(VarTag.LET, createVarName(), sExpr);

                            tVar.setDeclaredStaticType(SequenceType.create(AnyItemType.INSTANCE, Quantifier.QUANT_STAR));

                            pushVariableScope();

                            varScope.registerVariable(tVar);

                            List<TypeswitchExpression.Case> cases = new ArrayList<TypeswitchExpression.Case>();

                            for (CaseClauseNode ccNode : teNode.getCaseClauses()) {

                                SequenceType type = createSequenceType(ccNode.getType());

                                ForLetVariable caseVar = null;

                                pushVariableScope();

                                if (ccNode.getCaseVar() != null) {

                                    caseVar = new ForLetVariable(VarTag.LET, createQName(ccNode.getCaseVar()), new TreatExpression(

                                            currCtx, new VariableReferenceExpression(currCtx, tVar), type));

                                    caseVar.setDeclaredStaticType(type);

                                    varScope.registerVariable(caseVar);

                                }

                                Expression cExpr = translateExpression(ccNode.getValueExpr());

                                TypeswitchExpression.Case c = new TypeswitchExpression.Case(caseVar, type, cExpr);

                                cases.add(c);

                                popVariableScope();

                            }

                            Expression dExpr = translateExpression(teNode.getDefaultClause());

                            popVariableScope();

                            return new TypeswitchExpression(currCtx, tVar, cases, dExpr);

                        }

                        */

            case COMPUTED_TEXT_CONSTRUCTOR: {

                ComputedTextConstructorNode cNode = (ComputedTextConstructorNode) value;

                return translateComputedTextConstructorNode(tCtx, cNode);

            }

            case COMPUTED_PI_CONSTRUCTOR: {

                ComputedPIConstructorNode cNode = (ComputedPIConstructorNode) value;

                return translateComputedPIConstructorNode(tCtx, cNode);

            }

            case COMPUTED_COMMENT_CONSTRUCTOR: {

                ComputedCommentConstructorNode cNode = (ComputedCommentConstructorNode) value;

                return translateComputedCommentConstructorNode(tCtx, cNode);

            }

            case COMPUTED_DOCUMENT_CONSTRUCTOR: {

                ComputedDocumentConstructorNode cNode = (ComputedDocumentConstructorNode) value;

                return translateComputedDocumentConstructorNode(tCtx, cNode);

            }

            case COMPUTED_ELEMENT_CONSTRUCTOR: {

                ComputedElementConstructorNode cNode = (ComputedElementConstructorNode) value;

                return translateComputedElementConstructorNode(tCtx, cNode);

            }

            case COMPUTED_ATTRIBUTE_CONSTRUCTOR: {

                ComputedAttributeConstructorNode cNode = (ComputedAttributeConstructorNode) value;

                return translateComputedAttributeConstructorNode(tCtx, cNode);

            }

            case QNAME: {

                QNameNode qnNode = (QNameNode) value;

                return translateQNameNode(tCtx, qnNode);

            }

            case NCNAME: {

                NCNameNode ncnNode = (NCNameNode) value;

                return translateNCNameNode(tCtx, ncnNode);

            }

            case CDATA_SECTION: {

                CDataSectionNode cdsNode = (CDataSectionNode) value;

                return translateCDataSectionNode(tCtx, cdsNode);

            }

            case ORDERED_EXPRESSION: {

                OrderedExprNode oeNode = (OrderedExprNode) value;

                return translateOrderedExprNode(tCtx, oeNode);

            }

            case UNORDERED_EXPRESSION: {

                UnorderedExprNode ueNode = (UnorderedExprNode) value;

                return translateUnorderedExprNode(tCtx, ueNode);

            }

            case VALIDATE_EXPRESSION: {

                ValidateExprNode vNode = (ValidateExprNode) value;

                return translateValidateExprNode(tCtx, vNode);

            }

            default:

                throw new IllegalStateException("Unknown node: " + value.getTag());

        }

    }

    private LogicalVariable translateQuantifiedExprNode(TranslationContext tCtx, QuantifiedExprNode qeNode)

            throws SystemException {

        tCtx = tCtx.pushContext();

        int pushCount = 0;

        for (QuantifiedVarDeclNode qvdNode : qeNode.getVariables()) {

            ILogicalExpression seq = vre(translateExpression(qvdNode.getSequence(), tCtx));

            tCtx.pushVariableScope();

            LogicalVariable forLVar = newLogicalVariable();

            UnnestOperator unnest = new UnnestOperator(forLVar, mutable(ufce(BuiltinOperators.ITERATE, seq)));

            SequenceType forVarType = SequenceType.create(AnyItemType.INSTANCE, Quantifier.QUANT_ONE);

            if (qvdNode.getType() != null) {

                forVarType = createSequenceType(qvdNode.getType());

            }

            XQueryVariable forVar = new XQueryVariable(createQName(qvdNode.getVariable()), forVarType, forLVar);

            tCtx.varScope.registerVariable(forVar);

            unnest.getInputs().add(mutable(tCtx.op));

            tCtx.op = unnest;

            ++pushCount;

        }

        ILogicalExpression satExpr = sfce(BuiltinFunctions.FN_BOOLEAN_1,

                vre(translateExpression(qeNode.getSatisfiesExpr(), tCtx)));

        if (qeNode.getQuant() == QuantifierType.EVERY) {

            satExpr = sfce(BuiltinFunctions.FN_NOT_1, satExpr);

        }

        SelectOperator select = new SelectOperator(mutable(satExpr));

        select.getInputs().add(mutable(tCtx.op));

        tCtx.op = select;

        List<LogicalVariable> vars = new ArrayList<LogicalVariable>();

        List<Mutable<ILogicalExpression>> exprs = new ArrayList<Mutable<ILogicalExpression>>();

        LogicalVariable var = newLogicalVariable();

        vars.add(var);

        exprs.add(mutable(afce(BuiltinOperators.SEQUENCE, false,

                ce(SequenceType.create(BuiltinTypeRegistry.XS_BOOLEAN, Quantifier.QUANT_ONE), Boolean.TRUE))));

        AggregateOperator aop = new AggregateOperator(vars, exprs);

        aop.getInputs().add(mutable(tCtx.op));

        tCtx.op = aop;

        for (int i = 0; i < pushCount; ++i) {

            tCtx.popVariableScope();

        }

        tCtx = tCtx.popContext();

        LogicalVariable lVar = createAssignment(

                sfce(qeNode.getQuant() == QuantifierType.EVERY ? BuiltinFunctions.FN_EMPTY_1

                        : BuiltinFunctions.FN_EXISTS_1, vre(var)), tCtx);

        return lVar;

    }

    private LogicalVariable translateUnorderedExprNode(TranslationContext tCtx, UnorderedExprNode ueNode)

            throws SystemException {

        LogicalVariable lVar = createAssignment(

                sfce(BuiltinOperators.UNORDERED, vre(translateExpression(ueNode.getExpr(), tCtx))), tCtx);

        return lVar;

    }

    private LogicalVariable translateOrderedExprNode(TranslationContext tCtx, OrderedExprNode oeNode)

            throws SystemException {

        LogicalVariable lVar = createAssignment(

                sfce(BuiltinOperators.ORDERED, vre(translateExpression(oeNode.getExpr(), tCtx))), tCtx);

        return lVar;

    }

    private LogicalVariable translateCDataSectionNode(TranslationContext tCtx, CDataSectionNode cdsNode)

            throws SystemException {

        LogicalVariable lVar = createAssignment(

                sfce(BuiltinOperators.TEXT_CONSTRUCTOR,

                        ce(SequenceType.create(BuiltinTypeRegistry.XS_UNTYPED_ATOMIC, Quantifier.QUANT_ONE),

                                cdsNode.getContent())), tCtx);

        return lVar;

    }

    private LogicalVariable translateNCNameNode(TranslationContext tCtx, NCNameNode ncnNode) throws SystemException {

        LogicalVariable lVar = createAssignment(

                ce(SequenceType.create(BuiltinTypeRegistry.XS_STRING, Quantifier.QUANT_ONE), ncnNode.getName()), tCtx);

        return lVar;

    }

    private LogicalVariable translateQNameNode(TranslationContext tCtx, QNameNode qnNode) throws SystemException {

        LogicalVariable lVar = createAssignment(

                ce(SequenceType.create(BuiltinTypeRegistry.XS_QNAME, Quantifier.QUANT_ONE), createQName(qnNode)), tCtx);

        return lVar;