conteval.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_CONTEVAL_HPP_SENTRY
#define INTELIB_CONTEVAL_HPP_SENTRY

#include "../sexpress/sexpress.hpp"
#include "../sexpress/iexcept.hpp"
#include "../sexpress/gensref.hpp"

#ifndef INTELIB_CONTINUATION_KEEPS_STACK_INFO

#define INTELIB_CONTINUATION_KEEPS_STACK_INFO 1
#endif



class SExpressionSetfAgent : public SExpression {
public:
    static IntelibTypeId TypeId;

    SExpressionSetfAgent() : SExpression(TypeId) {}
    virtual void Setf(const SReference &val) = 0;

protected:
    virtual ~SExpressionSetfAgent() {}
};



class IntelibContinuation {
    SReference *result_stack;
    int result_stack_size;
    int result_stack_pointer;

    struct TodoItem {
        int opcode;
        SReference param;
#if INTELIB_CONTINUATION_KEEPS_STACK_INFO == 1
        SReference stack_info;
#endif
    };
    TodoItem *todo_stack;
    int todo_stack_size;
    int todo_stack_pointer;

    SReference current_context;

protected:
    SReference *PTheFalseValue;

public:
    IntelibContinuation();
    IntelibContinuation(const IntelibContinuation &other, bool ignored);
    virtual ~IntelibContinuation();


    virtual void JustEvaluate(const SReference& expr) = 0;

    virtual void CustomCommand(int opcode, const SReference& param);


    bool Step();

    int GetMark() const { return todo_stack_pointer; }

    bool Ready(int mark = 0) const { return todo_stack_pointer == mark; }
    SReference Get();


    void ReplaceContinuation(const IntelibContinuation &other);
private:
    IntelibContinuation(const IntelibContinuation &other) {}
    void operator=(const IntelibContinuation &other) {}

public:

    enum Instructions {
        just_evaluate =       -1,
        evaluate_prepared =   -2,
        evaluate_progn =      -3,
        quote_parameter =     -4,
        drop_result =         -5,
        return_unspecified =  -6,
        end_of_clauses =      -7,

        cond_clause =         -8,

        bail_on_false =       -9,

        set_context =        -10,

        assign_to =          -11, 

        assign_location =    -12,

        generic_iteration =  -13,
        iteration_callback = -14,
        max_command = -14
    };


    void PushTodo(int opcode, const SReference& param);

    void PushTodo(int opcode); // for the 'no parameter' case

    bool PopTodo(int &opcode, SReference& param);
    void PushResult(const SReference& param);
    bool PopResult(SReference& param);

    void RegularReturn(const SReference &ref);
    void ReferenceReturn(SReference &ref, const SReference &superstruct);
    void AgentReturn(const SReference &val, const SExpressionSetfAgent *ag);
    void TailReturn(const SReference &ref);
    void ReturnUnspecified();

    SReference GetContext() const { return current_context; }
    void SetContext(const SReference &cont) { current_context = cont; }


private:
    static bool pending_interruption;
    static bool interruptions_suspended;
public:
    static void InterruptEvaluator() { pending_interruption = true; }
    static void RemoveInterruption() { pending_interruption = false; }
    static void SuspendInterruptions() { interruptions_suspended = true; }
    static void ResumeInterruptions() { interruptions_suspended = false; }

    class Interruption {};

private:
    bool IsTrue(const SReference& expr)
        { return expr.GetPtr() != PTheFalseValue->GetPtr(); }
    void EvaluatePrepared(const SReference& expr);
    void FunctionCall(int paramscount);
    void PlacePrognToStack(const SReference& expr);
    void EvaluateCondClause(const SReference& expr);
    void BailOnFalse();
    void AssignLocation();
    void GenericIteration(const SReference& expr);
    void IterationCallback(const SReference& expr);

    bool AcceptsLocation() const;

    void DoFunctionCall(const SReference &save_fun,
                        int paramscount,
                        const SReference *paramsvector);


protected:

    void PlaceFormToStack(const SExpressionCons *form, int len);
};


class SExpressionGenericIterator : public SExpression {
public:
    SExpressionGenericIterator(IntelibTypeId &tid)
        : SExpression(tid) {}
    ~SExpressionGenericIterator() {}

    virtual bool NeedAnotherIteration(IntelibContinuation& lf) const = 0;
    virtual void ScheduleIteration(IntelibContinuation &lf) = 0;
    virtual void CollectResultOfIteration(IntelibContinuation &lf) = 0;
    virtual void ReturnFinalValue(IntelibContinuation &lf) = 0;
};

class IntelibX_continuation_unknown_operation : public IntelibX {
public:
    IntelibX_continuation_unknown_operation(SReference a_param);
};

class IntelibX_not_a_function : public IntelibX {
public:
    IntelibX_not_a_function(SReference a_param);
};


#endif

---