/* Find menu items for which the name, description or exec contains str.
* Return a list of struct menuitem_t * */
struct List *menuitems_match(char *str)
{
unsigned int i;
struct List *L = List_new();
for (i = 0; i < all_menu_items->size; i++)
{
struct menuitem_t *M = all_menu_items->items[i];
if (!M->name)
msg("BLANK NAME!\n");
if (strcasestr(M->name, str))
List_push_back(L, M);
else if (M->descr)
{
if (strcasestr(M->descr, str))
List_push_back(L, M);
}
}
return L;
}
void Manager_Insert()
{
char ch[256];
printf("문자 입력: ");
gets(ch);
int num=strlen(ch);
for(int i=0;i<num;i++)
{
List_push_back(&mm.li,ch[i]);
}
printf("입력결과: 총 %d개의 문자를 입력하셨습니다.\n",mm.li.count);
}
/*
* Returns all tokens delimeted by the given beginning and ending delimeters
*/
static void get_delimited_tokens(const Parser *parser,
const Symbol beg,
const Symbol end,
List **out)
{
if (parser == NULL || out == NULL) {
return;
}
Token *token;
token = NULL;
unsigned int i, open_count, close_count, group_index;
i = 0;
open_count = 0;
close_count = 0;
group_index = 0;
while ((token = List_get_data(parser->token_list, i)) != NULL) {
if (strcmp(token->value, beg.value) == 0) {
unsigned int j;
j = i;
Token *temp;
temp = NULL;
while ((temp = List_get_data(parser->token_list, j)) != NULL) {
Token *match;
match = Token_create(temp->value,
temp->begin, temp->end,
temp->type);
List_push_back(out[group_index], match);
if (strcmp(temp->value, beg.value) == 0) {
++open_count;
}
if (strcmp(temp->value, end.value) == 0) {
++close_count;
}
if (open_count == close_count) {
++group_index;
break;
}
++j;
}
}
++i;
}
}
/* Recursively scan through the given directory
* looking for .desktop files */
static void scan_applications_dir(char *path)
{
DIR *dp = opendir(path);
struct dirent *entry;
struct menuitem_t *M;
if (!dp)
{
perror(path);
return;
}
while ( (entry = readdir(dp)) )
{
char *n = entry->d_name, *fullpath;
if (!strcmp(n, "..") || !strcmp(n, "."))
continue;
fullpath = malloc( sizeof(char) * (strlen(n) + strlen(path) + 2) );
sprintf(fullpath, "%s/%s", path, n);
switch (entry->d_type)
{
case DT_DIR: /* Recursively scan directories */
scan_applications_dir(fullpath);
break;
case DT_REG: /* A regular file */
M = calloc(1, sizeof(struct menuitem_t));
read_desktop_file( fullpath, &(M->name), &(M->descr), &(M->exec) );
if ( (!M->name && !M->descr) || (!M->exec) )
{
free(M);
M = NULL;
}
else if (!M->name && M->descr)
{
M->name = M->descr;
M->descr = NULL;
}
if (M)
List_push_back(all_menu_items, M);
break;
}
free(fullpath);
}
closedir(dp);
}
void manager_insert()
{
int idx;int num;
printf("[insert]\n");
printf("문자입력하세요 \n");
fflush(stdin);
gets(arr);
num=strlen(arr);
for(idx=0;idx<num;idx++)
{
//List_push_front(&dlist,arr[idx]);
List_push_back(&dlist,arr[idx]);
}
printf("입력결과: 총 %d개의 문자를 입력하셨습니다.\n",dlist.count);
}
void TestData_list_uint_test(TestData _test)
{
uint i = 0;
///list _lst;
List _lst = List_new(Vptr, malloc, free);
List lst;
Iterator iter;
for (; i < _test->count; i++)
{
_test->data[i].uint32_var = i;
}
printf("push back begin test\n");
lst = List_Init(_lst, Uint32, malloc, free);
for (i = 0; i < _test->count; i++)
{
Iterator iter = List_push_back(lst, _test->data[i]);
if (List_get_value(iter).uint32_var != _test->data[i].uint32_var)
{
#if BIT_WIDTH == 64
printf("data error! tmp %d data %d i %I64d count %I64d", List_get_value(iter).uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#else
printf("data error! tmp %d data %d i %d count %d", List_get_value(iter).uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#endif
}
}
i = 0;
iter = List_begin(lst);
while (iter)
{
var tmp = List_get_value(iter);
if (tmp.uint32_var != _test->data[i].uint32_var)
{
#if BIT_WIDTH == 64
printf("data error! tmp %d data %d i %I64d count %I64d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#else
printf("data error! tmp %d data %d i %d count %d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#endif
}
iter = List_next(iter);
i++;
}
i = _test->count - 1;
iter = List_end(lst);
while (iter)
{
var tmp = List_get_value(iter);
if (tmp.uint32_var != _test->data[i].uint32_var)
{
#if BIT_WIDTH == 64
printf("data error! tmp %d data %d i %I64d count %I64d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#else
printf("data error! tmp %d data %d i %d count %d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#endif
}
iter = List_prev(iter);
i--;
}
List_Dest(lst);
printf("push back test end\n");
///
printf("insert after test0 begin\n");
lst = List_Init(lst, Uint32, malloc, free);
iter = List_push_back(lst, _test->data[0]);
for (i = 1; i < _test->count; i++)
{
iter = List_insert_after(lst, iter, _test->data[i]);
}
i = 0;
iter = List_begin(lst);
while (iter)
{
var tmp = List_get_value(iter);
if (tmp.uint32_var != _test->data[i].uint32_var)
{
#if BIT_WIDTH == 64
printf("data error! tmp %d data %d i %I64d count %I64d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#else
printf("data error! tmp %d data %d i %d count %d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#endif
}
iter = List_next(iter);
i++;
}
List_Dest(lst);
printf("insert after test0 end\n");
///
printf("insert after test1 begin\n");
lst = List_Init(lst, Uint32, malloc, free);
iter = List_push_back(lst, _test->data[0]);
List_push_back(lst, _test->data[_test->count - 1]);
for (i = 1; i < _test->count - 1; i++)
{
iter = List_insert_after(lst, iter, _test->data[i]);
}
i = 0;
iter = List_begin(lst);
while (iter)
{
var tmp = List_get_value(iter);
if (tmp.uint32_var != _test->data[i].uint32_var)
{
#if BIT_WIDTH == 64
printf("data error! tmp %d data %d i %I64d count %I64d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#else
printf("data error! tmp %d data %d i %d count %d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#endif
}
iter = List_next(iter);
i++;
}
List_Dest(lst);
printf("insert after test1 end\n");
///
printf("insert before test0 begin\n");
lst = List_Init(lst, Uint32, malloc, free);
iter = List_push_back(lst, _test->data[_test->count - 1]);
for (i = _test->count - 2; i; i--)
{
iter = List_insert_before(lst, iter, _test->data[i]);
}
List_insert_before(lst, iter, _test->data[0]);
i = 0;
iter = List_begin(lst);
while (iter)
{
var tmp = List_get_value(iter);
if (tmp.uint32_var != _test->data[i].uint32_var)
{
#if BIT_WIDTH == 64
printf("data error! tmp %d data %d i %I64d count %I64d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#else
printf("data error! tmp %d data %d i %d count %d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#endif
}
iter = List_next(iter);
i++;
}
List_Dest(lst);
printf("insert before test0 end\n");
///
///
printf("insert before test1 begin\n");
lst = List_Init(lst, Uint32, malloc, free);
iter = List_push_back(lst, _test->data[0]);
List_push_back(lst, _test->data[_test->count - 1]);
iter = List_end(lst);
for (i = _test->count - 2; i; i--)
{
iter = List_insert_before(lst, iter, _test->data[i]);
}
i = 0;
iter = List_begin(lst);
while (iter)
{
var tmp = List_get_value(iter);
if (tmp.uint32_var != _test->data[i].uint32_var)
{
#if BIT_WIDTH == 64
printf("data error! tmp %d data %d i %I64d count %I64d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#else
printf("data error! tmp %d data %d i %d count %d", tmp.uint32_var, _test->data[i].uint32_var, i, _test->count);
getchar();
exit(0);
#endif
}
iter = List_next(iter);
i++;
}
List_Dest(lst);
printf("insert before test1 end\n");
///
printf("test succ\n");
}
/*
* Match high level parser-tokens using lexer-tokens
*/
static void init_tokens(Parser *parser,
const Token *tokens,
const size_t token_count)
{
if (parser == NULL || tokens == NULL) {
return;
}
char escape_chars[parser->symbol_count][3];
{
unsigned int i;
for (i = 0; i < parser->symbol_count; ++i) {
if (i == 0) {
escape_chars[i][0] = '\0';
}
else {
escape_chars[i][0] = parser->symbols[SYMBOL_ESCAPE].value[0];
escape_chars[i][1] = parser->symbols[i].value[0];
escape_chars[i][2] = '\0';
}
}
}
unsigned int indices[token_count];
{
unsigned int i;
for (i = 0; i < token_count; ++i) {
indices[i] = 0;
}
}
char symbol_buffer[token_count + 1];
char literal_buffer[token_count + 1];
char symbol_match[1024];
char literal_match[1024];
symbol_buffer[0] = '\0';
literal_buffer[0] = '\0';
symbol_match[0] = '\0';
literal_match[0] = '\0';
unsigned int symbol_match_begin, symbol_match_end;
unsigned int literal_match_begin, literal_match_end;
TOKEN_TYPE symbol_match_type, literal_match_type;
symbol_match_begin = 0;
symbol_match_end = 0;
literal_match_begin = 0;
literal_match_end = 0;
symbol_match_type = TOKEN_UNKNOWN;
literal_match_type = TOKEN_UNKNOWN;
unsigned int i;
for (i = 0; i < token_count; ++i) {
unsigned int j, increment;
increment = 0;
for (j = i; j < token_count; ++j) {
strcat(symbol_buffer, tokens[j].value);
unsigned int k;
if (strlen(symbol_buffer) == 2
&& symbol_buffer[0] == parser->symbols[SYMBOL_ESCAPE].value[0]
) {
unsigned int match;
match = 0;
for (k = 1; k < parser->symbol_count; ++k) {
if (strcmp(symbol_buffer, escape_chars[k]) == 0) {
sprintf(symbol_match, "%s", symbol_buffer);
symbol_match_begin = i;
symbol_match_end = i + 1;
symbol_match_type = TOKEN_ESCAPE_CHAR;
indices[i] = 2;
if (i < token_count - 1) {
indices[i + 1] = 2;
increment = 1;
}
match = 1;
break;
}
}
if (match) {
break;
}
}
for (k = 1; k < parser->symbol_count; ++k) {
if (strcmp(symbol_buffer, parser->symbols[k].value) == 0) {
sprintf(symbol_match, "%s", symbol_buffer);
symbol_match_begin = i;
symbol_match_end = i;
symbol_match_type = TOKEN_SYMBOL;
indices[i] = 1;
break;
}
}
}
symbol_buffer[0] = '\0';
if (indices[i] != 1 && indices[i] != 2) {
strcat(literal_buffer, tokens[i].value);
}
else {
if (strlen(literal_buffer) == 1) {
sprintf(literal_match, "%s", literal_buffer);
literal_match_begin = i - (unsigned int) strlen(literal_buffer);
literal_match_end = literal_match_begin;
literal_match_type = TOKEN_LITERAL;
}
else if (strlen(literal_buffer) > 1) {
sprintf(literal_match, "%s", literal_buffer);
literal_match_begin = i - (unsigned int) strlen(literal_buffer);
literal_match_end = i - 1;
literal_match_type = TOKEN_LITERAL;
}
literal_buffer[0] = '\0';
}
{
if (literal_match[0] != '\0') {
Token *token;
token = Token_create(literal_match,
literal_match_begin, literal_match_end,
literal_match_type);
List_push_back(parser->token_list, token);
}
}
{
if (symbol_match[0] != '\0') {
Token *token;
token = Token_create(symbol_match,
symbol_match_begin, symbol_match_end,
symbol_match_type);
List_push_back(parser->token_list, token);
}
}
symbol_match[0] = '\0';
literal_match[0] = '\0';
i += increment;
}
}
