#ifndef __SYMBIAN32__

// zutil.c - misc utilities

//

// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

//

/*

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 1999 Sven Wischnowsky

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Sven Wischnowsky or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Sven Wischnowsky and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Sven Wischnowsky and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Sven Wischnowsky and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zutil.mdh"

#include "zutil.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

/* Style stuff. */

typedef struct stypat *Stypat;

typedef struct style *Style;

/* A pattern and the styles for it. */

struct style {

    Style next;			/* next in stypat list */

    Stypat pats;		/* patterns */

    char *name;

};

struct stypat {

    Stypat next;

    char *pat;			/* pattern string */

    Patprog prog;		/* compiled pattern */

    int weight;			/* how specific is the pattern? */

    Eprog eval;			/* eval-on-retrieve? */

    char **vals;

};

/* List of styles. */

static Style zstyles, zlstyles;

/* Memory stuff. */

static void

freestypat(Stypat p)

{

    zsfree(p->pat);

    freepatprog(p->prog);

    if (p->vals)

	freearray(p->vals);

    if (p->eval)

	freeeprog(p->eval);

    zfree(p, sizeof(*p));

}

static void

freeallstyles(void)

{

    Style s, sn;

    Stypat p, pn;

    for (s = zstyles; s; s = sn) {

	sn = s->next;

	for (p = s->pats; p; p = pn) {

	    pn = p->next;

	    freestypat(p);

	}

	zsfree(s->name);

	zfree(s, sizeof(*s));

    }

    zstyles = zlstyles = NULL;

}

/* Get the style struct for a name. */

static Style

getstyle(char *name)

{

    Style s;

    for (s = zstyles; s; s = s->next)

	if (!strcmp(name, s->name))

	    return s;

    return NULL;

}

/* Store a value for a style. */

static int

setstypat(Style s, char *pat, Patprog prog, char **vals, int eval)

{

    int weight, tmp, first;

    char *str;

    Stypat p, q, qq;

    Eprog eprog = NULL;

    if (eval) {

	int ef = errflag;

	eprog = parse_string(zjoin(vals, ' ', 1));

	errflag = ef;

	if (!eprog)

	{

	    freepatprog(prog);

	    return 1;

	}

	eprog = dupeprog(eprog, 0);

    }

    for (p = s->pats; p; p = p->next)

	if (!strcmp(pat, p->pat)) {

	    /* Exists -> replace. */

	    if (p->vals)

		freearray(p->vals);

	    if (p->eval)

		freeeprog(p->eval);

	    p->vals = zarrdup(vals);

	    p->eval = eprog;

	    freepatprog(prog);

	    return 0;

	}

    /* New pattern. */

    p = (Stypat) zalloc(sizeof(*p));

    p->pat = ztrdup(pat);

    p->prog = prog;

    p->vals = zarrdup(vals);

    p->eval = eprog;

    p->next = NULL;

    /* Calculate the weight. */

    for (weight = 0, tmp = 2, first = 1, str = pat; *str; str++) {

	if (first && *str == '*' && (!str[1] || str[1] == ':')) {

	    /* Only `*' in this component. */

	    tmp = 0;

	    continue;

	}

	first = 0;

	if (*str == '(' || *str == '|' || *str == '*' || *str == '[' ||

	    *str == '<' ||  *str == '?' || *str == '#' || *str == '^')

	    /* Is pattern. */

	    tmp = 1;

	if (*str == ':') {

	    /* Yet another component. */

	    first = 1;

	    weight += tmp;

	    tmp = 2;

	}

    }

    p->weight = (weight += tmp);

    for (qq = NULL, q = s->pats; q && q->weight >= weight;

	 qq = q, q = q->next);

    p->next = q;

    if (qq)

	qq->next = p;

    else

	s->pats = p;

    return 0;

}

/* Add a new style. */

static Style

addstyle(char *name)

{

    Style s;

    s = (Style) zalloc(sizeof(*s));

    s->next = NULL;

    s->pats = NULL;

    s->name = ztrdup(name);

    if (zlstyles)

	zlstyles->next = s;

    else

	zstyles = s;

    zlstyles = s;

    return s;

}

static char **

evalstyle(Stypat p)

{

    int ef = errflag;

    char **ret, *str;

    unsetparam("reply");

    execode(p->eval, 1, 0);

    if (errflag) {

	errflag = ef;

	return NULL;

    }

    errflag = ef;

    queue_signals();

    if ((ret = getaparam("reply")))

	ret = arrdup(ret);

    else if ((str = getsparam("reply"))) {

	ret = (char **) hcalloc(2 * sizeof(char *));

	ret[0] = dupstring(str);

    }

    unqueue_signals();

    unsetparam("reply");

    return ret;

}

/* Look up a style for a context pattern. This does the matching. */

static char **

lookupstyle(char *ctxt, char *style)

{

    Style s;

    Stypat p;

    for (s = zstyles; s; s = s->next)

	if (!strcmp(s->name, style))

	    for (p = s->pats; p; p = p->next)

		if (pattry(p->prog, ctxt))

		    return (p->eval ? evalstyle(p) : p->vals);

    return NULL;

}

static int

bin_zstyle(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))

{

    int min, max, n, add = 0, list = 0, eval = 0;

    if (!args[0])

	list = 1;

    else if (args[0][0] == '-') {

	char oc;

	if ((oc = args[0][1]) && oc != '-') {

	    if (args[0][2]) {

		zwarnnam(nam, "invalid argument: %s", args[0], 0);

		return 1;

	    }

	    if (oc == 'L')

		list = 2;

	    else if (oc == 'e') {

		eval = add = 1;

		args++;

	    }

	} else {

	    add = 1;

	    args++;

	}

    } else

	add = 1;

    if (add) {

	Style s;

	Patprog prog;

	char *pat;

	if (arrlen(args) < 2) {

	    zwarnnam(nam, "not enough arguments", NULL, 0);

	    return 1;

	}

	pat = dupstring(args[0]);

	tokenize(pat);

	if (!(prog = patcompile(pat, PAT_ZDUP, NULL))) {

	    zwarnnam(nam, "invalid pattern: %s", args[0], 0);

	    return 1;

	}

	if (!(s = getstyle(args[1])))

	    s = addstyle(args[1]);

	return setstypat(s, args[0], prog, args + 2, eval);

    }

    if (list) {

	Style s;

	Stypat p;

	char **v;

	for (s = zstyles; s; s = s->next) {

	    if (list == 1) {

		quotedzputs(s->name, stdout);

		putchar('\n');

	    }

	    for (p = s->pats; p; p = p->next) {

		if (list == 1)

		    printf("%s  %s", (p->eval ? "(eval)" : "      "), p->pat);

		else {

		    printf("zstyle %s", (p->eval ? "-e " : ""));

		    quotedzputs(p->pat, stdout);

		    printf(" %s", s->name);

		}

		for (v = p->vals; *v; v++) {

		    putchar(' ');

		    quotedzputs(*v, stdout);

		}

		putchar('\n');

	    }

	}

	return 0;

    }

    switch (args[0][1]) {

    case 'd': min = 0; max = -1; break;

    case 's': min = 3; max =  4; break;

    case 'b': min = 3; max =  3; break;

    case 'a': min = 3; max =  3; break;

    case 't': min = 2; max = -1; break;

    case 'T': min = 2; max = -1; break;

    case 'm': min = 3; max =  3; break;

    case 'g': min = 1; max =  3; break;

    default:

	zwarnnam(nam, "invalid option: %s", args[0], 0);

	return 1;

    }

    n = arrlen(args) - 1;

    if (n < min) {

	zwarnnam(nam, "not enough arguments", NULL, 0);

	return 1;

    } else if (max >= 0 && n > max) {

	zwarnnam(nam, "too many arguments", NULL, 0);

	return 1;

    }

    switch (args[0][1]) {

    case 'd':

	{

	    Style s;

	    if (args[1]) {

		if (args[2]) {

		    char *pat = args[1];

		    for (args += 2; *args; args++) {

			if ((s = getstyle(*args))) {

			    Stypat p, q;

			    for (q = NULL, p = s->pats; p;

				 q = p, p = p->next) {

				if (!strcmp(p->pat, pat)) {

				    if (q)

					q->next = p->next;

				    else

					s->pats = p->next;

				    freestypat(p);

				    break;

				}

			    }

			}

		    }

		} else {

		    Stypat p, q;

		    for (s = zstyles; s; s = s->next) {

			for (q = NULL, p = s->pats; p; q = p, p = p->next) {

			    if (!strcmp(p->pat, args[1])) {

				if (q)

				    q->next = p->next;

				else

				    s->pats = p->next;

				freestypat(p);

				break;

			    }

			}

		    }

		}

	    } else

		freeallstyles();

	}

	break;

    case 's':

	{

	    char **vals, *ret;

	    int val;

	    if ((vals = lookupstyle(args[1], args[2])) && vals[0]) {

		ret = sepjoin(vals, (args[4] ? args[4] : " "), 0);

		val = 0;

	    } else {

		ret = ztrdup("");

		val = 1;

	    }

	    setsparam(args[3], ret);

	    return val;

	}

	break;

    case 'b':

	{

	    char **vals, *ret;

	    int val;

	    if ((vals = lookupstyle(args[1], args[2])) &&

		vals[0] && !vals[1] &&

		(!strcmp(vals[0], "yes") ||

		 !strcmp(vals[0], "true") ||

		 !strcmp(vals[0], "on") ||

		 !strcmp(vals[0], "1"))) {

		ret = "yes";

		val = 0;

	    } else {

		ret = "no";

		val = 1;

	    }

	    setsparam(args[3], ztrdup(ret));

	    return val;

	}

	break;

    case 'a':

	{

	    char **vals, **ret;

	    int val;

	    if ((vals = lookupstyle(args[1], args[2]))) {

		ret = zarrdup(vals);

		val = 0;

	    } else {

		char *dummy = NULL;

		ret = zarrdup(&dummy);

		val = 1;

	    }

	    setaparam(args[3], ret);

	    return val;

	}

	break;

    case 't':

    case 'T':

	{

	    char **vals;

	    if ((vals = lookupstyle(args[1], args[2])) && vals[0]) {

		if (args[3]) {

		    char **ap = args + 3, **p;

		    while (*ap) {

			p = vals;

			while (*p)

			    if (!strcmp(*ap, *p++))

				return 0;

			ap++;

		    }

		    return 1;

		} else

		    return !(!strcmp(vals[0], "true") ||

			     !strcmp(vals[0], "yes") ||

			     !strcmp(vals[0], "on") ||

			     !strcmp(vals[0], "1"));

	    }

	    return (args[0][1] == 't' ? (vals ? 1 : 2) : 0);

	}

	break;

    case 'm':

	{

	    char **vals;

	    Patprog prog;

	    tokenize(args[3]);

	    if ((vals = lookupstyle(args[1], args[2])) &&

		(prog = patcompile(args[3], PAT_STATIC, NULL))) {

		while (*vals)

		    if (pattry(prog, *vals++))

			return 0;

	    }

	    return 1;

	}

	break;

    case 'g':

	{

	    LinkList l = newlinklist();

	    int ret = 1;

	    Style s;

	    Stypat p;

	    if (args[2]) {

		if (args[3]) {

		    if ((s = getstyle(args[3]))) {

			for (p = s->pats; p; p = p->next) {

			    if (!strcmp(args[2], p->pat)) {

				char **v = p->vals;

				while (*v)

				    addlinknode(l, *v++);

				ret = 0;

				break;

			    }

			}

		    }