darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-02-17 09:02:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

Itegration of corrector. Seems to be some leaks in the score keeping for the probability system.

Browse source
This commit is contained in:
Dale Weiler 2013-01-04 11:44:25 +00:00
parent d97e032fcf
commit 18b9473cf8
2 changed files with 78 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
correct.c
View file

@ -356,11 +356,12 @@ char *correct_str(ht table, const char *ident) {
if (correct_find(table, ident))
return found;
mem_d(found);
/*mem_d(found);*/
if ((e1rows = correct_size(ident))) {
e1 = correct_edit(ident);
if ((e1ident = correct_maximum(table, e1, e1rows))) {
mem_d(found);
found = util_strdup(e1ident);
correct_cleanup(e1, e1rows);
return found;
@ -368,8 +369,10 @@ char *correct_str(ht table, const char *ident) {
}
e2 = correct_known(table, e1, e1rows, &e2rows);
if (e2rows && ((e2ident = correct_maximum(table, e2, e2rows))))
if (e2rows && ((e2ident = correct_maximum(table, e2, e2rows)))) {
mem_d(found);
found = util_strdup(e2ident);
}
correct_cleanup(e1, e1rows);
correct_cleanup(e2, e2rows);

75
parser.c
View file

@ -74,6 +74,10 @@ typedef struct {
ht htglobals;
ht *typedefs;
/* same as above but for the spelling corrector */
ht *correct_variables;
size_t ***correct_variables_score; /* vector of vector of size_t* */
/* not to be used directly, we use the hash table */
ast_expression **_locals;
size_t *_blocklocals;
@ -1614,13 +1618,15 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
}
else
{
size_t i;
char *correct = NULL;
/*
* sometimes people use preprocessing predefs without enabling them
* i've done this thousands of times already myself. Lets check for
* it in the predef table. And diagnose it better :)
*/
if (!OPTS_FLAG(FTEPP_PREDEFS)) {
size_t i;
for (i = 0; i < sizeof(ftepp_predefs)/sizeof(*ftepp_predefs); i++) {
if (!strcmp(ftepp_predefs[i].name, parser_tokval(parser))) {
parseerror(parser, "unexpected ident: %s (use -fftepp-predef to enable pre-defined macros)", parser_tokval(parser));
@ -1629,7 +1635,29 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
}
}
parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
/*
* TODO: determine the best score for the identifier: be it
* a variable, a field.
*
* We should also consider adding correction tables for
* other things as well.
*/
for (i = 0; i < vec_size(parser->correct_variables); i++) {
correct = correct_str(parser->correct_variables[i], "ello");
if (strcmp(correct, parser_tokval(parser))) {
break;
} else if (correct) {
mem_d(correct);
}
}
if (correct) {
parseerror(parser, "unexpected ident: %s (did you mean %s?)", parser_tokval(parser), correct);
/*mem_d(correct);*/
} else {
parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
}
goto onerr;
}
}
@ -1968,6 +1996,10 @@ static void parser_enterblock(parser_t *parser)
vec_push(parser->typedefs, util_htnew(TYPEDEF_HT_SIZE));
vec_push(parser->_blocktypedefs, vec_size(parser->_typedefs));
vec_push(parser->_block_ctx, parser_ctx(parser));
/* corrector */
vec_push(parser->correct_variables, util_htnew(PARSER_HT_SIZE));
vec_push(parser->correct_variables_score, NULL);
}
static bool parser_leaveblock(parser_t *parser)
@ -1981,7 +2013,11 @@ static bool parser_leaveblock(parser_t *parser)
}
util_htdel(vec_last(parser->variables));
util_htdel(vec_last(parser->correct_variables)); /* corrector */
vec_free(vec_last(parser->correct_variables_score)); /* corrector */
vec_pop(parser->variables);
vec_pop(parser->correct_variables); /* corrector */
if (!vec_size(parser->_blocklocals)) {
parseerror(parser, "internal error: parser_leaveblock with no block (2)");
return false;
@ -2008,6 +2044,7 @@ static bool parser_leaveblock(parser_t *parser)
vec_pop(parser->typedefs);
vec_pop(parser->_block_ctx);
return rv;
}
@ -2015,6 +2052,13 @@ static void parser_addlocal(parser_t *parser, const char *name, ast_expression *
{
vec_push(parser->_locals, e);
util_htset(vec_last(parser->variables), name, (void*)e);
/* corrector */
correct_add (
vec_last(parser->correct_variables),
&vec_last(parser->correct_variables_score),
name
);
}
static ast_expression* process_condition(parser_t *parser, ast_expression *cond, bool *_ifnot)
@ -3542,6 +3586,7 @@ static bool parse_function_body(parser_t *parser, ast_value *var)
vec_push(parser->globals, (ast_expression*)thinkfunc);
util_htset(parser->htglobals, thinkfunc->name, thinkfunc);
nextthink = (ast_expression*)thinkfunc;
} else {
@ -4783,6 +4828,14 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
/* Add it to the local scope */
util_htset(vec_last(parser->variables), var->name, (void*)var);
/* corrector */
correct_add (
vec_last(parser->correct_variables),
&vec_last(parser->correct_variables_score),
var->name
);
/* now rename the global */
ln = strlen(var->name);
vec_append(defname, ln, var->name);
@ -4796,6 +4849,13 @@ static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofield
for (i = 0; i < 3; ++i) {
util_htset(vec_last(parser->variables), me[i]->name, (void*)(me[i]));
/* corrector */
correct_add(
vec_last(parser->correct_variables),
&vec_last(parser->correct_variables_score),
me[i]->name
);
vec_shrinkto(defname, prefix_len);
ln = strlen(me[i]->name);
vec_append(defname, ln, me[i]->name);
@ -5342,6 +5402,17 @@ void parser_cleanup()
vec_free(parser->_blocklocals);
vec_free(parser->_locals);
/* corrector */
for (i = 0; i < vec_size(parser->correct_variables); ++i) {
correct_del(parser->correct_variables[i], parser->correct_variables_score[i]);
}
for (i = 0; i < vec_size(parser->correct_variables_score); ++i) {
vec_free(parser->correct_variables_score[i]);
}
vec_free(parser->correct_variables);
vec_free(parser->correct_variables_score);
for (i = 0; i < vec_size(parser->_typedefs); ++i)
ast_delete(parser->_typedefs[i]);
vec_free(parser->_typedefs);