tm_update.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include <sqlite3.h>
   6
   7 #define JIM_EMBEDDED
   8 #include <jim.h>
   9
  10 #include "tmake.h"
  11 #include "tm_target.h"
  12 #include "tm_crypto.h"
  13 #include "tm_update.h"
  14
  15
  16 /* A list of targets that were updated during the current run */
  17 target_list *updated_targets = NULL;
  18
  19
  20 /* Returns true if a file exists and is readable.
  21  */
  22 int file_exists(const char *filename)
  23 {
  24         FILE *fp;
  25
  26         if ((fp = fopen(filename, "r"))) {
  27                 fclose(fp);
  28                 return 1;
  29         }
  30
  31         return 0;
  32 }
  33
  34
  35 /* Used takes a Jim interpreter and a Jim error code.
  36  * If there was an error, display an error message and exit.
  37  * Otherwise, do nothing.
  38  */
  39 void wrap(Jim_Interp *interp, int error)
  40 {
  41         if (error == JIM_ERR) {
  42                 Jim_MakeErrorMessage(interp);
  43                 fprintf(stderr, "%s\n", Jim_String(Jim_GetResult(interp)));
  44                 Jim_FreeInterp(interp);
  45                 exit(EXIT_FAILURE);
  46         }
  47 }
  48
  49
  50 /* Update a target using the associated rule from tm_rules.
  51  * Takes a SQLite database handle representing the sha1sum cache
  52  * and the name of the TMakefile being evaluated, along with
  53  * the name of the target to update.
  54  */
  55 int update(sqlite3 *db, const char *tmfile, const char *target)
  56 {
  57         unsigned char digest[CRYPTO_HASH_SIZE];
  58         char newhash[CRYPTO_HASH_STRING_LENGTH];
  59         tm_rule *rule = NULL;
  60         const char *fmt = "INSERT OR REPLACE INTO TMCache (TMakefile, Target, Hash) VALUES (?, ?, ?)";
  61         sqlite3_stmt *stm = NULL;
  62         const char *stmtail;
  63         int sqlrc;
  64
  65         rule = find_rule(target, tm_rules);
  66
  67         if (!rule) {
  68                 return (JIM_ERR);
  69         }
  70
  71         updated_targets = target_cons(rule->target, updated_targets);
  72
  73         if (rule->type == TM_EXPLICIT) {
  74                 TM_CRYPTO_HASH_DATA(rule->recipe, digest);
  75         } else if (rule->type == TM_FILENAME) {
  76                 TM_CRYPTO_HASH_FILE(target, digest);
  77         } else {
  78                 fprintf(stderr, "WARNING: Unknown rule type %d\n"
  79                                 "         Don't know how to update cache for %s\n", rule->type, target);
  80                 return (JIM_ERR);
  81         }
  82
  83         TM_CRYPTO_HASH_TO_STRING(digest, newhash);
  84
  85         sqlrc = sqlite3_prepare(db, fmt, -1, &stm, &stmtail);
  86         if (sqlrc != SQLITE_OK) {
  87                 fprintf(stderr, "WARNING: Unable to update cache for target %s\n", target);
  88                 return (JIM_ERR);
  89         }
  90
  91         sqlite3_bind_text(stm, 1, tmfile, -1, SQLITE_TRANSIENT);
  92         sqlite3_bind_text(stm, 2, target, -1, SQLITE_TRANSIENT);
  93         sqlite3_bind_text(stm, 3, newhash, -1, SQLITE_TRANSIENT);
  94         sqlrc = sqlite3_step(stm);
  95         if (sqlrc != SQLITE_DONE) {
  96                 fprintf(stderr, "WARNING: Error updating cache for target %s\n", target);
  97                 sqlite3_finalize(stm);
  98                 return (JIM_ERR);
  99         }
 100         sqlite3_finalize(stm);
 101         /*
 102         Adding this return to squelch compilation warning.
 103         Cory should review this code
 104         */
 105         return (JIM_OK);
 106 }
 107
 108
 109 /* Return 1 if target was updated, else return 0.
 110  */
 111 int was_updated(const char *target)
 112 {
 113         return target_exists(target, updated_targets);
 114 }
 115
 116
 117 /* Return 1 if a given target is out of date, else return 0.
 118  * Takes a SQLite database handle and the name of the TMakefile
 119  * being evaluated along with the name of the target.
 120  */
 121 int needs_update(sqlite3 *db, const char *tmfile, const char *target)
 122 {
 123         unsigned char digest[CRYPTO_HASH_SIZE];
 124         const char *oldhash = NULL;
 125         char newhash[CRYPTO_HASH_STRING_LENGTH];
 126         target_list *deps = NULL;
 127         tm_rule *rule = NULL;
 128         const char *fmt = "SELECT Hash FROM TMCache WHERE TMakefile = ? AND Target = ?";
 129         const char *stmtail = NULL;
 130         sqlite3_stmt *stm = NULL;
 131         int sqlrc;
 132
 133         rule = find_rule(target, tm_rules);
 134
 135         if (!rule) {
 136                 goto yes;
 137         }
 138
 139         for (deps = rule->deps; deps; deps = deps->next) {
 140                 if (was_updated(deps->name)) {
 141                         goto yes;
 142                 }
 143         }
 144
 145         sqlrc = sqlite3_prepare(db, fmt, -1, &stm, &stmtail);
 146         if (sqlrc != SQLITE_OK) {
 147                 fprintf(stderr, "WARNING: Unable to prepare database statement.\n"
 148                                 "         Assuming %s needs update.\n", target);
 149                 return 1;
 150         }
 151
 152         sqlite3_bind_text(stm, 1, tmfile, -1, SQLITE_TRANSIENT);
 153         sqlite3_bind_text(stm, 2, target, -1, SQLITE_TRANSIENT);
 154         sqlrc = sqlite3_step(stm);
 155         if (sqlrc != SQLITE_ROW) {
 156                 /* There was no row in the cache for this target, so update it */
 157                 goto yes;
 158         }
 159
 160         oldhash = (const char *)sqlite3_column_text(stm, 0);
 161         if (!oldhash) {
 162                 fprintf(stderr, "WARNING: Error getting cache for target %s\n", target);
 163                 goto yes;
 164         }
 165
 166         if (rule->type == TM_EXPLICIT) {
 167                 TM_CRYPTO_HASH_DATA(rule->recipe, digest);
 168         } else if (rule->type == TM_FILENAME) {
 169                 TM_CRYPTO_HASH_FILE(target, digest);
 170         } else {
 171                 fprintf(stderr, "WARNING: Unexpected rule type %d\n"
 172                                 "         Assuming %s needs update.\n", rule->type, target);
 173                 goto yes;
 174         }
 175         TM_CRYPTO_HASH_TO_STRING(digest, newhash);
 176
 177         if (strcmp(oldhash, newhash) == 0) {
 178                 goto no;
 179         } else {
 180                 goto yes;
 181         }
 182
 183         no:
 184                 sqlite3_finalize(stm);
 185                 return 0;
 186         yes:
 187                 sqlite3_finalize(stm);
 188                 return 1;
 189 }
 190
 191 /* Take a list of targets to check and return a sublist containing only
 192  * the targets that are out of date.
 193  * Takes a SQLite database handle and the name of the TMakefile being
 194  * evaluated along with the list of targets.
 195  */
 196 target_list *need_update(sqlite3 *db, const char *tmfile, target_list *targets)
 197 {
 198         target_list *oodate = NULL;
 199
 200         for (; targets; targets = targets->next) {
 201                 if (needs_update(db, tmfile, targets->name)) {
 202                         oodate = target_cons(targets->name, oodate);
 203                 }
 204         }
 205
 206         return oodate;
 207 }
 208
 209
 210 /* Update all the rules in sorted_rules that need updating.
 211  * Takes a SQLite database handle, a Jim interpreter containing
 212  * the recipe definitions, the name of the TMakefile that was
 213  * evaluated in the interpreter, the rules to be updated if needed
 214  * (in the order they are to be updated), whether or not to force
 215  * updates regardless of out-of-date status, and whether or not
 216  * we're running in silent mode.
 217  */
 218 void update_rules(sqlite3 *db, Jim_Interp *interp,
 219                   const char *tmfile,
 220                   tm_rule_list *sorted_rules,
 221                   int force,
 222                   int silence)
 223 {
 224         if (!sorted_rules) {
 225                 /* nothing to do */
 226                 return;
 227         }
 228
 229         for (; sorted_rules; sorted_rules = sorted_rules->next) {
 230                 tm_rule *rule = sorted_rules->rule;
 231                 if (rule->type == TM_EXPLICIT) {
 232                         /* If the rule has a recipe and needs an update */
 233                         if (rule->recipe
 234                         &&  (force || needs_update(db, tmfile, rule->target))) {
 235                                 /* Execute the recipe for the current rule */
 236                                 const char *fmt = "recipe::%s {%s} {%s} {%s}";
 237                                 int len = 0;
 238                                 char *cmd = NULL;
 239                                 const char *target = rule->target;
 240                                 char *inputs = target_list_to_string(rule->deps);
 241                                 target_list *oodate_deps = need_update(db, tmfile, rule->deps);
 242                                 char *oodate = target_list_to_string(oodate_deps);
 243                                 tm_rule_list *oodate_rules = find_rules(oodate_deps, tm_rules);
 244
 245                                 if (was_updated(target)) {
 246                                         goto done;
 247                                 }
 248
 249                                 update_rules(db, interp, tmfile, oodate_rules, force, silence);
 250
 251                                 if (!silence)
 252                                         printf("Making target %s:\n", rule->target);
 253                                 len = strlen(fmt) + strlen(target)*2 + strlen(inputs) + strlen(oodate) + 1;
 254                                 cmd = malloc(len);
 255                                 sprintf(cmd, fmt, target, target, inputs, oodate);
 256                                 wrap(interp, Jim_Eval(interp, cmd));
 257
 258                                 update(db, tmfile, rule->target);
 259                                 if (!silence)
 260                                         printf("\n");
 261
 262                                 done:
 263                                 free(cmd);
 264                                 free(oodate);
 265                                 free(inputs);
 266                                 free_rule_list(oodate_rules);
 267                                 free_target_list(oodate_deps);
 268
 269                                 rule->type = TM_UPDATED;
 270                         }
 271                 } else if (rule->type == TM_FILENAME) {
 272                         /* Check that the file actually exists */
 273                         if (!file_exists(rule->target)) {
 274                                 fprintf(stderr, "ERROR: Unable to find rule for target %s\n", rule->target);
 275                                 exit(EXIT_FAILURE);
 276                         }
 277                         if (force || needs_update(db, tmfile, rule->target)) {
 278                                 update(db, tmfile, rule->target);
 279                                 rule->type = TM_UPDATED;
 280                         }
 281                 }
 282         }
 283 }
 284