lib/keys.c File Reference

#include "common.h"
#include "keys.h"
#include "kxTok.h"

Include dependency graph for keys.c:

Go to the source code of this file.

Data Structures
struct	kvt
struct	exp
Enumerations
enum	keyExpType {   kxMatch, kxWildMatch, kxGT, kxGE,   kxLT, kxLE, kxAnd, kxOr,   kxNot, kxXor }
Functions
kvt *	newKvt (int size)
void	freeKvt (struct kvt **pKvt)
void	kvtClear (struct kvt *kvt)
keyVal *	kvtAdd (struct kvt *kvt, char *key, char *val)
void	kvtParseAdd (struct kvt *kvt, char *text)
keyVal *	kvtGet (struct kvt *kvt, char *key)
char *	kvtLookup (struct kvt *kvt, char *key)
void	kvtWriteAll (struct kvt *kvt, FILE *f, struct slName *hideList)
static void	getIntVals (struct kvt *kvt, struct exp *exp, int *retLeft, int *retRight)
static boolean	rkeyEval (struct kvt *kvt, struct exp *exp)
boolean	keyExpEval (struct keyExp *keyExp, struct kvt *kvt)
static void	advanceToken ()
static struct exp *	nextExp ()
static struct exp *	parseRelation ()
static struct exp *	parseParenthesized ()
static struct exp *	parseNot ()
static struct exp *	parseAndExp ()
static struct exp *	parseOrExp ()
static struct exp *	parseExp (struct kxTok *tokList)
keyExp *	keyExpParse (char *text)
boolean	keyTextScan (char *text, char *key, char *valBuf, int valBufSize)
Variables
static char const	rcsid [] = "$Id: keys.c,v 1.10 2005/04/10 14:41:23 markd Exp $"
static struct kxTok *	token

---

Enumeration Type Documentation

enum keyExpType

Enumerator:

kxMatch
kxWildMatch
kxGT
kxGE
kxLT
kxLE
kxAnd
kxOr
kxNot
kxXor

Definition at line 131 of file keys.c.

    {
    kxMatch,
    kxWildMatch,
    kxGT,      /* Greater Than */
    kxGE,      /* Greater Than or Equal */
    kxLT,      /* Less Than */
    kxLE,      /* Less Than or Equal */
    kxAnd,
    kxOr,
    kxNot,
    kxXor,
    };

---

Function Documentation

static void advanceToken

(

)

[static]

Definition at line 331 of file keys.c.

References kxTok::next, and token.

Referenced by parseAndExp(), parseNot(), parseOrExp(), parseParenthesized(), and parseRelation().

{
token = token->next;
}

Here is the caller graph for this function:

void freeKvt

(

struct kvt **

pKvt

)

Definition at line 32 of file keys.c.

References freeMem(), freez(), and kvt::table.

{
struct kvt *kvt;
if ((kvt = *pKvt) != NULL)
    {
    freeMem(kvt->table);
    freez(pKvt);
    }
}

Here is the call graph for this function:

static void getIntVals	(	struct kvt *	kvt,
		struct exp *	exp,
		int *	retLeft,
		int *	retRight
	)			[static]

Definition at line 152 of file keys.c.

References kvtLookup(), exp::left, and exp::right.

Referenced by rkeyEval().

{
char *rightString = exp->right;
char *leftKey = exp->left;
char *leftString = kvtLookup(kvt, leftKey);

if (leftString == NULL)
    *retLeft = 0;
else
    *retLeft = atoi(leftString);
if (rightString == NULL)
    *retRight = 0;
else
    *retRight = atoi(rightString);
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean keyExpEval	(	struct keyExp *	keyExp,
		struct kvt *	kvt
	)

Definition at line 321 of file keys.c.

References rkeyEval(), and keyExp::rootExp.

{
return rkeyEval(kvt, keyExp->rootExp);
}

Here is the call graph for this function:

struct keyExp* keyExpParse

(

char *

text

)

[read]

Definition at line 519 of file keys.c.

References AllocVar, kxTokenize(), parseExp(), keyExp::rootExp, tok, keyExp::tokenList, and TRUE.

{
struct keyExp *ke;
struct kxTok *tok;
AllocVar(ke);
ke->tokenList = tok = kxTokenize(text, TRUE);
ke->rootExp = parseExp(tok);

return ke;
}

Here is the call graph for this function:

boolean keyTextScan	(	char *	text,
		char *	key,
		char *	valBuf,
		int	valBufSize
	)

Definition at line 534 of file keys.c.

References FALSE, and TRUE.

{
int keySize = strlen(key);
char *s, *nl;
boolean ok = FALSE;

for (s = text; !isspace(s[0]); s = nl+1)
    {
    nl = strchr(s, '\n');
    assert(nl != NULL);
    if (s[keySize] == ' ' && memcmp(s, key, keySize) == 0)
        {
        char *val = s + keySize + 1;
        int valSize = nl - val;
        if (valSize >= valBufSize)
            valSize = valBufSize-1;
        memcpy(valBuf, val, valSize);
        valBuf[valSize] = 0;
        ok = TRUE;
        break;
        }
    }
return ok;
}

struct keyVal* kvtAdd	(	struct kvt *	kvt,
		char *	key,
		char *	val
	)			[read]

Definition at line 49 of file keys.c.

References kvt::alloced, errAbort(), keyVal::key, kvt::table, kvt::used, and keyVal::val.

Referenced by kvtParseAdd().

{
struct keyVal *kv;
if (kvt->used == kvt->alloced)
    errAbort("Too many keys in keyVal(%s %s)", key, val);
kv = &kvt->table[kvt->used++];
kv->key = key;
kv->val = val;
return kv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void kvtClear

(

struct kvt *

kvt

)

Definition at line 43 of file keys.c.

References kvt::used.

{
kvt->used = 0;
}

struct keyVal* kvtGet	(	struct kvt *	kvt,
		char *	key
	)			[read]

Definition at line 85 of file keys.c.

References sameString, kvt::table, and kvt::used.

Referenced by kvtLookup().

{
int i;
struct keyVal *keyTable = kvt->table;
int keysUsed = kvt->used;

for (i=0; i<keysUsed; ++i)
    {
    if (sameString(key, keyTable[i].key))
        return &keyTable[i];
    }
return NULL;
}

Here is the caller graph for this function:

char* kvtLookup	(	struct kvt *	kvt,
		char *	key
	)

Definition at line 100 of file keys.c.

References kvtGet(), and keyVal::val.

Referenced by getIntVals(), and rkeyEval().

{
struct keyVal *keyVal = kvtGet(kvt, key);
if (keyVal == NULL)
    return NULL;
else
    return keyVal->val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void kvtParseAdd	(	struct kvt *	kvt,
		char *	text
	)

Definition at line 61 of file keys.c.

References ArraySize, chopString(), and kvtAdd().

                                            :
 *     key val
 * for each line of text. Text gets many of it's
 * space characters and newlines replaced by 0's
 * and should persist until call to keysClear(). */
{
char *lines[256];
int lineCount;
int i;
char *k, *v;

lineCount = chopString(text, "\n\r", lines, ArraySize(lines));
for (i=0; i<lineCount; ++i)
    {
    k = lines[i];
    if ((v = strchr(k, ' ')) != NULL)
        {
        *v++ = 0;
        kvtAdd(kvt, k, v);
        }
    }
}

Here is the call graph for this function:

void kvtWriteAll	(	struct kvt *	kvt,
		FILE *	f,
		struct slName *	hideList
	)

Definition at line 111 of file keys.c.

References keyVal::key, mustWrite(), slNameInList(), kvt::table, kvt::used, and keyVal::val.

{
int i;
static char lf = '\n';
struct keyVal *kv = kvt->table;
int keyCount = kvt->used;

for (i=0; i<keyCount; ++i)
    {
    char *key = kv->key;
    if (kv->val != NULL && !slNameInList(hideList, key))
        fprintf(f, "%s %s\n", key, kv->val);
    ++kv;
    }
mustWrite(f, &lf, 1);   /* Instead of fputc for error checking. */
}

Here is the call graph for this function:

struct kvt* newKvt

(

int

size

)

[read]

Definition at line 21 of file keys.c.

References kvt::alloced, AllocVar, needMem(), and kvt::table.

{
struct kvt *kvt;
AllocVar(kvt);
kvt->alloced = size;
kvt->table = needMem(size * sizeof(kvt->table[0]));
return kvt;
}

Here is the call graph for this function:

static struct exp * nextExp

(

)

[static, read]

Definition at line 500 of file keys.c.

References parseOrExp().

Referenced by parseAndExp(), parseExp(), parseNot(), parseOrExp(), and parseParenthesized().

{
return parseOrExp();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct exp* parseAndExp

(

)

[static, read]

Definition at line 439 of file keys.c.

References advanceToken(), AllocVar, errAbort(), kxAnd, kxtAnd, exp::left, nextExp(), parseNot(), exp::right, kxTok::string, tok, token, exp::type, and kxTok::type.

Referenced by parseOrExp().

{
struct exp *left;
struct exp *right, *exp;
struct kxTok *tok;
enum kxTokType type;

if ((left = parseNot()) == NULL)
    return NULL;
if ((tok = token) == NULL)
    return left;
type = token->type;
if (type == kxtAnd)
    {
    advanceToken();
    right = nextExp();
    if (right == NULL)
        errAbort("Expecting expression on the other side of %s", tok->string);
    AllocVar(exp);
    exp->left = left;
    exp->right = right;
    exp->type = kxAnd;
    return exp;
    }
else
    return left;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct exp* parseExp

(

struct kxTok *

tokList

)

[static, read]

Definition at line 506 of file keys.c.

References errAbort(), kxtEnd, nextExp(), token, and kxTok::type.

Referenced by keyExpParse().

{
struct exp *exp;
token = tokList;
exp =  nextExp();
if (token->type != kxtEnd)
    {
    errAbort("Extra tokens past end of expression.  Missing &?");
    }
return exp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct exp* parseNot

(

)

[static, read]

Definition at line 418 of file keys.c.

References advanceToken(), AllocVar, kxNot, kxtNot, nextExp(), parseParenthesized(), exp::right, token, exp::type, and kxTok::type.

Referenced by parseAndExp().

{
struct exp *exp;
struct exp *right;

if (token == NULL)
    return NULL;
if (token->type == kxtNot)
    {
    advanceToken();
    right = nextExp();
    AllocVar(exp);
    exp->right = right;
    exp->type = kxNot;
    return exp;
    }
else
    return parseParenthesized();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct exp* parseOrExp

(

)

[static, read]

Definition at line 468 of file keys.c.

References advanceToken(), AllocVar, errAbort(), kxOr, kxtOr, kxtXor, kxXor, exp::left, nextExp(), parseAndExp(), exp::right, kxTok::string, tok, token, exp::type, and kxTok::type.

Referenced by nextExp().

{
struct exp *left;
struct exp *right, *exp;
struct kxTok *tok;
enum kxTokType type;

if ((left = parseAndExp()) == NULL)
    return NULL;
if ((tok = token) == NULL)
    return left;
type = token->type;
if (type == kxtOr || type == kxtXor)
    {
    advanceToken();
    right = nextExp();
    if (right == NULL)
        errAbort("Expecting expression on the other side of %s", tok->string);
    AllocVar(exp);
    exp->left = left;
    exp->right = right;
    if (type == kxtOr)
        exp->type = kxOr;
    else
        exp->type = kxXor;
    return exp;
    }
else
    return left;    
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct exp* parseParenthesized

(

)

[static, read]

Definition at line 397 of file keys.c.

References advanceToken(), errAbort(), kxtCloseParen, kxtOpenParen, nextExp(), parseRelation(), token, and kxTok::type.

Referenced by parseNot().

{
struct exp *exp;
if (token == NULL)
    return NULL;
if (token->type == kxtOpenParen)
    {
    advanceToken();
    exp = nextExp();
    if (token->type != kxtCloseParen)
        errAbort("Unmatched parenthesis");
    advanceToken();
    return exp;
    }
else
    {
    return parseRelation();
    }            
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct exp* parseRelation

(

)

[static, read]

Definition at line 339 of file keys.c.

References advanceToken(), AllocVar, errAbort(), kxGE, kxGT, kxLE, kxLT, kxMatch, kxtEquals, kxtGE, kxtGT, kxtLE, kxtLT, kxtString, kxtWildString, kxWildMatch, exp::left, exp::right, kxTok::string, token, exp::type, and kxTok::type.

Referenced by parseParenthesized().

{
struct kxTok *key, *match;

if (token == NULL)
    return NULL;
if (token->type != kxtString)
    errAbort("Expecting key got %s", token->string);
key = token;
advanceToken();
if (token->type == kxtEquals)
    {
    advanceToken();
    if (token->type == kxtString || token->type == kxtWildString)
        {
        struct exp *exp;
        match = token;
        advanceToken();
        AllocVar(exp);
        exp->left = key->string;
        exp->right = match->string;
        exp->type = (match->type == kxtString ? kxMatch : kxWildMatch);
        return exp;
        }
    else
        {
        errAbort("Expecting string to match in key=match expression,\ngot %s", token->string);
        }
    }
else if (token->type == kxtGT || token->type == kxtGE || token->type == kxtLT || token->type == kxtLE)
    {
    enum kxTokType relation = token->type;
    advanceToken();
    if (isdigit(token->string[0]))
        {
        struct exp *exp;
        match = token;
        advanceToken();
        AllocVar(exp);
        exp->left = key->string;
        exp->right = match->string;
        if (relation == kxtGT) exp->type = kxGT;
        else if (relation == kxtGE) exp->type = kxGE;
        else if (relation == kxtLT) exp->type = kxLT;
        else if (relation == kxtLE) exp->type = kxLE;
        return exp;
        }
    else
        {
        errAbort("Expecting number got %s", token->string);
        }
    }
else
    errAbort("Expecting = got %s", token->string);
return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean rkeyEval	(	struct kvt *	kvt,
		struct exp *	exp
	)			[static]

Definition at line 245 of file keys.c.

References errAbort(), getIntVals(), kvtLookup(), kxAnd, kxGE, kxGT, kxLE, kxLT, kxMatch, kxNot, kxOr, kxWildMatch, kxXor, exp::left, exp::right, sameString, sameWord, TRUE, exp::type, and wildMatch().

Referenced by keyExpEval().

{
if (exp == NULL)
    return TRUE;
switch (exp->type)
    {
    case kxMatch:
        {
        char *key = exp->left;
        char *matcher = exp->right;
        char *val = kvtLookup(kvt, key);
        if (val == NULL)
            return sameWord(matcher, "null");
        else
            return sameWord(matcher, val);
        }
    case kxWildMatch:
        {
        char *key = exp->left;
        char *matcher = exp->right;
        char *val = kvtLookup(kvt, key);
        if (val == NULL)
            return sameString(matcher, "*");
        else
            return wildMatch(matcher, val);
        }
    case kxGT:
        {
        int left, right;
        getIntVals(kvt, exp, &left, &right);
        return left > right;
        }
    case kxGE:
        {
        int left, right;
        getIntVals(kvt, exp, &left, &right);
        return left >= right;
        }
    case kxLT:
        {
        int left, right;
        getIntVals(kvt, exp, &left, &right);
        return left < right;
        }
    case kxLE:
        {
        int left, right;
        getIntVals(kvt, exp, &left, &right);
        return left <= right;
        }
    
    case kxNot:
        {
        return !rkeyEval(kvt, exp->right);
        }
    case kxAnd:
        {
        return rkeyEval(kvt, exp->left) && rkeyEval(kvt, exp->right);
        }
    case kxOr:
        {
        return rkeyEval(kvt, exp->left) || rkeyEval(kvt, exp->right);
        }
    case kxXor:
        {
        return rkeyEval(kvt, exp->left) ^ rkeyEval(kvt, exp->right);
        }
    default:
        {
        errAbort("unknown expression type %d", exp->type);
        return 0;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

char const rcsid[] = "$Id: keys.c,v 1.10 2005/04/10 14:41:23 markd Exp $" [static]

Definition at line 11 of file keys.c.

struct kxTok* token [static]

Definition at line 329 of file keys.c.

Referenced by advanceToken(), parseAndExp(), parseExp(), parseNot(), parseOrExp(), parseParenthesized(), and parseRelation().

---