gambas-source-code/main/lib/eval/CHighlight.c

/***************************************************************************

  CHighlight.c

  (c) 2000-2009 Benoît Minisini <gambas@users.sourceforge.net>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#define __CHIGHLIGHT_CPP

#include "gb_common.h"
#include "main.h"
#include "gb.eval.h"
#include "eval_analyze.h"

#include "CHighlight.h"

static void *_analyze_symbol = 0;
static void *_analyze_type = 0;
static void *_analyze_pos = 0;
static char *_analyze_text = 0;

static char *_purged_line = NULL;

static int get_char_length(unsigned char c)
{
  int n = 1;

  if (c & 0x80)
  {
    for (;;)
    {
      c <<= 1;
      if (!(c & 0x80))
        break;
      n++;
    }
  }

  return n;
}

static char *purge(const char *s, int len_s, bool comment, bool string)
{
  char c;
  uint i;
  int lc, ls;
  bool in_comment = FALSE;
  char wait = 0;
  char *r = NULL;
  
  for (i = 0; i < len_s; i += ls)
  {
    c = s[i];
    ls = lc = get_char_length((unsigned char)c);

    switch(wait)
    {
      case 0:

        if (in_comment)
        {
        	if (!comment)
          	c = ' ', lc = 1;
				}
        else if (c == '"')
          wait = '"';
        else if (c == '\'')
          in_comment = TRUE;

        break;

      case '"':
        if (c == '"')
          wait = 0;
				else if (c == '\\')
				{
					if (string)
					{
						if (i < len_s)
							GB.AddString(&r, &c, 1);
							//r += c;
						i++;
						c = s[i];
						lc = get_char_length((unsigned char)c);
					}
					else
					{
						i++;
						if (i < len_s)
							GB.AddString(&r, " ", 1);
							//r += ' ';
						c = ' ', lc = 1;
					}
				}
        else
        {
        	if (!string)
          	c = ' ', lc = 1;
				}
        break;
    }

		if (lc == 1)
    	GB.AddString(&r, &c, 1);
		else
    	GB.AddString(&r, &s[i], lc);
  }

	GB.FreeString(&_purged_line);
	_purged_line = r;
	
  return r;
}


static int convState(int state)
{
  switch(state)
  {
    case EVAL_TYPE_END: return HIGHLIGHT_NORMAL;
    case EVAL_TYPE_RESERVED: return HIGHLIGHT_KEYWORD;
    case EVAL_TYPE_IDENTIFIER: return HIGHLIGHT_SYMBOL;
    case EVAL_TYPE_CLASS: return HIGHLIGHT_DATATYPE;
    case EVAL_TYPE_NUMBER: return HIGHLIGHT_NUMBER;
    case EVAL_TYPE_STRING: return HIGHLIGHT_STRING;
    case EVAL_TYPE_SUBR: return HIGHLIGHT_SUBR;
    case EVAL_TYPE_COMMENT: return HIGHLIGHT_COMMENT;
    case EVAL_TYPE_OPERATOR: return HIGHLIGHT_OPERATOR;
    case EVAL_TYPE_DATATYPE: return HIGHLIGHT_DATATYPE;
    case EVAL_TYPE_ERROR: return HIGHLIGHT_ERROR;
		case EVAL_TYPE_ALTERNATE: return HIGHLIGHT_ALTERNATE;
		case EVAL_TYPE_HELP: return HIGHLIGHT_HELP;
		case EVAL_TYPE_PREPROCESSOR: return HIGHLIGHT_PREPROCESSOR;
    default: return HIGHLIGHT_NORMAL;
  }
}

static void analyze(const char *src, int len_src, bool rewrite, int state)
{
  GB_ARRAY garray, tarray, parray;
  int i, n, pos, len, p, upos, ulen, l;
  char *str;
  EVAL_ANALYZE result;

  EVAL_analyze(src, len_src, state == HIGHLIGHT_COMMENT ? EVAL_TYPE_COMMENT : EVAL_TYPE_END, &result, rewrite);

  n = 0;
  for (i = 0; i < result.len; i++)
  {
    if (result.color[i].state != EVAL_TYPE_END)
      n++;
  }

  GB.Array.New(&garray, GB_T_STRING, n);
  GB.Array.New(&tarray, GB_T_INTEGER, n);
  GB.Array.New(&parray, GB_T_INTEGER, n);

  pos = 0;
  upos = 0;
  i = 0;
  for (p = 0; p < result.len; p++)
  {
    len = result.color[p].len;

		ulen = 0;
		for (l = 0; l < len; l++)
			ulen += get_char_length(result.str[upos + ulen]);
		
    if (result.color[p].state != EVAL_TYPE_END)
    {
      str = GB.NewString(&result.str[upos], ulen);
      *((char **)GB.Array.Get(garray, i)) = str;
      *((int *)GB.Array.Get(tarray, i)) = convState(result.color[p].state);
      *((int *)GB.Array.Get(parray, i)) = pos;
      i++;
    }

    pos += len;
    upos += ulen;
  }

  GB.Unref(&_analyze_symbol);
  _analyze_symbol = garray;
  GB.Ref(garray);

  GB.Unref(&_analyze_type);
  _analyze_type = tarray;
  GB.Ref(tarray);

  GB.Unref(&_analyze_pos);
  _analyze_pos = parray;
  GB.Ref(parray);
  
	if (rewrite)
	{
		GB.FreeString(&_analyze_text);
		_analyze_text = result.str;
	}
	else
		GB.FreeString(&result.str);  
}

BEGIN_METHOD_VOID(CHIGHLIGHT_exit)

  GB.Unref(&_analyze_symbol);
  GB.Unref(&_analyze_type);
  GB.Unref(&_analyze_pos);
  GB.FreeString(&_analyze_text);
  GB.FreeString(&_purged_line);

END_METHOD



BEGIN_METHOD(CHIGHLIGHT_purge, GB_STRING text; GB_BOOLEAN comment; GB_BOOLEAN string)

  bool comment = VARGOPT(comment, FALSE);
  bool string = VARGOPT(string, FALSE);
  
  if (comment && string)	
  	GB.ReturnNewString(STRING(text), LENGTH(text));
	else
  	GB.ReturnString(purge(STRING(text), LENGTH(text), comment, string));

END_METHOD

BEGIN_METHOD(CHIGHLIGHT_analyze, GB_STRING text; GB_BOOLEAN rewrite; GB_INTEGER state)

  analyze(STRING(text), LENGTH(text), VARGOPT(rewrite, FALSE), VARGOPT(state, HIGHLIGHT_NORMAL));
  GB.ReturnObject(_analyze_symbol);

END_METHOD

BEGIN_PROPERTY(CHIGHLIGHT_analyze_symbols)

  GB.ReturnObject(_analyze_symbol);

END_PROPERTY

BEGIN_PROPERTY(CHIGHLIGHT_analyze_types)

  GB.ReturnObject(_analyze_type);

END_PROPERTY

BEGIN_PROPERTY(CHIGHLIGHT_analyze_positions)

  GB.ReturnObject(_analyze_pos);

END_PROPERTY

BEGIN_PROPERTY(CHIGHLIGHT_analyze_text)

  GB.ReturnString(_analyze_text);

END_PROPERTY


GB_DESC CHighlightDesc[] =
{
  GB_DECLARE("Highlight", 0), GB_VIRTUAL_CLASS(),

  GB_CONSTANT("Background", "i", HIGHLIGHT_BACKGROUND),
  GB_CONSTANT("Normal", "i", HIGHLIGHT_NORMAL),
  GB_CONSTANT("Keyword", "i", HIGHLIGHT_KEYWORD),
  GB_CONSTANT("Function", "i", HIGHLIGHT_SUBR),
  GB_CONSTANT("Operator", "i", HIGHLIGHT_OPERATOR),
  GB_CONSTANT("Symbol", "i", HIGHLIGHT_SYMBOL),
  GB_CONSTANT("Number", "i", HIGHLIGHT_NUMBER),
  GB_CONSTANT("String", "i", HIGHLIGHT_STRING),
  GB_CONSTANT("Comment", "i", HIGHLIGHT_COMMENT),
  GB_CONSTANT("Breakpoint", "i", HIGHLIGHT_BREAKPOINT),
  GB_CONSTANT("Current", "i", HIGHLIGHT_CURRENT),
  GB_CONSTANT("DataType", "i", HIGHLIGHT_DATATYPE),
  GB_CONSTANT("Selection", "i", HIGHLIGHT_SELECTION),
  GB_CONSTANT("Highlight", "i", HIGHLIGHT_HIGHLIGHT),
  GB_CONSTANT("CurrentLine", "i", HIGHLIGHT_LINE),
  GB_CONSTANT("Error", "i", HIGHLIGHT_ERROR),
  GB_CONSTANT("Alternate", "i", HIGHLIGHT_ALTERNATE),
  GB_CONSTANT("Help", "i", HIGHLIGHT_HELP),
  GB_CONSTANT("Preprocessor", "i", HIGHLIGHT_PREPROCESSOR),
  
  GB_STATIC_METHOD("_exit", NULL, CHIGHLIGHT_exit, NULL),
  GB_STATIC_METHOD("Analyze", "String[]", CHIGHLIGHT_analyze, "(Code)s[(Rewrite)b(State)i]"),
  GB_STATIC_PROPERTY_READ("Symbols", "String[]", CHIGHLIGHT_analyze_symbols),
  GB_STATIC_PROPERTY_READ("Types", "Integer[]", CHIGHLIGHT_analyze_types),
  GB_STATIC_PROPERTY_READ("Positions", "Integer[]", CHIGHLIGHT_analyze_positions),
  GB_STATIC_PROPERTY_READ("TextAfter", "s", CHIGHLIGHT_analyze_text),
  GB_STATIC_METHOD("Purge", "s", CHIGHLIGHT_purge, "(Code)s[(Comment)b(String)b]"),

  GB_END_DECLARE
};