4 * Copyright (C) 2007-2016 David Lutterkort
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * Author: David Lutterkort <dlutter@redhat.com>
31 #include <sys/types.h>
38 #include "transform.h"
41 /* Extension of source files */
42 #define AUG_EXT ".aug"
44 #define LNS_TYPE_CHECK(ctx) ((ctx)->aug->flags & AUG_TYPE_CHECK)
46 static const char *const builtin_module = "Builtin";
48 static const struct type string_type = { .ref = UINT_MAX, .tag = T_STRING };
49 static const struct type regexp_type = { .ref = UINT_MAX, .tag = T_REGEXP };
50 static const struct type lens_type = { .ref = UINT_MAX, .tag = T_LENS };
51 static const struct type tree_type = { .ref = UINT_MAX, .tag = T_TREE };
52 static const struct type filter_type = { .ref = UINT_MAX, .tag = T_FILTER };
53 static const struct type transform_type =
54 { .ref = UINT_MAX, .tag = T_TRANSFORM };
55 static const struct type unit_type = { .ref = UINT_MAX, .tag = T_UNIT };
57 const struct type *const t_string = &string_type;
58 const struct type *const t_regexp = ®exp_type;
59 const struct type *const t_lens = &lens_type;
60 const struct type *const t_tree = &tree_type;
61 const struct type *const t_filter = &filter_type;
62 const struct type *const t_transform = &transform_type;
63 const struct type *const t_unit = &unit_type;
65 static const char *const type_names[] = {
66 "string", "regexp", "lens", "tree", "filter",
67 "transform", "function", "unit", NULL
70 /* The anonymous identifier which we will never bind */
71 static const char anon_ident[] = "_";
73 static void print_value(FILE *out, struct value *v);
75 /* The evaluation context with all loaded modules and the bindings for the
76 * module we are working on in LOCAL
79 const char *name; /* The module we are working on */
81 struct binding *local;
84 static int init_fatal_exn(struct error *error) {
85 if (error->exn != NULL)
87 error->exn = make_exn_value(ref(error->info), "Error during evaluation");
88 if (error->exn == NULL)
90 error->exn->exn->seen = 1;
91 error->exn->exn->error = 1;
92 error->exn->exn->lines = NULL;
93 error->exn->exn->nlines = 0;
94 error->exn->ref = REF_MAX;
98 static void format_error(struct info *info, aug_errcode_t code,
99 const char *format, va_list ap) {
100 struct error *error = info->error;
101 char *si = NULL, *sf = NULL, *sd = NULL;
105 /* Only syntax errors are cumulative */
106 if (code != AUG_ESYNTAX)
107 FREE(error->details);
109 si = format_info(info);
110 r = vasprintf(&sf, format, ap);
113 if (error->details != NULL) {
114 r = xasprintf(&sd, "%s\n%s%s", error->details,
115 (si == NULL) ? "(no location)" : si,
116 (sf == NULL) ? "(no details)" : sf);
118 r = xasprintf(&sd, "%s%s",
119 (si == NULL) ? "(no location)" : si,
120 (sf == NULL) ? "(no details)" : sf);
123 free(error->details);
130 void syntax_error(struct info *info, const char *format, ...) {
131 struct error *error = info->error;
134 if (error->code != AUG_NOERROR && error->code != AUG_ESYNTAX)
137 va_start(ap, format);
138 format_error(info, AUG_ESYNTAX, format, ap);
142 void fatal_error(struct info *info, const char *format, ...) {
143 struct error *error = info->error;
146 if (error->code == AUG_EINTERNAL)
149 va_start(ap, format);
150 format_error(info, AUG_EINTERNAL, format, ap);
154 static void free_param(struct param *param) {
157 assert(param->ref == 0);
158 unref(param->info, info);
159 unref(param->name, string);
160 unref(param->type, type);
164 void free_term(struct term *term) {
167 assert(term->ref == 0);
171 free(term->autoload);
172 unref(term->decls, term);
176 unref(term->exp, term);
184 unref(term->left, term);
185 unref(term->right, term);
188 unref(term->value, value);
191 unref(term->ident, string);
194 unref(term->brexp, term);
197 unref(term->param, param);
198 unref(term->body, term);
201 unref(term->rexp, term);
204 unref(term->test, term);
205 unref(term->result, term);
211 unref(term->next, term);
212 unref(term->info, info);
213 unref(term->type, type);
217 static void free_binding(struct binding *binding) {
220 assert(binding->ref == 0);
221 unref(binding->next, binding);
222 unref(binding->ident, string);
223 unref(binding->type, type);
224 unref(binding->value, value);
228 void free_module(struct module *module) {
231 assert(module->ref == 0);
233 unref(module->next, module);
234 unref(module->bindings, binding);
235 unref(module->autoload, transform);
239 void free_type(struct type *type) {
242 assert(type->ref == 0);
244 if (type->tag == T_ARROW) {
245 unref(type->dom, type);
246 unref(type->img, type);
251 static void free_exn(struct exn *exn) {
255 unref(exn->info, info);
257 for (int i=0; i < exn->nlines; i++) {
264 void free_value(struct value *v) {
271 unref(v->string, string);
274 unref(v->regexp, regexp);
277 unref(v->lens, lens);
280 free_tree(v->origin);
283 unref(v->filter, filter);
286 unref(v->transform, transform);
290 unref(v->native->type, type);
294 unref(v->func, term);
295 unref(v->bindings, binding);
305 unref(v->info, info);
310 * Creation of (some) terms. Others are in parser.y
311 * Reference counted arguments are now owned by the returned object, i.e.
312 * the make_* functions do not increment the count.
313 * Returned objects have a referece count of 1.
315 struct term *make_term(enum term_tag tag, struct info *info) {
317 if (make_ref(term) < 0) {
326 struct term *make_param(char *name, struct type *type, struct info *info) {
327 struct term *term = make_term(A_FUNC, info);
330 make_ref_err(term->param);
331 term->param->info = ref(term->info);
332 make_ref_err(term->param->name);
333 term->param->name->str = name;
334 term->param->type = type;
341 struct value *make_value(enum value_tag tag, struct info *info) {
342 struct value *value = NULL;
343 if (make_ref(value) < 0) {
352 struct value *make_unit(struct info *info) {
353 return make_value(V_UNIT, info);
356 struct term *make_app_term(struct term *lambda, struct term *arg,
358 struct term *app = make_term(A_APP, info);
369 struct term *make_app_ident(char *id, struct term *arg, struct info *info) {
370 struct term *ident = make_term(A_IDENT, ref(info));
371 ident->ident = make_string(id);
372 if (ident->ident == NULL) {
378 return make_app_term(ident, arg, info);
381 struct term *build_func(struct term *params, struct term *exp) {
382 assert(params->tag == A_FUNC);
383 if (params->next != NULL)
384 exp = build_func(params->next, exp);
391 /* Ownership is taken as needed */
392 static struct value *make_closure(struct term *func, struct binding *bnds) {
393 struct value *v = NULL;
394 if (make_ref(v) == 0) {
396 v->info = ref(func->info);
398 v->bindings = ref(bnds);
403 struct value *make_exn_value(struct info *info,
404 const char *format, ...) {
410 va_start(ap, format);
411 r = vasprintf(&message, format, ap);
416 v = make_value(V_EXN, ref(info));
417 if (ALLOC(v->exn) < 0)
418 return info->error->exn;
420 v->exn->message = message;
425 void exn_add_lines(struct value *v, int nlines, ...) {
426 assert(v->tag == V_EXN);
429 if (REALLOC_N(v->exn->lines, v->exn->nlines + nlines) == -1)
431 va_start(ap, nlines);
432 for (int i=0; i < nlines; i++) {
433 char *line = va_arg(ap, char *);
434 v->exn->lines[v->exn->nlines + i] = line;
437 v->exn->nlines += nlines;
440 void exn_printf_line(struct value *exn, const char *format, ...) {
445 va_start(ap, format);
446 r = vasprintf(&line, format, ap);
449 exn_add_lines(exn, 1, line);
455 static int load_module(struct augeas *aug, const char *name);
456 static char *module_basename(const char *modname);
458 struct module *module_create(const char *name) {
459 struct module *module;
461 module->name = strdup(name);
465 static struct module *module_find(struct module *module, const char *name) {
466 list_for_each(e, module) {
467 if (STRCASEEQ(e->name, name))
473 static struct binding *bnd_lookup(struct binding *bindings, const char *name) {
474 list_for_each(b, bindings) {
475 if (STREQ(b->ident->str, name))
481 static char *modname_of_qname(const char *qname) {
482 char *dot = strchr(qname, '.');
486 return strndup(qname, dot - qname);
489 static int lookup_internal(struct augeas *aug, const char *ctx_modname,
490 const char *name, struct binding **bnd) {
491 char *modname = modname_of_qname(name);
495 if (modname == NULL) {
496 struct module *builtin =
497 module_find(aug->modules, builtin_module);
498 assert(builtin != NULL);
499 *bnd = bnd_lookup(builtin->bindings, name);
504 list_for_each(module, aug->modules) {
505 if (STRCASEEQ(module->name, modname)) {
506 *bnd = bnd_lookup(module->bindings, name + strlen(modname) + 1);
511 /* Try to load the module */
512 if (streqv(modname, ctx_modname)) {
516 int loaded = load_module(aug, modname) == 0;
524 struct lens *lens_lookup(struct augeas *aug, const char *qname) {
525 struct binding *bnd = NULL;
527 if (lookup_internal(aug, NULL, qname, &bnd) < 0)
529 if (bnd == NULL || bnd->value->tag != V_LENS)
531 return bnd->value->lens;
534 static struct binding *ctx_lookup_bnd(struct info *info,
535 struct ctx *ctx, const char *name) {
536 struct binding *b = NULL;
537 int nlen = strlen(ctx->name);
539 if (STREQLEN(ctx->name, name, nlen) && name[nlen] == '.')
542 b = bnd_lookup(ctx->local, name);
546 if (ctx->aug != NULL) {
548 r = lookup_internal(ctx->aug, ctx->name, name, &b);
551 char *modname = modname_of_qname(name);
552 syntax_error(info, "Could not load module %s for %s",
560 static struct value *ctx_lookup(struct info *info,
561 struct ctx *ctx, struct string *ident) {
562 struct binding *b = ctx_lookup_bnd(info, ctx, ident->str);
563 return b == NULL ? NULL : b->value;
566 static struct type *ctx_lookup_type(struct info *info,
567 struct ctx *ctx, struct string *ident) {
568 struct binding *b = ctx_lookup_bnd(info, ctx, ident->str);
569 return b == NULL ? NULL : b->type;
572 /* Takes ownership as needed */
573 static struct binding *bind_type(struct binding **bnds,
574 const char *name, struct type *type) {
575 struct binding *binding;
577 if (STREQ(name, anon_ident))
580 make_ref(binding->ident);
581 binding->ident->str = strdup(name);
582 binding->type = ref(type);
583 list_cons(*bnds, binding);
588 /* Takes ownership as needed */
589 static void bind_param(struct binding **bnds, struct param *param,
593 b->ident = ref(param->name);
594 b->type = ref(param->type);
600 static void unbind_param(struct binding **bnds, ATTRIBUTE_UNUSED struct param *param) {
601 struct binding *b = *bnds;
602 assert(b->ident == param->name);
603 assert(b->next != *bnds);
608 /* Takes ownership of VALUE */
609 static void bind(struct binding **bnds,
610 const char *name, struct type *type, struct value *value) {
611 struct binding *b = NULL;
613 if (STRNEQ(name, anon_ident)) {
614 b = bind_type(bnds, name, type);
615 b->value = ref(value);
620 * Some debug printing
623 static char *type_string(struct type *t);
625 static void dump_bindings(struct binding *bnds) {
626 list_for_each(b, bnds) {
627 char *st = type_string(b->type);
628 fprintf(stderr, " %s: %s", b->ident->str, st);
629 fprintf(stderr, " = ");
630 print_value(stderr, b->value);
636 static void dump_module(struct module *module) {
639 fprintf(stderr, "Module %s\n:", module->name);
640 dump_bindings(module->bindings);
641 dump_module(module->next);
645 static void dump_ctx(struct ctx *ctx) {
646 fprintf(stderr, "Context: %s\n", ctx->name);
647 dump_bindings(ctx->local);
648 if (ctx->aug != NULL) {
649 list_for_each(m, ctx->aug->modules)
657 void print_tree_braces(FILE *out, int indent, struct tree *tree) {
659 fprintf(out, "(null tree)\n");
662 list_for_each(t, tree) {
663 for (int i=0; i < indent; i++) fputc(' ', out);
665 if (t->label != NULL)
666 fprintf(out, "\"%s\"", t->label);
667 if (t->value != NULL)
668 fprintf(out, " = \"%s\"", t->value);
669 if (t->children != NULL) {
671 print_tree_braces(out, indent + 2, t->children);
672 for (int i=0; i < indent; i++) fputc(' ', out);
680 static void print_value(FILE *out, struct value *v) {
682 fprintf(out, "<null>");
688 fprintf(out, "\"%s\"", v->string->str);
691 fprintf(out, "/%s/", v->regexp->pattern->str);
694 fprintf(out, "<lens:");
695 print_info(out, v->lens->info);
699 print_tree_braces(out, 0, v->origin);
702 fprintf(out, "<filter:");
703 list_for_each(f, v->filter) {
704 fprintf(out, "%c%s%c", f->include ? '+' : '-', f->glob->str,
705 (f->next != NULL) ? ':' : '>');
709 fprintf(out, "<transform:");
710 print_info(out, v->transform->lens->info);
714 fprintf(out, "<native:");
715 print_info(out, v->info);
719 fprintf(out, "<closure:");
720 print_info(out, v->func->info);
724 if (! v->exn->seen) {
725 print_info(out, v->exn->info);
726 fprintf(out, "exception: %s\n", v->exn->message);
727 for (int i=0; i < v->exn->nlines; i++) {
728 fprintf(out, " %s\n", v->exn->lines[i]);
742 static int value_equal(struct value *v1, struct value *v2) {
743 if (v1 == NULL && v2 == NULL)
745 if (v1 == NULL || v2 == NULL)
747 if (v1->tag != v2->tag)
751 return STREQ(v1->string->str, v2->string->str);
754 // FIXME: Should probably build FA's and compare them
755 return STREQ(v1->regexp->pattern->str, v2->regexp->pattern->str);
758 return v1->lens == v2->lens;
761 return tree_equal(v1->origin->children, v2->origin->children);
764 return v1->filter == v2->filter;
767 return v1->transform == v2->transform;
770 return v1->native == v2->native;
773 return v1->func == v2->func && v1->bindings == v2->bindings;
785 struct type *make_arrow_type(struct type *dom, struct type *img) {
789 type->dom = ref(dom);
790 type->img = ref(img);
794 struct type *make_base_type(enum type_tag tag) {
796 return (struct type *) t_string;
797 else if (tag == T_REGEXP)
798 return (struct type *) t_regexp;
799 else if (tag == T_LENS)
800 return (struct type *) t_lens;
801 else if (tag == T_TREE)
802 return (struct type *) t_tree;
803 else if (tag == T_FILTER)
804 return (struct type *) t_filter;
805 else if (tag == T_TRANSFORM)
806 return (struct type *) t_transform;
807 else if (tag == T_UNIT)
808 return (struct type *) t_unit;
813 static const char *type_name(struct type *t) {
814 for (int i = 0; type_names[i] != NULL; i++)
816 return type_names[i];
821 static char *type_string(struct type *t) {
822 if (t->tag == T_ARROW) {
825 char *sd = type_string(t->dom);
826 char *si = type_string(t->img);
827 if (t->dom->tag == T_ARROW)
828 r = asprintf(&s, "(%s) -> %s", sd, si);
830 r = asprintf(&s, "%s -> %s", sd, si);
833 return (r == -1) ? NULL : s;
835 return strdup(type_name(t));
839 /* Decide whether T1 is a subtype of T2. The only subtype relations are
840 * T_STRING <: T_REGEXP and the usual subtyping of functions based on
841 * comparing domains/images
843 * Return 1 if T1 is a subtype of T2, 0 otherwise
845 static int subtype(struct type *t1, struct type *t2) {
848 /* We only promote T_STRING => T_REGEXP, no automatic conversion
849 of strings/regexps to lenses (yet) */
850 if (t1->tag == T_STRING)
851 return (t2->tag == T_STRING || t2->tag == T_REGEXP);
852 if (t1->tag == T_ARROW && t2->tag == T_ARROW) {
853 return subtype(t2->dom, t1->dom)
854 && subtype(t1->img, t2->img);
856 return t1->tag == t2->tag;
859 static int type_equal(struct type *t1, struct type *t2) {
860 return (t1 == t2) || (subtype(t1, t2) && subtype(t2, t1));
863 /* Return a type T with subtype(T, T1) && subtype(T, T2) */
864 static struct type *type_meet(struct type *t1, struct type *t2);
866 /* Return a type T with subtype(T1, T) && subtype(T2, T) */
867 static struct type *type_join(struct type *t1, struct type *t2) {
868 if (t1->tag == T_STRING) {
869 if (t2->tag == T_STRING)
871 else if (t2->tag == T_REGEXP)
873 } else if (t1->tag == T_REGEXP) {
874 if (t2->tag == T_STRING || t2->tag == T_REGEXP)
876 } else if (t1->tag == T_ARROW) {
877 if (t2->tag != T_ARROW)
879 struct type *dom = type_meet(t1->dom, t2->dom);
880 struct type *img = type_join(t1->img, t2->img);
881 if (dom == NULL || img == NULL) {
886 return make_arrow_type(dom, img);
887 } else if (type_equal(t1, t2)) {
893 /* Return a type T with subtype(T, T1) && subtype(T, T2) */
894 static struct type *type_meet(struct type *t1, struct type *t2) {
895 if (t1->tag == T_STRING) {
896 if (t2->tag == T_STRING || t2->tag == T_REGEXP)
898 } else if (t1->tag == T_REGEXP) {
899 if (t2->tag == T_STRING || t2->tag == T_REGEXP)
901 } else if (t1->tag == T_ARROW) {
902 if (t2->tag != T_ARROW)
904 struct type *dom = type_join(t1->dom, t2->dom);
905 struct type *img = type_meet(t1->img, t2->img);
906 if (dom == NULL || img == NULL) {
911 return make_arrow_type(dom, img);
912 } else if (type_equal(t1, t2)) {
918 static struct type *value_type(struct value *v) {
921 return make_base_type(T_STRING);
923 return make_base_type(T_REGEXP);
925 return make_base_type(T_LENS);
927 return make_base_type(T_TREE);
929 return make_base_type(T_FILTER);
931 return make_base_type(T_TRANSFORM);
933 return make_base_type(T_UNIT);
935 return ref(v->native->type);
937 return ref(v->func->type);
938 case V_EXN: /* Fail on exceptions */
945 /* Coerce V to the type T. Currently, only T_STRING can be coerced to
946 * T_REGEXP. Returns a value that is owned by the caller. Trying to perform
947 * an impossible coercion is a fatal error. Receives ownership of V.
949 static struct value *coerce(struct value *v, struct type *t) {
950 struct type *vt = value_type(v);
951 if (type_equal(vt, t)) {
955 if (vt->tag == T_STRING && t->tag == T_REGEXP) {
956 struct value *rxp = make_value(V_REGEXP, ref(v->info));
957 rxp->regexp = make_regexp_literal(v->info, v->string->str);
958 if (rxp->regexp == NULL) {
959 report_error(v->info->error, AUG_ENOMEM, NULL);
965 return make_exn_value(v->info, "Type %s can not be coerced to %s",
966 type_name(vt), type_name(t));
969 /* Return one of the expected types (passed as ...).
970 Does not give ownership of the returned type */
971 static struct type *expect_types_arr(struct info *info,
973 int ntypes, struct type *allowed[]) {
974 struct type *result = NULL;
976 for (int i=0; i < ntypes; i++) {
977 if (subtype(act, allowed[i])) {
982 if (result == NULL) {
984 for (int i=0; i < ntypes; i++) {
985 len += strlen(type_name(allowed[i]));
987 len += (ntypes - 1) * 4 + 1;
989 if (ALLOC_N(allowed_names, len) < 0)
991 for (int i=0; i < ntypes; i++) {
993 strcat(allowed_names, (i == ntypes - 1) ? ", or " : ", ");
994 strcat(allowed_names, type_name(allowed[i]));
996 char *act_str = type_string(act);
997 syntax_error(info, "type error: expected %s but found %s",
998 allowed_names, act_str);
1000 free(allowed_names);
1005 static struct type *expect_types(struct info *info,
1006 struct type *act, int ntypes, ...) {
1008 struct type *allowed[ntypes];
1010 va_start(ap, ntypes);
1011 for (int i=0; i < ntypes; i++)
1012 allowed[i] = va_arg(ap, struct type *);
1014 return expect_types_arr(info, act, ntypes, allowed);
1017 static struct value *apply(struct term *app, struct ctx *ctx);
1019 typedef struct value *(*impl0)(struct info *);
1020 typedef struct value *(*impl1)(struct info *, struct value *);
1021 typedef struct value *(*impl2)(struct info *, struct value *, struct value *);
1022 typedef struct value *(*impl3)(struct info *, struct value *, struct value *,
1024 typedef struct value *(*impl4)(struct info *, struct value *, struct value *,
1025 struct value *, struct value *);
1026 typedef struct value *(*impl5)(struct info *, struct value *, struct value *,
1027 struct value *, struct value *, struct value *);
1029 static struct value *native_call(struct info *info,
1030 struct native *func, struct ctx *ctx) {
1031 struct value *argv[func->argc + 1];
1032 struct binding *b = ctx->local;
1034 for (int i = func->argc - 1; i >= 0; i--) {
1038 argv[func->argc] = NULL;
1040 return func->impl(info, argv);
1043 static void type_error1(struct info *info, const char *msg, struct type *type) {
1044 char *s = type_string(type);
1045 syntax_error(info, "Type error: ");
1046 syntax_error(info, msg, s);
1050 static void type_error2(struct info *info, const char *msg,
1051 struct type *type1, struct type *type2) {
1052 char *s1 = type_string(type1);
1053 char *s2 = type_string(type2);
1054 syntax_error(info, "Type error: ");
1055 syntax_error(info, msg, s1, s2);
1060 static void type_error_binop(struct info *info, const char *opname,
1061 struct type *type1, struct type *type2) {
1062 char *s1 = type_string(type1);
1063 char *s2 = type_string(type2);
1064 syntax_error(info, "Type error: ");
1065 syntax_error(info, "%s of %s and %s is not possible", opname, s1, s2);
1070 static int check_exp(struct term *term, struct ctx *ctx);
1072 static struct type *require_exp_type(struct term *term, struct ctx *ctx,
1073 int ntypes, struct type *allowed[]) {
1076 if (term->type == NULL) {
1077 r = check_exp(term, ctx);
1082 return expect_types_arr(term->info, term->type, ntypes, allowed);
1085 static int check_compose(struct term *term, struct ctx *ctx) {
1086 struct type *tl = NULL, *tr = NULL;
1088 if (! check_exp(term->left, ctx))
1090 tl = term->left->type;
1092 if (tl->tag == T_ARROW) {
1093 /* Composition of functions f: a -> b and g: c -> d is defined as
1094 (f . g) x = g (f x) and is type correct if b <: c yielding a
1095 function with type a -> d */
1096 if (! check_exp(term->right, ctx))
1098 tr = term->right->type;
1099 if (tr->tag != T_ARROW)
1101 if (! subtype(tl->img, tr->dom))
1103 term->type = make_arrow_type(tl->dom, tr->img);
1104 } else if (tl->tag == T_UNIT) {
1105 if (! check_exp(term->right, ctx))
1107 term->type = ref(term->right->type);
1113 type_error_binop(term->info,
1114 "composition", term->left->type, term->right->type);
1118 static int check_binop(const char *opname, struct term *term,
1119 struct ctx *ctx, int ntypes, ...) {
1121 struct type *allowed[ntypes];
1122 struct type *tl = NULL, *tr = NULL;
1124 va_start(ap, ntypes);
1125 for (int i=0; i < ntypes; i++)
1126 allowed[i] = va_arg(ap, struct type *);
1129 tl = require_exp_type(term->left, ctx, ntypes, allowed);
1133 tr = require_exp_type(term->right, ctx, ntypes, allowed);
1137 term->type = type_join(tl, tr);
1138 if (term->type == NULL)
1142 type_error_binop(term->info, opname, term->left->type, term->right->type);
1146 static int check_value(struct term *term) {
1148 struct value *v = term->value;
1150 if (v->tag == V_REGEXP) {
1151 /* The only literal that needs checking are regular expressions,
1152 where we need to make sure the regexp is syntactically
1154 if (regexp_check(v->regexp, &msg) == -1) {
1155 syntax_error(v->info, "Invalid regular expression: %s", msg);
1158 term->type = make_base_type(T_REGEXP);
1159 } else if (v->tag == V_EXN) {
1160 /* Exceptions can't be typed */
1163 /* There are cases where we generate values internally, and
1164 those have their type already set; we don't want to
1166 if (term->type == NULL) {
1167 term->type = value_type(v);
1173 /* Return 1 if TERM passes, 0 otherwise */
1174 static int check_exp(struct term *term, struct ctx *ctx) {
1176 assert(term->type == NULL || term->tag == A_VALUE || term->ref > 1);
1177 if (term->type != NULL && term->tag != A_VALUE)
1180 switch (term->tag) {
1182 result = check_binop("union", term, ctx, 2, t_regexp, t_lens);
1185 result = check_binop("minus", term, ctx, 1, t_regexp);
1188 result = check_compose(term, ctx);
1191 result = check_binop("concatenation", term, ctx,
1192 4, t_string, t_regexp, t_lens, t_filter);
1196 result = check_exp(term->right, ctx);
1198 struct term *func = term->left;
1199 assert(func->tag == A_FUNC);
1200 assert(func->param->type == NULL);
1201 func->param->type = ref(term->right->type);
1203 result = check_exp(func, ctx);
1206 term->type = ref(func->type->img);
1212 result = check_exp(term->left, ctx) & check_exp(term->right, ctx);
1214 if (term->left->type->tag != T_ARROW) {
1215 type_error1(term->info,
1216 "expected function in application but found %s",
1222 result = expect_types(term->info,
1224 1, term->left->type->dom) != NULL;
1226 type_error_binop(term->info, "application",
1227 term->left->type, term->right->type);
1232 term->type = ref(term->left->type->img);
1235 result = check_value(term);
1239 struct type *t = ctx_lookup_type(term->info, ctx, term->ident);
1241 syntax_error(term->info, "Undefined variable %s",
1245 term->type = ref(t);
1250 result = check_exp(term->brexp, ctx);
1252 term->type = ref(expect_types(term->info, term->brexp->type,
1254 if (term->type == NULL) {
1255 type_error1(term->info,
1256 "[..] is only defined for lenses, not for %s",
1264 bind_param(&ctx->local, term->param, NULL);
1265 result = check_exp(term->body, ctx);
1268 make_arrow_type(term->param->type, term->body->type);
1270 unbind_param(&ctx->local, term->param);
1274 result = check_exp(term->exp, ctx);
1276 term->type = ref(expect_types(term->info, term->exp->type, 2,
1278 if (term->type == NULL) {
1279 type_error1(term->info,
1280 "Incompatible types: repetition is only defined"
1281 " for regexp and lens, not for %s",
1291 assert(!result || term->type != NULL);
1295 static int check_decl(struct term *term, struct ctx *ctx) {
1296 assert(term->tag == A_BIND || term->tag == A_TEST);
1298 if (term->tag == A_BIND) {
1299 if (!check_exp(term->exp, ctx))
1301 term->type = ref(term->exp->type);
1303 if (bnd_lookup(ctx->local, term->bname) != NULL) {
1304 syntax_error(term->info,
1305 "the name %s is already defined", term->bname);
1308 bind_type(&ctx->local, term->bname, term->type);
1309 } else if (term->tag == A_TEST) {
1310 if (!check_exp(term->test, ctx))
1312 if (term->result != NULL) {
1313 if (!check_exp(term->result, ctx))
1315 if (! type_equal(term->test->type, term->result->type)) {
1316 type_error2(term->info,
1317 "expected test result of type %s but got %s",
1318 term->result->type, term->test->type);
1322 if (expect_types(term->info, term->test->type, 2,
1323 t_string, t_tree) == NULL)
1326 term->type = ref(term->test->type);
1333 static int typecheck(struct term *term, struct augeas *aug) {
1337 const char *basenam;
1339 assert(term->tag == A_MODULE);
1341 /* Check that the module name is consistent with the filename */
1342 fname = module_basename(term->mname);
1344 basenam = strrchr(term->info->filename->str, SEP);
1345 if (basenam == NULL)
1346 basenam = term->info->filename->str;
1349 if (STRNEQ(fname, basenam)) {
1350 syntax_error(term->info,
1351 "The module %s must be in a file named %s",
1352 term->mname, fname);
1360 ctx.name = term->mname;
1361 list_for_each(dcl, term->decls) {
1362 ok &= check_decl(dcl, &ctx);
1364 unref(ctx.local, binding);
1368 static struct value *compile_exp(struct info *, struct term *, struct ctx *);
1370 static struct value *compile_union(struct term *exp, struct ctx *ctx) {
1371 struct value *v1 = compile_exp(exp->info, exp->left, ctx);
1374 struct value *v2 = compile_exp(exp->info, exp->right, ctx);
1380 struct type *t = exp->type;
1381 struct info *info = exp->info;
1382 struct value *v = NULL;
1393 if (t->tag == T_REGEXP) {
1394 v = make_value(V_REGEXP, ref(info));
1395 v->regexp = regexp_union(info, v1->regexp, v2->regexp);
1396 } else if (t->tag == T_LENS) {
1397 struct lens *l1 = v1->lens;
1398 struct lens *l2 = v2->lens;
1399 v = lns_make_union(ref(info), ref(l1), ref(l2), LNS_TYPE_CHECK(ctx));
1401 fatal_error(info, "Tried to union a %s and a %s to yield a %s",
1402 type_name(exp->left->type), type_name(exp->right->type),
1410 static struct value *compile_minus(struct term *exp, struct ctx *ctx) {
1411 struct value *v1 = compile_exp(exp->info, exp->left, ctx);
1414 struct value *v2 = compile_exp(exp->info, exp->right, ctx);
1420 struct type *t = exp->type;
1421 struct info *info = exp->info;
1426 if (t->tag == T_REGEXP) {
1427 struct regexp *re1 = v1->regexp;
1428 struct regexp *re2 = v2->regexp;
1429 struct regexp *re = regexp_minus(info, re1, re2);
1431 v = make_exn_value(ref(info),
1432 "Regular expression subtraction 'r1 - r2' failed");
1433 exn_printf_line(v, "r1: /%s/", re1->pattern->str);
1434 exn_printf_line(v, "r2: /%s/", re2->pattern->str);
1436 v = make_value(V_REGEXP, ref(info));
1441 fatal_error(info, "Tried to subtract a %s and a %s to yield a %s",
1442 type_name(exp->left->type), type_name(exp->right->type),
1450 static struct value *compile_compose(struct term *exp, struct ctx *ctx) {
1451 struct info *info = exp->info;
1454 if (exp->left->type->tag == T_ARROW) {
1455 // FIXME: This is really crufty, and should be desugared in the
1456 // parser so that we don't have to do all this manual type
1457 // computation. Should we write function compostion as
1458 // concatenation instead of using a separate syntax ?
1460 /* Build lambda x: exp->right (exp->left x) as a closure */
1461 char *var = strdup("@0");
1462 struct term *func = make_param(var, ref(exp->left->type->dom),
1464 func->type = make_arrow_type(exp->left->type->dom,
1465 exp->right->type->img);
1466 struct term *ident = make_term(A_IDENT, ref(info));
1467 ident->ident = ref(func->param->name);
1468 ident->type = ref(func->param->type);
1469 struct term *app = make_app_term(ref(exp->left), ident, ref(info));
1470 app->type = ref(app->left->type->img);
1471 app = make_app_term(ref(exp->right), app, ref(info));
1472 app->type = ref(app->right->type->img);
1474 build_func(func, app);
1476 if (!type_equal(func->type, exp->type)) {
1477 char *f = type_string(func->type);
1478 char *e = type_string(exp->type);
1480 "Composition has type %s but should have type %s", f, e);
1484 return info->error->exn;
1486 v = make_closure(func, ctx->local);
1489 v = compile_exp(exp->info, exp->left, ctx);
1491 v = compile_exp(exp->info, exp->right, ctx);
1496 static struct value *compile_concat(struct term *exp, struct ctx *ctx) {
1497 struct value *v1 = compile_exp(exp->info, exp->left, ctx);
1500 struct value *v2 = compile_exp(exp->info, exp->right, ctx);
1506 struct type *t = exp->type;
1507 struct info *info = exp->info;
1512 if (t->tag == T_STRING) {
1513 const char *s1 = v1->string->str;
1514 const char *s2 = v2->string->str;
1515 v = make_value(V_STRING, ref(info));
1516 make_ref(v->string);
1517 if (ALLOC_N(v->string->str, strlen(s1) + strlen(s2) + 1) < 0)
1519 char *s = v->string->str;
1522 } else if (t->tag == T_REGEXP) {
1523 v = make_value(V_REGEXP, ref(info));
1524 v->regexp = regexp_concat(info, v1->regexp, v2->regexp);
1525 } else if (t->tag == T_FILTER) {
1526 struct filter *f1 = v1->filter;
1527 struct filter *f2 = v2->filter;
1528 v = make_value(V_FILTER, ref(info));
1529 if (v2->ref == 1 && f2->ref == 1) {
1530 list_append(f2, ref(f1));
1531 v->filter = ref(f2);
1532 } else if (v1->ref == 1 && f1->ref == 1) {
1533 list_append(f1, ref(f2));
1534 v->filter = ref(f1);
1536 struct filter *cf1, *cf2;
1537 cf1 = make_filter(ref(f1->glob), f1->include);
1538 cf2 = make_filter(ref(f2->glob), f2->include);
1539 cf1->next = ref(f1->next);
1540 cf2->next = ref(f2->next);
1541 list_append(cf1, cf2);
1544 } else if (t->tag == T_LENS) {
1545 struct lens *l1 = v1->lens;
1546 struct lens *l2 = v2->lens;
1547 v = lns_make_concat(ref(info), ref(l1), ref(l2), LNS_TYPE_CHECK(ctx));
1550 fatal_error(info, "Tried to concat a %s and a %s to yield a %s",
1551 type_name(exp->left->type), type_name(exp->right->type),
1558 return exp->info->error->exn;
1561 static struct value *apply(struct term *app, struct ctx *ctx) {
1562 struct value *f = compile_exp(app->info, app->left, ctx);
1563 struct value *result = NULL;
1569 struct value *arg = compile_exp(app->info, app->right, ctx);
1575 assert(f->tag == V_CLOS);
1577 lctx.aug = ctx->aug;
1578 lctx.local = ref(f->bindings);
1579 lctx.name = ctx->name;
1581 arg = coerce(arg, f->func->param->type);
1585 bind_param(&lctx.local, f->func->param, arg);
1586 result = compile_exp(app->info, f->func->body, &lctx);
1587 unref(result->info, info);
1588 result->info = ref(app->info);
1589 unbind_param(&lctx.local, f->func->param);
1592 unref(lctx.local, binding);
1598 static struct value *compile_bracket(struct term *exp, struct ctx *ctx) {
1599 struct value *arg = compile_exp(exp->info, exp->brexp, ctx);
1602 assert(arg->tag == V_LENS);
1604 struct value *v = lns_make_subtree(ref(exp->info), ref(arg->lens));
1610 static struct value *compile_rep(struct term *rep, struct ctx *ctx) {
1611 struct value *arg = compile_exp(rep->info, rep->rexp, ctx);
1612 struct value *v = NULL;
1617 arg = coerce(arg, rep->type);
1618 if (rep->type->tag == T_REGEXP) {
1620 if (rep->quant == Q_STAR) {
1622 } else if (rep->quant == Q_PLUS) {
1624 } else if (rep->quant == Q_MAYBE) {
1630 v = make_value(V_REGEXP, ref(rep->info));
1631 v->regexp = regexp_iter(rep->info, arg->regexp, min, max);
1632 } else if (rep->type->tag == T_LENS) {
1633 int c = LNS_TYPE_CHECK(ctx);
1634 if (rep->quant == Q_STAR) {
1635 v = lns_make_star(ref(rep->info), ref(arg->lens), c);
1636 } else if (rep->quant == Q_PLUS) {
1637 v = lns_make_plus(ref(rep->info), ref(arg->lens), c);
1638 } else if (rep->quant == Q_MAYBE) {
1639 v = lns_make_maybe(ref(rep->info), ref(arg->lens), c);
1644 fatal_error(rep->info, "Tried to repeat a %s to yield a %s",
1645 type_name(rep->rexp->type), type_name(rep->type));
1651 static struct value *compile_exp(struct info *info,
1652 struct term *exp, struct ctx *ctx) {
1653 struct value *v = NULL;
1657 v = compile_compose(exp, ctx);
1660 v = compile_union(exp, ctx);
1663 v = compile_minus(exp, ctx);
1666 v = compile_concat(exp, ctx);
1669 v = apply(exp, ctx);
1672 if (exp->value->tag == V_NATIVE) {
1673 v = native_call(info, exp->value->native, ctx);
1675 v = ref(exp->value);
1679 v = ref(ctx_lookup(exp->info, ctx, exp->ident));
1682 v = compile_bracket(exp, ctx);
1685 v = make_closure(exp, ctx->local);
1688 v = compile_rep(exp, ctx);
1698 static int compile_test(struct term *term, struct ctx *ctx) {
1699 struct value *actual = compile_exp(term->info, term->test, ctx);
1700 struct value *expect = NULL;
1703 if (term->tr_tag == TR_EXN) {
1705 print_info(stdout, term->info);
1706 printf("Test run should have produced exception, but produced\n");
1707 print_value(stdout, actual);
1713 print_info(stdout, term->info);
1714 printf("exception thrown in test\n");
1715 print_value(stdout, actual);
1718 } else if (term->tr_tag == TR_CHECK) {
1719 expect = compile_exp(term->info, term->result, ctx);
1722 if (! value_equal(actual, expect)) {
1723 printf("Test failure:");
1724 print_info(stdout, term->info);
1726 printf(" Expected:\n");
1727 print_value(stdout, expect);
1729 printf(" Actual:\n");
1730 print_value(stdout, actual);
1735 printf("Test result: ");
1736 print_info(stdout, term->info);
1738 if (actual->tag == V_TREE) {
1739 print_tree_braces(stdout, 2, actual->origin->children);
1741 print_value(stdout, actual);
1747 reset_error(term->info->error);
1748 unref(actual, value);
1749 unref(expect, value);
1753 static int compile_decl(struct term *term, struct ctx *ctx) {
1754 if (term->tag == A_BIND) {
1757 struct value *v = compile_exp(term->info, term->exp, ctx);
1758 bind(&ctx->local, term->bname, term->type, v);
1760 if (EXN(v) && !v->exn->seen) {
1761 struct error *error = term->info->error;
1762 struct memstream ms;
1764 init_memstream(&ms);
1766 syntax_error(term->info, "Failed to compile %s",
1768 fprintf(ms.stream, "%s\n", error->details);
1769 print_value(ms.stream, v);
1770 close_memstream(&ms);
1773 free(error->details);
1774 error->details = ms.buf;
1776 result = !(EXN(v) || HAS_ERR(ctx->aug));
1779 } else if (term->tag == A_TEST) {
1780 return compile_test(term, ctx);
1786 static struct module *compile(struct term *term, struct augeas *aug) {
1788 struct transform *autoload = NULL;
1789 assert(term->tag == A_MODULE);
1793 ctx.name = term->mname;
1794 list_for_each(dcl, term->decls) {
1795 if (!compile_decl(dcl, &ctx))
1799 if (term->autoload != NULL) {
1800 struct binding *bnd = bnd_lookup(ctx.local, term->autoload);
1802 syntax_error(term->info, "Undefined transform in autoload %s",
1806 if (expect_types(term->info, bnd->type, 1, t_transform) == NULL)
1808 autoload = bnd->value->transform;
1810 struct module *module = module_create(term->mname);
1811 module->bindings = ctx.local;
1812 module->autoload = ref(autoload);
1815 unref(ctx.local, binding);
1820 * Defining native functions
1822 static struct info *
1823 make_native_info(struct error *error, const char *fname, int line) {
1825 if (make_ref(info) < 0)
1827 info->first_line = info->last_line = line;
1828 info->first_column = info->last_column = 0;
1829 info->error = error;
1830 if (make_ref(info->filename) < 0)
1832 info->filename->str = strdup(fname);
1839 int define_native_intl(const char *file, int line,
1840 struct error *error,
1841 struct module *module, const char *name,
1842 int argc, func_impl impl, ...) {
1843 assert(argc > 0); /* We have no unit type */
1847 struct term *params = NULL, *body = NULL, *func = NULL;
1849 struct value *v = NULL;
1850 struct info *info = NULL;
1853 info = make_native_info(error, file, line);
1858 for (int i=0; i < argc; i++) {
1861 tag = va_arg(ap, enum type_tag);
1862 type = make_base_type(tag);
1863 snprintf(ident, 10, "@%d", i);
1864 pterm = make_param(strdup(ident), type, ref(info));
1865 list_append(params, pterm);
1867 tag = va_arg(ap, enum type_tag);
1870 type = make_base_type(tag);
1879 if (ALLOC(v->native) < 0)
1881 v->native->argc = argc;
1882 v->native->type = type;
1883 v->native->impl = impl;
1888 body->info = ref(info);
1889 body->type = ref(type);
1890 body->tag = A_VALUE;
1894 func = build_func(params, body);
1899 ctx.local = ref(module->bindings);
1900 ctx.name = module->name;
1901 if (! check_exp(func, &ctx)) {
1902 fatal_error(info, "Typechecking native %s failed",
1906 v = make_closure(func, ctx.local);
1908 unref(module->bindings, binding);
1911 bind(&ctx.local, name, func->type, v);
1914 unref(module->bindings, binding);
1916 module->bindings = ctx.local;
1919 list_for_each(p, params) {
1929 /* Defined in parser.y */
1930 int augl_parse_file(struct augeas *aug, const char *name, struct term **term);
1932 static char *module_basename(const char *modname) {
1935 if (asprintf(&fname, "%s" AUG_EXT, modname) == -1)
1937 for (int i=0; i < strlen(modname); i++)
1938 fname[i] = tolower(fname[i]);
1942 static char *module_filename(struct augeas *aug, const char *modname) {
1944 char *filename = NULL;
1945 char *name = module_basename(modname);
1947 /* Module names that contain slashes can fool us into finding and
1948 * loading a module in another directory, but once loaded we won't find
1949 * it under MODNAME so that we will later try and load it over and
1951 if (index(modname, '/') != NULL)
1954 while ((dir = argz_next(aug->modpathz, aug->nmodpath, dir)) != NULL) {
1955 int len = strlen(name) + strlen(dir) + 2;
1958 if (REALLOC_N(filename, len) == -1)
1960 sprintf(filename, "%s/%s", dir, name);
1961 if (stat(filename, &st) == 0)
1971 int load_module_file(struct augeas *aug, const char *filename,
1973 struct term *term = NULL;
1976 if (aug->flags & AUG_TRACE_MODULE_LOADING)
1977 printf("Module %s", filename);
1978 augl_parse_file(aug, filename, &term);
1979 if (aug->flags & AUG_TRACE_MODULE_LOADING)
1980 printf(HAS_ERR(aug) ? " failed\n" : " loaded\n");
1983 if (! typecheck(term, aug))
1986 struct module *module = compile(term, aug);
1987 bool bad_module = (module == NULL);
1988 if (bad_module && name != NULL) {
1989 /* Put an empty placeholder on the module list so that
1990 * we don't retry loading this module everytime its mentioned
1992 module = module_create(name);
1994 if (module != NULL) {
1995 list_append(aug->modules, module);
1996 list_for_each(bnd, module->bindings) {
1997 if (bnd->value->tag == V_LENS) {
1998 lens_release(bnd->value->lens);
2002 ERR_THROW(bad_module, aug, AUG_ESYNTAX, "Failed to load %s", filename);
2006 // FIXME: This leads to a bad free of a string used in a del lens
2007 // To reproduce run lenses/tests/test_yum.aug
2012 static int load_module(struct augeas *aug, const char *name) {
2013 char *filename = NULL;
2015 if (module_find(aug->modules, name) != NULL)
2018 if ((filename = module_filename(aug, name)) == NULL)
2021 if (load_module_file(aug, filename, name) == -1)
2032 int interpreter_init(struct augeas *aug) {
2035 r = init_fatal_exn(aug->error);
2039 aug->modules = builtin_init(aug->error);
2040 if (aug->flags & AUG_NO_MODL_AUTOLOAD)
2043 // For now, we just load every file on the search path
2044 const char *dir = NULL;
2046 int gl_flags = GLOB_NOSORT;
2048 MEMZERO(&globbuf, 1);
2050 while ((dir = argz_next(aug->modpathz, aug->nmodpath, dir)) != NULL) {
2052 r = asprintf(&globpat, "%s/*.aug", dir);
2053 ERR_NOMEM(r < 0, aug);
2055 r = glob(globpat, gl_flags, NULL, &globbuf);
2056 if (r != 0 && r != GLOB_NOMATCH) {
2057 /* This really has to be an allocation failure; glob is not
2058 * supposed to return GLOB_ABORTED here */
2059 aug_errcode_t code =
2060 r == GLOB_NOSPACE ? AUG_ENOMEM : AUG_EINTERNAL;
2061 ERR_REPORT(aug, code, "glob failure for %s", globpat);
2065 gl_flags |= GLOB_APPEND;
2069 for (int i=0; i < globbuf.gl_pathc; i++) {
2072 p = strrchr(globbuf.gl_pathv[i], SEP);
2074 p = globbuf.gl_pathv[i];
2078 name = strndup(p, q - p);
2079 name[0] = toupper(name[0]);
2080 res = load_module(aug, name);
2094 * indent-tabs-mode: nil