WebSVN – SvarDOS – Diff – /localcfg/trunk/country.c


/*
 * functions that reads/writes from/to the localcfg country.sys-like file.
 * Copyright (C) Mateusz Viste 2015-2022
 */
 
#include <stdio.h>
#include <string.h>
 
#include "country.h"
 
 
struct funchdr {
  unsigned char funcname[8];
  unsigned short funcsiz;
};
 
static unsigned char filebuff[1024];
 
 
/* fills a country struct with default values */
static void country_default(struct country *countrydata) {
 
  /* first clear the memory */
  bzero(countrydata, sizeof(struct country));
 
  /* fill in CTYINFO fields (non-zero values only) */
  countrydata->CTYINFO.id = 1;
  countrydata->CTYINFO.codepage = 437;
  /* countrydata->CTYINFO.datefmt = COUNTRY_DATE_MDY;
  countrydata->CTYINFO.timefmt = COUNTRY_TIME12; */
  countrydata->CTYINFO.currsym[0] = '$';
  countrydata->CTYINFO.decimal[0] = '.';
  countrydata->CTYINFO.thousands[0] = ',';
  countrydata->CTYINFO.datesep[0] = '/';
  countrydata->CTYINFO.timesep[0] = ':';
  countrydata->CTYINFO.currprec = 2;
  /* countrydata->CTYINFO.currencydecsym = 0; */
  /* countrydata->CTYINFO.currencyspace = 0; */
  /* countrydata->CTYINFO.currencypos = 0; */
 
  /* fill in YESNO fields (non-zero values only) */
  countrydata->YESNO.yes[0] = 'Y';
  countrydata->YESNO.no[0] = 'N';
}
 
 
/* Loads data from a country.sys file into a country struct.
 * Returns 0 on success, non-zero otherwise. */
int country_read(struct country *countrydata, const char *fname) {
  short firstentryoffs;
  unsigned char *subfunctions[16] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
                                     NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
  short filesize;
  short subfunctionscount;
  unsigned char *functiondata;
  int x;
  FILE *fd;
 
  /* preload the country struct with default values */
  country_default(countrydata);
 
  /* load the file into buff, if file exists */
  fd = fopen(fname, "rb");
  if (fd == NULL) return(0); /* "file doesn't exist" is not an error condition */
  filesize = fread(filebuff, 1, sizeof(filebuff), fd);
  fclose(fd);
 
  /* check that it's a country file - should start with 0xFF COUNTRY 0x00 */
  if (memcmp(filebuff, "\377COUNTRY\0", 9) != 0) return(COUNTRY_ERR_INV_FORMAT);
 
  /* check that it's one of my country.sys files - should contain a trailer */
  if (memcmp(filebuff + filesize - 8, "LOCALCFG", 8) != 0) return(COUNTRY_ERR_NOT_LOCALCFG);
 
  /* read the offset of the entries index - must be at least 23 */
  functiondata = filebuff + 19;
  firstentryoffs = *((unsigned short *)functiondata);
  if ((firstentryoffs < 23) || (firstentryoffs >= filesize)) return(-4);
  functiondata = filebuff + firstentryoffs;
 
  /* how many entries do we have? I expect exactly one. */
  if (*((unsigned short *)functiondata) != 1) return(-5);
  /* skip to the first country entry */
  functiondata += 2;
 
  /* skip directly to the subfunctions of the first country */
  /* ddwords: size, country, codepage, reserved, reserved, offset */
  /* printf("Size = %d\n", READSHORT(functiondata)); */
  functiondata += 2; /* skip size */
  /* printf("Country = %d\n", READSHORT(functiondata[0]); */
  functiondata += 2; /* skip country */
  /* printf("Codepage = %d\n", READSHORT(functiondata)); */
  functiondata += 2; /* skip codepage */
  functiondata += 4; /* skip reserved fields */
  firstentryoffs = *((unsigned short *)functiondata); /* read offset of the subfunctions index */
  functiondata = filebuff + firstentryoffs;
 
  /* read all subfunctions, but no more than 15 */
  subfunctionscount = *((unsigned short *)functiondata);
  /* printf("Found %d subfunctions\n", subfunctionscount); */
  functiondata += 2;
  for (x = 0; (x < 15) && (x < subfunctionscount); x++) {
    short size = *((unsigned short *)functiondata);
    functiondata += 2;
    functiondata += 2; /* skip ID of the subfunction */
    subfunctions[x] = filebuff + *((unsigned short *)functiondata);
    /* printf("subfunction %d at 0x%p\n", x, subfunctions[x]); */
    functiondata += size - 2;
  }
 
  /* load every subfunction, and feed the country struct with data */
  for (x = 0; subfunctions[x] != NULL; x++) {
    struct funchdr *hdr = (void *)(subfunctions[x]);
    functiondata = subfunctions[x] + 10;
    /* */
    if ((memcmp(hdr->funcname, "\377YESNO  ", 8) == 0) && (hdr->funcsiz == 4)) {
      memcpy(&(countrydata->YESNO), functiondata, hdr->funcsiz);
    } else if ((memcmp(hdr->funcname, "\377CTYINFO", 8) == 0) && (hdr->funcsiz == 22)) {
      memcpy(&(countrydata->CTYINFO), functiondata, hdr->funcsiz);
    }
  }
 
  return(0);
}
 
 
#define MSB(x) (((x) >> 8) & 0xff)
#define LSB(x) ((x) & 0xff)
 
 
/* Computes a new country.sys file based on data from a country struct.
 * Returns 0 on success, non-zero otherwise. */
int country_write(const char *fname, struct country *c) {
  short filesize = 0;
  FILE *fd;
  int x;
  short subfunction_id[7] = {1,2,4,5,6,7,35};
  short subfunction_ptr[7];
 
  const unsigned char ucase_437[128] = {128, 154,  69,  65, 142,  65, 143, 128,
                                         69,  69,  69,  73,  73,  73, 142, 143,
                                        144, 146, 146,  79, 153,  79,  85,  85,
                                         89, 153, 154, 155, 156, 157, 158, 159,
                                         65,  73,  79,  85, 165, 165, 166, 167,
                                        168, 169, 170, 171, 172, 173, 174, 175,
                                        176, 177, 178, 179, 180, 181, 182, 183,
                                        184, 185, 186, 187, 188, 189, 190, 191,
                                        192, 193, 194, 195, 196, 197, 198, 199,
                                        200, 201, 202, 203, 204, 205, 206, 207,
                                        208, 209, 210, 211, 212, 213, 214, 215,
                                        216, 217, 218, 219, 220, 221, 222, 223,
                                        224, 225, 226, 227, 228, 229, 230, 231,
                                        232, 233, 234, 235, 236, 237, 238, 239,
                                        240, 241, 242, 243, 244, 245, 246, 247,
                                        248, 249, 250, 251, 252, 253, 254, 255};
 
  const unsigned char collate_437[256] = {  0,   1,   2,   3,   4,   5,   6,   7,
                                            8,   9,  10,  11,  12,  13,  14,  15,
                                           16,  17,  18,  19,  20,  21,  22,  23,
                                           24,  25,  26,  27,  28,  29,  30,  31,
                                           32,  33,  34,  35,  36,  37,  38,  39,
                                           40,  41,  42,  43,  44,  45,  46,  47,
                                           48,  49,  50,  51,  52,  53,  54,  55,
                                           56,  57,  58,  59,  60,  61,  62,  63,
                                           64,  65,  66,  67,  68,  69,  70,  71,
                                           72,  73,  74,  75,  76,  77,  78,  79,
                                           80,  81,  82,  83,  84,  85,  86,  87,
                                           88,  89,  90,  91,  92,  93,  94,  95,
                                           96,  65,  66,  67,  68,  69,  70,  71,
                                           72,  73,  74,  75,  76,  77,  78,  79,
                                           80,  81,  82,  83,  84,  85,  86,  87,
                                           88,  89,  90, 123, 124, 125, 126, 127,
                                           67,  85,  69,  65,  65,  65,  65,  67,
                                           69,  69,  69,  73,  73,  73,  65,  65,
                                           69,  65,  65,  79,  79,  79,  85,  85,
                                           89,  79,  85,  36,  36,  36,  36,  36,
                                           65,  73,  79,  85,  78,  78, 166, 167,
                                           63, 169, 170, 171, 172,  33,  34,  34,
                                          176, 177, 178, 179, 180, 181, 182, 183,
                                          184, 185, 186, 187, 188, 189, 190, 191,
                                          192, 193, 194, 195, 196, 197, 198, 199,
                                          200, 201, 202, 203, 204, 205, 206, 207,
                                          208, 209, 210, 211, 212, 213, 214, 215,
                                          216, 217, 218, 219, 220, 221, 222, 223,
                                          224,  83, 226, 227, 228, 229, 230, 231,
                                          232, 233, 234, 235, 236, 237, 238, 239,
                                          240, 241, 242, 243, 244, 245, 246, 247,
                                          248, 249, 250, 251, 252, 253, 254, 255};
 
  /* zero out filebuff */
  bzero(filebuff, sizeof(filebuff));
 
  /* compute the country.sys structures */
  memcpy(filebuff, "\377COUNTRY\0\0\0\0\0\0\0\0\1\0\1", 19); /* header */
  filesize = 19;
  /* first entry offset (always current offset+4) */
  filesize += 4;
  memcpy(filebuff + filesize - 4, &filesize, sizeof(filesize));
  /* number of entries */
  filebuff[filesize] = 1;
  filesize += 2;
  /* first (and only) entry / size, country, codepage, reserved(2), offset */
  filebuff[filesize++] = 12; /* size LSB */
  filebuff[filesize++] = 0;  /* size MSB */
  filebuff[filesize++] = LSB(c->CTYINFO.id);   /* country LSB */
  filebuff[filesize++] = MSB(c->CTYINFO.id);   /* country MSB */
  filebuff[filesize++] = LSB(c->CTYINFO.codepage); /* codepage LSB */
  filebuff[filesize++] = MSB(c->CTYINFO.codepage); /* codepage MSB */
  filesize += 4;       /* reserved bytes */
 
  filesize += 4;
  memcpy(filebuff + filesize - 4, &filesize, sizeof(filesize));
 
  /* index of subfunctions */
  filebuff[filesize] = 7; /* there are 7 subfunctions */
  filesize += 2;
  for (x = 0; x < 7; x++) { /* dump each subfunction (size, id, offset) */
    /* size is always 6 */
    filebuff[filesize] = 6;
    filesize += 2;
    /* id of the subfunction */
    filebuff[filesize++] = LSB(subfunction_id[x]);
    filebuff[filesize++] = MSB(subfunction_id[x]);
    /* remember the offset of the subfunction pointer for later */
    subfunction_ptr[x] = filesize;
    filesize += 4;
  }
 
  /* write the CTYINFO subfunction */
  memcpy(filebuff + subfunction_ptr[0], &filesize, sizeof(filesize));
 
  /* subfunction header */
  memcpy(filebuff + filesize, "\377CTYINFO", 8);
  filesize += 8;
  /* subfunction size */
  filebuff[filesize] = 22;
  filesize += 2;
 
  /* country preferences */
  memcpy(filebuff + filesize, &(c->CTYINFO), 22);
  filesize += 22;
 
  /* write the UCASE subfunction (used for LCASE, too) */
  memcpy(filebuff + subfunction_ptr[1], &filesize, sizeof(filesize));
  memcpy(filebuff + subfunction_ptr[2], &filesize, sizeof(filesize));
 
  /* subfunction header */
  memcpy(filebuff + filesize, "\377UCASE  ", 8);
  filesize += 8;
  /* subfunction size */
  filebuff[filesize++] = 128;
  filebuff[filesize++] = 0;
  /* UCASE table */
  memcpy(filebuff + filesize, ucase_437, 128);
  filesize += 128;
 
  /* write the FCHAR subfunction (filename terminator table) */
  memcpy(filebuff + subfunction_ptr[3], &filesize, sizeof(filesize));
 
  /* subfunction header */
  memcpy(filebuff + filesize, "\377FCHAR  ", 8);
  filesize += 8;
  /* subfunction size */
  filebuff[filesize++] = 22;
  filebuff[filesize++] = 0;
  /* values here are quite obscure, dumped from country.sys */
  filebuff[filesize++] = 142;
  filebuff[filesize++] = 0;
  filebuff[filesize++] = 255;
  filebuff[filesize++] = 65;
  filebuff[filesize++] = 0;
  filebuff[filesize++] = 32;
  filebuff[filesize++] = 238;
  /* list of characters that terminates a filename */
  filebuff[filesize++] = 14;  /* how many of them */
  filebuff[filesize++] = 46;  /* . */
  filebuff[filesize++] = 34;  /* " */
  filebuff[filesize++] = 47;  /* / */
  filebuff[filesize++] = 92;  /* \ */
  filebuff[filesize++] = 91;  /* [ */
  filebuff[filesize++] = 93;  /* ] */
  filebuff[filesize++] = 58;  /* : */
  filebuff[filesize++] = 124; /* | */
  filebuff[filesize++] = 60;  /* < */
  filebuff[filesize++] = 62;  /* > */
  filebuff[filesize++] = 43;  /* + */
  filebuff[filesize++] = 61;  /* = */
  filebuff[filesize++] = 59;  /* ; */
  filebuff[filesize++] = 44;  /* , */
 
  /* write the COLLATE subfunction */
  memcpy(filebuff + subfunction_ptr[4], &filesize, sizeof(filesize));
 
  /* subfunction header */
  memcpy(filebuff + filesize, "\377COLLATE", 8);
  filesize += 8;
  /* subfunction size */
  filebuff[filesize++] = LSB(256);
  filebuff[filesize++] = MSB(256);
  /* collation for standard CP437 */
  memcpy(filebuff + filesize, collate_437, 256);
  filesize += 256;
 
  /* write the DBCS subfunction */
  memcpy(filebuff + subfunction_ptr[5], &filesize, sizeof(filesize));
  /* subfunction header */
  memcpy(filebuff + filesize, "\377DBCS   ", 8);
  filesize += 8;
  /* subfunction size */
  filebuff[filesize++] = 0;
  filebuff[filesize++] = 0;
  /* table terminator (must be there even if no lenght is zero */
  filebuff[filesize++] = 0;
  filebuff[filesize++] = 0;
 
  /* write the YESNO subfunction */
  memcpy(filebuff + subfunction_ptr[6], &filesize, sizeof(filesize));
  memcpy(filebuff + filesize, "\377YESNO  ", 8);
  filesize += 8;
  filebuff[filesize] = 4;  /* size (LSB) */
  filesize += 2;
  memcpy(filebuff + filesize, &(c->YESNO), 4);
  filesize += 4;
 
  /* write the file trailer */
  memcpy(filebuff + filesize, "LOCALCFG", 8);
  filesize += 8;
 
  /* write the buffer to file */
  fd = fopen(fname, "wb");
  if (fd == NULL) return(-1);
  fwrite(filebuff, 1, filesize, fd);
  fclose(fd);
 
  return(0);
}
 

Subversion Repositories SvarDOS

(root)/localcfg/trunk/country.c – Rev 608 → 611

Rev 608		Rev 611
1	`/*`	1	`/*`
2	`* functions that reads/writes from/to the localcfg country.sys-like file.`	2	`* functions that reads/writes from/to the localcfg country.sys-like file.`
3	`* Copyright (C) Mateusz Viste 2015-2022`	3	`* Copyright (C) Mateusz Viste 2015-2022`
4	`*/`	4	`*/`
5		5
6	`#include <stdio.h>`	6	`#include <stdio.h>`
7	`#include <string.h>`	7	`#include <string.h>`
8		8
9	`#include "country.h"`	9	`#include "country.h"`
10		10
11		11
12	`struct funchdr {`	12	`struct funchdr {`
13	`unsigned char funcname[8];`	13	`unsigned char funcname[8];`
14	`unsigned short funcsiz;`	14	`unsigned short funcsiz;`
15	`};`	15	`};`
16		16
17	`static unsigned char filebuff[1024];`	17	`static unsigned char filebuff[1024];`
18		18
19		19
20	`/* fills a country struct with default values */`	20	`/* fills a country struct with default values */`
21	`static void country_default(struct country *countrydata) {`	21	`static void country_default(struct country *countrydata) {`
22		22
23	`/* first clear the memory */`	23	`/* first clear the memory */`
24	`bzero(countrydata, sizeof(struct country));`	24	`bzero(countrydata, sizeof(struct country));`
25		25
26	`/* fill in CTYINFO fields (non-zero values only) */`	26	`/* fill in CTYINFO fields (non-zero values only) */`
27	`countrydata->CTYINFO.id = 1;`	27	`countrydata->CTYINFO.id = 1;`
28	`countrydata->CTYINFO.codepage = 437;`	28	`countrydata->CTYINFO.codepage = 437;`
29	`/* countrydata->CTYINFO.datefmt = COUNTRY_DATE_MDY;`	29	`/* countrydata->CTYINFO.datefmt = COUNTRY_DATE_MDY;`
30	`countrydata->CTYINFO.timefmt = COUNTRY_TIME12; */`	30	`countrydata->CTYINFO.timefmt = COUNTRY_TIME12; */`
31	`countrydata->CTYINFO.currsym[0] = '$';`	31	`countrydata->CTYINFO.currsym[0] = '$';`
32	`countrydata->CTYINFO.decimal[0] = '.';`	32	`countrydata->CTYINFO.decimal[0] = '.';`
33	`countrydata->CTYINFO.thousands[0] = ',';`	33	`countrydata->CTYINFO.thousands[0] = ',';`
34	`countrydata->CTYINFO.datesep[0] = '/';`	34	`countrydata->CTYINFO.datesep[0] = '/';`
35	`countrydata->CTYINFO.timesep[0] = ':';`	35	`countrydata->CTYINFO.timesep[0] = ':';`
36	`countrydata->CTYINFO.currprec = 2;`	36	`countrydata->CTYINFO.currprec = 2;`
37	`/* countrydata->CTYINFO.currencydecsym = 0; */`	37	`/* countrydata->CTYINFO.currencydecsym = 0; */`
38	`/* countrydata->CTYINFO.currencyspace = 0; */`	38	`/* countrydata->CTYINFO.currencyspace = 0; */`
39	`/* countrydata->CTYINFO.currencypos = 0; */`	39	`/* countrydata->CTYINFO.currencypos = 0; */`
40		40