check_expr.c File Reference

#include "asterisk.h"
#include "asterisk/ast_expr.h"
#include "asterisk/inline_api.h"
#include "asterisk/lock.h"

Include dependency graph for check_expr.c:

Go to the source code of this file.

Data Structures
struct	varz

Macros
#define	AST_API_MODULE   1
#define	AST_API_MODULE   1
#define	ASTMM_LIBC   ASTMM_IGNORE

Enumerations
enum	ast_lock_type { AST_MUTEX , AST_RDLOCK , AST_WRLOCK }

Functions
int	ast_add_profile (const char *x, uint64_t scale)
	support for event profiling More...
struct ast_custom_function *	ast_custom_function_find (const char *name)
void	ast_log (int level, const char *file, int line, const char *function, const char *fmt,...)
	Used for sending a log message This is the standard logger function. Probably the only way you will invoke it would be something like this: ast_log(AST_LOG_WHATEVER, "Problem with the %s Captain. We should get some more. Will %d be enough?\n", "flux capacitor", 10); where WHATEVER is one of ERROR, DEBUG, EVENT, NOTICE, or WARNING depending on which log you wish to output to. These are implemented as macros, that will provide the function with the needed arguments. More...
int	check_eval (char *buffer, char *error_report)
unsigned int	check_expr (char *buffer, char *error_report)
char *	find_var (const char *varname)
int	main (int argc, char **argv)
void	parse_file (const char *fname)
void	set_var (const char *varname, const char *varval)

Variables
static int	global_expr_count =0
static int	global_expr_max_size =0
static int	global_expr_tot_size =0
static int	global_lineno = 1
static int	global_OK_count =0
struct varz *	global_varlist
static int	global_warn_count =0

Macro Definition Documentation

AST_API_MODULE [1/2]

#define AST_API_MODULE   1

Definition at line 31 of file check_expr.c.

AST_API_MODULE [2/2]

#define AST_API_MODULE   1

Definition at line 31 of file check_expr.c.

ASTMM_LIBC

#define ASTMM_LIBC   ASTMM_IGNORE

Definition at line 23 of file check_expr.c.

Enumeration Type Documentation

ast_lock_type

enum ast_lock_type

Enumerator
AST_MUTEX
AST_RDLOCK
AST_WRLOCK

Definition at line 35 of file check_expr.c.

                   {
            AST_MUTEX,
            AST_RDLOCK,
            AST_WRLOCK,
};

Function Documentation

ast_add_profile()

int ast_add_profile	(	const char *	x,
		uint64_t	scale
	)

support for event profiling

(note, this must be documented a lot more) ast_add_profile allocates a generic 'counter' with a given name, which can be shown with the command 'core show profile <name>'

The counter accumulates positive or negative values supplied by

See also

ast_add_profile(), dividing them by the 'scale' value passed in the create call, and also counts the number of 'events'. Values can also be taked by the TSC counter on ia32 architectures, in which case you can mark the start of an event calling ast_mark(id, 1) and then the end of the event with ast_mark(id, 0). For non-i386 architectures, these two calls return 0.

support for event profiling

Returns

Returns the identifier of the counter.

Definition at line 139 of file check_expr.c.

{ return 0;}

Referenced by extension_match_core().

ast_custom_function_find()

struct ast_custom_function * ast_custom_function_find

(

const char *

name

)

Definition at line 237 of file check_expr.c.

{
    return 0;
}

Referenced by ast_compile_ael2(), AST_TEST_DEFINE(), chanavail_exec(), config_curl(), destroy_curl(), op_func(), realtime_curl(), realtime_multi_curl(), require_curl(), store_curl(), update2_curl(), and update_curl().

ast_log()

void ast_log	(	int	level,
		const char *	file,
		int	line,
		const char *	function,
		const char *	fmt,
			...
	)

Used for sending a log message This is the standard logger function. Probably the only way you will invoke it would be something like this: ast_log(AST_LOG_WHATEVER, "Problem with the %s Captain. We should get some more. Will %d be enough?\n", "flux capacitor", 10); where WHATEVER is one of ERROR, DEBUG, EVENT, NOTICE, or WARNING depending on which log you wish to output to. These are implemented as macros, that will provide the function with the needed arguments.

Parameters

level	Type of log event
file	Will be provided by the AST_LOG_* macro
line	Will be provided by the AST_LOG_* macro
function	Will be provided by the AST_LOG_* macro
fmt	This is what is important. The format is the same as your favorite breed of printf. You know how that works, right? :-)

Definition at line 121 of file check_expr.c.

{
    va_list vars;
    va_start(vars,fmt);
 
    printf("LOG: lev:%d file:%s  line:%d func: %s  ",
           level, file, line, function);
    vprintf(fmt, vars);
    fflush(stdout);
    va_end(vars);
}

References make_ari_stubs::file.

check_eval()

int check_eval	(	char *	buffer,
		char *	error_report
	)

Definition at line 242 of file check_expr.c.

{
    char *cp, *ep;
    char s[4096];
    char evalbuf[80000];
    int result;
 
    error_report[0] = 0;
    ep = evalbuf;
 
    for (cp=buffer;*cp;cp++) {
        if (*cp == '$' && *(cp+1) == '{') {
            int brack_lev = 1;
            char *xp= cp+2;
 
            while (*xp) {
                if (*xp == '{')
                    brack_lev++;
                else if (*xp == '}')
                    brack_lev--;
 
                if (brack_lev == 0)
                    break;
                xp++;
            }
            if (*xp == '}') {
                char varname[200];
                char *val;
 
                strncpy(varname,cp+2, xp-cp-2);
                varname[xp-cp-2] = 0;
                cp = xp;
                val = find_var(varname);
                if (val) {
                    char *z = val;
                    while (*z)
                        *ep++ = *z++;
                }
                else {
                    *ep++ = '5';  /* why not */
                    *ep++ = '5';
                    *ep++ = '5';
                }
            }
            else {
                printf("Unterminated variable reference at line %d\n", global_lineno);
                *ep++ = *cp;
            }
        }
        else if (*cp == '\\') {
            /* braindead simple elim of backslash */
            cp++;
            *ep++ = *cp;
        }
        else
            *ep++ = *cp;
    }
    *ep++ = 0;
 
    /* now, run the test */
    result = ast_expr(evalbuf, s, sizeof(s),NULL);
    if (result) {
        sprintf(error_report,"line %d, evaluation of $[ %s ] result: %s\n", global_lineno, evalbuf, s);
        return 1;
    } else {
        sprintf(error_report,"line %d, evaluation of $[ %s ] result: ****SYNTAX ERROR****\n", global_lineno, evalbuf);
        return 1;
    }
}

References ast_expr(), find_var(), global_lineno, NULL, and result.

Referenced by parse_file().

check_expr()

unsigned int check_expr	(	char *	buffer,
		char *	error_report
	)

Definition at line 165 of file check_expr.c.

{
    char* cp;
    unsigned int warn_found = 0;
 
    error_report[0] = 0;
 
    for (cp = buffer; *cp; ++cp)
    {
        switch (*cp)
        {
            case '"':
                /* skip to the other end */
                while (*(++cp) && *cp != '"') ;
 
                if (*cp == 0)
                {
                    fprintf(stderr,
                        "Trouble? Unterminated double quote found at line %d\n",
                        global_lineno);
                }
                break;
 
            case '>':
            case '<':
            case '!':
                if (   (*(cp + 1) == '=')
                    && ( ( (cp > buffer) && (*(cp - 1) != ' ') ) || (*(cp + 2) != ' ') ) )
                {
                    char msg[200];
                    snprintf(msg,
                        sizeof(msg),
                        "WARNING: line %d: '%c%c' operator not separated by spaces. This may lead to confusion. You may wish to use double quotes to quote the grouping it is in. Please check!\n",
                        global_lineno, *cp, *(cp + 1));
                    strcat(error_report, msg);
                    ++global_warn_count;
                    ++warn_found;
                }
                break;
 
            case '|':
            case '&':
            case '=':
            case '+':
            case '-':
            case '*':
            case '/':
            case '%':
            case '?':
            case ':':
                if ( ( (cp > buffer) && (*(cp - 1) != ' ') ) || (*(cp + 1) != ' ') )
                {
                    char msg[200];
                    snprintf(msg,
                        sizeof(msg),
                        "WARNING: line %d: '%c' operator not separated by spaces. This may lead to confusion. You may wish to use double quotes to quote the grouping it is in. Please check!\n",
                        global_lineno, *cp );
                    strcat(error_report, msg);
                    ++global_warn_count;
                    ++warn_found;
                }
                break;
        }
    }
 
    return warn_found;
}

References global_lineno, and global_warn_count.

Referenced by parse_file().

find_var()

char * find_var

(

const char *

varname

)

Definition at line 141 of file check_expr.c.

{
    struct varz *t;
    for (t= global_varlist; t; t = t->next) {
        if (!strcmp(t->varname, varname)) {
            return t->varval;
        }
    }
    return 0;
}

References global_varlist, varz::next, varz::varname, and varz::varval.

Referenced by check_eval().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 406 of file check_expr.c.

{
    int argc1;
    char *eq;
 
    if (argc < 2) {
        printf("check_expr -- a program to look thru extensions.conf files for $[...] expressions,\n");
        printf("              and run them thru the parser, looking for problems\n");
        printf("Hey-- give me a path to an extensions.conf file!\n");
        printf(" You can also follow the file path with a series of variable decls,\n");
        printf("     of the form, varname=value, each separated from the next by spaces.\n");
        printf("     (this might allow you to avoid division by zero messages, check that math\n");
        printf("      is being done correctly, etc.)\n");
        printf(" Note that messages about operators not being surrounded by spaces is merely to alert\n");
        printf("  you to possible problems where you might be expecting those operators as part of a string.\n");
        printf("  (to include operators in a string, wrap with double quotes!)\n");
 
        exit(19);
    }
    global_varlist = 0;
    for (argc1=2;argc1 < argc; argc1++) {
        if ((eq = strchr(argv[argc1],'='))) {
            *eq = 0;
            set_var(argv[argc1],eq+1);
        }
    }
 
    /* parse command args for x=y and set varz */
 
    parse_file(argv[1]);
    return 0;
}

References global_varlist, parse_file(), and set_var().

parse_file()

void parse_file

(

const char *

fname

)

Definition at line 315 of file check_expr.c.

{
    FILE *f = fopen(fname,"r");
    FILE *l = fopen("expr2_log","w");
    int c1;
    char last_char= 0;
    char buffer[30000]; /* I sure hope no expr gets this big! */
 
    if (!f) {
        fprintf(stderr,"Couldn't open %s for reading... need an extensions.conf file to parse!\n",fname);
        exit(20);
    }
    if (!l) {
        fprintf(stderr,"Couldn't open 'expr2_log' file for writing... please fix and re-run!\n");
        exit(21);
    }
 
    global_lineno = 1;
 
    while ((c1 = fgetc(f)) != EOF) {
        if (c1 == '\n')
            global_lineno++;
        else if (c1 == '[') {
            if (last_char == '$') {
                /* bingo, an expr */
                int bracklev = 1;
                int bufcount = 0;
                int retval;
                char error_report[30000];
 
                while ((c1 = fgetc(f)) != EOF) {
                    if (c1 == '[')
                        bracklev++;
                    else if (c1 == ']')
                        bracklev--;
                    if (c1 == '\n') {
                        fprintf(l, "ERROR-- A newline in an expression? Weird! ...at line %d\n", global_lineno);
                        fclose(f);
                        fclose(l);
                        printf("--- ERROR --- A newline in the middle of an expression at line %d!\n", global_lineno);
                    }
 
                    if (bracklev == 0)
                        break;
                    buffer[bufcount++] = c1;
                }
                if (c1 == EOF) {
                    fprintf(l, "ERROR-- End of File Reached in the middle of an Expr at line %d\n", global_lineno);
                    fclose(f);
                    fclose(l);
                    printf("--- ERROR --- EOF reached in middle of an expression at line %d!\n", global_lineno);
                    exit(22);
                }
 
                buffer[bufcount] = 0;
                /* update stats */
                global_expr_tot_size += bufcount;
                global_expr_count++;
                if (bufcount > global_expr_max_size)
                    global_expr_max_size = bufcount;
 
                retval = check_expr(buffer, error_report); /* check_expr should bump the warning counter */
                if (retval != 0) {
                    /* print error report */
                    printf("Warning(s) at line %d, expression: $[%s]; see expr2_log file for details\n",
                           global_lineno, buffer);
                    fprintf(l, "%s", error_report);
                }
                else {
                    printf("OK -- $[%s] at line %d\n", buffer, global_lineno);
                    global_OK_count++;
                }
                error_report[0] = 0;
                retval = check_eval(buffer, error_report);
                fprintf(l, "%s", error_report);
            }
        }
        last_char = c1;
    }
    printf("Summary:\n  Expressions detected: %d\n  Expressions OK:  %d\n  Total # Warnings:   %d\n  Longest Expr:   %d chars\n  Ave expr len:  %d chars\n",
           global_expr_count,
           global_OK_count,
           global_warn_count,
           global_expr_max_size,
           (global_expr_count) ? global_expr_tot_size/global_expr_count : 0);
 
    fclose(f);
    fclose(l);
}

References check_eval(), check_expr(), global_expr_count, global_expr_max_size, global_expr_tot_size, global_lineno, global_OK_count, global_warn_count, and retval.

Referenced by main().

set_var()

void set_var	(	const char *	varname,
		const char *	varval
	)

Definition at line 154 of file check_expr.c.

{
    struct varz *t = (struct varz*)calloc(1,sizeof(struct varz));
    if (!t)
        return;
    strcpy(t->varname, varname);
    strcpy(t->varval, varval);
    t->next = global_varlist;
    global_varlist = t;
}

References calloc, global_varlist, varz::next, varz::varname, and varz::varval.

Referenced by main().

Variable Documentation

global_expr_count

int global_expr_count =0

static

Definition at line 102 of file check_expr.c.

Referenced by parse_file().

global_expr_max_size

int global_expr_max_size =0

static

Definition at line 103 of file check_expr.c.

Referenced by parse_file().

global_expr_tot_size

int global_expr_tot_size =0

static

Definition at line 104 of file check_expr.c.

Referenced by parse_file().

global_lineno

int global_lineno = 1

static

Definition at line 101 of file check_expr.c.

Referenced by check_eval(), check_expr(), and parse_file().

global_OK_count

int global_OK_count =0

static

Definition at line 106 of file check_expr.c.

Referenced by parse_file().

global_varlist

struct varz* global_varlist

Definition at line 115 of file check_expr.c.

Referenced by find_var(), main(), and set_var().

global_warn_count

int global_warn_count =0

static

Definition at line 105 of file check_expr.c.

Referenced by check_expr(), and parse_file().