Merge pull request #198 from sparkprime/extensions

Native Extensions

Author: sparkprime

core/ast.h

@@ -308,11 +308,11 @@ struct Binary : public AST {
  * interpreter.
  */
 struct BuiltinFunction : public AST {
-    unsigned long id;
+    std::string name;
     Identifiers params;
-    BuiltinFunction(const LocationRange &lr, unsigned long id,
+    BuiltinFunction(const LocationRange &lr, const std::string &name,
                     const Identifiers &params)
-      : AST(lr, AST_BUILTIN_FUNCTION, Fodder{}), id(id), params(params)
+      : AST(lr, AST_BUILTIN_FUNCTION, Fodder{}), name(name), params(params)
     { }
 };
 

core/desugarer.cpp

@@ -26,7 +26,12 @@ static const Fodder EF;  // Empty fodder.
 
 static const LocationRange E;  // Empty.
 
-static unsigned long max_builtin = 24;
+struct BuiltinDecl {
+    String name;
+    std::vector<String> params;
+};
+
+static unsigned long max_builtin = 25;
 BuiltinDecl jsonnet_builtin_decl(unsigned long builtin)
 {
     switch (builtin) {
@@ -55,6 +60,7 @@ BuiltinDecl jsonnet_builtin_decl(unsigned long builtin)
         case 22: return {U"modulo", {U"a", U"b"}};
         case 23: return {U"extVar", {U"x"}};
         case 24: return {U"primitiveEquals", {U"a", U"b"}};
+        case 25: return {U"native", {U"name"}};
         default:
         std::cerr << "INTERNAL ERROR: Unrecognized builtin function: " << builtin << std::endl;
         std::abort();
@@ -761,7 +767,7 @@ class Desugarer {
             fields.emplace_back(
                 ObjectField::HIDDEN,
                 str(decl.name),
-                make<BuiltinFunction>(E, c, params));
+                make<BuiltinFunction>(E, encode_utf8(decl.name), params));
         }
         fields.emplace_back(
             ObjectField::HIDDEN,

core/formatter.cpp

@@ -343,7 +343,7 @@ class Unparser {
             unparse(ast->right, true);
 
         } else if (auto *ast = dynamic_cast<const BuiltinFunction*>(ast_)) {
-            o << "/* builtin " << ast->id << " */ null";
+            o << "/* builtin " << ast->name << " */ null";
 
         } else if (auto *ast = dynamic_cast<const Conditional*>(ast_)) {
             o << "if";
@@ -1724,10 +1724,8 @@ class FixIndentation {
             expr(ast->right, new_indent, true);
 
         } else if (auto *ast = dynamic_cast<BuiltinFunction*>(ast_)) {
-            std::stringstream ss;
-            ss << ast->id;
             column += 11;  // "/* builtin "
-            column += ss.str().length();
+            column += ast->name.length();
             column += 8;  // " */ null"
 
         } else if (auto *ast = dynamic_cast<Conditional*>(ast_)) {

core/json.h

@@ -0,0 +1,32 @@
+/*
+Copyright 2015 Google Inc. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef JSONNET_JSON_H
+#define JSONNET_JSON_H
+
+#include <string>
+
+#include <libjsonnet.h>
+
+struct JsonnetJsonValue {
+    enum Kind {
+        STRING
+    };
+    Kind kind;
+    std::string string;
+};
+
+#endif

core/libjsonnet.cpp

@@ -30,6 +30,7 @@ extern "C" {
 
 #include "desugarer.h"
 #include "formatter.h"
+#include "json.h"
 #include "parser.h"
 #include "static_analysis.h"
 #include "vm.h"
@@ -50,6 +51,25 @@ static char *from_string(JsonnetVm* vm, const std::string &v)
 static char *default_import_callback(void *ctx, const char *dir, const char *file,
                                      char **found_here_cptr, int *success);
 
+const char *jsonnet_json_extract_string(JsonnetVm *vm, const struct JsonnetJsonValue *v)
+{
+    (void) vm;
+    if (v->kind != JsonnetJsonValue::STRING)
+        return nullptr;
+    return v->string.c_str();
+}
+
+/** Convert the given UTF8 string to a JsonnetJsonValue.
+ */
+JsonnetJsonValue *jsonnet_json_make_string(JsonnetVm *vm, const char *v)
+{
+    (void) vm;
+    JsonnetJsonValue *r = new JsonnetJsonValue();
+    r->kind = JsonnetJsonValue::STRING;
+    r->string = v;
+    return r;
+}
+
 struct JsonnetVm {
     double gcGrowthTrigger;
     unsigned maxStack;
@@ -58,6 +78,7 @@ struct JsonnetVm {
     std::map<std::string, VmExt> ext;
     std::map<std::string, VmExt> tla;
     JsonnetImportCallback *importCallback;
+    VmNativeCallbackMap nativeCallbacks;
     void *importCallbackContext;
     bool stringOutput;
     std::vector<std::string> jpaths;
@@ -212,6 +233,16 @@ void jsonnet_import_callback(struct JsonnetVm *vm, JsonnetImportCallback *cb, vo
     vm->importCallbackContext = ctx;
 }
 
+void jsonnet_native_callback(struct JsonnetVm *vm, const char *name, JsonnetNativeCallback *cb,
+                             void *ctx, const char * const *params)
+{
+    std::vector<std::string> params2;
+    for (; *params != nullptr; params++)
+        params2.push_back(*params);
+    vm->nativeCallbacks[name] = VmNativeCallback {cb, ctx, params2};
+}
+
+
 void jsonnet_ext_var(JsonnetVm *vm, const char *key, const char *val)
 {
     vm->ext[key] = VmExt(val, false);
@@ -373,8 +404,8 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
             case REGULAR: {
                 std::string json_str = jsonnet_vm_execute(
                     &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->importCallback, vm->importCallbackContext,
-                    vm->stringOutput);
+                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
+                    vm->importCallbackContext, vm->stringOutput);
                 json_str += "\n";
                 *error = false;
                 return from_string(vm, json_str);
@@ -384,8 +415,8 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
             case MULTI: {
                 std::map<std::string, std::string> files = jsonnet_vm_execute_multi(
                     &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->importCallback, vm->importCallbackContext,
-                    vm->stringOutput);
+                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
+                    vm->importCallbackContext, vm->stringOutput);
                 size_t sz = 1; // final sentinel
                 for (const auto &pair : files) {
                     sz += pair.first.length() + 1; // include sentinel
@@ -413,7 +444,8 @@ static char *jsonnet_evaluate_snippet_aux(JsonnetVm *vm, const char *filename,
             case STREAM: {
                 std::vector<std::string> documents = jsonnet_vm_execute_stream(
                     &alloc, expr, vm->ext, vm->maxStack, vm->gcMinObjects,
-                    vm->gcGrowthTrigger, vm->importCallback, vm->importCallbackContext);
+                    vm->gcGrowthTrigger, vm->nativeCallbacks, vm->importCallback,
+                    vm->importCallbackContext);
                 size_t sz = 1; // final sentinel
                 for (const auto &doc : documents) {
                     sz += doc.length() + 2; // Add a '\n' as well as sentinel

core/libjsonnet_test_snippet.c

@@ -16,19 +16,40 @@ limitations under the License.
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 
 #include <libjsonnet.h>
 
+struct JsonnetJsonValue *concat(void *ctx, const struct JsonnetJsonValue * const *argv, int *succ)
+{
+    struct JsonnetVm *vm = (struct JsonnetVm *)ctx;
+    const char *a = jsonnet_json_extract_string(vm, argv[0]);
+    const char *b = jsonnet_json_extract_string(vm, argv[1]);
+    if (a == NULL || b == NULL) {
+        struct JsonnetJsonValue *r = jsonnet_json_make_string(vm, "Bad params.");
+        *succ = 0;
+        return r;
+    }
+    char *str = malloc(strlen(a) + strlen(b) + 1);
+    sprintf(str, "%s%s", a, b);
+    struct JsonnetJsonValue *r = jsonnet_json_make_string(vm, str);
+    free(str);
+    *succ = 1;
+    return r;
+}
+
 int main(int argc, const char **argv)
 {
     int error;
     char *output;
     struct JsonnetVm *vm;
+    const char *params[] = {"a", "b", NULL};
     if (argc != 2) {
         fprintf(stderr, "libjsonnet_test_snippet <string>\n");
         return EXIT_FAILURE;
     }
     vm = jsonnet_make();
+    jsonnet_native_callback(vm, "concat", concat, vm, params);
     output = jsonnet_evaluate_snippet(vm, "snippet", argv[1], &error);
     if (error) {
         fprintf(stderr, "%s", output);

core/parser.h

@@ -36,14 +36,6 @@ AST *jsonnet_parse(Allocator *alloc, Tokens &tokens);
  */
 std::string jsonnet_unparse_number(double v);
 
-struct BuiltinDecl {
-    String name;
-    std::vector<String> params;
-};
-
-/** Returns the signature of each built-in function. */
-BuiltinDecl jsonnet_builtin_decl(unsigned long builtin);
-
 /** The inverse of jsonnet_parse.
  */
 std::string jsonnet_unparse_jsonnet(const AST *ast, const Fodder &final_fodder, unsigned indent,

core/state.h

@@ -221,7 +221,7 @@ struct HeapComprehensionObject : public HeapLeafObject {
 
 /** Stores the function itself and also the captured environment.
  *
- * Either body is non-null and builtin is 0, or body is null and builtin refers to a built-in
+ * Either body is non-null and builtinName is "", or body is null and builtin refers to a built-in
  * function.  In the former case, the closure represents a user function, otherwise calling it
  * will trigger the builtin function to execute.  Params is empty when the function is a
  * builtin.
@@ -243,14 +243,14 @@ struct HeapClosure : public HeapEntity {
     typedef std::vector<Param> Params;
     const Params params;
     const AST *body;
-    const unsigned long builtin;
+    std::string builtinName;
     HeapClosure(const BindingFrame &up_values,
                 HeapObject *self,
                 unsigned offset,
                 const Params &params,
-                const AST *body, unsigned long builtin)
+                const AST *body, const std::string &builtin_name)
       : upValues(up_values), self(self), offset(offset),
-        params(params), body(body), builtin(builtin)
+        params(params), body(body), builtinName(builtin_name)
     { }
 };