clearsilver-dev 0.10.5-1.3build1 / usr / include / ClearSilver / cs / cs.h

/*
 * Copyright 2001-2004 Brandon Long
 * All Rights Reserved.
 *
 * ClearSilver Templating System
 *
 * This code is made available under the terms of the ClearSilver License.
 * http://www.clearsilver.net/license.hdf
 *
 */

/*
 * CS Syntax (pseudo BNF, pseudo accurate)
 * ------------------------------------------------------------------
 * CS          := (ANYTHING COMMAND)*
 * CS_OPEN     := <?cs
 * CS_CLOSE    := ?>
 * COMMAND     := (CMD_IF | CMD_VAR | CMD_EVAR | CMD_INCLUDE | CMD_EACH
 *                 | CMD_DEF | CMD_CALL | CMD_SET | CMD_LOOP )
 * CMD_IF      := CS_OPEN IF CS_CLOSE CS CMD_ENDIF
 * CMD_ENDIF   := CS_OPEN ENDIF CS_CLOSE
 * CMD_INCLUDE := CS_OPEN INCLUDE CS_CLOSE
 * CMD_DEF     := CS_OPEN DEF CS_CLOSE
 * CMD_CALL    := CS_OPEN CALL CS_CLOSE
 * CMD_SET     := CS_OPEN SET CS_CLOSE
 * CMD_LOOP    := CS_OPEN LOOP CS_CLOSE
 * LOOP        := loop:VAR = EXPR, EXPR, EXPR
 * SET         := set:VAR = EXPR
 * EXPR        := (ARG | ARG OP EXPR)
 * CALL        := call:VAR LPAREN ARG (,ARG)* RPAREN
 * DEF         := def:VAR LPAREN ARG (,ARG)* RPAREN
 * INCLUDE     := include:(VAR|STRING)
 * IF          := (if:ARG OP ARG|if:ARG|if:!ARG)
 * ENDIF       := /if
 * OP          := ( == | != | < | <= | > | >= | || | && | + | - | * | / | % )
 * ARG         := (STRING|VAR|NUM)
 * STRING      := "[^"]"
 * VAR         := [^"<> ]+
 * NUM         := #[0-9]+
 */

#ifndef __CSHDF_H_
#define __CSHDF_H_ 1

#include "util/neo_misc.h"
#include "util/neo_err.h"
#include "util/ulist.h"
#include "util/neo_hdf.h"
#include "util/neo_str.h"

__BEGIN_DECLS

typedef enum
{
  /* Unary operators */
  CS_OP_NONE = (1<<0),
  CS_OP_EXISTS = (1<<1),
  CS_OP_NOT = (1<<2),
  CS_OP_NUM = (1<<3),

  /* Binary Operators */
  CS_OP_EQUAL = (1<<4),
  CS_OP_NEQUAL = (1<<5),
  CS_OP_LT = (1<<6),
  CS_OP_LTE = (1<<7),
  CS_OP_GT = (1<<8),
  CS_OP_GTE = (1<<9),
  CS_OP_AND = (1<<10),
  CS_OP_OR = (1<<11),
  CS_OP_ADD = (1<<12),
  CS_OP_SUB = (1<<13),
  CS_OP_MULT = (1<<14),
  CS_OP_DIV = (1<<15),
  CS_OP_MOD = (1<<16),

  /* Associative Operators */
  CS_OP_LPAREN = (1<<17),
  CS_OP_RPAREN = (1<<18),
  CS_OP_LBRACKET = (1<<19),
  CS_OP_RBRACKET = (1<<20),

  CS_OP_DOT = (1<<21),
  CS_OP_COMMA = (1<<22),

  /* Types */
  CS_TYPE_STRING = (1<<25),
  CS_TYPE_NUM = (1<<26),
  CS_TYPE_VAR = (1<<27),
  CS_TYPE_VAR_NUM = (1<<28),

  /* Not real types... */
  CS_TYPE_MACRO = (1<<29),
  CS_TYPE_FUNCTION = (1<<30)
} CSTOKEN_TYPE;

#define CS_OPS_UNARY (CS_OP_EXISTS | CS_OP_NOT | CS_OP_NUM | CS_OP_LPAREN)
#define CS_TYPES (CS_TYPE_STRING | CS_TYPE_NUM | CS_TYPE_VAR | CS_TYPE_VAR_NUM)
#define CS_OPS_LVALUE (CS_OP_DOT | CS_OP_LBRACKET | CS_TYPES)
#define CS_TYPES_VAR (CS_TYPE_VAR | CS_TYPE_VAR_NUM)
#define CS_TYPES_CONST (CS_TYPE_STRING | CS_TYPE_NUM)
#define CS_ASSOC (CS_OP_RPAREN | CS_OP_RBRACKET)

typedef struct _parse CSPARSE;
typedef struct _funct CS_FUNCTION;
typedef struct _escape_context CS_ECONTEXT;
typedef struct _position CS_POSITION;
typedef struct _error CS_ERROR;

typedef struct _arg
{
  CSTOKEN_TYPE op_type;
  char *argexpr;
  char *s;
  long int n;
  int alloc;
  struct _funct *function;
  struct _macro *macro;
  struct _arg *expr1;
  struct _arg *expr2;
  struct _arg *next;
} CSARG;

#define CSF_REQUIRED (1<<0)

typedef struct _tree 
{
  int node_num;
  int cmd;
  int flags;
  NEOS_ESCAPE escape;
  CSARG arg1;
  CSARG arg2;
  CSARG *vargs;

  char *fname;
  int linenum;
  int colnum;

  struct _tree *case_0;
  struct _tree *case_1;
  struct _tree *next;
} CSTREE;

typedef struct _local_map
{
  CSTOKEN_TYPE type;
  char *name;
  int map_alloc;
  /* These three (s,n,h) used to be a union, but now we sometimes allocate
   * a buffer in s with the "string" value of n, so its separate */
  char *s;
  long int n;
  HDF *h;
  int first;  /* This local is the "first" item in an each/loop */
  int last;   /* This local is the "last" item in an loop, each is calculated
               explicitly based on hdf_obj_next() in _builtin_last() */
  struct _local_map *next;
} CS_LOCAL_MAP;

typedef struct _macro
{
  char *name;
  int n_args;
  CSARG *args;

  CSTREE *tree;

  struct _macro *next;
} CS_MACRO;


/* CSOUTFUNC is a callback function for where cs_render will render the 
 * template to.
 * Technically, the char * for this func should be const char *, but that
 * would break existing code. */
typedef NEOERR* (*CSOUTFUNC)(void *, char *);

/* CSFUNCTION is a callback function used for handling a function made
 * available inside the template.  Used by cs_register_function.  Exposed
 * here as part of the experimental extension framework, this may change
 * in future versions. */
typedef NEOERR* (*CSFUNCTION)(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args,
                              CSARG *result);

/* CSSTRFUNC is a callback function for the more limited "string filter"
 * function handling.  String filters only take a string and return a 
 * string and have no "data" that is passed back, attempting to make them
 * "safe" from extensions that might try to do silly things like SQL queries.
 * */
typedef NEOERR* (*CSSTRFUNC)(const char *str, char **ret);

/* CSFILELOAD is a callback function to intercept file load requests and
 * provide templates via another mechanism.  This way you can load templates
 * that you compiled-into your binary, from in-memory caches, or from a
 * zip file, etc.  The HDF is provided so you can choose to use the 
 * hdf_search_path function to find the file.  contents should return
 * a full malloc copy of the contents of the file, which the parser will modify
 * and own and free.  Use cs_register_fileload to set this function for
 * your CSPARSE context. */
typedef NEOERR* (*CSFILELOAD)(void *ctx, HDF *hdf, const char *filename,
                              char **contents);

struct _funct
{
  char *name;
  int name_len;
  int n_args;
  NEOS_ESCAPE escape; /* States escaping exemptions. default: NONE. */

  CSFUNCTION function;
  CSSTRFUNC str_func;

  struct _funct *next;
};

/* This structure maintains the necessary running state to manage
 * automatic escaping in tandem with the 'escape' directive. It is passed
 * around inside _parse.
 */
struct _escape_context
{
  NEOS_ESCAPE global_ctx; /* Contains global default escaping mode:
			     none,html,js,url */
  NEOS_ESCAPE current;    /* Used to pass around parse and evaluation specific
                             data from subfunctions upward. */
  NEOS_ESCAPE next_stack; /* This is a big fat workaround. Since STACK_ENTRYs
                             are only added to the stack after the
                             command[].parse_handler() is called for the call
                             it is being setup for, this is used to pass state
                             forward.  E.g. This is used for 'def' to set UNDEF
                             escaping state to delay escaping status to
                             evaluation time. */
  NEOS_ESCAPE when_undef; /* Contains the escaping context to be used when a
                             UNDEF is being replaced at evaluation time.  E.g.
                             this is set in call_eval to force the macro code
                             to get call's parsing context at eval time. */
};

/* This structure is used to track current location within the CS file being
 * parsed. This information is used to find the filename and line number for
 * each node.
 */
struct _position {
  int line;        /* Line number for current position */
  int col;         /* Column number for current position */
  int cur_offset;  /* The current position - commence reading from here */
};

struct _error {
  NEOERR *err;
  struct _error *next;
};
  
struct _parse
{
  const char *context;   /* A string identifying where the parser is parsing */
  int in_file;           /* Indicates if current context is a file */
  int offset;

  int audit_mode;        /* If in audit_mode, gather some extra information */
  CS_POSITION pos;       /* Container for current position in CS file */
  CS_ERROR *err_list;    /* List of non-fatal errors encountered */
  
  char *context_string;
  CS_ECONTEXT escaping; /* Context container for escape data */

  char *tag;		/* Usually cs, but can be set via HDF Config.TagStart */
  int taglen;

  ULIST *stack;
  ULIST *alloc;         /* list of strings owned by CSPARSE and free'd when
                           its destroyed */
  CSTREE *tree;
  CSTREE *current;
  CSTREE **next;

  HDF *hdf;

  struct _parse *parent;  /* set on internally created parse instances to point
                             at the parent.  This can be used for hierarchical
                             scope in the future. */

  CS_LOCAL_MAP *locals;
  CS_MACRO *macros;
  CS_FUNCTION *functions;

  /* Output */
  void *output_ctx;
  CSOUTFUNC output_cb;

  void *fileload_ctx;
  CSFILELOAD fileload;

  /* Global hdf struct */
  /* smarti:  Added for support for global hdf under local hdf */
  HDF *global_hdf;
};

/*
 * Function: cs_init - create and initialize a CS context
 * Description: cs_init will create a CSPARSE structure and initialize
 *       it.  This structure maintains the state and information
 *       necessary for parsing and rendering a CS template.
 * Input: parse - a pointer to a pointer to a CSPARSE structure that
 *        will be created
 *        hdf - the HDF dataset to be used during parsing and rendering
 * Output: parse will contain a pointer to the allocated CSPARSE
 *         structure.  This structure will be deallocated with
 *         cs_destroy()
 * Return: NERR_NOMEM
 * MT-Level: cs routines perform no locking, and neither do hdf
 *           routines.  They should be safe in an MT environment as long
 *           as they are confined to a single thread.
 */
NEOERR *cs_init (CSPARSE **parse, HDF *hdf);

/*
 * Function: cs_parse_file - parse a CS template file
 * Description: cs_parse_file will parse the CS template located at
 *              path.  It will use hdf_search_path() if path does not
 *              begin with a '/'.  The parsed CS template will be
 *              appended to the current parse tree stored in the CSPARSE
 *              structure.  The entire file is loaded into memory and
 *              parsed in place.
 * Input: parse - a CSPARSE structure created with cs_init
 *        path - the path to the file to parse
 * Output: None
 * Return: NERR_ASSERT - if path == NULL
 *         NERR_NOT_FOUND - if path isn't found
 *         NERR_SYSTEM - if path can't be accessed
 *         NERR_NOMEM - unable to allocate memory to load file into memory
 *         NERR_PARSE - error in CS template
 */
NEOERR *cs_parse_file (CSPARSE *parse, const char *path);

/*
 * Function: cs_parse_string - parse a CS template string
 * Description: cs_parse_string parses a string.  The string is
 *              modified, and internal references are kept by the parse
 *              tree.  For this reason, ownership of the string is
 *              transfered to the CS system, and the string will be
 *              free'd when cs_destroy() is called.
 *              The parse information will be appended to the current
 *              parse tree.  During parse, the only HDF variables which
 *              are evaluated are those used in evar or include
 *              statements.
 * Input: parse - a CSPARSE structure created with cs_init
 *        buf - the string to parse.  Embedded NULLs are not currently
 *              supported
 *        blen - the length of the string
 * Output: None
 * Return: NERR_PARSE - error in CS template
 *         NERR_NOMEM - unable to allocate memory for parse structures
 *         NERR_NOT_FOUND - missing required variable
 */
NEOERR *cs_parse_string (CSPARSE *parse, char *buf, size_t blen);

/*
 * Function: cs_render - render a CS parse tree
 * Description: cs_render will evaluate a CS parse tree, calling the
 *              CSOUTFUNC passed to it for output.  Note that calling
 *              cs_render multiple times on the same parse tree may or
 *              may not render the same output as the set statement has
 *              side-effects, it updates the HDF data used by the
 *              render.  Typically, you will call one of the cs_parse
 *              functions before calling this function.
 * Input: parse - the CSPARSE structure containing the CS parse tree
 *                that will be evaluated
 *        ctx - user data that will be passed as the first variable to
 *              the CSOUTFUNC.
 *        cb - a CSOUTFUNC called to render the output.  A CSOUTFUNC is
 *             defined as:
 *                 typedef NEOERR* (*CSOUTFUNC)(void *, char *);
 * Output: None
 * Return: NERR_NOMEM - Unable to allocate memory for CALL or SET
 *                      functions
 *         any error your callback functions returns
 */
NEOERR *cs_render (CSPARSE *parse, void *ctx, CSOUTFUNC cb);

/*
 * Function: cs_dump - dump the cs parse tree
 * Description: cs_dump will dump the CS parse tree in the parse struct.
 *              This can be useful for debugging your templates.
 *              This function also uses the CSOUTFUNC callback to
 *              display the parse tree.
 * Input: parse - the CSPARSE structure created with cs_init
 *        ctx - user data to be passed to the CSOUTFUNC
 *        cb - a CSOUTFUNC callback
 * Output: None
 * Return: NERR_ASSERT if there is no parse tree
 *         anything your CSOUTFUNC may return
 */
NEOERR *cs_dump (CSPARSE *parse, void *ctx, CSOUTFUNC cb);

/*
 * Function: cs_destroy - clean up and dealloc a parse tree
 * Description: cs_destroy will clean up all the memory associated with
 *              a CSPARSE structure, including strings passed to
 *              cs_parse_string.  This does not clean up any memory
 *              allocated by your own CSOUTFUNC or the HDF data
 *              structure passed to cs_init.  It is safe to call this
 *              with a NULL pointer, and it will leave parse NULL as
 *              well (ie, it can be called more than once on the same
 *              var)
 * Input: parse - a pointer to a parse structure.
 * Output: parse - will be NULL
 * Return: None
 */
void cs_destroy (CSPARSE **parse);

/*
 * Function: cs_register_fileload - register a fileload function
 * Description: cs_register_fileload registers a fileload function that 
 *              overrides the built-in function.  The built-in function
 *              uses hdf_search_path and ne_file_load (based on stat/open/read)
 *              to find and load the file on every template render.
 *              You can override this function if you wish to provide
 *              other template search functions, or load the template
 *              from an in-memory cache, etc.
 *              This fileload function will be used by cs_parse, including
 *              any include: commands in the template.
 * Input: parse - a pointer to an initialized CSPARSE structure
 *        ctx - pointer that is passed to the CSFILELOAD function when called
 *        fileload - a CSFILELOAD function
 * Output: None
 * Return: None
 *
 */

void cs_register_fileload(CSPARSE *parse, void *ctx, CSFILELOAD fileload);

/*
 * Function: cs_register_strfunc - register a string handling function
 * Description: cs_register_strfunc will register a string function that
 *              can be called during CS render.  This not-callback is 
 *              designed to allow for string formating/escaping
 *              functions that are not built-in to CS (since CS is not
 *              HTML specific, for instance, but it is very useful to
 *              have CS have functions for javascript/html/url
 *              escaping).  Note that we explicitly don't provide any
 *              associated data or anything to attempt to keep you from
 *              using this as a generic callback...
 *              The format of a CSSTRFUNC is:
 *                 NEOERR * str_func(char *in, char **out);
 *              This function should not modify the input string, and 
 *              should allocate the output string with a libc function.
 *              (as we will call free on it)
 * Input: parse - a pointer to a CSPARSE structure initialized with cs_init()
 *        funcname - the name for the CS function call
 *                   Note that registering a duplicate funcname will
 *                   raise a NERR_DUPLICATE error
 *        str_func - a CSSTRFUNC not-callback
 * Return: NERR_NOMEM - failure to allocate any memory for data structures
 *         NERR_DUPLICATE - funcname already registered
 *          
 */
NEOERR *cs_register_strfunc(CSPARSE *parse, char *funcname, CSSTRFUNC str_func);

/*
 * Function: cs_register_esc_strfunc - cs_register_strfunc with escaping context
 * Description: cs_register_esc_strfunc functions exactly as cs_register_strfunc
 *              except that it changes the evaluation escaping context to disable
 *              default escaping.
 * Input: parse - a pointer to a CSPARSE structure initialized with cs_init()
 *        funcname - the name for the CS function call
 *                   Note that registering a duplicate funcname will
 *                   raise a NERR_DUPLICATE error
 *        str_func - a CSSTRFUNC not-callback
 * Return: NERR_NOMEM - failure to allocate any memory for data structures
 *         NERR_DUPLICATE - funcname already registered
 *
 */
NEOERR *cs_register_esc_strfunc(CSPARSE *parse, char *funcname,
                                CSSTRFUNC str_func);

/* Testing functions for future function api.  This api may change in the
 * future. */
NEOERR *cs_arg_parse(CSPARSE *parse, CSARG *args, const char *fmt, ...);
NEOERR *cs_arg_parsev(CSPARSE *parse, CSARG *args, const char *fmt, va_list ap);
NEOERR *cs_register_function(CSPARSE *parse, const char *funcname,
                                  int n_args, CSFUNCTION function);

__END_DECLS

#endif /* __CSHDF_H_ */