1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
/* $Id: pl-dwim.c,v 1.13 1999/11/25 11:25:23 jan Exp $
Copyright (c) 1990 Jan Wielemaker. All rights reserved.
See ../LICENCE to find out about your rights.
jan@swi.psy.uva.nl
Purpose: Do What I Mean support functions
*/
#include "pl-incl.h"
#include "pl-ctype.h"
forwards atom_t dwimMatch(char *, char *);
forwards bool oneTypo(char *, char *);
forwards bool twoTransposed(char *, char *);
forwards bool oneInserted(char *, char *);
forwards bool differentSeparated(char *, char *);
forwards char * subWord(char *, char *);
forwards bool subwordsTransposed(char *, char *);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Strings are supposed to be meant identical iff one of the following is
the case:
- They ARE identical
- One character is different (spy == spu)
- One character is inserted/deleted/added (debug == deug)
- Two adjecent characters are transposed (trace == tarce)
- `Sub-words' have been separated wrong (aB == a_b == ab)
- Two `Sub-words' have been transposed (exists_file == file_exists)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
static atom_t
dwimMatch(char *str1, char *str2)
{ int cl=0, l1, l2;
register char *s1 = str1;
register char *s2 = str2;
while(*s1 && *s1 == *s2) /* delete common part */
s1++, s2++, cl++;
l2 = (int) strlen(s2);
l1 = (int) strlen(s1);
if (abs(l1-l2) > 5) /* speed up a bit */
fail;
if ( l1 == 0 && l2 == 0 ) return ATOM_equal;
if ( cl + l1 < 3 || cl + l2 < 3 )
fail;
if ( l1 == l2 && oneTypo(s1, s2) ) return ATOM_mismatched_char;
if ( l1 == l2 && twoTransposed(s1, s2) ) return ATOM_transposed_char;
if ( (l2 == l1 + 1 && oneInserted(s1, s2)) ||
(l1 == l2 + 1 && oneInserted(s2, s1)) ) return ATOM_inserted_char;
if ( differentSeparated(str1, str2) ) return ATOM_separated;
if ( subwordsTransposed(str1, str2) ) return ATOM_transposed_word;
fail;
}
static bool
oneTypo(char *s1, char *s2)
{ if (s1[1] == EOS || streq(&s1[1], &s2[1]) )
succeed;
fail;
}
static
bool
twoTransposed(register char *s1, register char *s2)
{ if (s1[1] != EOS && s1[0] == s2[1] && s1[1] == s2[0] &&
(s1[2] == EOS || streq(&s1[2], &s2[2])))
succeed;
fail;
}
static bool
oneInserted(register char *s1, register char *s2)
{ if (streq(s1, &s2[1]) )
succeed;
fail;
}
static bool
differentSeparated(register char *s1, register char *s2)
{ register char c1, c2;
if ( *s1 != *s2 || *s1 == EOS )
fail;
c1 = *++s1, c2 = *++s2;
while(c1 && c1 == c2)
{ if ((c1 = *++s1) == '_')
{ c1 = *++s1;
} else
{ if (isLower(s1[-1]) && isUpper(c1))
c1 = makeLower(c1);
}
if ((c2 = *++s2) == '_')
{ c2 = *++s2;
} else
{ if (isLower(s2[-1]) && isUpper(c2))
c2 = makeLower(c2);
}
}
if (c1 == EOS && c2 == EOS)
succeed;
fail;
}
static char *
subWord(register char *s, register char *store)
{ *store++ = makeLower(*s);
s++;
for(;;)
{ if (*s == EOS)
{ *store = EOS;
return s;
}
if (*s == '_')
{ *store = EOS;
return ++s;
}
if (isLower(s[-1]) && isUpper(s[0]) )
{ *store = EOS;
return s;
}
*store++ = *s++;
}
}
static bool
subwordsTransposed(char *s1, char *s2)
{ char sw1a[1024], sw1b[1024];
char sw2a[1024], sw2b[1024];
while(*s1 && *s2)
{ s1 = subWord(s1, sw1a);
s2 = subWord(s2, sw2a);
if (!streq(sw1a, sw2a) )
{ if (*s1 == EOS || *s2 == EOS)
fail;
s1 = subWord(s1, sw1b);
s2 = subWord(s2, sw2b);
if (!streq(sw1a, sw2b) || !streq(sw1b, sw2a) )
fail;
}
}
if (*s1 == EOS && *s2 == EOS)
succeed;
fail;
}
/********************************
* PROLOG CONNECTION *
*********************************/
word
pl_dwim_match(term_t a1, term_t a2, term_t mm)
{ char *s1, *s2;
atom_t type;
if ( PL_get_chars(a1, &s1, CVT_ALL|BUF_RING) &&
PL_get_chars(a2, &s2, CVT_ALL|BUF_RING) &&
(type = dwimMatch(s1, s2)) &&
PL_unify_atom(mm, type) )
succeed;
fail;
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
$dwim_predicate(+Term, -Dwim) successively returns all predicates of the
specified module or context module that match in a DWIM sence the
predicate head.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
word
pl_dwim_predicate(term_t pred, term_t dwim, word h)
{ functor_t fdef;
Module module = (Module) NULL;
Procedure proc;
Symbol symb;
term_t head = PL_new_term_ref();
TableEnum e;
if ( ForeignControl(h) == FRG_CUTTED )
{ e = ForeignContextPtr(h);
freeTableEnum(e);
succeed;
}
if ( !PL_strip_module(pred, &module, head) )
fail;
if ( !PL_get_functor(head, &fdef) )
return PL_error(NULL, 0, NULL, ERR_TYPE, ATOM_callable, head);
if ( ForeignControl(h) == FRG_FIRST_CALL )
e = newTableEnum(module->procedures);
else
e = ForeignContextPtr(h);
while( (symb = advanceTableEnum(e)) )
{ Definition def;
char *name;
proc = symb->value;
def = proc->definition;
name = stringAtom(def->functor->name);
if ( dwimMatch(stringAtom(nameFunctor(fdef)), name) &&
isDefinedProcedure(proc) &&
(name[0] != '$' || SYSTEM_MODE) )
{ if ( !PL_unify_functor(dwim, def->functor->functor) )
continue;
ForeignRedoPtr(e);
}
}
freeTableEnum(e);
fail;
}
|
