/*

 * Copyright © 2008,2009 Red Hat, Inc.

 *

 * Red Hat Author(s): Behdad Esfahbod

 *

 * Permission to use, copy, modify, distribute, and sell this software and its

 * documentation for any purpose is hereby granted without fee, provided that

 * the above copyright notice appear in all copies and that both that

 * copyright notice and this permission notice appear in supporting

 * documentation, and that the name of the author(s) not be used in

 * advertising or publicity pertaining to distribution of the software without

 * specific, written prior permission.  The authors make no

 * representations about the suitability of this software for any purpose.  It

 * is provided "as is" without express or implied warranty.

 *

 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO

 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR

 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

 * PERFORMANCE OF THIS SOFTWARE.

 */

#include "fcint.h"

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

/* The language is documented in doc/fcformat.fncs

 * These are the features implemented:

 *

 * simple	%{elt}

 * width	%width{elt}

 * index	%{elt[idx]}

 * name=	%{elt=}

 * :name=	%{:elt}

 * default	%{elt:-word}

 * count	%{#elt}

 * subexpr	%{{expr}}

 * filter-out	%{-elt1,elt2,elt3{expr}}

 * filter-in	%{+elt1,elt2,elt3{expr}}

 * conditional	%{?elt1,elt2,!elt3{}{}}

 * enumerate	%{[]elt1,elt2{expr}}

 * langset	langset enumeration using the same syntax

 * builtin	%{=blt}

 * convert	%{elt|conv1|conv2|conv3}

 *

 * converters:

 * basename	FcStrBasename

 * dirname	FcStrDirname

 * downcase	FcStrDowncase

 * shescape

 * cescape

 * xmlescape

 * delete	delete chars

 * escape	escape chars

 * translate	translate chars

 *

 * builtins:

 * unparse	FcNameUnparse

 * fcmatch	fc-match default

 * fclist	fc-list default

 * fccat	fc-cat default

 * pkgkit	PackageKit package tag format

 *

 *

 * Some ideas for future syntax extensions:

 *

 * - verbose builtin that is like FcPatternPrint

 * - allow indexing subexprs using '%{[idx]elt1,elt2{subexpr}}'

 * - allow indexing in +, -, ? filtering?

 * - conditional/filtering/deletion on binding (using '(w)'/'(s)'/'(=)' notation)

 */

#define FCCAT_FORMAT	"\"%{file|basename|cescape}\" %{index} \"%{-file{%{=unparse|cescape}}}\""

#define FCMATCH_FORMAT	"%{file:-<unknown filename>|basename}: \"%{family[0]:-<unknown family>}\" \"%{style[0]:-<unknown style>}\""

#define FCLIST_FORMAT	"%{?file{%{file}: }}%{-file{%{=unparse}}}"

#define PKGKIT_FORMAT	"%{[]family{font(%{family|downcase|delete( )})\n}}%{[]lang{font(:lang=%{lang|downcase|translate(_,-)})\n}}"

static void

message (const char *fmt, ...)

{

    va_list	args;

    va_start (args, fmt);

    fprintf (stderr, "Fontconfig: Pattern format error: ");

    vfprintf (stderr, fmt, args);

    fprintf (stderr, ".\n");

    va_end (args);

}

typedef struct _FcFormatContext

{

    const FcChar8 *format_orig;

    const FcChar8 *format;

    int            format_len;

    FcChar8       *word;

    FcBool         word_allocated;

} FcFormatContext;

static FcBool

FcFormatContextInit (FcFormatContext *c,

		     const FcChar8   *format,

		     FcChar8         *scratch,

		     int              scratch_len)

{

    c->format_orig = c->format = format;

    c->format_len = strlen ((const char *) format);

    if (c->format_len < scratch_len)

    {

	c->word = scratch;

	c->word_allocated = FcFalse;

    }

    else

    {

	c->word = malloc (c->format_len + 1);

	c->word_allocated = FcTrue;

    }

    return c->word != NULL;

}

static void

FcFormatContextDone (FcFormatContext *c)

{

    if (c && c->word_allocated)

    {

	free (c->word);

    }

}

static FcBool

consume_char (FcFormatContext *c,

	      FcChar8          term)

{

    if (*c->format != term)

	return FcFalse;

    c->format++;

    return FcTrue;

}

static FcBool

expect_char (FcFormatContext *c,

	      FcChar8          term)

{

    FcBool res = consume_char (c, term);

    if (!res)

    {

	if (c->format == c->format_orig + c->format_len)

	    message ("format ended while expecting '%c'",

		     term);

	else

	    message ("expected '%c' at %d",

		     term, c->format - c->format_orig + 1);

    }

    return res;

}

static FcBool

FcCharIsPunct (const FcChar8 c)

{

    if (c < '0')

	return FcTrue;

    if (c <= '9')

	return FcFalse;

    if (c < 'A')

	return FcTrue;

    if (c <= 'Z')

	return FcFalse;

    if (c < 'a')

	return FcTrue;

    if (c <= 'z')

	return FcFalse;

    if (c <= '~')

	return FcTrue;

    return FcFalse;

}

static char escaped_char(const char ch)

{

    switch (ch) {

    case 'a':   return '\a';

    case 'b':   return '\b';

    case 'f':   return '\f';

    case 'n':   return '\n';

    case 'r':   return '\r';

    case 't':   return '\t';

    case 'v':   return '\v';

    default:    return ch;

    }

}

static FcBool

read_word (FcFormatContext *c)

{

    FcChar8 *p;

    p = c->word;

    while (*c->format)

    {

	if (*c->format == '\\')

	{

	    c->format++;

	    if (*c->format)

	      *p++ = escaped_char (*c->format++);

	    continue;

	}

	else if (FcCharIsPunct (*c->format))

	    break;

	*p++ = *c->format++;

    }

    *p = '\0';

    if (p == c->word)

    {

	message ("expected identifier at %d",

		 c->format - c->format_orig + 1);

	return FcFalse;

    }

    return FcTrue;

}

static FcBool

read_chars (FcFormatContext *c,

	    FcChar8          term)

{

    FcChar8 *p;

    p = c->word;

    while (*c->format && *c->format != '}' && *c->format != term)

    {

	if (*c->format == '\\')

	{

	    c->format++;

	    if (*c->format)

	      *p++ = escaped_char (*c->format++);

	    continue;

	}

	*p++ = *c->format++;

    }

    *p = '\0';

    if (p == c->word)

    {

	message ("expected character data at %d",

		 c->format - c->format_orig + 1);

	return FcFalse;

    }

    return FcTrue;

}

static FcBool

FcPatternFormatToBuf (FcPattern     *pat,

		      const FcChar8 *format,

		      FcStrBuf      *buf);

static FcBool

interpret_builtin (FcFormatContext *c,

		   FcPattern       *pat,

		   FcStrBuf        *buf)

{

    FcChar8       *new_str;

    FcBool         ret;

    if (!expect_char (c, '=') ||

	!read_word (c))

	return FcFalse;

    /* try simple builtins first */

    if (0) { }

#define BUILTIN(name, func) \

    else if (0 == strcmp ((const char *) c->word, name))\

	do { new_str = func (pat); ret = FcTrue; } while (0)

    BUILTIN ("unparse",  FcNameUnparse);

 /* BUILTIN ("verbose",  FcPatternPrint); XXX */

#undef BUILTIN

    else

	ret = FcFalse;

    if (ret)

    {

	if (new_str)

	{

	    FcStrBufString (buf, new_str);

	    FcStrFree (new_str);

	    return FcTrue;

	}

	else

	    return FcFalse;

    }

    /* now try our custom formats */

    if (0) { }

#define BUILTIN(name, format) \

    else if (0 == strcmp ((const char *) c->word, name))\

	ret = FcPatternFormatToBuf (pat, (const FcChar8 *) format, buf)

    BUILTIN ("fccat",    FCCAT_FORMAT);

    BUILTIN ("fcmatch",  FCMATCH_FORMAT);

    BUILTIN ("fclist",   FCLIST_FORMAT);

    BUILTIN ("pkgkit",   PKGKIT_FORMAT);

#undef BUILTIN

    else

	ret = FcFalse;

    if (!ret)

	message ("unknown builtin \"%s\"",

		 c->word);

    return ret;

}

static FcBool

interpret_expr (FcFormatContext *c,

		FcPattern       *pat,

		FcStrBuf        *buf,

		FcChar8          term);

static FcBool

interpret_subexpr (FcFormatContext *c,

		   FcPattern       *pat,

		   FcStrBuf        *buf)

{

    return expect_char (c, '{') &&

	   interpret_expr (c, pat, buf, '}') &&

	   expect_char (c, '}');

}

static FcBool

maybe_interpret_subexpr (FcFormatContext *c,

			 FcPattern       *pat,

			 FcStrBuf        *buf)

{

    return (*c->format == '{') ?

	   interpret_subexpr (c, pat, buf) :

	   FcTrue;

}

static FcBool

skip_subexpr (FcFormatContext *c);

static FcBool

skip_percent (FcFormatContext *c)

{

    if (!expect_char (c, '%'))

	return FcFalse;

    /* skip an optional width specifier */

    if (strtol ((const char *) c->format, (char **) &c->format, 10))

        {/* don't care */}

    if (!expect_char (c, '{'))

	return FcFalse;

    while(*c->format && *c->format != '}')

    {

	switch (*c->format)

	{

	case '\\':

	    c->format++; /* skip over '\\' */

	    if (*c->format)

		c->format++;

	    continue;

	case '{':

	    if (!skip_subexpr (c))

		return FcFalse;

	    continue;

	}

	c->format++;

    }

    return expect_char (c, '}');

}

static FcBool

skip_expr (FcFormatContext *c)

{

    while(*c->format && *c->format != '}')

    {

	switch (*c->format)

	{

	case '\\':

	    c->format++; /* skip over '\\' */

	    if (*c->format)

		c->format++;

	    continue;

	case '%':

	    if (!skip_percent (c))

		return FcFalse;

	    continue;

	}

	c->format++;

    }

    return FcTrue;

}

static FcBool

skip_subexpr (FcFormatContext *c)

{

    return expect_char (c, '{') &&

	   skip_expr (c) &&

	   expect_char (c, '}');

}

static FcBool

maybe_skip_subexpr (FcFormatContext *c)

{

    return (*c->format == '{') ?

	   skip_subexpr (c) :

	   FcTrue;

}

static FcBool

interpret_filter_in (FcFormatContext *c,

		     FcPattern       *pat,

		     FcStrBuf        *buf)

{

    FcObjectSet  *os;

    FcPattern    *subpat;

    if (!expect_char (c, '+'))

	return FcFalse;

    os = FcObjectSetCreate ();

    if (!os)

	return FcFalse;

    do

    {

	/* XXX binding */

	if (!read_word (c) ||

	    !FcObjectSetAdd (os, (const char *) c->word))

	{

	    FcObjectSetDestroy (os);

	    return FcFalse;

	}

    }

    while (consume_char (c, ','));

    subpat = FcPatternFilter (pat, os);

    FcObjectSetDestroy (os);

    if (!subpat ||

	!interpret_subexpr (c, subpat, buf))

	return FcFalse;

    FcPatternDestroy (subpat);

    return FcTrue;

}

static FcBool

interpret_filter_out (FcFormatContext *c,

		      FcPattern       *pat,

		      FcStrBuf        *buf)

{

    FcPattern    *subpat;

    if (!expect_char (c, '-'))

	return FcFalse;

    subpat = FcPatternDuplicate (pat);

    if (!subpat)

	return FcFalse;

    do

    {

	if (!read_word (c))

	{

	    FcPatternDestroy (subpat);

	    return FcFalse;

	}

	FcPatternDel (subpat, (const char *) c->word);

    }

    while (consume_char (c, ','));

    if (!interpret_subexpr (c, subpat, buf))

	return FcFalse;

    FcPatternDestroy (subpat);

    return FcTrue;

}

static FcBool

interpret_cond (FcFormatContext *c,

		FcPattern       *pat,

		FcStrBuf        *buf)

{

    FcBool pass;

    if (!expect_char (c, '?'))

	return FcFalse;

    pass = FcTrue;

    do

    {

	FcBool negate;

	FcValue v;

	negate = consume_char (c, '!');

	if (!read_word (c))

	    return FcFalse;

	pass = pass &&

	       (negate ^

		(FcResultMatch ==

		 FcPatternGet (pat, (const char *) c->word, 0, &v)));

    }

    while (consume_char (c, ','));

    if (pass)

    {

	if (!interpret_subexpr  (c, pat, buf) ||

	    !maybe_skip_subexpr (c))

	    return FcFalse;

    }

    else

    {

	if (!skip_subexpr (c) ||

	    !maybe_interpret_subexpr  (c, pat, buf))

	    return FcFalse;

    }

    return FcTrue;

}

static FcBool

interpret_count (FcFormatContext *c,

		 FcPattern       *pat,

		 FcStrBuf        *buf)

{

    int count;

    FcPatternIter iter;

    FcChar8 buf_static[64];

    if (!expect_char (c, '#'))

	return FcFalse;

    if (!read_word (c))

	return FcFalse;

    count = 0;

    if (FcPatternFindIter (pat, &iter, (const char *) c->word))

    {

	count = FcPatternIterValueCount (pat, &iter);

    }

    snprintf ((char *) buf_static, sizeof (buf_static), "%d", count);

    FcStrBufString (buf, buf_static);

    return FcTrue;

}

static FcBool

interpret_enumerate (FcFormatContext *c,

		     FcPattern       *pat,

		     FcStrBuf        *buf)

{

    FcObjectSet   *os;

    FcPattern     *subpat;

    const FcChar8 *format_save;

    int            idx;

    FcBool         ret, done;

    FcStrList      *lang_strs;

    if (!expect_char (c, '[') ||

	!expect_char (c, ']'))

	return FcFalse;

    os = FcObjectSetCreate ();

    if (!os)

	return FcFalse;

    ret = FcTrue;

    do

    {

	if (!read_word (c) ||

	    !FcObjectSetAdd (os, (const char *) c->word))

	{

	    FcObjectSetDestroy (os);

	    return FcFalse;

	}

    }

    while (consume_char (c, ','));

    /* If we have one element and it's of type FcLangSet, we want

     * to enumerate the languages in it. */

    lang_strs = NULL;

    if (os->nobject == 1)

    {

	FcLangSet *langset;

	if (FcResultMatch ==

	    FcPatternGetLangSet (pat, os->objects[0], 0, &langset))

	{

	    FcStrSet *ss;

	    if (!(ss = FcLangSetGetLangs (langset)) ||

		!(lang_strs = FcStrListCreate (ss)))

		goto bail0;

	}

    }

    subpat = FcPatternDuplicate (pat);

    if (!subpat)

	goto bail0;

    format_save = c->format;

    idx = 0;

    do

    {

	int i;

	done = FcTrue;

	if (lang_strs)

	{

	    FcChar8 *lang;

	    FcPatternDel (subpat, os->objects[0]);

	    if ((lang = FcStrListNext (lang_strs)))

	    {

		/* XXX binding? */

		FcPatternAddString (subpat, os->objects[0], lang);

		done = FcFalse;

	    }

	}

	else

	{

	    for (i = 0; i < os->nobject; i++)

	    {

		FcValue v;

		/* XXX this can be optimized by accessing valuelist linked lists

		 * directly and remembering where we were.  Most (all) value lists

		 * in normal uses are pretty short though (language tags are

		 * stored as a LangSet, not separate values.). */

		FcPatternDel (subpat, os->objects[i]);

		if (FcResultMatch ==

		    FcPatternGet (pat, os->objects[i], idx, &v))

		{

		    /* XXX binding */

		    FcPatternAdd (subpat, os->objects[i], v, FcFalse);

		    done = FcFalse;

		}

	    }

	}

	if (!done)

	{

	    c->format = format_save;

	    ret = interpret_subexpr (c, subpat, buf);

	    if (!ret)

		goto bail;

	}

	idx++;

    } while (!done);

    if (c->format == format_save)

	skip_subexpr (c);

bail:

    FcPatternDestroy (subpat);

bail0:

    if (lang_strs)

	FcStrListDone (lang_strs);

    FcObjectSetDestroy (os);

    return ret;

}

static FcBool

interpret_simple (FcFormatContext *c,

		  FcPattern       *pat,

		  FcStrBuf        *buf)

{

    FcPatternIter iter;

    FcBool        add_colon = FcFalse;

    FcBool        add_elt_name = FcFalse;

    int           idx;

    FcChar8      *else_string;

    if (consume_char (c, ':'))

	add_colon = FcTrue;

    if (!read_word (c))

	return FcFalse;

    idx = -1;

    if (consume_char (c, '['))

    {

	idx = strtol ((const char *) c->format, (char **) &c->format, 10);

	if (idx < 0)

	{

	    message ("expected non-negative number at %d",

		     c->format-1 - c->format_orig + 1);

	    return FcFalse;

	}

	if (!expect_char (c, ']'))

	    return FcFalse;

    }

    if (consume_char (c, '='))

	add_elt_name = FcTrue;

    /* modifiers */

    else_string = NULL;

    if (consume_char (c, ':'))

    {

	FcChar8 *orig;

	/* divert the c->word for now */

	orig = c->word;

	c->word = c->word + strlen ((const char *) c->word) + 1;

	/* for now we just support 'default value' */

	if (!expect_char (c, '-') ||

	    !read_chars (c, '|'))

	{

	    c->word = orig;

	    return FcFalse;

	}

	else_string = c->word;

	c->word = orig;

    }

    if (FcPatternFindIter (pat, &iter, (const char *) c->word) || else_string)

    {

	FcValueListPtr l = NULL;

	if (add_colon)

	    FcStrBufChar (buf, ':');

	if (add_elt_name)

	{

	    FcStrBufString (buf, c->word);

	    FcStrBufChar (buf, '=');

	}

	l = FcPatternIterGetValues (pat, &iter);

	if (idx != -1)

	{

	    while (l && idx > 0)

	    {

		l = FcValueListNext(l);

		idx--;

	    }

	    if (l && idx == 0)

	    {

		if (!FcNameUnparseValue (buf, &l->value, '\0'))

		    return FcFalse;

	    }

	    else goto notfound;

        }

	else if (l)

	{

	    FcNameUnparseValueList (buf, l, '\0');

	}

	else

	{

    notfound:

	    if (else_string)

		FcStrBufString (buf, else_string);

	}

    }

    return FcTrue;

}

static FcBool

cescape (FcFormatContext *c FC_UNUSED,

	 const FcChar8   *str,

	 FcStrBuf        *buf)

{

    /* XXX escape \n etc? */

    while(*str)

    {

	switch (*str)

	{

	case '\\':

	case '"':

	    FcStrBufChar (buf, '\\');

	    break;

	}

	FcStrBufChar (buf, *str++);

    }

    return FcTrue;

}

static FcBool

shescape (FcFormatContext *c FC_UNUSED,

	  const FcChar8   *str,

	  FcStrBuf        *buf)

{

    FcStrBufChar (buf, '\'');

    while(*str)

    {

	if (*str == '\'')

	    FcStrBufString (buf, (const FcChar8 *) "'\\''");

	else

	    FcStrBufChar (buf, *str);

	str++;

    }

    FcStrBufChar (buf, '\'');

    return FcTrue;

}

static FcBool

xmlescape (FcFormatContext *c FC_UNUSED,

	   const FcChar8   *str,

	   FcStrBuf        *buf)

{

    /* XXX escape \n etc? */

    while(*str)

    {

	switch (*str)

	{

	case '&': FcStrBufString (buf, (const FcChar8 *) "&"); break;

	case '<': FcStrBufString (buf, (const FcChar8 *) "<");  break;

	case '>': FcStrBufString (buf, (const FcChar8 *) ">");  break;

	default:  FcStrBufChar   (buf, *str);                      break;

	}

	str++;

    }

    return FcTrue;

}

static FcBool

delete_chars (FcFormatContext *c,

	      const FcChar8   *str,

	      FcStrBuf        *buf)

{

    /* XXX not UTF-8 aware */

    if (!expect_char (c, '(') ||

	!read_chars (c, ')') ||

	!expect_char (c, ')'))

	return FcFalse;

    while(*str)

    {

	FcChar8 *p;

	p = (FcChar8 *) strpbrk ((const char *) str, (const char *) c->word);

	if (p)

	{

	    FcStrBufData (buf, str, p - str);

	    str = p + 1;

	}

	else

	{

	    FcStrBufString (buf, str);

	    break;

	}

    }

    return FcTrue;

}

static FcBool

escape_chars (FcFormatContext *c,

	      const FcChar8   *str,

	      FcStrBuf        *buf)

{

    /* XXX not UTF-8 aware */