C++ rt_strlen函数代码示例

void rtgui_textbox_set_value(struct rtgui_textbox* box, const char* text)
{
	if (box->text != RT_NULL)
	{
		if (box->line_length > rt_strlen(text) + 1)
		{
			rt_memcpy(box->text, text, rt_strlen(text) + 1);
			/* set current position */
			box->position = 0;
			return;
		}
		else
		{
			/* free the old text */
			rtgui_free(box->text);
			box->text = RT_NULL;
		}
	}

	box->line_length = RTGUI_TEXTBOX_LINE_MAX > rt_strlen(text) + 1 ?
		RTGUI_TEXTBOX_LINE_MAX : rt_strlen(text) + 1;

	/* allocate line buffer */
	box->text = rtgui_malloc(box->line_length);
	rt_memset(box->text, 0, box->line_length);

	/* copy text */
	rt_memcpy(box->text, text, rt_strlen(text) + 1);

	/* set current position */
	box->position = 0;
}

int rthw_wifi_ap_start(char *ssid, char *password, int channel)
{
    int mode = 0, timeout = 20;
    rtw_security_t security_type = RTW_SECURITY_WPA2_AES_PSK;
    char *name = RT_NULL;

    mode = rthw_wifi_mode_get();
    if (mode == RTHW_MODE_AP)
    {
        name = WLAN0_NAME;
    }
    else if (mode == RTHW_MODE_STA_AP)
    {
        name = WLAN1_NAME;
    }
    else
    {
        return -1;
    }

    if(wext_get_mode(name, &mode) < 0)
    {
        rt_kprintf("L:%d wifi get mode err\n", __LINE__);
        return -1;
    }
    if (password == RT_NULL)
    {
        security_type = RTW_SECURITY_OPEN;
    }

    if(wifi_start_ap(ssid, security_type, password, rt_strlen(ssid), rt_strlen(password), 6) != 0)
    {
        rt_kprintf("ERROR: wifi_start_ap failed\n");
        return -1;
    }

    while(1) 
    {
        char essid[33];
        if(wext_get_ssid(name, (unsigned char *) essid) > 0)
        {
            if(strcmp((const char *) essid, (const char *)ssid) == 0) 
            {
                rt_kprintf("%s started\n", ssid);
                break;
            }
        }
        if(timeout == 0) 
        {
            rt_kprintf("Start AP timeout\n");   
            return -1;
        }
        rt_thread_delay(1 * RT_TICK_PER_SECOND);
        timeout --;
    }

    return 0;
}

/*
 * row, col 都是从0开始编号
 */
void rtgui_form_set_item(rtgui_form_t *form, const char * const item, int row, int col, int isupdate)
{
	int offset, len1, len2, i;
	char *pch;
	const char *pch1;

	if (NULL==form || NULL==item)
		return;

	if (row > form->row_cnt_of_fbody || col >= form->head_item_cnt) {
		printf_syn("fun:%s(), row(%d) or col(%d) error, should(%d, %d), %s!\n", __FUNCTION__, row, col,
				   (form->row_cnt_of_fbody+1), form->head_item_cnt, form->head_name[0]);
		return;
	}
	if (FAIL == get_offset_of_col(form, col, &offset))
		return;

	if (row < 1)
		return;
#if 0
	pch  = form->fbody + (row-1)*form->bytes_of_row;
	form_debug(("before set item[%s], %dth line:%s!\n", item, row, pch));
#endif
	/* 编译器对item的处理在某些条件下似乎会出现bug, const char *item */
	len1 = rt_strlen(item);
	len2 = rt_strlen(form->head_name[col]);
	pch  = form->fbody + (row-1)*form->bytes_of_row + offset;
	pch1 = item;
	i = MIN(len1, len2);

	form_debug(("len1:%d, len2:%d, i:%d, item[%s], %#x, %#x, %#x\n", len1, len2, i, item, item, *item, *(item+1)));

	len2 -= i;
	while (0 != i) {
		*pch++ = *pch1++;
		--i;
	}

	/* 用空格填充列剩余位置及列间隔 */
	len2 += GAG_BETWEEN_COL;
	while (len2--)
		*pch++ = ' ';

	/* 将每行的最后一列的最后一个字节设置为'\0' */
	if ((col+1) == form->head_item_cnt)
		*--pch = '\0';

#if 0
	pch  = form->fbody + (row-1)*form->bytes_of_row;
	form_debug(("after set, %dth line:%s!\n", row, pch));
#endif
	if (0 != isupdate)
		rtgui_form_update_row(form, row);

	//rtgui_widget_update(RTGUI_WIDGET(form));
	return;
}

void print_sink_data(void)
{
	int i, j, k;
	struct sinkinfo_wl_data_item_st *p;
	rt_err_t ret;
	char title[DEV_SN_BUF_STRING_WITH_NUL_LEN_MAX+4];

	if (NULL == sink_wl_collect_data) {
		printf_syn("func:%s(),  sink_wl_collect_data is NULL\n", __FUNCTION__);
		return;
	}

	ret = rt_sem_take(&sink_wl_data_sem, RT_WAITING_FOREVER);
	if (RT_EOK != ret) {
		printf_syn("take sink_wl_data_sem fail(%d)\n", ret);
		return;
	}

	p = sink_wl_collect_data;
#if 0
	rt_strncpy(title, p->pt_ct_sn, sizeof(title));
	i = rt_strlen(p->pt_ct_sn);
	title[i++] = ' ';
	title[i++] = 'p';
	title[i++] = 'a';
	j = i - 1;
	title[i++] = '-';
	title[i++] = '\0';
#endif

	for (k=0; k<SINKINFO_WL_DATA_ITEM_MAX_NO; ++k) {
		if ('\0' != p->pt_ct_sn[0]) {
			
			rt_strncpy(title, p->pt_ct_sn, sizeof(title));
			i = rt_strlen(p->pt_ct_sn);
			title[i++] = ' ';
			title[i++] = 'p';
			title[i++] = 'a';
			j = i - 1;
			title[i++] = '-';
			title[i++] = '\0';
			
			printf_syn("index %4d:\n", k);
			print_pt_ct_st_info(title, &p->item.ptc_data.pt_pa);
			title[j] = 'b';
			print_pt_ct_st_info(title, &p->item.ptc_data.pt_pb);
			title[j] = 'c';
			print_pt_ct_st_info(title, &p->item.ptc_data.pt_pc);
		}

		++p;
	}

	rt_sem_release(&sink_wl_data_sem);

	return;
}

int dfs_elm_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count)
{
    DIR *dir;
    FILINFO fno;
    FRESULT result;
    rt_uint32_t index;
    struct dirent *d;

    dir = (DIR *)(file->data);
    RT_ASSERT(dir != RT_NULL);

    /* make integer count */
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
    if (count == 0)
        return -DFS_STATUS_EINVAL;

    index = 0;
    while (1)
    {
        char *fn;

        d = dirp + index;

        result = f_readdir(dir, &fno);
        if (result != FR_OK || fno.fname[0] == 0)
            break;

#if _USE_LFN
        fn = *fno.fname ? fno.fname : fno.altname;
#else
        fn = fno.fname;
#endif

        d->d_type = DFS_DT_UNKNOWN;
        if (fno.fattrib & AM_DIR)
            d->d_type = DFS_DT_DIR;
        else
            d->d_type = DFS_DT_REG;

        d->d_namlen = (rt_uint8_t)rt_strlen(fn);
        d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
        rt_strncpy(d->d_name, fn, rt_strlen(fn) + 1);

        index ++;
        if (index * sizeof(struct dirent) >= count)
            break;
    }

    if (index == 0)
        return elm_result_to_dfs(result);

    file->pos += index * sizeof(struct dirent);

    return index * sizeof(struct dirent);
}

rt_inline void tof_print(struct hm_tof_data* data)
{
    static char ble_buf[100];
    sprintf(ble_buf, "%ld:tof up=%f down=%f speed=%f\n\r",
            data->time, data->data.up, data->data.down, data->speed);
#if (HM_BOARD_UART_6 == 1)
    hm_ble_write(ble_buf, rt_strlen(ble_buf)+1);
#else
    rt_kprintf(ble_buf, rt_strlen(ble_buf)+1);
#endif
}

rt_inline void temp_print(struct hm_temp_data* data)
{
    static char ble_buf[100];
    sprintf(ble_buf, "%ld:temp R_hot=%f R_cold=%f hot=%f cold=%f\n\r",
            data->time, data->data.hot, data->data.cold, data->hot, data->cold);
#if (HM_BOARD_UART_6 == 1)
    hm_ble_write(ble_buf, rt_strlen(ble_buf)+1);
#else
    rt_kprintf(ble_buf, rt_strlen(ble_buf)+1);
#endif
}

rt_err_t rt_wlan_device_control(struct rt_wlan_device* device, rt_uint8_t cmd, void* arg)
{
    rt_err_t result;

    RT_ASSERT(device != RT_NULL);

    result = RT_EOK;
    switch (cmd)
    {
    case WLAN_CTRL_SET_SSID:
        RT_ASSERT(arg != RT_NULL);

        if (rt_strlen((char*)arg) >= SSID_NAME_MAX) result = -RT_ERROR;
        else
        {
            rt_strncpy(device->ssid, (char*)arg, SSID_NAME_MAX);
        }
        break;

    case WLAN_CTRL_SET_PASSWORD:
        RT_ASSERT(arg != RT_NULL);
        
        if (rt_strlen((char*)arg) >= PASSWORD_LENGTH_MAX) result = -RT_ERROR;
        else
        {
            rt_strncpy(device->password, (char*)arg, PASSWORD_LENGTH_MAX);
        }
        break;

    case WLAN_CTRL_SET_SECURITY:
        RT_ASSERT(arg != RT_NULL);
        device->security = *(rt_uint8_t*)arg;
        break;

    case WLAN_CTRL_SET_MODE:
        RT_ASSERT(arg != RT_NULL);
        device->mode = *(rt_uint8_t*)arg;
        break;

    case WLAN_CTRL_SET_CHANNEL:
        device->channel = *(rt_uint8_t*)arg;
        break;

	case WLAN_CTRL_SET_BSADDR:
		rt_memcpy(device->bs_addr, (rt_uint8_t*) arg, MAC_LENGTH_MAX);
		break;
    }
    
    return result;
}

/*
 * row, col 都是从0开始编号, 是表格的全局编号
 */
void rtgui_form_set_row(rtgui_form_t *form, const char *const rowstr, int row)
{
	int len1, len2, i;
	char *pch;
	const char *pch1;

	if (NULL==form || NULL==rowstr)
		return;

	if (row > form->row_cnt_of_fbody || row<1) {
		form_debug(("fun:%s(), row(%d) error!\n", __FUNCTION__, row));
		return;
	}

	/* 编译器对item的处理在某些条件下似乎会出现bug, const char *item */
	len1 = rt_strlen(rowstr);
	len2 = form->bytes_of_row;
	pch  = form->fbody + (row-1)*form->bytes_of_row;
	pch1 = rowstr;
	i = MIN(len1, len2);

	while (0 != i) {
		*pch++ = *pch1++;
		--i;
	}

	/* 将每行的最后一列的最后一个字节设置为'\0' */
	pch  = form->fbody + (row)*form->bytes_of_row - 1;
	*pch = '\0';

	return;
}

/**
 * This function will return the first occurrence of a string.
 *
 * @param s1 the source string
 * @param s2 the find string
 *
 * @return the first occurrence of a s2 in s1, or RT_NULL if no found.
 */
char *rt_strstr(const char *s1, const char *s2)
{
	int l1, l2;

	l2 = rt_strlen(s2);
	if (!l2)
		return (char *)s1;
	l1 = rt_strlen(s1);
	while (l1 >= l2) {
		l1 --;
		if (!rt_memcmp(s1, s2, l2))
			return (char *)s1;
		s1 ++;
	}
	return RT_NULL;
}

static char* _module_name(const char *path)
{
    const char *first, *end, *ptr;
    char *name;
    int size;

    ptr   = (char *)path;
    first = ptr;
    end   = path + rt_strlen(path);

    while (*ptr != '\0')
    {
        if (*ptr == '/')
            first = ptr + 1;
        if (*ptr == '.')
            end = ptr - 1;

        ptr ++;
    }

    size = end - first + 1;
    name = rt_malloc(size);
    rt_strncpy(name, first, size);
    name[size] = '\0';

    return name;
}

/*
 * head_name[] -- 最后一个元素必须是NULL
 * rows -- 包含表头在内
 */
rtgui_form_t *rtgui_form_create(const char *head_name[], int rows, int cols, rtgui_rect_t *rect)
{
	int i, len;
	struct rtgui_form *form;

	if (NULL==head_name || NULL==rect)
		return NULL;

	form = (struct rtgui_form *)rtgui_widget_create(RTGUI_FORM_TYPE);
	if (NULL == form)
		return NULL;

	i = 0;
	while (NULL != head_name[i])
		++i;

	if (i != cols) {
		form_debug(("%s(), head items (%d) not same as cols(%d)!\n", __FUNCTION__, i, cols));
		goto err_entry;
	}

	form_debug(("%s(), line:%d: rows:%d, cols:%d!\n", __FUNCTION__, __LINE__, rows, cols));

	len = 0;
	for (i=0; i<cols; ++i) {
		len += rt_strlen(head_name[i]);
	}
	len += cols * GAG_BETWEEN_COL;

	form->fbody = rt_calloc(len*(rows-1), 1); /* 不包含表格头部占用的存储空间 */
	if (NULL == form->fbody) {
		form_debug(("fun:%s(), line:%d:%d malloc fail!\n", __FUNCTION__, __LINE__, len*(rows-1)));
		goto err_entry;
	}

	form->head_name = rt_calloc(cols, sizeof(head_name[0]));
	if (NULL == form->head_name) {
		form_debug(("fun:%s(), line:%d:%d malloc fail!\n", __FUNCTION__, __LINE__, cols * sizeof(head_name[0])));
		rt_free(form->fbody);
		goto err_entry;
	}

	form_debug(("%s(), line:%d: fbody-len:%d, head-name-len:%d!\n", __FUNCTION__, __LINE__,
				len*(rows-1), cols * sizeof(head_name[0])));

	for (i=0; i<cols; ++i) {
		form->head_name[i] = head_name[i];
	}
	form->head_item_cnt		= cols;
	form->row_cnt_of_fbody	= rows - 1;
	form->bytes_of_row		= len;

	rtgui_widget_set_rect(RTGUI_WIDGET(form), rect);

	return form;

err_entry:
	rtgui_widget_destroy(RTGUI_WIDGET(form));
	return NULL;
}

int cmd_mv(int argc, char** argv)
{
    if (argc != 3)
    {
        rt_kprintf("Usage: mv SOURCE DEST\n");
        rt_kprintf("Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.\n");
    }
    else
    {
		int fd;
		char *dest = RT_NULL;

        rt_kprintf("%s => %s\n", argv[1], argv[2]);

		fd = open(argv[2], O_DIRECTORY, 0);
		if (fd >= 0)
		{
			char *src;
			
			close(fd);

			/* it's a directory */			
			dest = (char*)rt_malloc(DFS_PATH_MAX);
			if (dest == RT_NULL)
			{
				rt_kprintf("out of memory\n");
				return -RT_ENOMEM;
			}

			src = argv[1] + rt_strlen(argv[1]);
			while (src != argv[1]) 
			{
				if (*src == '/') break;
				src --;
			}

			rt_snprintf(dest, DFS_PATH_MAX - 1, "%s/%s", argv[2], src);
		}
		else
		{
			fd = open(argv[2], O_RDONLY, 0);
			if (fd >= 0)
			{
				close(fd);
				
				unlink(argv[2]);
			}

			dest = argv[2];
		}

		rename(argv[1], dest);
		if (dest != RT_NULL && dest != argv[2]) rt_free(dest);
    }

    return 0;
}

int dfs_romfs_getdents(struct dfs_fd *file, struct dirent *dirp, uint32_t count)
{
    rt_size_t index;
    const char *name;
    struct dirent *d;
    struct romfs_dirent *dirent, *sub_dirent;

    dirent = (struct romfs_dirent *)file->data;
    if (check_dirent(dirent) != 0)
        return -EIO;
    RT_ASSERT(dirent->type == ROMFS_DIRENT_DIR);

    /* enter directory */
    dirent = (struct romfs_dirent *)dirent->data;

    /* make integer count */
    count = (count / sizeof(struct dirent));
    if (count == 0)
        return -EINVAL;

    index = 0;
    for (index = 0; index < count && file->pos < file->size; index ++)
    {
        d = dirp + index;

        sub_dirent = &dirent[file->pos];
        name = sub_dirent->name;

        /* fill dirent */
        if (sub_dirent->type == ROMFS_DIRENT_DIR)
            d->d_type = DT_DIR;
        else
            d->d_type = DT_REG;

        d->d_namlen = rt_strlen(name);
        d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
        rt_strncpy(d->d_name, name, rt_strlen(name) + 1);

        /* move to next position */
        ++ file->pos;
    }

    return index * sizeof(struct dirent);
}

void rtgui_textbox_ondraw(rtgui_textbox_t *box)
{
	/* draw button */
	rtgui_rect_t rect;
	struct rtgui_dc *dc;
	rtgui_color_t fc;

	RT_ASSERT(box != RT_NULL);

	/* begin drawing */
	dc = rtgui_dc_begin_drawing(RTGUI_WIDGET(box));
	if (dc == RT_NULL)
		return;

	/* get widget rect */
	rtgui_widget_get_rect(RTGUI_WIDGET(box), &rect);
	fc = RTGUI_WIDGET_FOREGROUND(box);

	rtgui_rect_inflate(&rect, -1);

	/* fill widget rect with white color */
	RTGUI_WIDGET_BACKGROUND(box) = white;
	rtgui_dc_fill_rect(dc, &rect);

	rtgui_rect_inflate(&rect, 1);
	/* draw border */
	RTGUI_WIDGET_FOREGROUND(box) = RTGUI_RGB(123, 158, 189);
	rtgui_dc_draw_rect(dc, &rect);

	/* draw text */
	RTGUI_WIDGET_FOREGROUND(box) = fc;
	if (box->text != RT_NULL)
	{
		rect.x1 += RTGUI_WIDGET_DEFAULT_MARGIN;
		/* draw single text */
		if (box->flag & RTGUI_TEXTBOX_MASK)
		{
			/* draw mask char */
			rt_size_t len = rt_strlen(box->text);
			if (len > 0)
			{
				char *text_mask = rtgui_malloc(len + 1);
				rt_memset(text_mask, box->mask_char, len + 1);
				text_mask[len] = 0;
				rtgui_dc_draw_text(dc, text_mask+box->first_pos, &rect);
				rtgui_free(text_mask);
			}
		}
		else
		{
			rtgui_dc_draw_text(dc, box->text+box->first_pos, &rect);
		}
	}

	rtgui_dc_end_drawing(dc);
}