xlsxwriter 0.2.1.pre → 0.2.2

data/ext/xlsxwriter/libxlsxwriter/src/workbook.c

@@ -3,7 +3,7 @@
  *
  * Used in conjunction with the libxlsxwriter library.
  *
- * Copyright 2014-2019, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
+ * Copyright 2014-2020, John McNamara, jmcnamara@cpan.org. See LICENSE.txt.
  *
  */
 
@@ -17,11 +17,15 @@ STATIC int _worksheet_name_cmp(lxw_worksheet_name *name1,
                                lxw_worksheet_name *name2);
 STATIC int _chartsheet_name_cmp(lxw_chartsheet_name *name1,
                                 lxw_chartsheet_name *name2);
+STATIC int _image_md5_cmp(lxw_image_md5 *tuple1, lxw_image_md5 *tuple2);
+
 #ifndef __clang_analyzer__
 LXW_RB_GENERATE_WORKSHEET_NAMES(lxw_worksheet_names, lxw_worksheet_name,
                                 tree_pointers, _worksheet_name_cmp);
 LXW_RB_GENERATE_CHARTSHEET_NAMES(lxw_chartsheet_names, lxw_chartsheet_name,
                                  tree_pointers, _chartsheet_name_cmp);
+LXW_RB_GENERATE_IMAGE_MD5S(lxw_image_md5s, lxw_image_md5,
+                           tree_pointers, _image_md5_cmp);
 #endif
 
 /*
@@ -49,6 +53,12 @@ _chartsheet_name_cmp(lxw_chartsheet_name *name1, lxw_chartsheet_name *name2)
     return lxw_strcasecmp(name1->name, name2->name);
 }
 
+STATIC int
+_image_md5_cmp(lxw_image_md5 *tuple1, lxw_image_md5 *tuple2)
+{
+    return strcmp(tuple1->md5, tuple2->md5);
+}
+
 /*
  * Free workbook properties.
  */
@@ -97,6 +107,8 @@ lxw_workbook_free(lxw_workbook *workbook)
     struct lxw_worksheet_name *next_worksheet_name;
     struct lxw_chartsheet_name *chartsheet_name;
     struct lxw_chartsheet_name *next_chartsheet_name;
+    struct lxw_image_md5 *image_md5;
+    struct lxw_image_md5 *next_image_md5;
     lxw_chart *chart;
     lxw_format *format;
     lxw_defined_name *defined_name;
@@ -204,7 +216,36 @@ lxw_workbook_free(lxw_workbook *workbook)
         free(workbook->chartsheet_names);
     }
 
+    if (workbook->image_md5s) {
+        for (image_md5 = RB_MIN(lxw_image_md5s, workbook->image_md5s);
+             image_md5; image_md5 = next_image_md5) {
+
+            next_image_md5 =
+                RB_NEXT(lxw_image_md5s, workbook->image_md5, image_md5);
+            RB_REMOVE(lxw_image_md5s, workbook->image_md5s, image_md5);
+            free(image_md5->md5);
+            free(image_md5);
+        }
+
+        free(workbook->image_md5s);
+    }
+
+    if (workbook->header_image_md5s) {
+        for (image_md5 = RB_MIN(lxw_image_md5s, workbook->header_image_md5s);
+             image_md5; image_md5 = next_image_md5) {
+
+            next_image_md5 =
+                RB_NEXT(lxw_image_md5s, workbook->image_md5, image_md5);
+            RB_REMOVE(lxw_image_md5s, workbook->header_image_md5s, image_md5);
+            free(image_md5->md5);
+            free(image_md5);
+        }
+
+        free(workbook->header_image_md5s);
+    }
+
     lxw_hash_free(workbook->used_xf_formats);
+    lxw_hash_free(workbook->used_dxf_formats);
     lxw_sst_free(workbook->sst);
     free(workbook->options.tmpdir);
     free(workbook->ordered_charts);
@@ -220,9 +261,15 @@ void
 lxw_workbook_set_default_xf_indices(lxw_workbook *self)
 {
     lxw_format *format;
+    int32_t index = 0;
 
     STAILQ_FOREACH(format, self->formats, list_pointers) {
-        lxw_format_get_xf_index(format);
+
+        /* Skip the hyperlink format. */
+        if (index != 1)
+            lxw_format_get_xf_index(format);
+
+        index++;
     }
 }
 
@@ -258,7 +305,7 @@ _prepare_fonts(lxw_workbook *self)
                 uint16_t *font_index = calloc(1, sizeof(uint16_t));
                 *font_index = index;
                 format->font_index = index;
-                format->has_font = 1;
+                format->has_font = LXW_TRUE;
                 lxw_insert_hash_element(fonts, key, font_index,
                                         sizeof(lxw_font));
                 index++;
@@ -268,6 +315,18 @@ _prepare_fonts(lxw_workbook *self)
 
     lxw_hash_free(fonts);
 
+    /* For DXF formats we only need to check if the properties have changed. */
+    LXW_FOREACH_ORDERED(used_format_element, self->used_dxf_formats) {
+        lxw_format *format = (lxw_format *) used_format_element->value;
+
+        /* The only font properties that can change for a DXF format are:
+         * color, bold, italic, underline and strikethrough. */
+        if (format->font_color || format->bold || format->italic
+            || format->underline || format->font_strikeout) {
+            format->has_dxf_font = LXW_TRUE;
+        }
+    }
+
     self->font_count = index;
 }
 
@@ -312,6 +371,15 @@ _prepare_borders(lxw_workbook *self)
         }
     }
 
+    /* For DXF formats we only need to check if the properties have changed. */
+    LXW_FOREACH_ORDERED(used_format_element, self->used_dxf_formats) {
+        lxw_format *format = (lxw_format *) used_format_element->value;
+
+        if (format->left || format->right || format->top || format->bottom) {
+            format->has_dxf_border = LXW_TRUE;
+        }
+    }
+
     lxw_hash_free(borders);
 
     self->border_count = index;
@@ -361,6 +429,17 @@ _prepare_fills(lxw_workbook *self)
     lxw_insert_hash_element(fills, default_fill_2, fill_index2,
                             sizeof(lxw_fill));
 
+    /* For DXF formats we only need to check if the properties have changed. */
+    LXW_FOREACH_ORDERED(used_format_element, self->used_dxf_formats) {
+        lxw_format *format = (lxw_format *) used_format_element->value;
+
+        if (format->pattern || format->bg_color || format->fg_color) {
+            format->has_dxf_fill = LXW_TRUE;
+            format->dxf_bg_color = format->bg_color;
+            format->dxf_fg_color = format->fg_color;
+        }
+    }
+
     LXW_FOREACH_ORDERED(used_format_element, self->used_xf_formats) {
         lxw_format *format = (lxw_format *) used_format_element->value;
         lxw_fill *key = lxw_format_get_fill_key(format);
@@ -482,6 +561,41 @@ _prepare_num_formats(lxw_workbook *self)
         }
     }
 
+    LXW_FOREACH_ORDERED(used_format_element, self->used_dxf_formats) {
+        lxw_format *format = (lxw_format *) used_format_element->value;
+
+        /* Format already has a number format index. */
+        if (format->num_format_index)
+            continue;
+
+        /* Check if there is a user defined number format string. */
+        if (*format->num_format) {
+            char num_format[LXW_FORMAT_FIELD_LEN] = { 0 };
+            lxw_snprintf(num_format, LXW_FORMAT_FIELD_LEN, "%s",
+                         format->num_format);
+
+            /* Look up the num_format in the hash table. */
+            hash_element = lxw_hash_key_exists(num_formats, num_format,
+                                               LXW_FORMAT_FIELD_LEN);
+
+            if (hash_element) {
+                /* Num_Format has already been used. */
+                format->num_format_index = *(uint16_t *) hash_element->value;
+            }
+            else {
+                /* This is a new num_format. */
+                num_format_index = calloc(1, sizeof(uint16_t));
+                *num_format_index = index;
+                format->num_format_index = index;
+                lxw_insert_hash_element(num_formats, format->num_format,
+                                        num_format_index,
+                                        LXW_FORMAT_FIELD_LEN);
+                index++;
+                /* Don't update num_format_count for DXF formats. */
+            }
+        }
+    }
+
     lxw_hash_free(num_formats);
 
     self->num_format_count = num_format_count;
@@ -735,7 +849,7 @@ _populate_range_data_cache(lxw_workbook *self, lxw_series_range *range)
                 return;
             }
 
-            cell_obj = lxw_worksheet_find_cell(row_obj, col_num);
+            cell_obj = lxw_worksheet_find_cell_in_row(row_obj, col_num);
 
             if (cell_obj) {
                 if (cell_obj->type == NUMBER_CELL) {
@@ -847,6 +961,9 @@ _populate_range_dimensions(lxw_workbook *self, lxw_series_range *range)
 STATIC void
 _populate_range(lxw_workbook *self, lxw_series_range *range)
 {
+    if (!range)
+        return;
+
     _populate_range_dimensions(self, range);
     _populate_range_data_cache(self, range);
 }
@@ -860,6 +977,7 @@ _add_chart_cache_data(lxw_workbook *self)
 {
     lxw_chart *chart;
     lxw_chart_series *series;
+    uint16_t i;
 
     STAILQ_FOREACH(chart, self->ordered_charts, ordered_list_pointers) {
 
@@ -874,6 +992,11 @@ _add_chart_cache_data(lxw_workbook *self)
             _populate_range(self, series->categories);
             _populate_range(self, series->values);
             _populate_range(self, series->title.range);
+
+            for (i = 0; i < series->data_label_count; i++) {
+                lxw_chart_custom_label *data_label = &series->data_labels[i];
+                _populate_range(self, data_label->range);
+            }
         }
     }
 }
@@ -886,11 +1009,16 @@ _prepare_drawings(lxw_workbook *self)
 {
     lxw_sheet *sheet;
     lxw_worksheet *worksheet;
-    lxw_image_options *image_options;
+    lxw_object_properties *object_props;
     uint32_t chart_ref_id = 0;
     uint32_t image_ref_id = 0;
+    uint32_t ref_id = 0;
     uint32_t drawing_id = 0;
     uint8_t is_chartsheet;
+    lxw_image_md5 tmp_image_md5;
+    lxw_image_md5 *new_image_md5 = NULL;
+    lxw_image_md5 *found_duplicate_image = NULL;
+    uint8_t i;
 
     STAILQ_FOREACH(sheet, self->sheets, list_pointers) {
         if (sheet->is_chartsheet) {
@@ -902,42 +1030,178 @@ _prepare_drawings(lxw_workbook *self)
             is_chartsheet = LXW_FALSE;
         }
 
-        if (STAILQ_EMPTY(worksheet->image_data)
-            && STAILQ_EMPTY(worksheet->chart_data))
+        if (STAILQ_EMPTY(worksheet->image_props)
+            && STAILQ_EMPTY(worksheet->chart_data)
+            && !worksheet->has_header_vml) {
             continue;
+        }
 
         drawing_id++;
 
-        STAILQ_FOREACH(image_options, worksheet->chart_data, list_pointers) {
+        /* Prepare worksheet images. */
+        STAILQ_FOREACH(object_props, worksheet->image_props, list_pointers) {
+
+            if (object_props->image_type == LXW_IMAGE_PNG)
+                self->has_png = LXW_TRUE;
+
+            if (object_props->image_type == LXW_IMAGE_JPEG)
+                self->has_jpeg = LXW_TRUE;
+
+            if (object_props->image_type == LXW_IMAGE_BMP)
+                self->has_bmp = LXW_TRUE;
+
+            /* Check for duplicate images and only store the first instance. */
+            if (object_props->md5) {
+                tmp_image_md5.md5 = object_props->md5;
+                found_duplicate_image = RB_FIND(lxw_image_md5s,
+                                                self->image_md5s,
+                                                &tmp_image_md5);
+            }
+
+            if (found_duplicate_image) {
+                ref_id = found_duplicate_image->id;
+                object_props->is_duplicate = LXW_TRUE;
+            }
+            else {
+                image_ref_id++;
+                ref_id = image_ref_id;
+
+#ifndef USE_NO_MD5
+                new_image_md5 = calloc(1, sizeof(lxw_image_md5));
+#endif
+                if (new_image_md5 && object_props->md5) {
+                    new_image_md5->id = ref_id;
+                    new_image_md5->md5 = lxw_strdup(object_props->md5);
+
+                    RB_INSERT(lxw_image_md5s, self->image_md5s,
+                              new_image_md5);
+                }
+            }
+
+            lxw_worksheet_prepare_image(worksheet, ref_id, drawing_id,
+                                        object_props);
+        }
+
+        /* Prepare worksheet charts. */
+        STAILQ_FOREACH(object_props, worksheet->chart_data, list_pointers) {
             chart_ref_id++;
             lxw_worksheet_prepare_chart(worksheet, chart_ref_id, drawing_id,
-                                        image_options, is_chartsheet);
-            if (image_options->chart)
-                STAILQ_INSERT_TAIL(self->ordered_charts, image_options->chart,
+                                        object_props, is_chartsheet);
+            if (object_props->chart)
+                STAILQ_INSERT_TAIL(self->ordered_charts, object_props->chart,
                                    ordered_list_pointers);
         }
 
-        STAILQ_FOREACH(image_options, worksheet->image_data, list_pointers) {
+        /* Prepare worksheet header/footer images. */
+        for (i = 0; i < LXW_HEADER_FOOTER_OBJS_MAX; i++) {
+
+            object_props = *worksheet->header_footer_objs[i];
+            if (!object_props)
+                continue;
 
-            if (image_options->image_type == LXW_IMAGE_PNG)
+            if (object_props->image_type == LXW_IMAGE_PNG)
                 self->has_png = LXW_TRUE;
 
-            if (image_options->image_type == LXW_IMAGE_JPEG)
+            if (object_props->image_type == LXW_IMAGE_JPEG)
                 self->has_jpeg = LXW_TRUE;
 
-            if (image_options->image_type == LXW_IMAGE_BMP)
+            if (object_props->image_type == LXW_IMAGE_BMP)
                 self->has_bmp = LXW_TRUE;
 
-            image_ref_id++;
+            /* Check for duplicate images and only store the first instance. */
+            if (object_props->md5) {
+                tmp_image_md5.md5 = object_props->md5;
+                found_duplicate_image = RB_FIND(lxw_image_md5s,
+                                                self->header_image_md5s,
+                                                &tmp_image_md5);
+            }
+
+            if (found_duplicate_image) {
+                ref_id = found_duplicate_image->id;
+                object_props->is_duplicate = LXW_TRUE;
+            }
+            else {
+                image_ref_id++;
+                ref_id = image_ref_id;
+
+#ifndef USE_NO_MD5
+                new_image_md5 = calloc(1, sizeof(lxw_image_md5));
+#endif
+                if (new_image_md5 && object_props->md5) {
+                    new_image_md5->id = ref_id;
+                    new_image_md5->md5 = lxw_strdup(object_props->md5);
+
+                    RB_INSERT(lxw_image_md5s, self->header_image_md5s,
+                              new_image_md5);
+                }
+            }
 
-            lxw_worksheet_prepare_image(worksheet, image_ref_id, drawing_id,
-                                        image_options);
+            lxw_worksheet_prepare_header_image(worksheet, ref_id,
+                                               object_props);
         }
+
     }
 
     self->drawing_count = drawing_id;
 }
 
+/*
+ * Iterate through the worksheets and set up the VML objects.
+ */
+
+STATIC void
+_prepare_vml(lxw_workbook *self)
+{
+    lxw_worksheet *worksheet;
+    lxw_sheet *sheet;
+    uint32_t comment_id = 0;
+    uint32_t vml_drawing_id = 0;
+    uint32_t vml_data_id = 1;
+    uint32_t vml_header_id = 0;
+    uint32_t vml_shape_id = 1024;
+    uint32_t comment_count = 0;
+
+    STAILQ_FOREACH(sheet, self->sheets, list_pointers) {
+        if (sheet->is_chartsheet)
+            continue;
+        else
+            worksheet = sheet->u.worksheet;
+
+        if (!worksheet->has_vml && !worksheet->has_header_vml)
+            continue;
+
+        if (worksheet->has_vml) {
+            self->has_vml = LXW_TRUE;
+            if (worksheet->has_comments) {
+                self->comment_count++;
+                comment_id++;
+                self->has_comments = LXW_TRUE;
+            }
+
+            vml_drawing_id++;
+
+            comment_count = lxw_worksheet_prepare_vml_objects(worksheet,
+                                                              vml_data_id,
+                                                              vml_shape_id,
+                                                              vml_drawing_id,
+                                                              comment_id);
+
+            /* Each VML should start with a shape id incremented by 1024. */
+            vml_data_id += 1 * ((1024 + comment_count) / 1024);
+            vml_shape_id += 1024 * ((1024 + comment_count) / 1024);
+        }
+
+        if (worksheet->has_header_vml) {
+            self->has_vml = LXW_TRUE;
+            vml_drawing_id++;
+            vml_header_id++;
+            lxw_worksheet_prepare_header_vml_objects(worksheet,
+                                                     vml_header_id,
+                                                     vml_drawing_id);
+        }
+    }
+}
+
 /*
  * Iterate through the worksheets and store any defined names used for print
  * ranges or repeat rows/columns.
@@ -1432,6 +1696,16 @@ workbook_new_opt(const char *filename, lxw_workbook_options *options)
     GOTO_LABEL_ON_MEM_ERROR(workbook->chartsheet_names, mem_error);
     RB_INIT(workbook->chartsheet_names);
 
+    /* Add the image MD5 tree. */
+    workbook->image_md5s = calloc(1, sizeof(struct lxw_image_md5s));
+    GOTO_LABEL_ON_MEM_ERROR(workbook->image_md5s, mem_error);
+    RB_INIT(workbook->image_md5s);
+
+    /* Add the image MD5 tree. */
+    workbook->header_image_md5s = calloc(1, sizeof(struct lxw_image_md5s));
+    GOTO_LABEL_ON_MEM_ERROR(workbook->header_image_md5s, mem_error);
+    RB_INIT(workbook->header_image_md5s);
+
     /* Add the charts list. */
     workbook->charts = calloc(1, sizeof(struct lxw_charts));
     GOTO_LABEL_ON_MEM_ERROR(workbook->charts, mem_error);
@@ -1464,6 +1738,10 @@ workbook_new_opt(const char *filename, lxw_workbook_options *options)
     workbook->used_xf_formats = lxw_hash_new(128, 1, 0);
     GOTO_LABEL_ON_MEM_ERROR(workbook->used_xf_formats, mem_error);
 
+    /* Add a hash table to track format indices. */
+    workbook->used_dxf_formats = lxw_hash_new(128, 1, 0);
+    GOTO_LABEL_ON_MEM_ERROR(workbook->used_dxf_formats, mem_error);
+
     /* Add the worksheets list. */
     workbook->custom_properties =
         calloc(1, sizeof(struct lxw_custom_properties));
@@ -1477,12 +1755,20 @@ workbook_new_opt(const char *filename, lxw_workbook_options *options)
     /* Initialize its index. */
     lxw_format_get_xf_index(format);
 
+    /* Add the default hyperlink format. */
+    format = workbook_add_format(workbook);
+    GOTO_LABEL_ON_MEM_ERROR(format, mem_error);
+    format_set_hyperlink(format);
+    workbook->default_url_format = format;
+
     if (options) {
         workbook->options.constant_memory = options->constant_memory;
         workbook->options.tmpdir = lxw_strdup(options->tmpdir);
         workbook->options.use_zip64 = options->use_zip64;
     }
 
+    workbook->max_url_length = 2079;
+
     return workbook;
 
 mem_error:
@@ -1501,7 +1787,7 @@ workbook_add_worksheet(lxw_workbook *self, const char *sheetname)
     lxw_worksheet *worksheet = NULL;
     lxw_worksheet_name *worksheet_name = NULL;
     lxw_error error;
-    lxw_worksheet_init_data init_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+    lxw_worksheet_init_data init_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     char *new_name = NULL;
 
     if (sheetname) {
@@ -1540,6 +1826,8 @@ workbook_add_worksheet(lxw_workbook *self, const char *sheetname)
     init_data.active_sheet = &self->active_sheet;
     init_data.first_sheet = &self->first_sheet;
     init_data.tmpdir = self->options.tmpdir;
+    init_data.default_url_format = self->default_url_format;
+    init_data.max_url_length = self->max_url_length;
 
     /* Create a new worksheet object. */
     worksheet = lxw_worksheet_new(&init_data);
@@ -1583,7 +1871,7 @@ workbook_add_chartsheet(lxw_workbook *self, const char *sheetname)
     lxw_chartsheet *chartsheet = NULL;
     lxw_chartsheet_name *chartsheet_name = NULL;
     lxw_error error;
-    lxw_worksheet_init_data init_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+    lxw_worksheet_init_data init_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     char *new_name = NULL;
 
     if (sheetname) {
@@ -1685,6 +1973,7 @@ workbook_add_format(lxw_workbook *self)
     RETURN_ON_MEM_ERROR(format, NULL);
 
     format->xf_format_indices = self->used_xf_formats;
+    format->dxf_format_indices = self->used_dxf_formats;
     format->num_xf_formats = &self->num_xf_formats;
 
     STAILQ_INSERT_TAIL(self->formats, format, list_pointers);
@@ -1702,6 +1991,7 @@ workbook_close(lxw_workbook *self)
     lxw_worksheet *worksheet = NULL;
     lxw_packager *packager = NULL;
     lxw_error error = LXW_NO_ERROR;
+    char codename[LXW_MAX_SHEETNAME_LENGTH] = { 0 };
 
     /* Add a default worksheet if non have been added. */
     if (!self->num_sheets)
@@ -1739,11 +2029,18 @@ workbook_close(lxw_workbook *self)
             else
                 worksheet = sheet->u.worksheet;
 
-            if (!worksheet->vba_codename)
-                worksheet_set_vba_name(worksheet, worksheet->name);
+            if (!worksheet->vba_codename) {
+                lxw_snprintf(codename, LXW_MAX_SHEETNAME_LENGTH, "Sheet%d",
+                             worksheet->index + 1);
+
+                worksheet_set_vba_name(worksheet, codename);
+            }
         }
     }
 
+    /* Prepare the worksheet VML elements such as comments. */
+    _prepare_vml(self);
+
     /* Set the defined names for the worksheets such as Print Titles. */
     _prepare_defined_names(self);
 
@@ -1903,6 +2200,8 @@ workbook_set_properties(lxw_workbook *self, lxw_doc_properties *user_props)
         GOTO_LABEL_ON_MEM_ERROR(doc_props->hyperlink_base, mem_error);
     }
 
+    doc_props->created = user_props->created;
+
     self->properties = doc_props;
 
     return LXW_NO_ERROR;
@@ -2150,6 +2449,27 @@ workbook_get_chartsheet_by_name(lxw_workbook *self, const char *name)
         return NULL;
 }
 
+/*
+ * Get the default URL format.
+ */
+lxw_format *
+workbook_get_default_url_format(lxw_workbook *self)
+{
+    return self->default_url_format;
+}
+
+/*
+ * Unset the default URL format.
+ */
+void
+workbook_unset_default_url_format(lxw_workbook *self)
+{
+    self->default_url_format->hyperlink = LXW_FALSE;
+    self->default_url_format->xf_id = 0;
+    self->default_url_format->underline = LXW_UNDERLINE_NONE;
+    self->default_url_format->theme = 0;
+}
+
 /*
  * Validate the worksheet name based on Excel's rules.
  */
@@ -2168,10 +2488,6 @@ workbook_validate_sheet_name(lxw_workbook *self, const char *sheetname)
     if (sheetname[0] == '\'' || sheetname[strlen(sheetname) - 1] == '\'')
         return LXW_ERROR_SHEETNAME_START_END_APOSTROPHE;
 
-    /* Check that the worksheet name isn't the reserved work "History". */
-    if (lxw_strcasecmp(sheetname, "history") == 0)
-        return LXW_ERROR_SHEETNAME_RESERVED;
-
     /* Check if the worksheet name is already in use. */
     if (workbook_get_worksheet_by_name(self, sheetname))
         return LXW_ERROR_SHEETNAME_ALREADY_USED;
@@ -2198,7 +2514,7 @@ workbook_add_vba_project(lxw_workbook *self, const char *filename)
     }
 
     /* Check that the vbaProject file exists and can be opened. */
-    filehandle = fopen(filename, "rb");
+    filehandle = lxw_fopen(filename, "rb");
     if (!filehandle) {
         LXW_WARN_FORMAT1("workbook_add_vba_project(): "
                          "file doesn't exist or can't be opened: %s.",