void config_file::parse_key(config_file::value& value, std::string& key, const std::string& strvalue) { value::value_type keytype = config_file::parse_keytype(key); value.type_ = keytype; if(keytype == value::RAW_VALUE){ value.raw_value_ = strvalue; } else if(keytype == value::ARRAY){ size_t index; bool ret_val = parse_array(key, index); if(index>=value.array_.size()) { value.array_.resize(index + 1); } parse_key(value.array_[index], key, strvalue); } else if(keytype == value::RECORD){ std::string recordname = parse_record_name(key); mapi it = value.record_.find(recordname); if(it == value.record_.end()){ config_file::value new_value; parse_key(new_value, key, strvalue); value.record_.insert(mapt::value_type(recordname, new_value)); } else{ parse_key(it->second, key, strvalue); } } }
/****************************************************************************** * * * Function: load_aliases * * * * Purpose: load aliases from configuration * * * * Parameters: lines - aliase entries from configuration file * * * * Comments: calls add_alias() for each entry * * * ******************************************************************************/ void load_aliases(char **lines) { char **pline, *r, *c; for (pline = lines; NULL != *pline; pline++) { r = *pline; if (SUCCEED != parse_key(&r) || ':' != *r) { zabbix_log(LOG_LEVEL_CRIT, "cannot add alias \"%s\": invalid character at position %ld", *pline, (r - *pline) + 1); exit(EXIT_FAILURE); } c = r++; if (SUCCEED != parse_key(&r) || '\0' != *r) { zabbix_log(LOG_LEVEL_CRIT, "cannot add alias \"%s\": invalid character at position %ld", *pline, (r - *pline) + 1); exit(EXIT_FAILURE); } *c++ = '\0'; add_alias(*pline, c); *--c = ':'; } }
// Lua: ip = wifi.xx.setip() static int wifi_setip( lua_State* L, uint8_t mode ) { struct ip_info pTempIp; wifi_get_ip_info(mode, &pTempIp); if (!lua_istable(L, 1)) return luaL_error( L, "wrong arg type" ); uint32_t ip = parse_key(L, "ip"); if(ip!=0) pTempIp.ip.addr = ip; ip = parse_key(L, "netmask"); if(ip!=0) pTempIp.netmask.addr = ip; ip = parse_key(L, "gateway"); if(mode==SOFTAP_IF || ip!=0) pTempIp.gw.addr = ip; if(STATION_IF == mode) { wifi_station_dhcpc_stop(); lua_pushboolean(L,wifi_set_ip_info(mode, &pTempIp)); } else { wifi_softap_dhcps_stop(); lua_pushboolean(L,wifi_set_ip_info(mode, &pTempIp)); wifi_softap_dhcps_start(); } return 1; }
static int quest_close(t_cmds **cmds, t_shell *shell) { if (ft_strlen((*cmds)->cmd) == 0) exit(0); parse_key(185, cmds, shell); parse_key(DELETE, cmds, shell); return (1); }
bool IniSimpleParser::parse(const char* file_path) { input_file_.open(file_path, ios::in); if (input_file_.fail()) return false; settings_pairs_ = map<string, string>(); string line_content; while (input_file_.eof() == false) { try{ getline(input_file_, line_content); }catch (exception e){ cout << e.what() << endl; input_file_.close(); return false; } if (is_content_available(line_content) == false) continue; int seperator_pos; string key = parse_key(line_content, seperator_pos); string value = parse_value(line_content, seperator_pos + 1); settings_pairs_.insert(pair<string, string>(key, value)); } input_file_.close(); return true; }
static int do_append( struct chronos_handle * handle, int argc, char** argv ){ int key_parsed = 0; struct index_key key; if( argc > 4 && strncmp("-t", argv[3], 2) == 0 ){ int rc = parse_key( argv[4], strlen( argv[4] ), & key ); if( rc == 0 ){ key_parsed = 1; } else { bad_key(rc, argv[4]); return rc; } } int rc = 0; if( key_parsed ){ rc = chronos_append( handle, & key, 0 ); } else { rc = chronos_append( handle, NULL, 0 ); } if( rc != 0 ){ if( rc == C_PROVIDED_KEY_NOT_LATEST ){ fprintf( stderr, "can't insert keys before the last entry.\n"); } else if ( rc == C_IO_NEEDS_A_PIPE ) { fprintf( stderr, "error reading stdin, it must be a pipe!\n"); } else { perror("chronos_append"); } return rc; } return 0; }
static int do_get( struct chronos_handle * handle, int argc, char** argv ){ struct index_key key; int rc = parse_key( argv[3], strlen( argv[3] ), & key ); if( rc != 0 ){ bad_key(rc, argv[3]); return rc; } struct index_entry entry; rc = chronos_find( handle, & key, & entry ); if( rc != 0 ){ if( rc != C_NOT_FOUND ){ perror("chronos_find"); } return rc; } // output to stdout chronos_output( handle, & entry, 1 ); if( rc != 0 ){ perror("chronos_output"); return rc; } return 0; }
static bool parse_keys(struct key_chain *chain, const char *keys) { int i = 0; clear(chain); while (keys[i]) { int start; while (keys[i] == ' ') i++; start = i; while (keys[i] && keys[i] != ' ') i++; if (start == i) break; if (chain->count >= ARRAY_COUNT(chain->keys)) { error_msg("Too many keys."); return false; } if (!parse_key(&chain->types[chain->count], &chain->keys[chain->count], keys + start, i - start)) return false; chain->count++; } if (chain->count == 0) { error_msg("Empty key not allowed."); return false; } return true; }
static int parser_insert_node(Parser *parser, char *key, char *value) { if(!key || !value) { PRINTF("invalid parameter!\n"); return -1; } PRINTF("start!\n"); char *widget_name = NULL; TagType type = TAG_CONTENT; int is_ddl = 0; int ddl_id = 0; TagNode *node = NULL; char tmp_key_buf[32] = {0}; memcpy(tmp_key_buf, key, strlen(key)); parse_key(key, &widget_name, &type, &is_ddl, &ddl_id); PRINTF("\nafter parse key\n"); printf("widget_name(%s) type(%d), is_ddl(%d), ddl_id(%d)\n", widget_name, type, is_ddl, ddl_id); node = create_tree_node(type, widget_name, is_ddl, ddl_id, tmp_key_buf); printf("after create_tree_node type(%d), widget_name(%s), is_ddl(%d), ddl_id(%d)\n", node->tag_type, \ node->tag_name, node->is_ddl, node->ddl_id); parser_tree_insert_node(parser, node); return 0; }
static int check_events(void) { struct input_event *iev; int ret = 0; int rep_config_done = 0; int rep_keys_done = 0; read_events(); while (have_events()) { iev = next_event(); switch (iev->type) { case EV_REP: ret = parse_autorepeat_config(iev); rep_config_done = 1; break; case EV_KEY: ret = parse_key(iev); rep_keys_done = 1; break; default: tst_resm(TFAIL, "Unexpected event type '0x%04x' received", iev->type); ret = 0; break; } if (!ret || (rep_config_done && rep_keys_done)) break; } return ret; }
// Lua: ip = wifi.ap.dhcp.config() static int wifi_ap_dhcp_config( lua_State* L ) { if (!lua_istable(L, 1)) return luaL_error( L, "wrong arg type" ); struct dhcps_lease lease; uint32_t ip; ip = parse_key(L, "start"); if (ip == 0) return luaL_error( L, "wrong arg type" ); lease.start_ip = ip; NODE_DBG(IPSTR, IP2STR(&lease.start_ip)); NODE_DBG("\n"); // use configured max_connection to determine end struct softap_config config; wifi_softap_get_config(&config); lease.end_ip = lease.start_ip; ip4_addr4(&lease.end_ip) += config.max_connection - 1; char temp[64]; c_sprintf(temp, IPSTR, IP2STR(&lease.start_ip)); lua_pushstring(L, temp); c_sprintf(temp, IPSTR, IP2STR(&lease.end_ip)); lua_pushstring(L, temp); // note: DHCP max range = 101 from start_ip to end_ip wifi_softap_dhcps_stop(); wifi_softap_set_dhcps_lease(&lease); wifi_softap_dhcps_start(); return 2; }
/*========================================== * is_key_in_use -- Return TRUE if a live record *========================================*/ BOOLEAN is_key_in_use (CNSTRING key) { DELETESET set=0; INT keynum=0; char ktype=0; CNSTRING barekey=0; BOOLEAN result=FALSE; if (!parse_key(key, &ktype, &keynum)) { char msg[512]; snprintf(msg, sizeof(msg)/sizeof(msg[0]), "Bad key passed to is_key_in_use: %s", key); FATAL2(msg); } set = get_deleteset_from_type(ktype); ASSERT(keynum>0); result = xref_isvalid_impl(set, keynum); strfree((STRING *)&barekey); return result; }
bool add_keys_from_file(const char *key_file) { int size; FILE *fd = fopen(key_file, "r"); if(fd == NULL) { if(g_debug) perror("cannot open key file"); return false; } fseek(fd, 0, SEEK_END); size = ftell(fd); fseek(fd, 0, SEEK_SET); char *buf = xmalloc(size + 1); if(fread(buf, 1, size, fd) != (size_t)size) { if(g_debug) perror("Cannot read key file"); fclose(fd); return false; } buf[size] = 0; fclose(fd); if(g_debug) printf("Parsing key file '%s'...\n", key_file); char *p = buf; while(1) { struct crypto_key_t k; /* parse key */ if(!parse_key(&p, &k)) { if(g_debug) printf("invalid key file\n"); return false; } if(g_debug) { printf("Add key: "); print_key(&k, true); } add_keys(&k, 1); /* request at least one space character before next key, or end of file */ if(*p != 0 && !isspace(*p)) { if(g_debug) printf("invalid key file\n"); return false; } /* skip whitespace */ while(isspace(*p)) p++; if(*p == 0) break; } free(buf); return true; }
static void exec_release(const char* args, context_t* ctx, debug_t* dbg) { joypad_key_t key = parse_key(args); (void)dbg; if (key != KEY_INVALID) { printf("Released %s\n", args); joypad_release(ctx, key); } }
#include "assert.h" #include "stdlib.h" #include "stdio.h" #include "allegro.h" #include "string.h" #include "ctype.h" //#include "memory.h" #include "trace.h" #include "strparse.h" #ifndef EXPERIMENTAL_NOTE_TRACK #include "allegrord.h" #endif /* EXPERIMENTAL_NOTE_TRACK */ #define streql(s1, s2) (strcmp(s1, s2) == 0) #define field_max 80 //Note that this is an #ifdef, not an #ifndef #ifdef EXPERIMENTAL_NOTE_TRACK class Alg_reader { public: FILE *file; int line_no; String_parse line_parser; bool line_parser_flag; char field[field_max]; bool error_flag; Alg_seq_ptr seq; double tsnum; double tsden; Alg_reader(FILE *a_file, Alg_seq_ptr new_seq); void readline(); Alg_parameters_ptr process_attributes(Alg_parameters_ptr attributes, double time); bool parse(); long parse_chan(char *field); long parse_int(char *field); int find_real_in(char *field, int n); double parse_real(char *field); void parse_error(char *field, long offset, char *message); double parse_dur(char *field, double base); double parse_after_dur(double dur, char *field, int n, double base); double parse_loud(char *field); long parse_key(char *field); double parse_pitch(char *field); long parse_after_key(int key, char *field, int n); long find_int_in(char *field, int n); bool parse_attribute(char *field, Alg_parameter_ptr parm); bool parse_val(Alg_parameter_ptr param, char *s, int i); bool check_type(char type_char, Alg_parameter_ptr param); }; #endif /* EXPERIMENTAL_NOTE_TRACK */ void subseq(char *result, char *source, int from, int to) { memcpy(result, source + from, to - from); result[to - from] = 0; } #ifndef EXPERIMENTAL_NOTE_TRACK double Allegro_reader::parse_pitch(char *field) #else /* EXPERIMENTAL_NOTE_TRACK */ double Alg_reader::parse_pitch(char *field) #endif /* EXPERIMENTAL_NOTE_TRACK */ { if (isdigit(field[1])) { char real_string[80]; int last = find_real_in(field, 1); subseq(real_string, field, 1, last); return atof(real_string); } else { return (double) parse_key(field); } }
int main(void) { size_t i; for(i = 0; i < sizeof(keys) / sizeof(struct key); i++) { int res = parse_key(keys[i].text, keys[i].formatted, keys[i].valid); if(res != EXIT_SUCCESS) { return res; } } return EXIT_SUCCESS; }
static int parse_key_three(size_t key, t_cmds **cmd, t_shell *shell) { if (key == 344) { while ((*cmd)->pointer > 0 && (*cmd)->cmd[(*cmd)->pointer] == ' ') parse_key(186, cmd, shell); while ((*cmd)->pointer > 0 && (*cmd)->cmd[(*cmd)->pointer] != ' ') parse_key(186, cmd, shell); } else if (key == 343) { while ((*cmd)->pointer < (int)ft_strlen((*cmd)->cmd) && (*cmd)->cmd[(*cmd)->pointer] != ' ') parse_key(185, cmd, shell); while ((*cmd)->pointer < (int)ft_strlen((*cmd)->cmd) && (*cmd)->cmd[(*cmd)->pointer] == ' ') parse_key(185, cmd, shell); } else return (parse_key_four(-1, key, cmd, shell)); return (1); }
/* pair = key ':' value */ static int parse_pair(struct frozen *f) { int current_path_len; const char *tok; skip_whitespaces(f); tok = f->cur; TRY(parse_key(f)); current_path_len = append_to_path(f, *tok == '"' ? tok + 1 : tok, *tok == '"' ? f->cur - tok - 2 : f->cur - tok); TRY(test_and_skip(f, ':')); TRY(parse_value(f)); truncate_path(f, current_path_len); return 0; }
/* * Read keyfile and look for lines starting with keywords "up, down, left, * right, stop, pause & exit". When found, send the rest of the string to * parse_key(). If invalid keyword found, or parse_key() returns true, * report syntax error to stderr and return to caller. * Return values: * 0: Success * 1: Can't open file * 2: Syntax error */ int setkeys(char* path) { FILE *file; char line[MAXLINE]; char keyword[MAXLINE]; char value[MAXLINE]; int matches; int error_flag = 0; int i; /* Open file for reading */ if ( ! (file = fopen(path, "r")) ) { return 1; } /* Read lines from file */ while (fgets(line, MAXLINE, file) != NULL) { if (line[0] == '#') { continue; } /* Ket keyword and value from line */ matches = sscanf(line, "%s%s", keyword, value); if (matches == EOF) { continue; } /* Compare word from line with valid keywords. On syntax error, report * error and return 1 to caller. */ error_flag = 1; /* Murphy's law */ for (i = 0; i < KEYWORDS_COUNT; i++) { if (strcmp(keyword, kw[i].keyword) == 0) { error_flag = 0; if (parse_key(value, kw[i].global) != 0) { error_flag = 1; } break; } } if (error_flag) { error(0, 0, "Keyfile syntax error -- %s", path); return 2; } } /* Whole file read with no errors */ return 0; }
static void snew_key_from_str (uc *string, char *what) { int i; int meta; int old_display; uc chr; old_display = window_display; window_display = 0; if ((meta = parse_key(string, &chr)) == -1) return; window_display = old_display; if (lookup_function(what, &i) == 1) new_key(meta, chr, i, 0, NULL); return; }
int main() { setup(); sidebar *sb = create_sidebar(); setup_sidebar_items(sb); content_pane *cp = create_content_pane(); setup_content_items(cp); wrapper *wp = create_wrapper(cp, sb); print_wrapper(wp); int x, y; getmaxyx(stdscr, x, y); mvprintw(20, 21, "x: %d y: %d", x, y); parse_key(wp); tear_down(); return 0; }
/*=================================================== * addxref_impl -- Mark key free (accepts string key, any type) * key: [IN] key to delete (add to free set) * silent: [IN] if FALSE, ASSERT if record is already free *=================================================*/ static BOOLEAN addxref_impl (CNSTRING key, DUPS dups) { char ktype=0; INT keynum=0; if (!parse_key(key, &ktype, &keynum)) { char msg[512]; snprintf(msg, sizeof(msg)/sizeof(msg[0]), "Bad key passed to addxref_impl: %s", key); FATAL2(msg); } switch(ktype) { case 'I': return addixref_impl(keynum, dups); case 'F': return addfxref_impl(keynum, dups); case 'S': return addsxref_impl(keynum, dups); case 'E': return addexref_impl(keynum, dups); case 'X': return addxxref_impl(keynum, dups); default: ASSERT(0); return FALSE; } }
static bool parse_key(unsigned char *type, unsigned int *key, const char *str, int len) { unsigned char ch; int i; if (len == 1) { *type = KEY_NORMAL; *key = str[0]; return true; } if (buf_str_case_equal(str, len, "sp") || buf_str_case_equal(str, len, "space")) { *type = KEY_NORMAL; *key = ' '; return true; } ch = toupper(str[1]); if (str[0] == '^' && len == 2) { if (ch >= 0x40 && ch < 0x60) { *type = KEY_NORMAL; *key = ch - 0x40; return true; } if (ch == '?') { *type = KEY_NORMAL; *key = 0x7f; return true; } } if (toupper(str[0]) == 'M' && str[1] == '-' && parse_key(type, key, str + 2, len - 2)) { *type = KEY_META; return true; } for (i = 0; i < NR_SKEYS; i++) { if (buf_str_case_equal(str, len, special_names[i])) { *type = KEY_SPECIAL; *key = i; return true; } } error_msg("Invalid key %s", str); return false; }
void run_command_unbind(char *argstr) /* {{{ */ { /** * unbind a key * syntax - mode key */ char *modestr = NULL, *keystr = NULL, *keyname = NULL; prog_mode mode; int ret = 0; /* parse args */ if (argstr != NULL) ret = sscanf(argstr, "%ms %m[^\n]", &modestr, &keystr); if (ret != 2) { statusbar_message(cfg.statusbar_timeout, "syntax: unbind <mode> <key>"); tnc_fprintf(logfp, LOG_ERROR, "syntax: unbind <mode> <key> [%d](%s)", ret, argstr); goto cleanup; } /* parse mode */ if (str_eq(modestr, "pager")) mode = MODE_PAGER; else if (str_eq(modestr, "tasklist")) mode = MODE_TASKLIST; else mode = MODE_ANY; int key = parse_key(keystr); remove_keybinds(key, mode); keyname = name_key(key); statusbar_message(cfg.statusbar_timeout, "key unbound: %s (%d)", keyname, key); goto cleanup; cleanup: free(keyname); free(modestr); free(keystr); return; } /* }}} */
static grub_video_color_t parse_color (char *name, grub_uint32_t *fill) { int fg, bg; char *p, *n; n = grub_menu_next_field (name, ','); if (n) *fill = parse_key (n); if (*name == '#') { grub_uint32_t rgb; rgb = grub_strtoul (name + 1, &name, 16); if (grub_menu_region_get_current ()->map_rgb) { grub_menu_restore_field (n, ','); return grub_menu_region_get_current ()->map_rgb (rgb >> 16, rgb >> 8, rgb); }
void parse_object(const char* json, JsonObject& object) { CE_ASSERT_NOT_NULL(json); if (*json == '{') { json = skip_spaces(++json); if (*json == '}') return; while (*json) { const char* key_begin = *json == '"' ? (json + 1) : json; TempAllocator256 ta; DynamicString key(ta); json = parse_key(json, key); FixedString fs_key(key_begin, key.length()); json = skip_spaces(json); json = next(json, (*json == '=') ? '=' : ':'); json = skip_spaces(json); map::set(object, fs_key, json); json = skip_value(json); json = skip_spaces(json); if (*json == '}') return; json = skip_spaces(json); } } CE_FATAL("Bad object"); }
static void parse_root_object(const char* json, JsonObject& object) { CE_ENSURE(NULL != json); while (*json) { const char* key_begin = *json == '"' ? (json + 1) : json; TempAllocator256 ta; DynamicString key(ta); json = parse_key(json, key); FixedString fs_key(key_begin, key.length()); json = skip_spaces(json); json = next(json, (*json == '=') ? '=' : ':'); json = skip_spaces(json); map::set(object._map, fs_key, json); json = skip_value(json); json = skip_spaces(json); } }
// pair = key ':' value static int parse_pair(struct frozen *f) { TRY(parse_key(f)); TRY(test_and_skip(f, ':')); TRY(parse_value(f)); return 0; }
gboolean module_feedkey(int kv, int kvstate) { int lkv = tolower(kv); int shift_m=(kvstate&ShiftMask) > 0; // printf("%x %c %d\n", kv, kv, shift_m); if (kvstate & ControlMask) return FALSE; if (kvstate & (Mod1Mask|Mod4Mask|Mod5Mask)) return FALSE; if (kv==XK_Shift_L||kv==XK_Shift_R) { key_press_time = gmf.mf_current_time(); } if (!gmf.mf_tsin_pho_mode()) return 0; gboolean b_is_empty = is_empty(); switch (kv) { case XK_F7: if (is_empty()) return FALSE; state = STATE_ROMANJI; if (state_hira_kata != STATE_kata) state_hira_kata = STATE_kata; else state_hira_kata = STATE_hira; disp_input(); return TRUE; case XK_F8: if (is_empty()) return FALSE; state = STATE_ROMANJI; if (state_hira_kata != STATE_half_kata) state_hira_kata = STATE_half_kata; else state_hira_kata = STATE_hira; disp_input(); return TRUE; case XK_F11: system("kasumi &"); return TRUE; case XK_F12: system("kasumi -a &"); return TRUE; case XK_Up: if (b_is_empty) return FALSE; if (state==STATE_SELECT) { int N = page_N(); gmf.mf_tss->pho_menu_idx--; if (gmf.mf_tss->pho_menu_idx < 0) gmf.mf_tss->pho_menu_idx = N - 1; disp_select(); } return TRUE; case XK_Down: if (b_is_empty) return FALSE; if (state==STATE_CONVERT) { state = STATE_SELECT; gmf.mf_tss->sel_pho = TRUE; // puts("STATE_SELECT"); disp_select(); } else if (state==STATE_SELECT) { int N = page_N(); gmf.mf_tss->pho_menu_idx=(gmf.mf_tss->pho_menu_idx+1)% N; disp_select(); } return TRUE; case XK_Return: if (b_is_empty) return FALSE; if (state==STATE_SELECT) { if (select_idx(gmf.mf_tss->pho_menu_idx)) goto send; return TRUE; } send: return module_flush_input(); case XK_Escape: if (state==STATE_SELECT) { state = STATE_CONVERT; gmf.mf_tss->sel_pho = FALSE; gmf.mf_clear_sele(); } else if (state==STATE_CONVERT) goto rom; return FALSE; case XK_BackSpace: if (b_is_empty) { state_hira_kata = STATE_hira; return FALSE; } gmf.mf_hide_selections_win(); if (state&(STATE_CONVERT|STATE_SELECT)) { rom: // puts("romanji"); state = STATE_ROMANJI; cursor = jpN; segN = 0; disp_input(); return TRUE; } // puts("back"); if (keysN) { keysN--; keys[keysN]=0; } else if (jpN && cursor) { delete_jpstr(cursor-1); cursor--; } else return FALSE; disp_input(); auto_hide(); return TRUE; case XK_Delete: if (b_is_empty) return FALSE; if (state&STATE_ROMANJI) { if (keysN) return TRUE; delete_jpstr(cursor); disp_input(); } auto_hide(); return TRUE; case XK_Left: if (b_is_empty) return FALSE; if (state&STATE_ROMANJI) { if (keysN) keysN = 0; else { if (cursor) cursor--; } disp_input(); } else if (state&STATE_CONVERT) { if (shift_m) { anthy_resize_segment(ac, cursor, -1); load_seg(); } else { if (cursor) cursor--; } disp_convert(); } return TRUE; case XK_Right: if (b_is_empty) return FALSE; if (state&STATE_ROMANJI) { if (cursor < jpN) cursor++; disp_input(); } else if (state&STATE_CONVERT) { if (shift_m) { anthy_resize_segment(ac, cursor, 1); load_seg(); } else { if (cursor < segN-1) cursor++; } disp_convert(); } return TRUE; case XK_Home: if (b_is_empty) return FALSE; cursor = 0; if (state&STATE_ROMANJI) { disp_input(); } else if (state&STATE_CONVERT) { disp_convert(); } return TRUE; case XK_End: if (b_is_empty) return FALSE; if (state&STATE_ROMANJI) { cursor = jpN; disp_input(); } else if (state&STATE_CONVERT) { cursor = segN-1; disp_convert(); } return TRUE; case XK_Prior: if (state!=STATE_SELECT) return FALSE; prev_page(); return TRUE; case XK_Next: if (state!=STATE_SELECT) return FALSE; next_page(); return TRUE; case ' ': if (b_is_empty) return FALSE; goto lab1; default: if (state==STATE_SELECT) { char *pp; if ((pp=strchr(*gmf.mf_pho_selkey, lkv))) { int c=pp-*gmf.mf_pho_selkey; if (select_idx(c)) goto send; } return TRUE; } } // printf("kv %d\n", kv); if (!is_legal_char(kv)) return FALSE; kv = lkv; if (state==STATE_CONVERT && kv!=' ') { send_seg(); state = STATE_ROMANJI; } lab1: if (state==STATE_ROMANJI) { if (keysN < MAX_KEYS) keys[keysN++]=kv; keys[keysN]=0; parse_key(); disp_input(); } module_show_win(); if (kv==' ') { if (state==STATE_ROMANJI) { char tt[512]; clear_seg_label(); merge_jp(tt, TRUE); // dbg("tt %s %d\n", tt, strlen(tt)); anthy_set_string(ac, tt); load_seg(); } else if (state==STATE_CONVERT) { state = STATE_SELECT; gmf.mf_tss->sel_pho = TRUE; // puts("STATE_SELECT"); disp_select(); } else if (state==STATE_SELECT) { next_page(); } } return TRUE; }
LoadTedrc(char *tedname, int depth, int kdefmapno) { FILE *fp; char ss[8192],ibuf[2048],*tt,*uu,*vv,*ww,*xx; int len,i,j,lno; int hdef[128]; extern int X_inited; KEYDEF *kdef=kdefmap[kdefmapno]; int kdefno=kdefno_m[kdefmapno]; if ((fp=init_tedrc_fname(tedname, depth))==NULL) return 1; if (kdefno && !depth) { for(j=0;j<kdefno;j++) free(kdef[j].cmd); if (!kdefmapno) free_lang(); free(kdef); kdefmap[kdefmapno]=NULL; if (kdefmapno) { free(mode_str_m[kdefmapno]); mode_str_m[kdefmapno]=NULL; } kdef=NULL; } #if 0 printf("-- %d %d %s\n",depth, kdefmapno, ftedrc); #endif if (kdef==NULL) { MAX_KEY_DEF=280; if ((kdef=mmalloc(sizeof(KEYDEF)*MAX_KEY_DEF,"LoadTedrc"))==NULL) exit(1); kdefmap[kdefmapno]=kdef; kdefno_m[kdefmapno]=kdefno=0; } if (!depth) qsort(kmap,kname_no,sizeof(KEYMAP),qcmpxk); tedrcfname=tedname; lno=0; while (!feof(fp)) { int next_l; ss[0]=0; next_l=0; for(;;) { lno++; len=mfgets(ibuf,sizeof(ibuf),fp); if (!len) { next_l=1; break; } if (ibuf[len-1]=='\n') ibuf[--len]=0; if (!len) { next_l=1; break; } while (len && (ibuf[len-1]==' '||ibuf[len-1]==9)) len--; if (!len) { next_l=1; break; } if (ibuf[len-1]=='\\') { ibuf[len-1]=0; strcat(ss,ibuf); } else { strcat(ss,ibuf); break; } } if (next_l) continue; tt=skip_spc(ss); uu=to_spc(tt); vv=skip_spc(uu); *uu=0; if (tt[0]=='#') continue; if (!strcmp(tt,"d")) { ww=to_spc(vv); if (!(*vv)) lper(tedname,lno,"argument expected"); kdef[kdefno].klen=parse_key(tedname, lno,vv,ww,kdef[kdefno].kcode); if ((i=kcode_exist(kdefno,kdef,kdefno))<kdefno) free(kdef[i].cmd); xx=skip_spc(ww); kdef[i].cmd=strdup(parse_Cstr(tedname, lno,xx,&uu)); kdef[i].type=0; if (i==kdefno) incr_kdefno(&kdef,kdefmapno,&kdefno); continue; } else if (!strcmp(tt,"f")) { ww=to_spc(vv); if (!(*vv)) lper(tedname,lno,"argument expected"); kdef[kdefno].klen=parse_key(tedname, lno,vv,ww,kdef[kdefno].kcode); if ((i=kcode_exist(kdefno,kdef,kdefno))<kdefno) free(kdef[i].cmd); xx=skip_spc(ww); if (parse_stmt(tedname, lno,xx,&kdef[i].cmd,&kdef[i].type)) { if (i==kdefno) incr_kdefno(&kdef,kdefmapno,&kdefno); } continue; } if (kdefmapno) lper(tedname,lno,"%s for LoadKeyDefInto can accept 'f' and 'd' command only", tedname); if (!strcmp(tt,"s")) { ww=to_spc(vv); xx=skip_spc(ww); *ww=0; for(i=0;i<sizeof(locolor)/sizeof(locolor[0]);i++) if (!strcmp(vv,locolor[i].cname)) break; if (i==sizeof(locolor)/sizeof(locolor[0])) lper(tedname,lno,"Unknown Def color %s",vv); ww=to_spc(xx); *ww=0; strcpy(locolor[i].caddr,xx); } else if (!strcmp(tt,"set")) { ww=to_spc(vv); xx=skip_spc(ww); tt=to_spc(xx); if (!(*ww)) lper(tedname,lno,"argument expected"); *ww=0; for(i=0;i<sizeof(sets)/sizeof(sets[0]);i++) if (!strcmp(sets[i].sname,vv)) break; if (i==sizeof(sets)/sizeof(sets[0])) lper2(tedname,lno,"Unknown set %s",vv); else { *tt=0; *(sets[i].saddr)=atoi(xx); } } else if (!strcmp(tt,"lang") && !depth) { extern char DirectCommentChars[]; int keywcnt=3,LangIdx,ColIdx,AllocN=32,kwidx, MaxKeywordLen=0; char *ff; KW *kw; if (depth) p_err("cannot define 'lang' in include %s", tedname); tt=parse_Cstr(tedname, lno,vv,&uu); i=strlen(tt)+2; if ((vv=mmalloc(i,"LoadTedrc"))==NULL) exit(1); if ((kw=mmalloc(AllocN*sizeof(KW),"LoadTedrc 2"))==NULL) exit(1); LangExt[LangN]=strcat(strcpy(vv,tt)," "); kw[0].coloridx=ColorCnt; strcpy(pc_color[ColorCnt].fg_str,getstr(uu,&vv)); strcpy(pc_color[ColorCnt++].bg_str,getstr(vv,&uu)); uu=skip_spc(uu); DirectCommentChars[LangN]=*uu; kw[1].coloridx=ColorCnt; strcpy(pc_color[ColorCnt].fg_str,getstr(uu+1,&vv)); strcpy(pc_color[ColorCnt++].bg_str,getstr(vv,&uu)); kw[2].coloridx=ColorCnt; strcpy(pc_color[ColorCnt].fg_str,getstr(uu+1,&vv)); strcpy(pc_color[ColorCnt++].bg_str,getstr(vv,&uu)); for(;;) { if (!*uu) break; strcpy(pc_color[ColorCnt].fg_str,getstr(uu+1,&vv)); strcpy(pc_color[ColorCnt].bg_str,getstr(vv,&uu)); uu=skip_spc(uu); ww=tt=parse_Cstr(tedname, lno,uu,&vv); uu=vv; xx=tt+strlen(tt); for(;;) { char *pstr; tt=to_spc(ww); vv=skip_spc(tt); *(tt)=0; if (pstr=strchr(ww,'(')) { kw[keywcnt].arg=strdup(pstr); *pstr=0; } else kw[keywcnt].arg=0; kw[keywcnt].keyword=strdup(ww); if (strlen(ww) > MaxKeywordLen) MaxKeywordLen=strlen(ww); kw[keywcnt].coloridx=ColorCnt; #if 0 printf("%d %d %d %s\n",LangN,keywcnt, ColorCnt, kw[keywcnt].keyword); #endif keywcnt++; if (keywcnt+3>=AllocN) { AllocN+=32; if ((kw=mrealloc(kw,AllocN*sizeof(KW),"LoadTedrc 3"))==NULL) exit(1); } ww=vv; if (ww==xx) break; } ColorCnt++; } qsort(kw+3,keywcnt-3,sizeof(KW), kwcmp); LangKw[LangN]=kw; LangMaxKeywordLen[LangN]=MaxKeywordLen; LangKwN[LangN++]=keywcnt; if (LangN>=MaxLang) { error("Too many languages defined"); error("Remove unused language in tedrc or modify ted.h and recompile"); exit(1); } } else if (!strcmp(tt,"include")) { if (depth > 10) { error("include too many level ??"); continue; } ww=to_spc(vv); xx=skip_spc(ww); if (!(*vv)) lper(tedname,lno,"argument expected"); *ww=0; LoadTedrc(vv,depth+1,kdefmapno); tedrcfname=tedname; } else if (!strcmp(tt,"filebrowser")) { ww=to_spc(vv); xx=skip_spc(ww); if (!(*vv)) lper(tedname,lno,"argument expected"); init_reg_exp(vv); } else if (!strcmp(tt,"fontlist")) { ww=to_spc(vv); xx=skip_spc(ww); if (!(*vv)) lper(tedname,lno,"argument expected"); setFontList(vv); } else if (!strcmp(tt,"LoadKeyDefInto")) { int no; char mstr[16], *p; tt=parse_Cstr(tedname, lno,vv,&uu); if (!(*tt)) lper(tedname,lno,"file name expected"); ww=skip_spc(uu); if (!*ww) lper(tedname,lno,"Bind number expected"); no=*ww-'0'; if (no<=0 || no>=4) lper(tedname,lno,"Bind number must be less than 4 and greater than 0"); if ((p=strchr(tt,'.'))==NULL) { mode_str_m[no]=" "; } else { p++; if (! *p) mode_str_m[no]=strdup(" "); else mode_str_m[no]=strdup(p); } LoadTedrc(tt,0,no); } } fclose(fp); if (!depth) { kdefno=kdefno_m[kdefmapno]; qsort(kdef,kdefno,sizeof(kdef[0]),qcmp); bzero(hdef,sizeof(hdef)); bzero(kdefhash[kdefmapno],128*sizeof(int)); for(i=0;i<kdefno;i++) { j=KEYHASH(kdef[i].kcode[0]); if (hdef[j]) continue; hdef[j]=1; kdefhash[kdefmapno][j]=i; } kdefhash[kdefmapno][127]=kdefno; for(i=126;i>=0;i--) if (!hdef[i]) kdefhash[kdefmapno][i]=kdefhash[kdefmapno][i+1]; ReLoadTed=1; if (X_inited) alloc_pc_colors(); } return 0; }