/* Copyright 1997 Acorn Computers Ltd
*
* 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.
*/
/***************************************************/
/* File : Save.c */
/* */
/* Purpose: Save functions for the browser. */
/* */
/* Author : A.D.Hodgkinson */
/* */
/* History: 04-Dec-96: Created. */
/***************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "swis.h"
#include "flex.h"
#include "HTMLLib.h" /* HTML library API, Which will include html2_ext.h, tags.h and struct.h */
#include "wimp.h"
#include "wimplib.h"
#include "event.h"
#include "toolbox.h"
#include "window.h"
#include "menu.h"
#include "saveas.h"
#include "svcprint.h"
#include "Global.h"
#include "Utils.h"
#include "ChoiceDefs.h"
#include "Fetch.h" /* (Which itself includes URLstat.h) */
#include "Filetypes.h"
#include "Fontmanage.h"
#include "Hotlist.h"
#include "Protocols.h"
#include "URLutils.h"
#include "Save.h"
/* Static function prototypes */
static int save_save_string (FILE * file, char * string);
static int save_save_colour (FILE * file, int colour);
static int save_save_number (FILE * file, int number);
static int save_save_yes_no (FILE * file, int yes);
static int save_save_general (FILE * file, int how_many, const int numbers[], const char * strings[], int match, int def);
/* Locals */
static char * last_path = NULL;
/*************************************************/
/* save_record_path() */
/* */
/* Record the given pathname for future use. No */
/* errors are raised if the memory allocation to */
/* do this fails. */
/* */
/* Note that <Wimp$Scrap>... and */
/* <Wimp$ScrapDir>... are two exceptions - paths */
/* starting with these are not recorded. */
/* */
/* Parameters: Pointer to a pathname to record. */
/*************************************************/
void save_record_path(const char * path)
{
if (!path) return;
/* Check for the special cases */
if (!strncmp(path, "<Wimp$Scrap>", 12) || !strncmp(path, "<Wimp$ScrapDir>", 15)) return;
/* Otherwise, record the path, failing silently if */
/* we can't claim enough memory for it. */
free(last_path);
last_path = malloc(strlen(path) + 1);
if (last_path) strcpy(last_path, path);
}
/*************************************************/
/* save_return_last_path() */
/* */
/* Used mostly for filling in writables of save */
/* dialogues with paths based on previous saves. */
/* */
/* Returns: Pointer to the last pathname that */
/* was used for saving, or NULL if */
/* no such record is available. */
/*************************************************/
const char * save_return_last_path(void)
{
return last_path;
}
/*************************************************/
/* save_save_source() */
/* */
/* Saves the document source for a given browser */
/* to the given path, setting the filetype as */
/* HTML or text as appropriate. */
/* */
/* Parameters: Pointer to a null-terminated */
/* pathname to save to; */
/* */
/* Pointer to a browser_data struct */
/* owning the source to save. */
/*************************************************/
_kernel_oserror * save_save_source(char * path, browser_data * b)
{
_kernel_oserror * e;
/* Sanity checks */
if (!b || !b->source || !path || !*path)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid parameters to save_save_source: %p, %p (source %p)",
path,
b,
b ? b->source : NULL);
return &erb;
#else
return NULL;
#endif
}
save_record_path(path);
/* Save the file - lock flex heap to ensure save transfer */
flex_set_budge(0);
e = _swix(OS_File,
_INR(0,2) | _INR(4,5),
10, /* Save block of memory as a typed file */
path,
b->page_is_text ? FileType_TEXT : FileType_HTML,
b->source,
((char *) b->source) + flex_size((flex_ptr) &b->source));
/* Unlock flex */
flex_set_budge(1);
return e;
}
/*************************************************/
/* save_transfer_source() */
/* */
/* Save a browser's page source as an HTML file, */
/* through a RAM transfer buffer with */
/* Wimp_TransferBlock. */
/* */
/* Intended to be called as a response to a */
/* Message_RAMFetch from another task. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the document source; */
/* */
/* Pointer to an int, in which the */
/* amount of data transferred so */
/* far should be stored on entry; */
/* */
/* Pointer to the WimpMessage struct */
/* corresponding to the */
/* Message_RAMFetch that led to this */
/* function being called. */
/* */
/* Returns: The contents of the int holding */
/* the amount of data transferred */
/* prior to the function call are */
/* updated with the new amount */
/* transferred. Callers should use */
/* this in any future calls, and it */
/* *must* be checked for a value of */
/* -1, which indicates the transfer */
/* is complete (so any tidying up */
/* should be done if there is an */
/* error returned, or if the int is */
/* filled in with a value of -1). */
/* */
/* Assumes: The various pointers may be NULL, */
/* though if they are the function */
/* does nothing (it just exits). */
/*************************************************/
_kernel_oserror * save_transfer_source(browser_data * b, int * transferred, WimpMessage * m)
{
_kernel_oserror * e = NULL;
int size = save_source_size(b);
int left;
int write;
/* Sanity check */
if (!b || !b->source || !transferred || !m)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid parameters to save_transfer_source: %p (source %p), %p, %p",
b,
b ? b->source : NULL,
transferred,
m);
return &erb;
#else
return NULL;
#endif
}
left = size - *transferred;
/* If we have data to transfer, do so */
if (left >= 0)
{
/* Use either the buffer size, or the bytes left, whichever */
/* is the smallest. */
write = left > m->data.ram_fetch.buffer_size ? m->data.ram_fetch.buffer_size : left;
if (write)
{
/* Transfer the data - must lock the flex heap for the */
/* duration of this... */
flex_set_budge(0);
e = wimp_transfer_block(task_handle,
(char *) b->source + (*transferred),
m->hdr.sender,
m->data.ram_fetch.buffer,
write);
/* Unlock flex and report any errors */
flex_set_budge(1);
if (e) return e;
}
/* If we have any data left to send, reply with a Message_RAMTransmit */
e = protocols_atats_send_ram_transmit(m, write, write < m->data.ram_fetch.buffer_size);
/* Increment the transferred counter */
*transferred += write;
left -= write;
}
/* Finished */
return e;
}
/*************************************************/
/* save_source_size() */
/* */
/* Returns the size that a given HTML source */
/* document would take on disc. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* owning the source to save. */
/* */
/* Returns: Size the file will be. */
/*************************************************/
int save_source_size(browser_data * b)
{
/* Sanity check */
if (!b || !b->source)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid parameters to save_source_size: %p (source %p)",
b,
b ? b->source : NULL);
show_error_ret(&erb);
#endif
return 0;
}
/* For now this is trivially simple, but in future it */
/* could take account of, for example, inserting a */
/* <BASE> tag into the document. */
return flex_size((flex_ptr) &b->source);
}
/*************************************************/
/* save_save_object() */
/* */
/* Called when a fetch is to be spooled to disc. */
/* Handles saving as much data as is already */
/* fetched, and setting the relevant parts of */
/* the given browser_data structure up with the */
/* output file details. */
/* */
/* Parameters: Pointer to a null-terminated */
/* pathname to save to; */
/* */
/* Pointer to a browser_data struct */
/* relevant to the object to save. */
/*************************************************/
_kernel_oserror * save_save_object(char * path, browser_data * b)
{
/* Sanity check */
if (!b || !path || !*path)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid parameters to save_save_object: %p, %p",
path,
b);
return &erb;
#else
return NULL;
#endif
}
save_record_path(path);
/* If using a small fetch window, set the title to the save pathname */
if (b->small_fetch)
{
char title[Limits_Title];
StrNCpy0(title, path);
/* Don't treat any errors here as fatal */
show_error_ret(window_set_title(0, b->self_id, title));
}
/* Open the file */
b->save_file = fopen(path, "wb");
if (!b->save_file)
{
fetch_stop(b, 0);
RetLastE;
}
else
{
int bytes;
/* Set the filetype to DEADDEAD, to represent an incomplete */
/* file (particularly good on later Filers, which display */
/* a special sprite for this). */
_swix(OS_File,
_INR(0,2),
2, /* Set load address */
path,
0xdeaddead);
_swix(OS_File,
_INR(0,1) | _IN(3),
3, /* Set exec address */
path,
0xdeaddead);
if (b->source)
{
/* Any data in the source store represents already */
/* fetched bits of the file. Must lock flex down */
/* over the save to make sure the heap doesn't */
/* shift over the call to fwrite. */
flex_set_budge(0);
bytes = fwrite(b->source,
1,
flex_size((flex_ptr) &b->source),
b->save_file);
flex_set_budge(1);
/* If we didn't transfer as much as we expected, complain */
if (bytes != flex_size((flex_ptr) &b->source))
{
/* Report any errors */
fetch_stop(b, 0);
RetLastE;
}
else
{
/* Otherwise, get rid of the data in the source store */
/* as it's been written to the file. */
flex_free((flex_ptr) &b->source);
b->source = NULL;
}
}
}
return NULL;
}
/*************************************************/
/* save_object_size() */
/* */
/* Returns the estimated size that a given */
/* object will be after being spooled through */
/* the fetcher. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* relevant to the object to save. */
/* */
/* Returns: *Estimated* size of the object. */
/*************************************************/
int save_object_size(browser_data * b)
{
/* For now, we just don't know this information... */
return 4096;
}
/*************************************************/
/* save_save_uri() */
/* */
/* Save the contents of a link as a URI file. */
/* */
/* Parameters: Pointer to a null-terminated */
/* pathname to save to; */
/* */
/* Pointer to the URI to save; */
/* */
/* Pointer to the URL title, or NULL */
/* / null string for no title; */
/* */
/* 0 to save as a URI file, else */
/* save as a non-terminated string */
/* with type FileType_URL (ANT */
/* suite URL file). */
/*************************************************/
_kernel_oserror * save_save_uri(char * path, char * url, char * title, int write_url)
{
_kernel_oserror * e = NULL;
FILE * file;
/* Sanity check */
if (title && !*title) title = NULL;
if (!path || !*path || !url || !*url)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid parameters to save_save_uri: %p, %p, %d",
path,
url,
write_url);
return &erb;
#else
return NULL;
#endif
}
save_record_path(path);
/* Try and open the file */
file = fopen(path, "wb");
if (!file) RetLastE;
/* Write the contents */
if (!write_url)
{
/* URI file */
if (
fprintf(file,
"URI\t100\n\t# %s v",
lookup_token("_TaskName",1,0)) < 0
)
erb = *_kernel_last_oserror(), e = &erb;
else if (
fprintf(file,
"%s\n\n\t%s",
lookup_token("Version:(Unknown!)",0,0),
url) < 0
)
erb = *_kernel_last_oserror(), e = &erb;
else if (
fprintf(file,
"\n\t%s",
title ? title : "*") < 0
)
erb = *_kernel_last_oserror(), e = &erb;
}
else
{
/* URL file */
if (fprintf(file, url) < 0) erb = *_kernel_last_oserror(), e = &erb;
}
/* Close the file and return any error that may have */
/* happened during the file writing stage */
fclose(file);
if (e) return &erb;
/* Exit via. setting the filetype */
return _swix(OS_File,
_INR(0,2),
18, /* Set type of named object */
path,
write_url ? FileType_URL : FileType_URI);
}
/*************************************************/
/* save_transfer_uri() */
/* */
/* Save the contents of a link as a URI file, */
/* through a RAM transfer buffer with */
/* Wimp_TransferBlock. */
/* */
/* Intended to be called as a response to a */
/* Message_RAMFetch from another task. */
/* */
/* Parameters: Pointer to the URL to save; */
/* */
/* Pointer to the URL title, or NULL */
/* / null string for no title; */
/* */
/* 0 to save as a URI file, else */
/* save as a non-terminated string */
/* with type FileType_URL (ANT */
/* suite URL file); */
/* */
/* Pointer to an int, in which the */
/* amount of data transferred so */
/* far should be stored on entry; */
/* */
/* Pointer to the WimpMessage struct */
/* corresponding to the */
/* Message_RAMFetch that led to this */
/* function being called. */
/* */
/* Returns: The contents of the int holding */
/* the amount of data transferred */
/* prior to the function call are */
/* updated with the new amount */
/* transferred. Callers should use */
/* this in any future calls, and it */
/* *must* be checked for a value of */
/* -1, which indicates the transfer */
/* is complete (so any tidying up */
/* should be done if there is an */
/* error returned, or if the int is */
/* filled in with a value of -1). */
/* */
/* Assumes: The various pointers may be NULL, */
/* though if they are the function */
/* does nothing (it just exits). */
/*************************************************/
_kernel_oserror * save_transfer_uri(char * url, char * title, int write_url, int * transferred, WimpMessage * m)
{
_kernel_oserror * e = NULL;
char * uri_file = NULL;
int size = save_uri_size(url, title, write_url);
int left;
int write;
/* Sanity check */
if (title && !*title) title = NULL;
if (!url || !*url || !transferred || !m)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid parameters to save_transfer_uri: %p, %d, %p, %p",
url,
write_url,
transferred,
m);
return &erb;
#else
return NULL;
#endif
}
left = size - *transferred;
/* Each time the function is called, rebuild the URI file in a */
/* temporary buffer. */
if (size > 0 && left > 0)
{
uri_file = malloc(size + 1); /* + 1 to account for terminators */
if (!uri_file)
{
e = make_no_memory_error(10);
goto save_transfer_uri_exit;
}
/* Build the URI or URL file */
if (!write_url)
{
int written;
/* URI file */
written = sprintf(uri_file,
"URI\t100\n\t# %s v",
lookup_token("_TaskName",1,0));
written += sprintf(uri_file + written,
"%s\n\n\t%s",
lookup_token("Version:(Unknown!)",0,0),
url);
written += sprintf(uri_file + written,
"\n\t%s",
title ? title : "*");
}
else
{
/* URL file */
strcpy(uri_file, url);
}
}
/* If we have data to transfer, do so */
if (left >= 0)
{
/* Use either the buffer size, or the bytes left, whichever */
/* is the smallest. */
write = left > m->data.ram_fetch.buffer_size ? m->data.ram_fetch.buffer_size : left;
if (write)
{
/* Transfer the data */
e = wimp_transfer_block(task_handle,
uri_file + (*transferred),
m->hdr.sender,
m->data.ram_fetch.buffer,
write);
if (e) goto save_transfer_uri_exit;
}
/* If we have any data left to send, reply with a Message_RAMTransmit */
e = protocols_atats_send_ram_transmit(m, write, write < m->data.ram_fetch.buffer_size);
/* Increment the transferred counter */
*transferred += write;
left -= write;
}
/* Finished */
save_transfer_uri_exit:
/* Free the URI file buffer, if we claimed one */
if (uri_file) free (uri_file);
return e;
}
/*************************************************/
/* save_uri_size() */
/* */
/* Returns the size, in bytes, that a URI or URL */
/* file will be. */
/* */
/* Parameters: Pointer to the URL that would be */
/* saved; */
/* */
/* Pointer to the URL title, or NULL */
/* / null string for no title; */
/* */
/* 0 to find the length of a URI */
/* file, 1 to find the length of a */
/* URL file (as in save_save_uri). */
/* */
/* Returns: The size, in bytes, that the file */
/* will be. */
/*************************************************/
int save_uri_size(char * url, char * title, int write_url)
{
int len = 0;
/* Sanity check */
if (title && !*title) title = NULL;
if (!url || !*url)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid parameters to save_uri_size: %p, %d",
url,
write_url);
show_error_ret(&erb);
#endif
return 0;
}
if (!write_url)
{
/* URI file */
len = strlen("URI\t100\n\t# ");
len += strlen(lookup_token("_TaskName",1,0));
len += strlen(" v");
len += strlen(lookup_token("Version:(Unknown!)",0,0));
len += strlen("\n\n\t");
len += strlen(url);
len += strlen("\n\t");
len += strlen(title ? title : "*");
}
else
{
/* URL file */
len = strlen(url); /* (No terminator needed in URL files, so no '+ 1') */
}
return len;
}
/*************************************************/
/* save_build_messages_path() */
/* */
/* Builds a pathname in a malloc block through */
/* which the Choices or Controls file may be */
/* accessed. The caller is responsible for */
/* freeing the block. */
/* */
/* Parameters: 0 for the Choices file (to load), */
/* 1 for the Controls file (to */
/* load), 2 for the Choices file (to */
/* save), 3 for the Controls file */
/* (to save). */
/* */
/* Returns: Pointer to a null-terminated */
/* pathname, in a malloc block, or */
/* NULL if there was an error. */
/*************************************************/
char * save_build_messages_path(int which)
{
int len, exists;
char * path;
char * sysvar;
char * defpath;
len = strlen(lookup_token("_TaskName", 1, 0));
len += sizeof("$ControlsFile"); /* Longer than "$ChoicesFile"! */
sysvar = malloc(len);
if (!sysvar) return NULL;
else strcpy(sysvar, tokens);
switch (which)
{
case 0:
{
strcat(sysvar, "$ChoicesFile");
defpath = ".Choices";
}
break;
case 1:
{
strcat(sysvar, "$ControlsFile");
defpath = ".Controls";
}
break;
case 2:
{
strcat(sysvar, "$ChoicesSave");
defpath = ".Choices";
}
break;
case 3:
{
strcat(sysvar, "$ControlsSave");
defpath = ".Controls";
}
break;
default:
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Fatal;
sprintf(erb.errmess,
"In open_messages_file, passed unrecognised parameter value '%d'",
which);
/* OK, so you'll get the above error and then callers will */
/* probably think this call ran out of memory due to the */
/* NULL return (assuming the below call doesn't cause an */
/* immediate exit - it depends on what stage of */
/* initialisation the browser is at). But at least you get */
/* to see what is happening. */
show_error_ret(&erb);
free(sysvar);
return NULL;
#else
free(sysvar);
return NULL;
#endif
}
}
/* First, find the system variable length. Must use _kernel_swi */
/* here for various reasons. */
{
_kernel_swi_regs r;
r.r[0] = (int) sysvar;
r.r[1] = (int) NULL;
r.r[2] = -1;
r.r[3] = 0;
r.r[4] = 0;
/* Equivalent to getenv(), but the RISC OS implementation evaluates */
/* the system variable as an expression which we don't want (at */
/* least, not under RISC OS); hence the direct use of the SWI. */
_kernel_swi(OS_ReadVarVal, &r, &r);
len = -r.r[2]; /* This includes a terminator */
}
if (!len)
{
/* Variable doesn't exist */
len = strlen(task_dir) + strlen(defpath) + 1;
exists = 0;
}
else exists = 1;
/* Allocate space */
path = calloc(len + 1, 1);
if (!path)
{
free(sysvar);
return NULL;
}
/* Read the variable or copy the data in */
if (exists) _swix(OS_ReadVarVal,
_INR(0,4),
sysvar, /* Variable name */
path, /* Buffer */
len, /* Size of buffer */
0, /* Name pointer (0 for 1st call) */
4); /* Variable type (4 = literal string) */
else
{
strcpy(path, task_dir);
strcat(path, defpath);
}
free(sysvar);
return path;
}
/*************************************************/
/* save_save_string() */
/* */
/* Output a string */
/* */
/* Parameters: Pointer to a FILE struct holding */
/* info on the file to write to; */
/* */
/* String number to write. */
/* */
/* Returns: Number of characters written, or */
/* EOF if there was an error. */
/*************************************************/
static int save_save_string(FILE * file, char * string)
{
int length;
if ((length = strlen(string)) == 0) return 0;
if (fprintf(file, "%s", string) < length) return EOF;
return length;
}
/*************************************************/
/* save_save_colour() */
/* */
/* Output a colour number in the format seen in */
/* the Choices file, to a given file. */
/* */
/* Parameters: Pointer to a FILE struct holding */
/* info on the file to write to; */
/* */
/* Colour number to write. */
/* */
/* Returns: Number of characters written, or */
/* EOF if there was an error. */
/*************************************************/
static int save_save_colour(FILE * file, int colour)
{
if (fprintf(file, "0x%08x", colour) < 10) return EOF;
return 10;
}
/*************************************************/
/* save_save_number() */
/* */
/* Output a number as ASCII, to a given file. */
/* */
/* Parameters: Pointer to a FILE struct holding */
/* info on the file to write to; */
/* */
/* Number to write. */
/* */
/* Returns: Number of characters written, or */
/* EOF if there was an error. */
/*************************************************/
static int save_save_number(FILE * file, int number)
{
char buffer[64];
int len;
len = sprintf(buffer, "%d", number);
if (fprintf(file, "%s", buffer) < len) return EOF;
return len;
}
/*************************************************/
/* save_save_yes_no() */
/* */
/* Output either 'yes' or 'no' to a given file. */
/* */
/* Parameters: Pointer to a FILE struct holding */
/* info on the file to write to; */
/* */
/* 0 to write 'no', else 'yes'. */
/* */
/* Returns: Number of characters written, or */
/* EOF if there was an error. */
/*************************************************/
static int save_save_yes_no(FILE * file, int yes)
{
if (!yes)
{
if (fprintf(file, "no") < 2) return EOF;
}
else
{
if (fprintf(file, "yes") < 3) return EOF;
}
return !yes ? 2 : 3;
}
/*************************************************/
/* save_save_font() */
/* */
/* Saves a typeface definition in the form */
/* required by the browser font manager. */
/* */
/* Parameters: Pointer to a FILE struct holding */
/* info on the file to write to; */
/* */
/* The name of the typeface to save. */
/* */
/* Returns: Number of characters written, or */
/* EOF if there was an error. */
/* */
/* Assumes: No sanity checking is given on */
/* any of the supplied parameters... */
/*************************************************/
static int save_save_font(FILE * file, char * typefacename)
{
fm_typeface * tfptr;
tfptr = fm_find_typeface(typefacename);
if (!tfptr) return EOF;
return fprintf(file,
"%s=%s:%s:%s:%s;%s",
tfptr->name,
tfptr->fontnames[0],
tfptr->fontnames[1],
tfptr->fontnames[2],
tfptr->fontnames[3],
tfptr->alternative);
}
/*************************************************/
/* save_save_general() */
/* */
/* Save a general item to the given file. This */
/* is for items with a discrete set of values */
/* that map to a discrete set of strings. */
/* */
/* Parameters: Pointer to a FILE struct holding */
/* info on the file to write to; */
/* */
/* The number of discrete values */
/* that the item may take; */
/* */
/* Pointer to an array of the above */
/* size holding the values; */
/* */
/* Pointer to an array of (char *)'s */
/* pointing to the strings that map */
/* to the values in the int array; */
/* */
/* Value to match out of those given */
/* in the int array; */
/* */
/* Default item (from 1 to the value */
/* given in the second parameter) to */
/* use if the match value is not */
/* found in the int array. */
/* */
/* Returns: Number of characters written, or */
/* EOF if there was an error. */
/* */
/* Assumes: No sanity checking is given on */
/* any of the supplied parameters... */
/*************************************************/
static int save_save_general(FILE * file, int how_many, const int numbers[], const char * strings[], int match, int def)
{
int i, found = 0;
const char * string = NULL;
int sl;
/* Try to find the match value in the array of ints */
for (i = 0; i < how_many && !found; i++)
{
if (numbers[i] == match) string = strings[i], found = 1;
}
/* If not found, raise an error in TRACE builds, and pick */
/* the given default string */
if (!found)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Match value '%d' not found in save_save_general (",
match);
for (
i = 0;
i < how_many && strlen(erb.errmess) + strlen(strings[i]) + 9 < sizeof(erb.errmess);
i++
)
{
strcat(erb.errmess, strings[i]);
if (i != how_many - 1) strcat(erb.errmess, ", ");
if (i == how_many - 2) strcat(erb.errmess, "or ");
}
strcat(erb.errmess, ").");
show_error_ret(&erb);
#endif
if (def > how_many) def = how_many;
string = strings[def - 1];
}
/* Output the item to the file */
if (!string) return EOF;
sl = strlen(string);
if (fprintf(file, "%s", string) < sl) return EOF;
return sl;
}
/*************************************************/
/* save_save_choices() */
/* */
/* Saves out the Choices file to either the */
/* given path or to the path constructed in */
/* save_build_messages_page. Uses the global */
/* Choices block as the source of what should be */
/* written. */
/* */
/* Parameters: Pointer to a null-terminated path */
/* to write the file to, or NULL for */
/* default (see description above). */
/*************************************************/
_kernel_oserror * save_save_choices(char * path)
{
_kernel_oserror * e = NULL;
FILE * file = NULL;
char * out = NULL;
char * canonicalised_out = NULL;
char * p = NULL; /* Moves through the file loaded into a malloc block. */
char * op = NULL; /* Remembers the start address of the block. */
char * en; /* Remembers the end address of the block. */
int size;
int type;
#ifdef TRACE
if (tl & (1u<<26)) Printf("save_save_choices: Called\n");
#endif
/* Find out where to get the file from */
if (path && *path) out = path;
else out = save_build_messages_path(2);
if (!out) return make_no_memory_error(14);
/* Now ensure the path is there */
(utils_canonicalise_path(out, &canonicalised_out));
/* Can get rid of 'out' if we allocated it locally */
if (!path || !*path)
{
free(out);
out = NULL;
}
if (!canonicalised_out) return make_no_memory_error(14);
#ifdef TRACE
if (tl & (1u<<26)) Printf("save_save_choices: Working with file '%s'\n", canonicalised_out);
#endif
/* Ensure this path is available */
e = utils_build_tree(canonicalised_out);
if (e) goto save_save_choices_read_error;
/* Find out how big the file is - for this of course, use */
/* the *load* path, not the canonicalised save path */
{
char * load_path = save_build_messages_path(0);
if (!load_path)
{
free(canonicalised_out);
return make_no_memory_error(14);
}
e = _swix(OS_File,
_INR(0,1) | _OUT(0) | _OUT(4),
17,
load_path,
&type,
&size);
/* Throw the local path away - want to minimise how many */
/* malloc blocks we're juggling for fear of opening up a */
/* memory leak in here */
free(load_path);
if (e || type != 1) goto save_save_choices_read_error;
}
/* Allocate memory for the file */
p = malloc(size + 1);
if (!p)
{
free(canonicalised_out);
return make_no_memory_error(14);
}
en = p + size;
op = p;
/* Read the file into memory - again, use the load path */
/* not the save path. Rebuild this path to avoid having */
/* any more malloc blocks flying about (see comments */
/* earlier) - it doesn't take long to do this, and the */
/* function isn't speed critical anyway. */
{
char * load_path = save_build_messages_path(0);
if (!load_path)
{
free(canonicalised_out);
free(op);
return make_no_memory_error(14);
}
e = _swix(OS_File,
_INR(0,3),
16,
load_path,
p,
0);
free(load_path);
if (e) goto save_save_choices_read_error;
}
/* Force a null terminator at the end, so strchr() calls */
/* (or equivalent code fragments) don't run off the end */
/* of the block. */
p[size] = 0;
/* Open it for writing */
file = fopen(canonicalised_out, "wb");
if (!file) goto save_save_choices_write_error;
/* Use the original file in memory as a reference for */
/* writing the new one. */
do
{
/* Comments or white space */
if (*p == '#' || *p < ' ')
{
/* Output until an end of line marker */
while (*p >= ' ')
{
if (fputc(*p++, file) == EOF) goto save_save_choices_write_error;
}
/* Output any control characters - we thus preserve */
/* CR, LF, CR+LF or whatever was in the original file */
while (*p < ' ' && p < en)
{
if (fputc(*p++, file) == EOF) goto save_save_choices_write_error;
}
}
/* If not comments or white space, must have a token */
else
{
char * token_end;
int len;
token_end = p;
/* Search for a ':', but don't go off the end of a line */
while (*token_end > 31 && *token_end != ':') token_end++;
len = token_end - p; /* Doesn't include ':' in the count */
if (*token_end == ':' && len)
{
int i, result = 0;
for (i = 0; i <= len; i++) /* '<=' to include the ':' */
{
if (fputc(p[i], file) == EOF) goto save_save_choices_write_error;
}
/* Now it just gets tedious...! */
if (!strncmp(p, "HomePage", len)) result = save_save_string(file, choices.home_page);
else if (!strncmp(p, "BackColour", len)) result = save_save_colour(file, choices.background_colour);
else if (!strncmp(p, "TextColour", len)) result = save_save_colour(file, choices.text_colour);
else if (!strncmp(p, "LinkColour", len)) result = save_save_colour(file, choices.link_colour);
else if (!strncmp(p, "UsedColour", len)) result = save_save_colour(file, choices.used_colour);
else if (!strncmp(p, "FollColour", len)) result = save_save_colour(file, choices.followed_colour);
else if (!strncmp(p, "SeleColour", len)) result = save_save_colour(file, choices.selected_colour);
else if (!strncmp(p, "SupportTables", len)) result = save_save_yes_no(file, choices.support_tables);
else if (!strncmp(p, "TableOuter", len))
{
static const char * s[] = {
"2d",
"auto",
"3d",
"never"
};
static const int v[] = {
Choices_TableOuter_Always2D,
Choices_TableOuter_Auto,
Choices_TableOuter_Always3D,
Choices_TableOuter_Never
};
result = save_save_general(file, 4, v, s, choices.table_outer, 3);
}
else if (!strncmp(p, "TableInner", len))
{
static const char * s[] = {
"2d",
"auto",
"3d",
"never"
};
static const int v[] = {
Choices_TableInner_Always2D,
Choices_TableInner_Auto,
Choices_TableInner_Always3D,
Choices_TableInner_Never
};
result = save_save_general(file, 4, v, s, choices.table_inner, 3);
}
else if (!strncmp(p, "FontSize", len)) result = save_save_number(file, choices.font_size);
else if (!strncmp(p, "TTAspect", len)) result = save_save_number(file, choices.tt_aspect);
else if (!strncmp(p, "SystemFont", len)) result = save_save_yes_no(file, choices.system_font);
else if (!strncmp(p, "Typeface1", len)) result = save_save_font(file, "fixed");
else if (!strncmp(p, "Typeface2", len)) result = save_save_font(file, "sans");
else if (!strncmp(p, "Typeface3", len)) result = save_save_font(file, "serif");
else if (!strncmp(p, "Encoding", len)) result = save_save_number(file, choices.encoding);
else if (!strncmp(p, "UnderlineLinks", len)) result = save_save_yes_no(file, choices.underline_links);
else if (!strncmp(p, "UseSourceCols", len)) result = save_save_yes_no(file, choices.use_source_cols);
else if (!strncmp(p, "ShowForeground", len)) result = save_save_yes_no(file, choices.show_foreground);
else if (!strncmp(p, "ShowBackground", len)) result = save_save_yes_no(file, choices.show_background);
else if (!strncmp(p, "LeftMargin", len)) result = save_save_number(file, choices.left_margin);
else if (!strncmp(p, "RightMargin", len)) result = save_save_number(file, choices.right_margin);
else if (!strncmp(p, "QuoteMargin", len)) result = save_save_number(file, choices.quote_margin);
else if (!strncmp(p, "Leading", len)) result = save_save_number(file, choices.leading);
else if (!strncmp(p, "LeftIndent", len)) result = save_save_number(file, choices.left_indent);
else if (!strncmp(p, "MaxImages", len)) result = save_save_number(file, choices.maximages);
else if (!strncmp(p, "ClientPull", len)) result = save_save_yes_no(file, choices.client_pull);
else if (!strncmp(p, "SupportFrames", len)) result = save_save_yes_no(file, choices.support_frames);
else if (!strncmp(p, "SupportObject", len)) result = save_save_yes_no(file, choices.support_object);
else if (!strncmp(p, "PlugInControl", len))
{
static const char * s[] = {
"never",
"viewed",
"asap"
};
static const int v[] = {
Choices_PlugIns_Never,
Choices_PlugIns_Viewed,
Choices_PlugIns_ASAP
};
result = save_save_general(file, 3, v, s, choices.plugin_control, 3);
}
else if (!strncmp(p, "SeeFetches", len)) result = save_save_yes_no(file, choices.see_fetches);
else if (!strncmp(p, "SaveHotlist", len))
{
static const char * s[] = {
"never",
"once",
"always"
};
static const int v[] = {
Choices_SaveHotlist_Never,
Choices_SaveHotlist_Once,
Choices_SaveHotlist_Always
};
result = save_save_general(file, 3, v, s, choices.save_hotlist, 3);
}
else if (!strncmp(p, "AddHotlist", len))
{
static const char * s[] = {
"top",
"bottom"
};
static const int v[] = {
Choices_AddHotlist_Top,
Choices_AddHotlist_Bottom
};
result = save_save_general(file, 2, v, s, choices.add_hotlist, 2);
}
else if (!strncmp(p, "HotlistType", len))
{
static const char * s[] = {
"urls",
"descriptions"
};
static const int v[] = {
Choices_HotlistType_URLs,
Choices_HotlistType_Descriptions
};
result = save_save_general(file, 2, v, s, choices.hotlist_show, 2);
}
else if (!strncmp(p, "AutoOpenDelay", len)) result = save_save_number(file, choices.auto_open_delay);
else if (!strncmp(p, "AutoScrollDelay", len)) result = save_save_number(file, choices.auto_scroll_delay);
else if (!strncmp(p, "AutoScrollMargin", len)) result = save_save_number(file, choices.auto_scroll_margin);
else if (!strncmp(p, "MaxSize", len)) result = save_save_number(file, choices.max_size / 1024); /* (Convert bytes to K) */
else if (!strncmp(p, "ImageMaxSize", len)) result = save_save_number(file, choices.image_max_size / 1024);
else if (!strncmp(p, "ExpiryAge", len)) result = save_save_number(file, choices.expiry_age);
else if (!strncmp(p, "ImageExpiryAge", len)) result = save_save_number(file, choices.image_expiry_age);
else if (!strncmp(p, "ShowURLs", len)) result = save_save_yes_no(file, choices.show_urls);
else if (!strncmp(p, "SaveHistory", len))
{
static const char * s[] = {
"never",
"once",
"always"
};
static const int v[] = {
Choices_SaveHistory_Never,
Choices_SaveHistory_Once,
Choices_SaveHistory_Always
};
result = save_save_general(file, 3, v, s, choices.save_history, 3);
}
else if (!strncmp(p, "SaveImageHistory", len))
{
static const char * s[] = {
"never",
"once",
"always"
};
static const int v[] = {
Choices_SaveImageHistory_Never,
Choices_SaveImageHistory_Once,
Choices_SaveImageHistory_Always
};
result = save_save_general(file, 3, v, s, choices.save_image_history, 3);
}
else if (!strncmp(p, "URLbar", len)) result = save_save_yes_no(file, choices.url_bar);
else if (!strncmp(p, "ButtonBar", len)) result = save_save_yes_no(file, choices.button_bar);
else if (!strncmp(p, "StatusBar", len)) result = save_save_yes_no(file, choices.status_bar);
else if (!strncmp(p, "MoveGadgets", len))
{
static const char * s[] = {
"never",
"atend",
"during"
};
static const int v[] = {
Choices_MoveGadgets_Never,
Choices_MoveGadgets_AtEnd,
Choices_MoveGadgets_During
};
result = save_save_general(file, 3, v, s, choices.move_gadgets, 3);
}
else if (!strncmp(p, "Width", len)) result = save_save_number(file, choices.width);
else if (!strncmp(p, "Height", len)) result = save_save_number(file, choices.height);
else if (!strncmp(p, "OverrideX", len)) result = save_save_number(file, choices.override_x);
else if (!strncmp(p, "OverrideY", len)) result = save_save_number(file, choices.override_y);
else if (!strncmp(p, "SolidResize", len))
{
static const char * s[] = {
"no",
"yes",
"always"
};
static const int v[] = {
Choices_SolidResize_No,
Choices_SolidResize_Yes,
Choices_SolidResize_Always
};
result = save_save_general(file, 3, v, s, choices.solid_resize, 3);
}
else if (!strncmp(p, "FullScreen", len)) result = save_save_yes_no(file, choices.full_screen);
else if (!strncmp(p, "HScroll", len))
{
static const char * s[] = {
"no",
"yes",
"auto"
};
static const int v[] = {
Choices_HScroll_No,
Choices_HScroll_Yes,
Choices_HScroll_Auto
};
result = save_save_general(file, 3, v, s, choices.h_scroll, 3);
}
else if (!strncmp(p, "VScroll", len))
{
static const char * s[] = {
"no",
"yes",
"auto"
};
static const int v[] = {
Choices_VScroll_No,
Choices_VScroll_Yes,
Choices_VScroll_Auto
};
result = save_save_general(file, 3, v, s, choices.v_scroll, 3);
}
else if (!strncmp(p, "RefoWait", len)) result = save_save_yes_no(file, choices.refo_wait);
else if (!strncmp(p, "RefoHang", len)) result = save_save_yes_no(file, choices.refo_hang);
else if (!strncmp(p, "RefoTime", len)) result = save_save_number(file, choices.refo_time);
else if (!strncmp(p, "FixedPtr", len)) result = save_save_yes_no(file, choices.fixed_pointer);
else if (!strncmp(p, "HighlightLks", len)) result = save_save_yes_no(file, choices.highlight_links);
else if (!strncmp(p, "KeyboardCtl", len)) result = save_save_yes_no(file, choices.keyboard_ctrl);
else if (!strncmp(p, "Clone", len)) result = save_save_yes_no(file, choices.clone);
else if (!strncmp(p, "UseProxy", len)) result = save_save_yes_no(file, choices.use_proxy);
else if (!strncmp(p, "ProxyAddress", len)) result = save_save_string(file, choices.proxy_address);
else if (!strncmp(p, "StartProxy", len)) result = save_save_yes_no(file, choices.start_proxy);
#ifndef SINGLE_USER
else if (!strncmp(p, "PostIn", len)) result = save_save_string(file, choices.post_in);
else if (!strncmp(p, "PostOut", len)) result = save_save_string(file, choices.post_out);
#endif
else
{
/* Token we don't understand - output the rest of the line */
#ifdef TRACE
if (tl & (1u<<26))
{
Printf("save_save_choices: Unrecognised token '");
for (i = 0; i <= len; i++)
{
Printf("%c", p[i]);
}
Printf("'\n");
}
#endif
p += len + 1;
while (*p >= ' ' && result != EOF) result = fputc(*p++, file);
}
if (result == EOF) goto save_save_choices_write_error;
/* Skip to the end of the line */
while (*p >= ' ') p++;
/* Output any control characters - we thus preserve */
/* CR, LF, CR+LF or whatever was in the original file */
while (*p < ' ' && p < en)
{
if (fputc(*p++, file) == EOF) goto save_save_choices_write_error;
}
}
else
{
/* Unrecognised line contents; spit out the whole line */
#ifdef TRACE
if (tl & (1u<<26))
{
int i = 0;
Printf("save_save_choices: Unknown line fragment '");
while (p[i] >= ' ')
{
Printf("%c", p[i++]);
}
Printf("'\n");
}
#endif
while (*p >= ' ')
{
if (fputc(*p++, file) == EOF) goto save_save_choices_write_error;
}
}
}
}
while (p < en);
/* Close the output file */
fclose(file);
/* Set the filetype - not essential, just nice to have, so */
/* let it fail silently. */
_swix(OS_File,
_INR(0,2),
18, /* Set type of named object */
canonicalised_out,
FileType_TEXT);
/* Free the canonicalised path */
free(canonicalised_out);
/* Free the old Choices file */
free(op);
/* Finished */
#ifdef TRACE
if (tl & (1u<<26)) Printf("save_save_choices: Successful\n");
#endif
return NULL;
/* Error condition exits */
save_save_choices_read_error:
if (!path || !*path) free(out);
free(op);
free(canonicalised_out);
erb.errnum = Utils_Error_Custom_Message;
StrNCpy0(erb.errmess,
lookup_token("COChoices:Can't open the Choices file - the preferences cannot be saved.",
0,
0));
#ifdef TRACE
if (tl & (1u<<26)) Printf("save_save_choices: Can't open Choices file, exitting\n");
#endif
return &erb;
save_save_choices_write_error:
erb = *_kernel_last_oserror();
if (file) fclose(file);
/* We really want to avoid leaving a broken Choices file, so */
/* have a last ditch go at dumping the original file down. */
_swix(OS_File,
_INR(0,2) | _INR(4,5),
10,
out,
FileType_TEXT,
op,
en);
/* Free any temporary blocks */
if (!path || !*path) free(out);
free(op);
free(canonicalised_out);
#ifdef TRACE
if (tl & (1u<<26)) Printf("save_save_choices: Exitting with error\n");
#endif
return &erb;
}