示例#1
0
void
gui_input_delete_end_of_line (const char *args)
{
    char *start;
    int size_deleted, length_deleted, pos_start;

    /* make C compiler happy */
    (void) args;
    
    if (gui_current_window->buffer->input)
    {
        start = utf8_add_offset (gui_current_window->buffer->input_buffer,
                                 gui_current_window->buffer->input_buffer_pos);
        pos_start = start - gui_current_window->buffer->input_buffer;
        size_deleted = strlen (start);
        length_deleted = utf8_strlen (start);
        gui_input_clipboard_copy (start, size_deleted);
        start[0] = '\0';
        gui_current_window->buffer->input_buffer_size = strlen (gui_current_window->buffer->input_buffer);
        gui_current_window->buffer->input_buffer_length = utf8_strlen (gui_current_window->buffer->input_buffer);
        gui_input_optimize_size (gui_current_window->buffer);
        gui_completion_stop (gui_current_window->buffer->completion, 1);
        gui_input_text_changed_modifier_and_signal (gui_current_window->buffer);
    }
}
示例#2
0
int
gui_completion_nickncmp (const char *base_word, const char *nick, int max)
{
    char *base_word2, *nick2;
    int case_sensitive, return_cmp;

    case_sensitive = CONFIG_BOOLEAN(config_completion_nick_case_sensitive);

    if (!CONFIG_STRING(config_completion_nick_ignore_chars)
        || !CONFIG_STRING(config_completion_nick_ignore_chars)[0]
        || !base_word[0] || !nick[0]
        || gui_completion_nick_has_ignored_chars (base_word))
    {
        return (case_sensitive) ?
            strncmp (base_word, nick, max) :
            string_strncasecmp (base_word, nick, max);
    }

    base_word2 = gui_completion_nick_strdup_ignore_chars (base_word);
    nick2 = gui_completion_nick_strdup_ignore_chars (nick);

    return_cmp = (case_sensitive) ?
        strncmp (base_word2, nick2, utf8_strlen (base_word2)) :
        string_strncasecmp (base_word2, nick2, utf8_strlen (base_word2));

    free (base_word2);
    free (nick2);

    return return_cmp;
}
示例#3
0
/**
 * Insert 'ch' at position 'pos'
 *
 * Returns 1 if the line needs to be refreshed, 2 if not
 * and 0 if nothing was inserted (no room)
 */
static int insert_char(struct current *current, int pos, int ch)
{
    char buf[3];
    int n = utf8_getchars(buf, ch);

    if (has_room(current, n) && pos >= 0 && pos <= current->chars) {
        int p1, p2;
        int ret = 1;
        p1 = utf8_index(current->buf, pos);
        p2 = p1 + n;

#ifdef USE_TERMIOS
        /* optimise the case where adding a single char to the end and no scrolling is needed */
        if (current->pos == pos && current->chars == pos) {
            if (ch >= ' ' && utf8_strlen(current->prompt, -1) + utf8_strlen(current->buf, current->len) < current->cols - 1) {
                IGNORE_RC(write(current->fd, buf, n));
                ret = 2;
            }
        }
#endif

        memmove(current->buf + p2, current->buf + p1, current->len - p1);
        memcpy(current->buf + p1, buf, n);
        current->len += n;

        current->chars++;
        if (current->pos >= pos) {
            current->pos++;
        }
        return ret;
    }
    return 0;
}
示例#4
0
/**
 * Removes the char at 'pos'.
 *
 * Returns 1 if the line needs to be refreshed, 2 if not
 * and 0 if nothing was removed
 */
static int remove_char(struct current *current, int pos)
{
    if (pos >= 0 && pos < current->chars) {
        int p1, p2;
        int ret = 1;
        p1 = utf8_index(current->buf, pos);
        p2 = p1 + utf8_index(current->buf + p1, 1);

#ifdef USE_TERMIOS
        /* optimise remove char in the case of removing the last char */
        if (current->pos == pos + 1 && current->pos == current->chars) {
            if (current->buf[pos] >= ' ' && utf8_strlen(current->prompt, -1) + utf8_strlen(current->buf, current->len) < current->cols - 1) {
                ret = 2;
                fd_printf(current->fd, "\b \b");
            }
        }
#endif

        /* Move the null char too */
        memmove(current->buf + p1, current->buf + p2, current->len - p2 + 1);
        current->len -= (p2 - p1);
        current->chars--;

        if (current->pos > pos) {
            current->pos--;
        }
        return ret;
    }
    return 0;
}
示例#5
0
文件: wee-utf8.c 项目: matsuu/weechat
int
utf8_strlen_screen (const char *string)
{
    int length, num_char;
    wchar_t *wstring;
    
    if (!string)
        return 0;
    
    if (!local_utf8)
        return utf8_strlen (string);
    
    num_char = mbstowcs (NULL, string, 0) + 1;
    wstring = malloc ((num_char + 1) * sizeof (wstring[0]));
    if (!wstring)
        return utf8_strlen (string);
    
    if (mbstowcs (wstring, string, num_char) == (size_t)(-1))
    {
        free (wstring);
        return utf8_strlen (string);
    }
    
    length = wcswidth (wstring, num_char);
    free (wstring);
    return length;
}
示例#6
0
void
gui_completion_list_add (struct t_gui_completion *completion, const char *word,
                         int nick_completion, const char *where)
{
    char buffer[512];

    if (!word || !word[0])
        return;

    if (!completion->base_word || !completion->base_word[0]
        || (nick_completion && (gui_completion_nickncmp (completion->base_word, word,
                                                         utf8_strlen (completion->base_word)) == 0))
        || (!nick_completion && (string_strncasecmp (completion->base_word, word,
                                                     utf8_strlen (completion->base_word)) == 0)))
    {
        if (nick_completion && (completion->base_word_pos == 0))
        {
            snprintf (buffer, sizeof (buffer), "%s%s",
                      word, CONFIG_STRING(config_completion_nick_completer));
            weelist_add (completion->completion_list, buffer, where,
                         (nick_completion) ? (void *)1 : (void *)0);
        }
        else
        {
            weelist_add (completion->completion_list, word, where,
                         (nick_completion) ? (void *)1 : (void *)0);
        }
    }
}
void ST7920_Lite_Status_Screen::draw_status_message() {
  const char *str = ui.status_message;

  set_ddram_address(DDRAM_LINE_4);
  begin_data();
  #if ENABLED(STATUS_MESSAGE_SCROLLING)

    uint8_t slen = utf8_strlen(str);

    if (slen <= LCD_WIDTH) {
      // String fits the LCD, so just print it
      write_str(str);
      for (; slen < LCD_WIDTH; ++slen) write_byte(' ');
    }
    else {
      // String is larger than the available space in screen.

      // Get a pointer to the next valid UTF8 character
      const char *stat = str + ui.status_scroll_offset;

      // Get the string remaining length
      const uint8_t rlen = utf8_strlen(stat);

      // If we have enough characters to display
      if (rlen >= LCD_WIDTH) {
        // The remaining string fills the screen - Print it
        write_str(stat, LCD_WIDTH);
      }
      else {
        // The remaining string does not completely fill the screen
        write_str(stat);                        // The string leaves space
        uint8_t chars = LCD_WIDTH - rlen;         // Amount of space left in characters

        write_byte('.');                        // Always at 1+ spaces left, draw a dot
        if (--chars) {                          // Draw a second dot if there's space
          write_byte('.');
          if (--chars)
            write_str(str, chars);              // Print a second copy of the message
        }
      }

      // Adjust by complete UTF8 characters
      if (ui.status_scroll_offset < slen) {
        ui.status_scroll_offset++;
        while (!START_OF_UTF8_CHAR(str[ui.status_scroll_offset]))
          ui.status_scroll_offset++;
      }
      else
        ui.status_scroll_offset = 0;
    }

  #else

    uint8_t slen = utf8_strlen(str);
    write_str(str, LCD_WIDTH);
    for (; slen < LCD_WIDTH; ++slen) write_byte(' ');

  #endif
}
示例#8
0
// ----------------------------------------------------------------------------
void
text_buffer_add_text( text_buffer_t * self,
                      vec2 * pen, markup_t * markup,
                      const char * text, size_t length )
{
    font_manager_t * manager = self->manager;
    size_t i;
    const char * prev_character = NULL;

    if( markup == NULL )
    {
        return;
    }

    if( !markup->font )
    {
        markup->font = font_manager_get_from_markup( manager, markup );
        if( ! markup->font )
        {
            fprintf( stderr, "Houston, we've got a problem !\n" );
            exit( EXIT_FAILURE );
        }
    }

    if( length == 0 )
    {
        length = utf8_strlen(text);
    }
    if( vertex_buffer_size( self->buffer ) == 0 )
    {
        self->origin = *pen;
        self->line_left = pen->x;
        self->bounds.left = pen->x;
        self->bounds.top = pen->y;
    }
    else
    {
        if (pen->x < self->origin.x)
        {
            self->origin.x = pen->x;
        }
        if (pen->y != self->last_pen_y)
        {
            text_buffer_finish_line(self, pen, false);
        }
    }

    for( i = 0; utf8_strlen( text + i ) && length; i += utf8_surrogate_len( text + i ) )
    {
        text_buffer_add_char( self, pen, markup, text + i, prev_character );
        prev_character = text + i;
        length--;
    }

    self->last_pen_y = pen->y;
}
示例#9
0
void
gui_completion_list_add (struct t_gui_completion *completion, const char *word,
                         int nick_completion, const char *where)
{
    struct t_gui_completion_word *completion_word;
    char buffer[512];
    int index;

    if (!word || !word[0])
        return;

    if (!completion->base_word || !completion->base_word[0]
        || (nick_completion && (gui_completion_nickncmp (completion->base_word, word,
                                                         utf8_strlen (completion->base_word)) == 0))
        || (!nick_completion && (string_strncasecmp (completion->base_word, word,
                                                     utf8_strlen (completion->base_word)) == 0)))
    {
        completion_word = malloc (sizeof (*completion_word));
        if (completion_word)
        {
            completion_word->nick_completion = nick_completion;
            completion_word->count = 0;

            index = -1;
            if (strcmp (where, WEECHAT_LIST_POS_BEGINNING) == 0)
            {
                completion->list->sorted = 0;
                index = 0;
            }
            else if (strcmp (where, WEECHAT_LIST_POS_END) == 0)
            {
                completion->list->sorted = 0;
                index = -1;
            }

            if (nick_completion && (completion->base_word_pos == 0))
            {
                snprintf (buffer, sizeof (buffer), "%s%s",
                          word,
                          CONFIG_STRING(config_completion_nick_completer));
                completion_word->word = strdup (buffer);
                arraylist_insert (completion->list, index, completion_word);
                completion->add_space = 0;
            }
            else
            {
                completion_word->word = strdup (word);
                arraylist_insert (completion->list, index, completion_word);
            }
        }
    }
}
示例#10
0
void
gui_input_history_global_next ()
{
    if ((gui_current_window->buffer->input)
        && (gui_current_window->buffer->text_search == GUI_TEXT_SEARCH_DISABLED))
    {
        if (history_global_ptr)
        {
            history_global_ptr = history_global_ptr->prev_history;
            if (history_global_ptr)
            {
                gui_current_window->buffer->input_buffer_size =
                    strlen (history_global_ptr->text);
                gui_current_window->buffer->input_buffer_length =
                    utf8_strlen (history_global_ptr->text);
            }
            else
            {
                gui_current_window->buffer->input_buffer[0] = '\0';
                gui_current_window->buffer->input_buffer_size = 0;
                gui_current_window->buffer->input_buffer_length = 0;
            }
            gui_input_optimize_size (gui_current_window->buffer);
            gui_current_window->buffer->input_buffer_pos =
                gui_current_window->buffer->input_buffer_length;
            gui_current_window->buffer->input_buffer_1st_display = 0;
            if (history_global_ptr)
            {
                strcpy (gui_current_window->buffer->input_buffer,
                        history_global_ptr->text);
            }
            gui_input_text_changed_modifier_and_signal (gui_current_window->buffer);
        }
    }
}
示例#11
0
文件: Regex.cpp 项目: lzpfmh/fibjs
result_t Regex::test(const char *str, bool &retVal)
{
    int32_t rc = 0;
    int32_t ovector[RE_SIZE];
    int32_t len = (int32_t) qstrlen(str);
    const char *end = str + len;

    if (m_bGlobal)
    {
        int32_t n = m_nlastIndex;
        while (n > 0 && utf8_getchar(str, end))
            n--;
    }

    if (*str)
    {
        len = (int32_t) qstrlen(str);

        rc = pcre_exec(m_re, NULL, str, len, 0, 0, ovector, RE_SIZE);
        if (rc < 0)
        {
            rc = 0;
            m_nlastIndex = 0;
        }
    }

    if (rc)
    {
        retVal = true;
        if (m_bGlobal)
            m_nlastIndex += utf8_strlen(str, ovector[2 * rc - 1]);
    }

    return 0;
}
示例#12
0
void
gui_input_history_next ()
{
    if (gui_current_window->buffer->input)
    {
        if (gui_current_window->buffer->text_search == GUI_TEXT_SEARCH_DISABLED)
        {
            if (gui_current_window->buffer->ptr_history)
            {
                gui_current_window->buffer->ptr_history =
                    gui_current_window->buffer->ptr_history->prev_history;
                if (gui_current_window->buffer->ptr_history)
                {
                    gui_current_window->buffer->input_buffer_size =
                        strlen (gui_current_window->buffer->ptr_history->text);
                    gui_current_window->buffer->input_buffer_length =
                        utf8_strlen (gui_current_window->buffer->ptr_history->text);
                }
                else
                {
                    gui_current_window->buffer->input_buffer[0] = '\0';
                    gui_current_window->buffer->input_buffer_size = 0;
                    gui_current_window->buffer->input_buffer_length = 0;
                }
                gui_input_optimize_size (gui_current_window->buffer);
                gui_current_window->buffer->input_buffer_pos =
                    gui_current_window->buffer->input_buffer_length;
                gui_current_window->buffer->input_buffer_1st_display = 0;
                if (gui_current_window->buffer->ptr_history)
                {
                    strcpy (gui_current_window->buffer->input_buffer,
                            gui_current_window->buffer->ptr_history->text);
                }
            }
            else
            {
                /* add line to history then clear input */
                if (gui_current_window->buffer->input_buffer_size > 0)
                {
                    gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0';
                    gui_history_buffer_add (gui_current_window->buffer, gui_current_window->buffer->input_buffer);
                    gui_history_global_add (gui_current_window->buffer->input_buffer);
                    gui_current_window->buffer->input_buffer[0] = '\0';
                    gui_current_window->buffer->input_buffer_size = 0;
                    gui_current_window->buffer->input_buffer_length = 0;
                    gui_current_window->buffer->input_buffer_pos = 0;
                    gui_current_window->buffer->input_buffer_1st_display = 0;
                    gui_input_optimize_size (gui_current_window->buffer);
                }
            }
            gui_input_text_changed_modifier_and_signal (gui_current_window->buffer);
        }
        else
        {
            /* search forward in buffer history */
            gui_current_window->buffer->text_search = GUI_TEXT_SEARCH_FORWARD;
            (void) gui_window_search_text (gui_current_window);
        }
    }
}
示例#13
0
static void set_current(struct current *current, const char *str)
{
    strncpy(current->buf, str, current->bufmax);
    current->buf[current->bufmax - 1] = 0;
    current->len = strlen(current->buf);
    current->pos = current->chars = utf8_strlen(current->buf, current->len);
}
示例#14
0
/**
 * Returns length of given string for parser's encoding
 */
static size_t acmp_strlen(ACMP *parser, const char *str) {
#ifdef ACMP_USE_UTF8
    return (parser->is_utf8 == 0) ? strlen(str) : utf8_strlen(str);
#else
    return strlen(str);
#endif
}
示例#15
0
文件: wee-utf8.c 项目: Ratler/weechat
int
utf8_strlen_screen (const char *string)
{
    int length, num_char;
    wchar_t *alloc_wstring, *ptr_wstring, wstring[4+2];

    if (!string || !string[0])
        return 0;

    if (!local_utf8)
        return utf8_strlen (string);

    alloc_wstring = NULL;

    if (!string[1] || !string[2] || !string[3] || !string[4])
    {
        /* optimization for max 4 chars: no malloc */
        num_char = 4 + 1;
        ptr_wstring = wstring;
    }
    else
    {
        num_char = mbstowcs (NULL, string, 0) + 1;
        alloc_wstring = malloc ((num_char + 1) * sizeof (alloc_wstring[0]));
        if (!alloc_wstring)
            return utf8_strlen (string);
        ptr_wstring = alloc_wstring;
    }

    if (mbstowcs (ptr_wstring, string, num_char) != (size_t)(-1))
    {
        length = wcswidth (ptr_wstring, num_char);
        /*
         * ensure the size is always >= 1, to prevent any display bug
         * (for example size of UTF-8 char U+26C4 is -1, why? mystery...)
         */
        if (length < 1)
            length = 1;
    }
    else
        length = utf8_strlen (string);

    if (alloc_wstring)
        free (alloc_wstring);

    return length;
}
示例#16
0
文件: utf8.c 项目: Toeger/f-irc
void utf8_strcat_utf8_string(utf8_string *work, const utf8_string *in)
{
	const int len = utf8_strlen(in);
	int loop;

	for(loop=0; loop<len; loop++)
		add_utf8_to_utf8_string(work, in -> string[loop]);
}
示例#17
0
size_t linkage_get_word_char_end(const Linkage linkage, WordIdx w)
{
	if (linkage->num_words <= w) return 0; /* bounds-check */
	int pos = linkage->wg_path_display[w]->end - linkage->sent->orig_sentence;
	char *sentchunk = alloca(pos+1);
	strncpy(sentchunk, linkage->sent->orig_sentence, pos);
	sentchunk[pos] = '\0';
	return utf8_strlen(sentchunk);
}
示例#18
0
/* добавить текст в буффер */
static void
bufferAppend(char *data, int len, FB2Content *fb) /*, int remove_spaces)*/
{
  char **buffer;
  size_t *buffer_size;
  int *current_index;
  /*int new_len;*/

  if (!data) return;

  /* добавляем в текущий буффер */
  if (fb->current_buffer == DESCRIPTION_BUFFER) {
    buffer = &(fb->description);
    buffer_size = &(fb->description_buffer_size);
    current_index = &(fb->description_current_index);
  } else if (fb->current_buffer == TEXT_BUFFER) {
    buffer = &(fb->text);
    buffer_size = &(fb->text_buffer_size);
    current_index = &(fb->text_current_index);
  } else if (fb->current_buffer == BINARY_BUFFER) {
    buffer = &(fb->binaries[fb->num_binaries]->buffer);
    buffer_size = &(fb->binaries[fb->num_binaries]->buffer_size);
    current_index = &(fb->binaries[fb->num_binaries]->current_index);
  }

  /* remove spaces */
/*
  if (remove_spaces) {
    new_len = removeSpaces(data, len);
    len = new_len;
  }
*/
  /* realloc buffer */
  if (*current_index+len >= *buffer_size) {
    while (1) {
      *buffer_size = *buffer_size*2;
      *buffer = (char *) realloc(*buffer, *buffer_size);
      if (*current_index+len < *buffer_size) {
	break;
      }
    }
  }

  strncpy((*buffer) + *current_index, data, len);
  *current_index += len;

  if (fb->current_buffer == TEXT_BUFFER) {
    int u_len;
    u_len = utf8_strlen(data);
    fb->utf8_current_index += u_len;
  }

  return;
}
示例#19
0
static int completeLine(struct current *current) {
    linenoiseCompletions lc = { 0, NULL };
    int c = 0;

    completionCallback(current->buf,&lc,completionUserdata);
    if (lc.len == 0) {
        beep();
    } else {
        size_t stop = 0, i = 0;

        while(!stop) {
            /* Show completion or original buffer */
            if (i < lc.len) {
                struct current tmp = *current;
                tmp.buf = lc.cvec[i];
                tmp.pos = tmp.len = strlen(tmp.buf);
                tmp.chars = utf8_strlen(tmp.buf, tmp.len);
                refreshLine(current->prompt, &tmp);
            } else {
                refreshLine(current->prompt, current);
            }

            c = fd_read(current);
            if (c == -1) {
                break;
            }

            switch(c) {
                case '\t': /* tab */
                    i = (i+1) % (lc.len+1);
                    if (i == lc.len) beep();
                    break;
                case 27: /* escape */
                    /* Re-show original buffer */
                    if (i < lc.len) {
                        refreshLine(current->prompt, current);
                    }
                    stop = 1;
                    break;
                default:
                    /* Update buffer and return */
                    if (i < lc.len) {
                        set_current(current,lc.cvec[i]);
                    }
                    stop = 1;
                    break;
            }
        }
    }

    freeCompletions(&lc);
    return c; /* Return last read character */
}
示例#20
0
文件: utf8.c 项目: baohaojun/dico
static int
op_strlen(int argc, char **argv)
{
    char *opname = *argv++;
    argc--;
    if (argc != 1) {
	dico_log(L_ERR, 0, "%s requires one argument", opname);
	return 1;
    }
    printf("%lu\n", (unsigned long) utf8_strlen(argv[0]));
    return 0;
}
示例#21
0
int
System(char *command)			/* command is a UTF-8 string */
{ STARTUPINFOW sinfo;
  PROCESS_INFORMATION pinfo;
  int shell_rval;
  size_t len;
  wchar_t *wcmd;

  memset(&sinfo, 0, sizeof(sinfo));
  sinfo.cb = sizeof(sinfo);

  len = utf8_strlen(command, strlen(command));
  wcmd = PL_malloc((len+1)*sizeof(wchar_t));
  utf8towcs(wcmd, command);

  if ( CreateProcessW(NULL,			/* module */
		      wcmd,			/* command line */
		      NULL,			/* Security stuff */
		      NULL,			/* Thread security stuff */
		      FALSE,			/* Inherit handles */
		      CREATE_NO_WINDOW,		/* flags */
		      NULL,			/* environment */
		      NULL,			/* CWD */
		      &sinfo,			/* startup info */
		      &pinfo) )			/* process into */
  { BOOL rval;
    DWORD code;

    CloseHandle(pinfo.hThread);			/* don't need this */
    PL_free(wcmd);

    do
    { MSG msg;

      if ( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
      { TranslateMessage(&msg);
	DispatchMessage(&msg);
      } else
	Sleep(50);

      rval = GetExitCodeProcess(pinfo.hProcess, &code);
    } while(rval == TRUE && code == STILL_ACTIVE);

    shell_rval = (rval == TRUE ? code : -1);
    CloseHandle(pinfo.hProcess);
  } else
  { PL_free(wcmd);
    return shell_rval = -1;
  }

  return shell_rval;
}
示例#22
0
static unsigned int text_width(char* str)
{
    if (iconvW == NULL)
        iconvW = iconv_open("ucs-4be", "utf-8");
    if (iconvW == (iconv_t) -1)
    {
        return utf8_strlen(str);
    }
    else
    {
        size_t len = strlen(str);
        size_t charlen = utf8_strlen(str);
        unsigned *wmessage;
        size_t wlen = (len + 1) * sizeof (unsigned);
        wmessage = (unsigned *) fcitx_malloc0 ((len + 1) * sizeof (unsigned));

        char *inp = str;
        char *outp = (char*) wmessage;

        iconv(iconvW, &inp, &len, &outp, &wlen);

        int i = 0;
        int width = 0;
        for (i = 0; i < charlen; i ++)
        {
            if (is_double_width(wmessage[i]))
                width += 2;
            else
                width += 1;
        }


        free(wmessage);
        return width;
    }
}
示例#23
0
文件: rst.c 项目: blackb1rd/ctags
/* TODO: parse overlining & underlining as distinct sections. */
static void findRstTags (void)
{
    vString *name = vStringNew ();
    fpos_t filepos;
    const unsigned char *line;

    memset(&filepos, 0, sizeof(fpos_t));
    memset(kindchars, 0, sizeof kindchars);
    nestingLevels = nestingLevelsNew();

    while ((line = readLineFromInputFile ()) != NULL)
    {
        int line_len = strlen((const char*) line);
        int name_len_bytes = vStringLength(name);
        int name_len = utf8_strlen(vStringValue(name), name_len_bytes);

        /* if the name doesn't look like UTF-8, assume one-byte charset */
        if (name_len < 0)
            name_len = name_len_bytes;

        /* underlines must be the same length or more */
        if (line_len >= name_len && name_len > 0 &&
                ispunct(line[0]) && issame((const char*) line))
        {
            char c = line[0];
            int kind = get_kind(c);

            if (kind >= 0)
            {
                makeRstTag(name, kind, filepos);
                continue;
            }
        }
        vStringClear (name);
        if (!isspace(*line))
        {
            vStringCatS(name, (const char*)line);
            filepos = getInputFilePosition();
        }
        vStringTerminate(name);
    }
    vStringDelete (name);
    nestingLevelsFree(nestingLevels);
}
示例#24
0
文件: Regex.cpp 项目: lzpfmh/fibjs
result_t Regex::exec(const char *str, v8::Local<v8::Array> &retVal)
{
    int32_t rc = 0;
    int32_t ovector[RE_SIZE];
    int32_t len = (int32_t) qstrlen(str);
    const char *end = str + len;
    int32_t i;

    if (m_bGlobal)
    {
        int32_t n = m_nlastIndex;
        while (n > 0 && utf8_getchar(str, end))
            n--;
    }

    if (*str)
    {
        len = (int32_t) qstrlen(str);

        rc = pcre_exec(m_re, NULL, str, len, 0, 0, ovector, RE_SIZE);
        if (rc < 0)
        {
            rc = 0;
            m_nlastIndex = 0;
        }
    }

    if (rc)
    {
        Isolate* isolate = Isolate::now();
        retVal = v8::Array::New(isolate->m_isolate, rc);

        for (i = 0; i < rc; i++)
            retVal->Set(i,
                        v8::String::NewFromUtf8(isolate->m_isolate, str + ovector[2 * i],
                                                v8::String::kNormalString,
                                                ovector[2 * i + 1] - ovector[2 * i]));

        if (m_bGlobal)
            m_nlastIndex += utf8_strlen(str, ovector[2 * rc - 1]);
    }

    return rc ? 0 : CALL_RETURN_NULL;
}
示例#25
0
TEST(CoreUtf8, Size)
{
    /* char size */
    LONGS_EQUAL(0, utf8_char_size (NULL));
    LONGS_EQUAL(1, utf8_char_size (""));
    LONGS_EQUAL(1, utf8_char_size ("A"));
    LONGS_EQUAL(2, utf8_char_size ("ë"));
    LONGS_EQUAL(3, utf8_char_size ("€"));
    LONGS_EQUAL(3, utf8_char_size (cjk_yellow));
    LONGS_EQUAL(4, utf8_char_size (han_char));

    /* char size on screen */
    LONGS_EQUAL(0, utf8_char_size_screen (NULL));
    LONGS_EQUAL(0, utf8_char_size_screen (""));
    LONGS_EQUAL(1, utf8_char_size_screen ("A"));
    LONGS_EQUAL(1, utf8_char_size_screen ("ë"));
    LONGS_EQUAL(1, utf8_char_size_screen ("€"));
    LONGS_EQUAL(2, utf8_char_size_screen (cjk_yellow));

    /* length of string (in chars) */
    LONGS_EQUAL(0, utf8_strlen (NULL));
    LONGS_EQUAL(0, utf8_strlen (""));
    LONGS_EQUAL(1, utf8_strlen ("A"));
    LONGS_EQUAL(1, utf8_strlen ("ë"));
    LONGS_EQUAL(1, utf8_strlen ("€"));
    LONGS_EQUAL(1, utf8_strlen (cjk_yellow));
    LONGS_EQUAL(1, utf8_strlen (han_char));

    /* length of string (in chars, for max N bytes) */
    LONGS_EQUAL(0, utf8_strnlen (NULL, 0));
    LONGS_EQUAL(0, utf8_strnlen ("", 0));
    LONGS_EQUAL(1, utf8_strnlen ("AZ", 1));
    LONGS_EQUAL(1, utf8_strnlen ("ëZ", 2));
    LONGS_EQUAL(1, utf8_strnlen ("€Z", 3));
    LONGS_EQUAL(1, utf8_strnlen (han_char_z, 4));

    /* length of string on screen (in chars) */
    LONGS_EQUAL(0, utf8_strlen_screen (NULL));
    LONGS_EQUAL(0, utf8_strlen_screen (""));
    LONGS_EQUAL(1, utf8_strlen_screen ("A"));
    LONGS_EQUAL(1, utf8_strlen_screen ("ë"));
    LONGS_EQUAL(1, utf8_strlen_screen ("€"));
    LONGS_EQUAL(1, utf8_strlen_screen ("\x7f"));
    LONGS_EQUAL(2, utf8_strlen_screen (cjk_yellow));
}
示例#26
0
void
gui_input_replace_input (struct t_gui_buffer *buffer, const char *new_input)
{
    int size, length;
    
    size = strlen (new_input);
    length = utf8_strlen (new_input);
    
    /* compute new buffer size */
    buffer->input_buffer_size = size;
    buffer->input_buffer_length = length;
    gui_input_optimize_size (buffer);
    
    /* copy new string to input */
    strcpy (buffer->input_buffer, new_input);
    
    /* move cursor to the end of new input if it is now after the end */
    if (buffer->input_buffer_pos > buffer->input_buffer_length)
        buffer->input_buffer_pos = buffer->input_buffer_length;
}
示例#27
0
static KMETHOD String_search(KonohaContext *kctx, KonohaStack *sfp)
{
	kRegExp *re = sfp[1].asRegExp;
	intptr_t loc = -1;
	if(!IS_NULL(re) && S_size(re->pattern) > 0) {
		kregmatch_t pmatch[2]; // modified by @utrhira
		const char *str = S_text(sfp[0].asString);  // necessary
		int res = pcre_regexec(kctx, re->reg, str, 1, pmatch, re->eflags);
		if(res == 0) {
			loc = pmatch[0].rm_so;
			if(loc != -1 && !kString_is(ASCII, sfp[0].asString)) {
				loc = utf8_strlen(str, loc);
			}
		}
		else {
			//TODO
			//LOG_regex(kctx, sfp, res, re, str);
		}
	}
	KReturnUnboxValue(loc);
}
示例#28
0
TEST(Utf8, Size)
{
    /* char size */
    LONGS_EQUAL(0, utf8_char_size (NULL));
    LONGS_EQUAL(1, utf8_char_size (""));
    LONGS_EQUAL(1, utf8_char_size ("A"));
    LONGS_EQUAL(2, utf8_char_size ("ë"));
    LONGS_EQUAL(3, utf8_char_size ("€"));
    LONGS_EQUAL(4, utf8_char_size (han_char));

    /* char size on screen */
    LONGS_EQUAL(0, utf8_char_size_screen (NULL));
    LONGS_EQUAL(0, utf8_char_size_screen (""));
    LONGS_EQUAL(1, utf8_char_size_screen ("A"));
    LONGS_EQUAL(1, utf8_char_size_screen ("ë"));
    LONGS_EQUAL(1, utf8_char_size_screen ("€"));
    /* this test does not work on Ubuntu Precise: it returns 2 instead of 1 */
    /*LONGS_EQUAL(1, utf8_char_size_screen (han_char));*/

    /* length of string (in chars) */
    LONGS_EQUAL(0, utf8_strlen (NULL));
    LONGS_EQUAL(0, utf8_strlen (""));
    LONGS_EQUAL(1, utf8_strlen ("A"));
    LONGS_EQUAL(1, utf8_strlen ("ë"));
    LONGS_EQUAL(1, utf8_strlen ("€"));
    LONGS_EQUAL(1, utf8_strlen (han_char));

    /* length of string (in chars, for max N bytes) */
    LONGS_EQUAL(0, utf8_strnlen (NULL, 0));
    LONGS_EQUAL(0, utf8_strnlen ("", 0));
    LONGS_EQUAL(1, utf8_strnlen ("AZ", 1));
    LONGS_EQUAL(1, utf8_strnlen ("ëZ", 2));
    LONGS_EQUAL(1, utf8_strnlen ("€Z", 3));
    LONGS_EQUAL(1, utf8_strnlen (han_char_z, 4));

    /* length of string on screen (in chars) */
    LONGS_EQUAL(0, utf8_strlen_screen (NULL));
    LONGS_EQUAL(0, utf8_strlen_screen (""));
    LONGS_EQUAL(1, utf8_strlen_screen ("A"));
    LONGS_EQUAL(1, utf8_strlen_screen ("ë"));
    LONGS_EQUAL(1, utf8_strlen_screen ("€"));
    /* this test does not work on Ubuntu Precise: it returns 2 instead of 1 */
    /*LONGS_EQUAL(1, utf8_strlen_screen (han_char));*/
    LONGS_EQUAL(1, utf8_strlen_screen ("\x7f"));
}
示例#29
0
int
gui_completion_nickncmp (const char *base_word, const char *nick, int max)
{
    char *base_word2, *nick2;
    int return_cmp;

    if (!CONFIG_STRING(config_completion_nick_ignore_chars)
        || !CONFIG_STRING(config_completion_nick_ignore_chars)[0]
        || !base_word || !nick || !base_word[0] || !nick[0]
        || gui_completion_nick_has_ignored_chars (base_word))
        return string_strncasecmp (base_word, nick, max);

    base_word2 = gui_completion_nick_strdup_ignore_chars (base_word);
    nick2 = gui_completion_nick_strdup_ignore_chars (nick);

    return_cmp = string_strncasecmp (base_word2, nick2,
                                     utf8_strlen (base_word2));

    free (base_word2);
    free (nick2);

    return return_cmp;
}
示例#30
0
int
gui_input_insert_string (struct t_gui_buffer *buffer, const char *string,
                         int pos)
{
    int pos_start, size, length;
    char *ptr_start;
    
    if (buffer->input)
    {
        if (pos == -1)
            pos = buffer->input_buffer_pos;
        
        size = strlen (string);
        length = utf8_strlen (string);
        
        /* increase buffer size */
        buffer->input_buffer_size += size;
        buffer->input_buffer_length += length;
        gui_input_optimize_size (buffer);
        buffer->input_buffer[buffer->input_buffer_size] = '\0';
        
        /* move end of string to the right */
        ptr_start = utf8_add_offset (buffer->input_buffer, pos);
        pos_start = ptr_start - buffer->input_buffer;
        memmove (ptr_start + size, ptr_start, strlen (ptr_start));
        
        /* insert new string */
        ptr_start = utf8_add_offset (buffer->input_buffer, pos);
        pos_start = ptr_start - buffer->input_buffer;
        strncpy (ptr_start, string, size);
        
        buffer->input_buffer_pos += length;
        
        return length;
    }
    return 0;
}