runstack.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2012, Andy Bierman, All Rights Reserved.
 * Copyright (c) 2012 - 2021, YumaWorks, Inc., All Rights Reserved.
 *
 * 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.
 */
#ifndef _H_runstack
#define _H_runstack
 
/*  FILE: runstack.h
*********************************************************************
*                                   *
*            P U R P O S E                  *
*                                   *
*********************************************************************/
 
/*********************************************************************
*                                   *
*          C H A N G E   H I S T O R Y              *
*                                   *
*********************************************************************
 
date         init     comment
----------------------------------------------------------------------
22-aug-07    abb      Begun; split from ncxcli.c
24-apr-10    abb      Redesign to use dynamic memory,
                      allow recursion, and support multiple
                      concurrent contexts
26-apr-10    abb      added conditional cmd and loop support
*/
 
#ifndef _H_dlq
#include "dlq.h"
#endif
 
#ifndef _H_status
#include "status.h"
#endif
 
#ifndef _H_val
#include "val.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
/********************************************************************
*                                   *
*            C O N S T A N T S              *
*                                   *
*********************************************************************/
 
 
#define RUNSTACK_MAX_PARMS  9
 
 
#define RUNSTACK_MAX_NEST   512
 
#define RUNSTACK_MAX_LOOP   65535
 
 
/********************************************************************
*                                   *
*                T Y P E S                  *
*                                   *
*********************************************************************/
 
typedef enum runstack_src_t_ {
    RUNSTACK_SRC_NONE,     
    RUNSTACK_SRC_USER,     
    RUNSTACK_SRC_SCRIPT,   
    RUNSTACK_SRC_LOOP      
} runstack_src_t;
 
 
typedef enum runstack_condtype_t_ {
    RUNSTACK_COND_NONE,    
    RUNSTACK_COND_IF,      
    RUNSTACK_COND_LOOP     
} runstack_condtype_t;
 
 
typedef enum runstack_ifstate_t_ {
    RUNSTACK_IF_NONE,     
    RUNSTACK_IF_IF,       
    RUNSTACK_IF_ELIF,     
    RUNSTACK_IF_ELSE      
} runstack_ifstate_t;
 
 
typedef enum runstack_loopstate_t_ {
    RUNSTACK_LOOP_NONE,         
    RUNSTACK_LOOP_COLLECTING,   
    RUNSTACK_LOOP_LOOPING       
} runstack_loopstate_t;
 
 
typedef enum runstack_queue_type_t_ {
    RUNSTACK_QUE_NONE,       
    RUNSTACK_QUE_LOCAL,      
    RUNSTACK_QUE_SESSION,    
    RUNSTACK_QUE_GROUP,      
    RUNSTACK_QUE_GLOBAL      
}  runstack_queue_type_t;
 
 
typedef struct runstack_ifcb_t_ {
    runstack_ifstate_t    ifstate;      
    boolean               parentcond;   
    boolean               startcond;    
    boolean               curcond;      
    boolean               ifused;       
} runstack_ifcb_t;
 
 
typedef struct runstack_line_t_ {
    dlq_hdr_t             qhdr;   
    xmlChar              *line;   
} runstack_line_t;
 
 
typedef struct runstack_loopcb_t_ {
    uint32                     maxloops;
 
    uint32                     loop_count;
 
    runstack_loopstate_t       loop_state;
 
    boolean                    startcond;
 
    struct xpath_pcb_t_       *xpathpcb;
 
    val_value_t               *docroot;
 
    struct runstack_loopcb_t_ *collector;
 
    runstack_line_t           *first_line;
 
    runstack_line_t           *cur_line;
 
    runstack_line_t           *last_line;
 
    boolean                    empty_block;
 
    dlq_hdr_t                  lineQ;   
} runstack_loopcb_t;
 
 
typedef struct runstack_condcb_t_ {
    dlq_hdr_t                  qhdr;
 
    runstack_condtype_t        cond_type;
 
    union u_ {
        runstack_loopcb_t      loopcb;   
        runstack_ifcb_t        ifcb;     
    } u;
} runstack_condcb_t;
 
 
typedef struct runstack_entry_t_ {
    dlq_hdr_t    qhdr;        
    uint32       level;
 
    FILE        *fp;
 
    xmlChar     *source;
 
    xmlChar     *buff;
 
    int          bufflen;
 
    uint32       linenum;
    dlq_hdr_t    parmQ;    
    dlq_hdr_t    varQ;     
    dlq_hdr_t    condcbQ;  
} runstack_entry_t;
 
 
typedef struct runstack_context_t_ {
    boolean            cond_state;
 
    boolean            script_cancel;
 
    uint32             script_level;
 
    uint32             max_script_level;
 
    runstack_src_t     cur_src;
 
    dlq_hdr_t          runstackQ;    
    dlq_hdr_t          globalQ;      
    dlq_hdr_t          zeroQ;        
    dlq_hdr_t          zero_condcbQ;  
    dlq_hdr_t         *sessionQ;   
    dlq_hdr_t         *groupQ;     
} runstack_context_t;
 
 
/********************************************************************
*                                   *
*           F U N C T I O N S               *
*                                   *
*********************************************************************/
 
 
extern uint32
    runstack_level (runstack_context_t *rcxt);
 
 
extern status_t
    runstack_push (runstack_context_t *rcxt,
                   const xmlChar *source,
           FILE *fp);
 
extern void
    runstack_pop (runstack_context_t *rcxt);
 
 
extern xmlChar *
    runstack_get_cmd (runstack_context_t *rcxt,
                      status_t *res);
 
 
extern void
    runstack_cancel (runstack_context_t *rcxt);
 
 
extern void
    runstack_clear_cancel (runstack_context_t *rcxt);
 
 
extern dlq_hdr_t *
    runstack_get_que (runstack_context_t *rcxt,
                      runstack_queue_type_t quetype);
 
 
extern dlq_hdr_t *
    runstack_get_parm_que (runstack_context_t *rcxt);
 
 
extern void
    runstack_init (void);
 
 
extern void
    runstack_cleanup (void);
 
 
extern void
    runstack_clean_context (runstack_context_t *rcxt);
 
 
extern void
    runstack_free_context (runstack_context_t *rcxt);
 
 
extern void
    runstack_init_context (runstack_context_t *rcxt);
 
 
extern runstack_context_t *
    runstack_new_context (void);
 
 
extern void
    runstack_session_cleanup (runstack_context_t *rcxt);
 
 
extern runstack_src_t
    runstack_get_source (runstack_context_t *rcxt);
 
 
extern status_t
    runstack_save_line (runstack_context_t *rcxt,
                        const xmlChar *line);
 
 
extern xmlChar *
    runstack_get_loop_cmd (runstack_context_t *rcxt,
                           status_t *res);
 
 
extern boolean
    runstack_get_cond_state (runstack_context_t *rcxt);
 
 
extern status_t
    runstack_handle_while (runstack_context_t *rcxt,
                           uint32 maxloops,
                           struct xpath_pcb_t_ *xpathpcb,
                           val_value_t *docroot);
 
 
extern status_t
    runstack_handle_if (runstack_context_t *rcxt,
                        boolean startcond);
 
 
extern status_t
    runstack_handle_elif (runstack_context_t *rcxt,
                          boolean startcond);
 
 
extern status_t
    runstack_handle_else (runstack_context_t *rcxt);
 
 
extern status_t
    runstack_handle_end (runstack_context_t *rcxt);
 
 
extern boolean
    runstack_get_if_used (runstack_context_t *rcxt);
 
 
extern void
    runstack_set_sessionQ (runstack_context_t *rcxt,
                           dlq_hdr_t *sessionQ);
 
 
extern void
    runstack_set_groupQ (runstack_context_t *rcxt,
                         dlq_hdr_t *groupQ);
 
 
#ifdef __cplusplus
}  /* end extern 'C' */
#endif
 
#endif      /* _H_runstack */