Complete.cpp

   1 /* Cycript - The Truly Universal Scripting Language
   2  * Copyright (C) 2009-2016  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 <typeinfo>
  23
  24 #include "cycript.hpp"
  25
  26 #include "Driver.hpp"
  27 #include "Replace.hpp"
  28 #include "String.hpp"
  29
  30 static CYExpression *ParseExpression(CYPool &pool, CYUTF8String code) {
  31     std::stringstream stream;
  32     stream << '(' << code << ')';
  33     CYDriver driver(pool, *stream.rdbuf());
  34     if (driver.Parse() || !driver.errors_.empty())
  35         return NULL;
  36
  37     CYOptions options;
  38     CYContext context(options);
  39
  40     CYStatement *statement(driver.script_->code_);
  41     _assert(statement != NULL);
  42     _assert(statement->next_ == NULL);
  43
  44     CYExpress *express(dynamic_cast<CYExpress *>(driver.script_->code_));
  45     _assert(express != NULL);
  46
  47     CYParenthetical *parenthetical(dynamic_cast<CYParenthetical *>(express->expression_));
  48     _assert(parenthetical != NULL);
  49
  50     return parenthetical->expression_;
  51 }
  52
  53 _visible char **CYComplete(const char *word, const std::string &line, CYUTF8String (*run)(CYPool &pool, const std::string &)) {
  54     CYLocalPool pool;
  55
  56     std::stringbuf stream(line);
  57     CYDriver driver(pool, stream);
  58
  59     driver.auto_ = true;
  60
  61     if (driver.Parse() || !driver.errors_.empty())
  62         return NULL;
  63
  64     if (driver.mode_ == CYDriver::AutoNone)
  65         return NULL;
  66
  67     CYExpression *expression;
  68
  69     CYOptions options;
  70     CYContext context(options);
  71
  72     std::ostringstream prefix;
  73
  74     switch (driver.mode_) {
  75         case CYDriver::AutoPrimary:
  76             expression = $ CYThis();
  77         break;
  78
  79         case CYDriver::AutoDirect:
  80             expression = driver.context_;
  81         break;
  82
  83         case CYDriver::AutoIndirect:
  84             expression = $ CYIndirect(driver.context_);
  85         break;
  86
  87         case CYDriver::AutoMessage: {
  88             CYDriver::Context &thing(driver.contexts_.back());
  89             expression = $M($C1($V("object_getClass"), thing.context_), $S("prototype"));
  90             for (CYDriver::Context::Words::const_iterator part(thing.words_.begin()); part != thing.words_.end(); ++part)
  91                 prefix << (*part)->word_ << ':';
  92         } break;
  93
  94         case CYDriver::AutoResolve:
  95             expression = $M(driver.context_, $S("$cyr"));
  96         break;
  97
  98         case CYDriver::AutoStruct:
  99             expression = $ CYThis();
 100             prefix << "$cys";
 101         break;
 102
 103         case CYDriver::AutoEnum:
 104             expression = $ CYThis();
 105             prefix << "$cye";
 106         break;
 107
 108         default:
 109             _assert(false);
 110     }
 111
 112     std::string begin(prefix.str());
 113
 114     CYBoolean *message;
 115     if (driver.mode_ == CYDriver::AutoMessage)
 116         message = $ CYTrue();
 117     else
 118         message = $ CYFalse();
 119
 120     driver.script_ = $ CYScript($ CYExpress($C4(ParseExpression(pool,
 121     "   function(value, prefix, word, message) {\n"
 122     "       var object = value;\n"
 123     "       var names = [];\n"
 124     "       var before = prefix.length;\n"
 125     "       prefix += word;\n"
 126     "       var entire = prefix.length;\n"
 127     "       if (false) {\n"
 128     "           for (var name in object)\n"
 129     "               if (name.substring(0, entire) == prefix)\n"
 130     "                   names.push(name);\n"
 131     "       } else do {\n"
 132     "           if (object.hasOwnProperty(\"cy$complete\"))\n"
 133     "               names = names.concat(object.cy$complete.call(value, prefix, message));\n"
 134     "           try {\n"
 135     "               var local = Object.getOwnPropertyNames(object);\n"
 136     "           } catch (e) {\n"
 137     "               continue;\n"
 138     "           }\n"
 139     "           for (var name of local)\n"
 140     "               if (name.substring(0, entire) == prefix)\n"
 141     "                   names.push(name);\n"
 142     "       } while (object = typeof object === 'object' ? Object.getPrototypeOf(object) : object.__proto__);\n"
 143     "       return names;\n"
 144     "   }\n"
 145     ), expression, $S(begin.c_str()), $S(word), message)));
 146
 147     driver.script_->Replace(context);
 148
 149     std::stringbuf str;
 150     CYOutput out(str, options);
 151     out << *driver.script_;
 152
 153     std::string code(str.str());
 154     CYUTF8String json(run(pool, code));
 155     // XXX: if this fails we should not try to parse it
 156
 157     CYExpression *result(ParseExpression(pool, json));
 158     if (result == NULL)
 159         return NULL;
 160
 161     CYArray *array(dynamic_cast<CYArray *>(result->Primitive(context)));
 162     if (array == NULL)
 163         return NULL;
 164
 165     // XXX: use an std::set?
 166     typedef std::vector<CYUTF8String> Completions;
 167     Completions completions;
 168
 169     std::string common;
 170     bool rest(false);
 171
 172     for (CYElement *element(array->elements_); element != NULL; ) {
 173         CYElementValue *value(dynamic_cast<CYElementValue *>(element));
 174         _assert(value != NULL);
 175         element = value->next_;
 176
 177         _assert(value->value_ != NULL);
 178         CYString *string(value->value_->String(context));
 179         if (string == NULL)
 180             CYThrow("string was actually %s", typeid(*value->value_).name());
 181
 182         CYUTF8String completion;
 183         if (string->size_ != 0)
 184             completion = {string->value_, string->size_};
 185         else if (driver.mode_ == CYDriver::AutoMessage)
 186             completion = "]";
 187         else
 188             continue;
 189
 190         completion.data += begin.size();
 191         completion.size -= begin.size();
 192
 193         if (CYStartsWith(completion, "$cy"))
 194             continue;
 195         completions.push_back(completion);
 196
 197         if (!rest) {
 198             common = completion;
 199             rest = true;
 200         } else {
 201             size_t limit(completion.size), size(common.size());
 202             if (size > limit)
 203                 common = common.substr(0, limit);
 204             else
 205                 limit = size;
 206             for (limit = 0; limit != size; ++limit)
 207                 if (common[limit] != completion.data[limit])
 208                     break;
 209             if (limit != size)
 210                 common = common.substr(0, limit);
 211         }
 212     }
 213
 214     size_t count(completions.size());
 215     if (count == 0)
 216         return NULL;
 217
 218     size_t colon(common.find(':'));
 219     if (colon != std::string::npos)
 220         common = common.substr(0, colon + 1);
 221     if (completions.size() == 1)
 222         common += ' ';
 223
 224     char **results(reinterpret_cast<char **>(malloc(sizeof(char *) * (count + 2))));
 225
 226     results[0] = strdup(common.c_str());
 227     size_t index(0);
 228     for (Completions::const_iterator i(completions.begin()); i != completions.end(); ++i)
 229         results[++index] = strdup(i->data);
 230     results[count + 1] = NULL;
 231
 232     return results;
 233 }