]> git.saurik.com Git - cycript.git/blob - Complete.cpp
Verify lexer tokens are always default reductions.
[cycript.git] / Complete.cpp
1 /* Cycript - Optimizing JavaScript Compiler/Runtime
2 * Copyright (C) 2009-2015 Jay Freeman (saurik)
3 */
4
5 /* GNU Affero General Public License, Version 3 {{{ */
6 /*
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Affero General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU Affero General Public License for more details.
16
17 * You should have received a copy of the GNU Affero General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/
20 /* }}} */
21
22 #include "cycript.hpp"
23
24 #include "Driver.hpp"
25 #include "Replace.hpp"
26 #include "String.hpp"
27
28 static CYExpression *ParseExpression(CYPool &pool, CYUTF8String code) {
29 std::stringstream stream;
30 stream << '(' << code << ')';
31 CYDriver driver(pool, stream);
32 if (driver.Parse() || !driver.errors_.empty())
33 return NULL;
34
35 CYOptions options;
36 CYContext context(options);
37
38 CYStatement *statement(driver.script_->code_);
39 _assert(statement != NULL);
40 _assert(statement->next_ == NULL);
41
42 CYExpress *express(dynamic_cast<CYExpress *>(driver.script_->code_));
43 _assert(express != NULL);
44
45 CYParenthetical *parenthetical(dynamic_cast<CYParenthetical *>(express->expression_));
46 _assert(parenthetical != NULL);
47
48 return parenthetical->expression_;
49 }
50
51 _visible char **CYComplete(const char *word, const std::string &line, CYUTF8String (*run)(CYPool &pool, const std::string &)) {
52 CYLocalPool pool;
53
54 std::istringstream stream(line);
55 CYDriver driver(pool, stream);
56
57 driver.auto_ = true;
58
59 if (driver.Parse() || !driver.errors_.empty())
60 return NULL;
61
62 if (driver.mode_ == CYDriver::AutoNone)
63 return NULL;
64
65 CYExpression *expression;
66
67 CYOptions options;
68 CYContext context(options);
69
70 std::ostringstream prefix;
71
72 switch (driver.mode_) {
73 case CYDriver::AutoPrimary:
74 expression = $ CYThis();
75 break;
76
77 case CYDriver::AutoDirect:
78 expression = driver.context_;
79 break;
80
81 case CYDriver::AutoIndirect:
82 expression = $ CYIndirect(driver.context_);
83 break;
84
85 case CYDriver::AutoMessage: {
86 CYDriver::Context &thing(driver.contexts_.back());
87 expression = $M($C1($V("object_getClass"), thing.context_), $S("messages"));
88 for (CYDriver::Context::Words::const_iterator part(thing.words_.begin()); part != thing.words_.end(); ++part)
89 prefix << (*part)->word_ << ':';
90 } break;
91
92 default:
93 _assert(false);
94 }
95
96 std::string begin(prefix.str());
97
98 driver.script_ = $ CYScript($ CYExpress($C3(ParseExpression(pool,
99 " function(object, prefix, word) {\n"
100 " var names = [];\n"
101 " var before = prefix.length;\n"
102 " prefix += word;\n"
103 " var entire = prefix.length;\n"
104 " if (false) {\n"
105 " for (var name in object)\n"
106 " if (name.substring(0, entire) == prefix)\n"
107 " names.push(name.substr(before));\n"
108 " } else do {\n"
109 " try {\n"
110 " var local = Object.getOwnPropertyNames(object);\n"
111 " } catch (e) {\n"
112 " continue;\n"
113 " }\n"
114 " for (var name of local)\n"
115 " if (name.substring(0, entire) == prefix)\n"
116 " names.push(name.substr(before));\n"
117 " } while (object = typeof object === 'object' ? Object.getPrototypeOf(object) : object.__proto__);\n"
118 " return names;\n"
119 " }\n"
120 ), expression, $S(begin.c_str()), $S(word))));
121
122 driver.script_->Replace(context);
123
124 std::stringbuf str;
125 CYOutput out(str, options);
126 out << *driver.script_;
127
128 std::string code(str.str());
129 CYUTF8String json(run(pool, code));
130 // XXX: if this fails we should not try to parse it
131
132 CYExpression *result(ParseExpression(pool, json));
133 if (result == NULL)
134 return NULL;
135
136 CYArray *array(dynamic_cast<CYArray *>(result->Primitive(context)));
137 if (array == NULL)
138 return NULL;
139
140 // XXX: use an std::set?
141 typedef std::vector<std::string> Completions;
142 Completions completions;
143
144 std::string common;
145 bool rest(false);
146
147 for (CYElement *element(array->elements_); element != NULL; ) {
148 CYElementValue *value(dynamic_cast<CYElementValue *>(element));
149 _assert(value != NULL);
150 element = value->next_;
151
152 CYString *string(dynamic_cast<CYString *>(value->value_));
153 _assert(string != NULL);
154
155 std::string completion;
156 if (string->size_ != 0)
157 completion.assign(string->value_, string->size_);
158 else if (driver.mode_ == CYDriver::AutoMessage)
159 completion = "]";
160 else
161 continue;
162
163 completions.push_back(completion);
164
165 if (!rest) {
166 common = completion;
167 rest = true;
168 } else {
169 size_t limit(completion.size()), size(common.size());
170 if (size > limit)
171 common = common.substr(0, limit);
172 else
173 limit = size;
174 for (limit = 0; limit != size; ++limit)
175 if (common[limit] != completion[limit])
176 break;
177 if (limit != size)
178 common = common.substr(0, limit);
179 }
180 }
181
182 size_t count(completions.size());
183 if (count == 0)
184 return NULL;
185
186 size_t colon(common.find(':'));
187 if (colon != std::string::npos)
188 common = common.substr(0, colon + 1);
189 if (completions.size() == 1)
190 common += ' ';
191
192 char **results(reinterpret_cast<char **>(malloc(sizeof(char *) * (count + 2))));
193
194 results[0] = strdup(common.c_str());
195 size_t index(0);
196 for (Completions::const_iterator i(completions.begin()); i != completions.end(); ++i)
197 results[++index] = strdup(i->c_str());
198 results[count + 1] = NULL;
199
200 return results;
201 }