Home | History | Annotate | Download | only in edify 
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <stdio.h>
     18 #include <stdlib.h>
     19 #include <string.h>
     20 
     21 #include <string>
     22 
     23 #include "expr.h"
     24 #include "parser.h"
     25 
     26 extern int yyparse(Expr** root, int* error_count);
     27 
     28 int expect(const char* expr_str, const char* expected, int* errors) {
     29     Expr* e;
     30     char* result;
     31 
     32     printf(".");
     33 
     34     int error_count = parse_string(expr_str, &e, &error_count);
     35     if (error_count > 0) {
     36         printf("error parsing \"%s\" (%d errors)\n",
     37                expr_str, error_count);
     38         ++*errors;
     39         return 0;
     40     }
     41 
     42     State state;
     43     state.cookie = NULL;
     44     state.script = strdup(expr_str);
     45     state.errmsg = NULL;
     46 
     47     result = Evaluate(&state, e);
     48     free(state.errmsg);
     49     free(state.script);
     50     if (result == NULL && expected != NULL) {
     51         printf("error evaluating \"%s\"\n", expr_str);
     52         ++*errors;
     53         return 0;
     54     }
     55 
     56     if (result == NULL && expected == NULL) {
     57         return 1;
     58     }
     59 
     60     if (strcmp(result, expected) != 0) {
     61         printf("evaluating \"%s\": expected \"%s\", got \"%s\"\n",
     62                expr_str, expected, result);
     63         ++*errors;
     64         free(result);
     65         return 0;
     66     }
     67 
     68     free(result);
     69     return 1;
     70 }
     71 
     72 int test() {
     73     int errors = 0;
     74 
     75     expect("a", "a", &errors);
     76     expect("\"a\"", "a", &errors);
     77     expect("\"\\x61\"", "a", &errors);
     78     expect("# this is a comment\n"
     79            "  a\n"
     80            "   \n",
     81            "a", &errors);
     82 
     83 
     84     // sequence operator
     85     expect("a; b; c", "c", &errors);
     86 
     87     // string concat operator
     88     expect("a + b", "ab", &errors);
     89     expect("a + \n \"b\"", "ab", &errors);
     90     expect("a + b +\nc\n", "abc", &errors);
     91 
     92     // string concat function
     93     expect("concat(a, b)", "ab", &errors);
     94     expect("concat(a,\n \"b\")", "ab", &errors);
     95     expect("concat(a + b,\nc,\"d\")", "abcd", &errors);
     96     expect("\"concat\"(a + b,\nc,\"d\")", "abcd", &errors);
     97 
     98     // logical and
     99     expect("a && b", "b", &errors);
    100     expect("a && \"\"", "", &errors);
    101     expect("\"\" && b", "", &errors);
    102     expect("\"\" && \"\"", "", &errors);
    103     expect("\"\" && abort()", "", &errors);   // test short-circuiting
    104     expect("t && abort()", NULL, &errors);
    105 
    106     // logical or
    107     expect("a || b", "a", &errors);
    108     expect("a || \"\"", "a", &errors);
    109     expect("\"\" || b", "b", &errors);
    110     expect("\"\" || \"\"", "", &errors);
    111     expect("a || abort()", "a", &errors);     // test short-circuiting
    112     expect("\"\" || abort()", NULL, &errors);
    113 
    114     // logical not
    115     expect("!a", "", &errors);
    116     expect("! \"\"", "t", &errors);
    117     expect("!!a", "t", &errors);
    118 
    119     // precedence
    120     expect("\"\" == \"\" && b", "b", &errors);
    121     expect("a + b == ab", "t", &errors);
    122     expect("ab == a + b", "t", &errors);
    123     expect("a + (b == ab)", "a", &errors);
    124     expect("(ab == a) + b", "b", &errors);
    125 
    126     // substring function
    127     expect("is_substring(cad, abracadabra)", "t", &errors);
    128     expect("is_substring(abrac, abracadabra)", "t", &errors);
    129     expect("is_substring(dabra, abracadabra)", "t", &errors);
    130     expect("is_substring(cad, abracxadabra)", "", &errors);
    131     expect("is_substring(abrac, axbracadabra)", "", &errors);
    132     expect("is_substring(dabra, abracadabrxa)", "", &errors);
    133 
    134     // ifelse function
    135     expect("ifelse(t, yes, no)", "yes", &errors);
    136     expect("ifelse(!t, yes, no)", "no", &errors);
    137     expect("ifelse(t, yes, abort())", "yes", &errors);
    138     expect("ifelse(!t, abort(), no)", "no", &errors);
    139 
    140     // if "statements"
    141     expect("if t then yes else no endif", "yes", &errors);
    142     expect("if \"\" then yes else no endif", "no", &errors);
    143     expect("if \"\" then yes endif", "", &errors);
    144     expect("if \"\"; t then yes endif", "yes", &errors);
    145 
    146     // numeric comparisons
    147     expect("less_than_int(3, 14)", "t", &errors);
    148     expect("less_than_int(14, 3)", "", &errors);
    149     expect("less_than_int(x, 3)", "", &errors);
    150     expect("less_than_int(3, x)", "", &errors);
    151     expect("greater_than_int(3, 14)", "", &errors);
    152     expect("greater_than_int(14, 3)", "t", &errors);
    153     expect("greater_than_int(x, 3)", "", &errors);
    154     expect("greater_than_int(3, x)", "", &errors);
    155 
    156     // big string
    157     expect(std::string(8192, 's').c_str(), std::string(8192, 's').c_str(), &errors);
    158 
    159     printf("\n");
    160 
    161     return errors;
    162 }
    163 
    164 void ExprDump(int depth, Expr* n, char* script) {
    165     printf("%*s", depth*2, "");
    166     char temp = script[n->end];
    167     script[n->end] = '\0';
    168     printf("%s %p (%d-%d) \"%s\"\n",
    169            n->name == NULL ? "(NULL)" : n->name, n->fn, n->start, n->end,
    170            script+n->start);
    171     script[n->end] = temp;
    172     int i;
    173     for (i = 0; i < n->argc; ++i) {
    174         ExprDump(depth+1, n->argv[i], script);
    175     }
    176 }
    177 
    178 int main(int argc, char** argv) {
    179     RegisterBuiltins();
    180     FinishRegistration();
    181 
    182     if (argc == 1) {
    183         return test() != 0;
    184     }
    185 
    186     FILE* f = fopen(argv[1], "r");
    187     if (f == NULL) {
    188         printf("%s: %s: No such file or directory\n", argv[0], argv[1]);
    189         return 1;
    190     }
    191     char buffer[8192];
    192     int size = fread(buffer, 1, 8191, f);
    193     fclose(f);
    194     buffer[size] = '\0';
    195 
    196     Expr* root;
    197     int error_count = 0;
    198     int error = parse_string(buffer, &root, &error_count);
    199     printf("parse returned %d; %d errors encountered\n", error, error_count);
    200     if (error == 0 || error_count > 0) {
    201 
    202         ExprDump(0, root, buffer);
    203 
    204         State state;
    205         state.cookie = NULL;
    206         state.script = buffer;
    207         state.errmsg = NULL;
    208 
    209         char* result = Evaluate(&state, root);
    210         if (result == NULL) {
    211             printf("result was NULL, message is: %s\n",
    212                    (state.errmsg == NULL ? "(NULL)" : state.errmsg));
    213             free(state.errmsg);
    214         } else {
    215             printf("result is [%s]\n", result);
    216         }
    217     }
    218     return 0;
    219 }
    220