Package abstrasy

Examples of abstrasy.Heap$DynamicConstants


                 * (foreach-sum [l1]...[ln] do {...})
                 */
                Node argv;
               
                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012
               
                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                /*
                 * Correction du 10 mai 2011:
                 * =========================
                 *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
                 *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
                 *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
                 *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
                 *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
                 *    la retourner directement comme résultat.
                 *   
                 */
                while (interpreter.isCanIterate() && row.hasNext()) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(row.getNext());
                    argv_h.put(PCoder.ARGV, argv); // optimisation du 09/03/2012
                    xnode = enode.exec(true);
                }

                Heap.pull(); // supprimer l'espace local...
                Heap.pull(); // supprimer l'espace pour argv...
            }
            else if (btype.isPCode(PCoder.PC_LIST)) {
                /**
                 * (foreach-sum [l1]...[ln] list{...})
                 */
                Node argv;
                xnode = Node.createCList();

                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012

                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                while (interpreter.isCanIterate() && row.hasNext()) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(row.getNext());
View Full Code Here


             *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
             *    la retourner directement comme résultat.
             *   
             */
            global.push();
            Heap local = global.current();
           
            while (interpreter.isCanIterate() && xnode==null) {
                xnode = enode.exec(true);
                _clear_closure_(local);
            }
View Full Code Here

        Node moduleNode;
        if (fn == null) {
            /**
             * forme (object)
             */
            Heap heap = new Heap();
            moduleNode = new Node(heap);
            moduleNode.setType(Node.TYPE_NAMESPACE);
            moduleNode.setFinalNode(false);
           
            if (symbol != null) {
                /**
                 * forme (object 'symbol)
                 */
                if(forceFinal && !symbol.isImmutable()){
                    throw new InterpreterException(StdErrors.Immutable_symbol_required);
                }
                else{
                    Heap.defv(symbol, moduleNode.letFinal(symbol.isImmutable()));
                }
            }
        }
        else if (fn.isNamespace()) {
            /**
             * fn est vObject...
             */
            if (symbol != null) {
                /**
                 * Attention, il faut respecter la finalité...
                 *
                 * objet | symbol | # | Op.
                 * final | final  |   |
                 * ------+--------+---+------
                 *   0   |    0   | 0 | deref
                 *   0   |    1   | 1 | clone
                 *   1   |    0   | 2 | clone
                 *   1   |    1   | 3 | deref
                 *
                 */
                int code = (fn.isFinalNode() ? 2: 0) + (symbol.isImmutable() ? 1: 0);
                switch (code) {
                    case 0:
                    case 3:{
                        Heap heap = new Heap((Heap)fn.getExternal());
                        moduleNode = new Node(heap);
                        moduleNode.setType(Node.TYPE_NAMESPACE);
                        moduleNode.setFinalNode(false);
                        break;
                    }
                    default:
                        moduleNode = Node.createClone(fn);
                }
                if(forceFinal && !symbol.isImmutable()){
                    throw new InterpreterException(StdErrors.Immutable_symbol_required);
                }
                else{
                    Heap.defv(symbol, moduleNode.letFinal(symbol.isImmutable()));
                }
            }
            else {
                /**
                * pas de symbole...
                * On clone d'office...
                */
                moduleNode = Node.createClone(fn);
            }
        }
        else {
            /**
             * fn est lazy...
             */
            Heap heap = new Heap();
            moduleNode = new Node(heap);
            moduleNode.setType(Node.TYPE_NAMESPACE);
            moduleNode.setFinalNode(false);
            if (symbol != null) {
View Full Code Here

        Node cnode = startAt.getSubNode(1, Node.TYPE_NAMESPACE);

        /**
         * récupère l'espace de noms de l'élément...
         */
        Heap spacename = (Heap)cnode.getExternal();
       
       
        /**
         * récupère les mixins possibles...
         */
 
View Full Code Here

                 * (foreach-part [liste] do {...})
                 */
                Node argv;

                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012
               
                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                /*
                 * Correction du 10 mai 2011:
                 * =========================
                 *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
                 *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
                 *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
                 *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
                 *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
                 *    la retourner directement comme résultat.
                 *   
                 */
                while (interpreter.isCanIterate() && permut.hasNext() && xnode==null) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(permut.getNext());
                    argv_h.put(PCoder.ARGV, argv);
                    xnode = enode.exec(true);
                }

                Heap.pull(); // supprimer l'espace local...
                Heap.pull(); // supprimer l'espace de noms pour argv...

            }
            else if (btype.isPCode(PCoder.PC_LIST)) {
                /**
                 * (foreach-part [liste] list{...})
                 */
                Node argv;
                xnode = Node.createCList();

                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012

                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                while (interpreter.isCanIterate() && permut.hasNext()) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(permut.getNext());
View Full Code Here

            interpreter.setInLoop(true);
            //
            int href = global.size();
            int slock = global.getOffset();
           
            Heap local=new Heap();
            global.push(local);
            //
           
            /*
             * Correction du 10 mai 2011:
             * =========================
             *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
             *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
             *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
             *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
             *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
             *    la retourner directement comme résultat.
             *   
             */
            boolean loop = true;
            while (loop) {
                _clear_closure_(local);
                xnode = enode.exec(true);
                loop = xnode==null && interpreter.isCanIterate() && (untilLoop ? !xPC_Condition(local, cnode): xPC_Condition(local, cnode));
            }
            //
            global.pull();

            if (global.size() != href) {
                global.setOffset(slock);
                global.setSize(href); // restaurer le heap à la bonne taille
            }
            //
            interpreter.consumeBreakCode_onLoop();
            interpreter.setCanLoop(oldCanLoop);
            interpreter.setInLoop(oldInLoop);
            return xnode;

        }
        else {
            // forme (do {...} forever)
            modenode = startAt.getSubNode(2, Node.TYPE_PCODE);
            if (!modenode.isPCode(PCoder.PC_FOREVER)) {
                throw new InterpreterException(StdErrors.Syntax_error);
            }
        }
        Node enode = startAt.getSubNode(1, Node.TYPE_LAZY);
        Interpreter interpreter = Interpreter.mySelf();
        StaticHeap global = interpreter.getGLOBAL();
        boolean oldCanLoop = interpreter.isCanLoop();
        boolean oldInLoop = interpreter.isInLoop();
        interpreter.setCanLoop(true);
        interpreter.setInLoop(true);

        //
        int href = global.size();
        int slock = global.getOffset();
        //int tlock = global.getTailStack().getLock();


        // FERMETURE NECESSAIRE...
        //System.out.println("FOREVER: push...");
        global.push();
        Heap local=global.current();
       
        /*
         * Correction du 10 mai 2011:
         * =========================
         *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
View Full Code Here

                 * (foreach-all-different [l1] [l2]...[ln] do {...})
                 */
                Node argv;
               
                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012

                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                /*
                 * Correction du 10 mai 2011:
                 * =========================
                 *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
                 *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
                 *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
                 *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
                 *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
                 *    la retourner directement comme résultat.
                 *   
                 */
                while (interpreter.isCanIterate() && product.hasNext() && xnode==null) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(product.getNext());
                    argv_h.put(PCoder.ARGV, argv);   // argv peut être assigner de cette manière (il est dans un espace de noms exclusif)...
                    xnode = enode.exec(true);
                }

                Heap.pull(); // supprimer l'espace local...
                Heap.pull(); // supprimer l'espace exclusif argv

            }
            else if (btype.isPCode(PCoder.PC_LIST)) {
                /**
                 * (foreach-all-different[l1] [l2]...[ln] list{...})
                 */
                Node argv;
                xnode = Node.createCList();

                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012
               
                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                while (interpreter.isCanIterate() && product.hasNext()) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(product.getNext());
View Full Code Here

                Node argv;
                /*
                 * un Heap rien que pour recevoir argv...
                 */
                Heap.push(); // nouvel espace local
                Heap argv_h=Heap.current(); // optimisation du 09/03/2012...
               
                /**
                 * Pour allez plus vite, on défini une section pour les 2 sources possibles...
                 * De cette manière on diminue un peu le nombre de tests à réaliser...
                 */
                if (lNode.getQType()==Node.TYPE_CLIST) {
                    /**
                     * une liste...
                     */
                    Heap.push(); // nouvel espace local
                    Heap local=Heap.current();
                   
                    /*
                     * Correction du 10 mai 2011:
                     * =========================
                     *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
                     *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
                     *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
                     *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
                     *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
                     *    la retourner directement comme résultat.
                     *   
                     */
                    while (interpreter.isCanIterate() && (nlist < lNode.size()) && xnode==null) {
                        _clear_closure_(local);
                        Node tmpn = lNode.elementAt(nlist);
                        argv = Node.createCList();
                        argv.addElement(tmpn); // argv0 = element
                        argv.addElement(new Node(nlist++)); // argv1 = index
                        argv_h.put(PCoder.ARGV, argv); // optimisation du 09/03/2012... (argv peut être fixé de cette manière - son espace est exclusif)
                        xnode = enode.exec(true);
                    }
                    Heap.pull(); // supprimer l'espace local...
                }
                else {
                    /**
                     * un générateur...
                     */
                    Node tmpn = lNode; // différent de null... pour commencer...
                    Node fxarg=new Node(0).letFinal(true);
                    Node fxn = Node.createExpr().append(lNode).append(fxarg);
                    Heap.push(); // nouvel espace local
                    Heap local = Heap.current();
                   
                    /*
                     * Correction du 10 mai 2011:
                     * =========================
                     *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
                     *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
                     *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
                     *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
                     *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
                     *    la retourner directement comme résultat.
                     *   
                     */
                    while (interpreter.isCanIterate() && tmpn != null && xnode==null) {
                        fxarg.setNumber(nlist);
                        _clear_closure_(local);
                        tmpn = fxn.exec(true);
                        if (tmpn != null) {
                            local.clear();
                            argv = Node.createCList();
                            argv.addElement(tmpn); // argv0 = element
                            argv.addElement(new Node(nlist++)); // argv1 = index
                            argv_h.put(PCoder.ARGV, argv); // optimisation du 09/03/2012...
                            xnode = enode.exec(true);  
                        }   
                    }

                    Heap.pull(); // supprimer l'espace local...
                }
               
                Heap.pull(); // supprimer l'espace pour argv... // optimisation du 09/03/2012...
               
            }
            else if (btype.isPCode(PCoder.PC_LIST)) {
                /**
                 * (foreach xxx list{...})
                 */
                int nlist = 0;
                Node argv;
                xnode = Node.createCList();
               
                /*
                 * un Heap rien que pour recevoir argv...
                 */
                Heap.push(); // nouvel espace local
                Heap argv_h=Heap.current(); // optimisation du 09/03/2012...
               
                /**
                 * Pour allez plus vite, on défini une section pour les 2 sources possibles...
                 * De cette manière on diminue un peu le nombre de tests à réaliser...
                 */
                if (lNode.getQType()==Node.TYPE_CLIST) {
                    /**
                     * une liste...
                     */
                    Heap.push(); // nouvel espace local
                    Heap local=Heap.current();
                   
                    while (interpreter.isCanIterate() && (nlist < lNode.size())) {
                        _clear_closure_(local);
                        argv = Node.createCList();
                        Node tmpn = lNode.elementAt(nlist);
                        argv.addElement(tmpn); // argv0 = element
                        argv.addElement(new Node(nlist++)); // argv1 = index
                        argv_h.put(PCoder.ARGV, argv); // optimisation du 09/03/2012...
                        rnode = enode.exec(true);
                        if (rnode != null)
                            xnode.addElement(rnode.secure());
                       
                    }
                   
                    Heap.pull(); // supprimer l'espace local...
                }
                else {
                    /**
                     * un générateur...
                     */
                    Node tmpn = lNode; // différent de null... pour commencer...
                    Node fxarg=new Node(0).letFinal(true);
                    Node fxn = Node.createExpr().append(lNode).append(fxarg);
                    Heap.push(); // nouvel espace local
                    Heap local=Heap.current();
                   
                    while (interpreter.isCanIterate() && tmpn != null) {
                        fxarg.setNumber(nlist);
                        _clear_closure_(local);
                        tmpn = fxn.exec(true);
                        if (tmpn != null) {
                            argv = Node.createCList();
                            argv.addElement(tmpn); // argv0 = element
                            argv.addElement(new Node(nlist++)); // argv1 = index
                            local.clear();
                            argv_h.put(PCoder.ARGV, argv); // optimisation du 09/03/2012...
                            rnode = enode.exec(true);
                            if (rnode != null) {
                                xnode.addElement(rnode);
                            }
View Full Code Here

            if (tcode.isPCode(PCoder.PC_DO)) {

                // closure pour le corps
                global.push();
                Heap myClosure = global.current();

                /*
                 * Correction du 10 mai 2011:
                 * =========================
                 *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
                 *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
                 *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
                 *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
                 *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
                 *    la retourner directement comme résultat.
                 *
                 */
                while (xnode == null && interpreter.isCanIterate() && xPC_ConditionX(myClosure, cnode)) {
                    _clear_closure_(myClosure);
                    xnode = enode.exec(true);
                }
                global.pull();

            }
            else if (tcode.isPCode(PCoder.PC_LIST)) {
                /**
                 * boucle génératrice de listes.
                 *
                 * respecte la protection des listes finale.
                 *
                 * -> résultat jamais final.
                 *
                 */
                xnode = Node.createCList();
                //

                // closure pour le corps
                global.push();
                Heap myClosure = global.current();
                while (interpreter.isCanIterate() && xPC_ConditionX(myClosure, cnode)) {
                    _clear_closure_(myClosure);
                    rnode = enode.exec(true);
                    if (rnode != null)
                        xnode.addElement(rnode.secure());
View Full Code Here

                 * (foreach-product [l1] [l2]...[ln] do {...})
                 */
                Node argv;

                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012

                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                /*
                 * Correction du 10 mai 2011:
                 * =========================
                 *    Les boucles du type do{...} s'arrête dès qu'un résultat est retourné. Cela ne signifie
                 *    bien entendu pas que la condition qui permet l'itération n'est pas vérifiée. Toutefois,
                 *    comme les boucle du type do{...} ne peuvent retourner qu'un seul résultat, il est inutile
                 *    de relancer l'itération suivante ddès qu'un résultat est fourni. Ainsi, pour permettre
                 *    de continuer la boucle, il est possible de placer le résultat dans une variable et non de
                 *    la retourner directement comme résultat.
                 *   
                 */
                while (interpreter.isCanIterate() && product.hasNext() && xnode==null) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(product.getNext());
                    argv_h.put(PCoder.ARGV, argv);
                    xnode = enode.exec(true);
                }

                Heap.pull(); // supprimer l'espace local...
                Heap.pull(); // supprimer l'espace argv...

            }
            else if (btype.isPCode(PCoder.PC_LIST)) {
                /**
                 * (foreach-product [l1] [l2]...[ln] list{...})
                 */
                Node argv;
                xnode = Node.createCList();

                Heap.push(); // nouvel espace local pour argv (exclusivment)
                Heap argv_h = Heap.current(); // optimisation du 09/03/2012

                Heap.push(); // nouvel espace local
                Heap local = Heap.current();

                while (interpreter.isCanIterate() && product.hasNext()) {
                    _clear_closure_(local);
                    argv = Node.createCList();
                    argv.setArray(product.getNext());
View Full Code Here

TOP

Related Classes of abstrasy.Heap$DynamicConstants

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.