Subversion Repositories SvarDOS

Rev

Rev 1072 | Rev 1629 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
421 mateuszvis 1
/* This file is part of the SvarCOM project and is published under the terms
2
 * of the MIT license.
3
 *
959 mateusz.vi 4
 * Copyright (C) 2021-2022 Mateusz Viste
421 mateuszvis 5
 *
6
 * Permission is hereby granted, free of charge, to any person obtaining a
7
 * copy of this software and associated documentation files (the "Software"),
8
 * to deal in the Software without restriction, including without limitation
9
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10
 * and/or sell copies of the Software, and to permit persons to whom the
11
 * Software is furnished to do so, subject to the following conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be included in
14
 * all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22
 * DEALINGS IN THE SOFTWARE.
23
 */
24
 
352 mateuszvis 25
/*
26
 * a variety of helper functions
27
 */
28
 
396 mateuszvis 29
#include <i86.h>    /* MK_FP() */
420 mateuszvis 30
#include <stdio.h>  /* sprintf() */
437 mateuszvis 31
#include <string.h> /* memcpy() */
396 mateuszvis 32
 
968 mateusz.vi 33
#include "svarlang.lib\svarlang.h"
34
 
437 mateuszvis 35
#include "env.h"
36
 
352 mateuszvis 37
#include "helpers.h"
38
 
420 mateuszvis 39
 
965 mateusz.vi 40
 
530 mateuszvis 41
/* case-insensitive comparison of strings, compares up to maxlen characters.
42
 * returns non-zero on equality. */
43
int imatchlim(const char *s1, const char *s2, unsigned short maxlen) {
44
  while (maxlen--) {
352 mateuszvis 45
    char c1, c2;
46
    c1 = *s1;
47
    c2 = *s2;
48
    if ((c1 >= 'a') && (c1 <= 'z')) c1 -= ('a' - 'A');
49
    if ((c2 >= 'a') && (c2 <= 'z')) c2 -= ('a' - 'A');
50
    /* */
51
    if (c1 != c2) return(0);
530 mateuszvis 52
    if (c1 == 0) break;
352 mateuszvis 53
    s1++;
54
    s2++;
55
  }
530 mateuszvis 56
  return(1);
352 mateuszvis 57
}
58
 
59
 
60
/* returns zero if s1 starts with s2 */
61
int strstartswith(const char *s1, const char *s2) {
62
  while (*s2 != 0) {
63
    if (*s1 != *s2) return(-1);
64
    s1++;
65
    s2++;
66
  }
67
  return(0);
68
}
369 mateuszvis 69
 
70
 
538 mateuszvis 71
/* outputs a NULL-terminated string to handle (1=stdout 2=stderr) */
72
void output_internal(const char *s, unsigned char nl, unsigned char handle) {
73
  const static unsigned char *crlf = "\r\n";
369 mateuszvis 74
  _asm {
445 mateuszvis 75
    push ds
76
    pop es         /* make sure es=ds (scasb uses es) */
77
    /* get length of s into CX */
78
    mov ax, 0x4000 /* ah=DOS "write to file" and AL=0 for NULL matching */
79
    mov dx, s      /* set dx to string (required for later) */
80
    mov di, dx     /* set di to string (for NULL matching) */
81
    mov cx, 0xffff /* preset cx to 65535 (-1) */
82
    cld            /* clear DF so scasb increments DI */
83
    repne scasb    /* cmp al, es:[di], inc di, dec cx until match found */
84
    /* CX contains (65535 - strlen(s)) now */
85
    not cx         /* reverse all bits so I get (strlen(s) + 1) */
86
    dec cx         /* this is CX length */
87
    jz WRITEDONE   /* do nothing for empty strings */
88
 
89
    /* output by writing to stdout */
90
    /* mov ah, 0x40 */  /* DOS 2+ -- write to file via handle */
538 mateuszvis 91
    xor bh, bh
92
    mov bl, handle /* set handle (1=stdout 2=stderr) */
445 mateuszvis 93
    /* mov cx, xxx */ /* write CX bytes */
94
    /* mov dx, s   */ /* DS:DX is the source of bytes to "write" */
369 mateuszvis 95
    int 0x21
445 mateuszvis 96
    WRITEDONE:
97
 
98
    /* print out a CR/LF trailer if nl set */
538 mateuszvis 99
    test byte ptr [nl], 0xff
369 mateuszvis 100
    jz FINITO
538 mateuszvis 101
    /* bx still contains handle */
102
    mov ah, 0x40 /* "write to file" */
103
    mov cx, 2
445 mateuszvis 104
    mov dx, crlf
369 mateuszvis 105
    int 0x21
106
    FINITO:
107
  }
108
}
388 mateuszvis 109
 
110
 
542 mateuszvis 111
void nls_output_internal(unsigned short id, unsigned char nl, unsigned char handle) {
538 mateuszvis 112
  const char *NOTFOUND = "NLS_STRING_NOT_FOUND";
968 mateusz.vi 113
  const char *ptr = svarlang_strid(id);
985 mateusz.vi 114
  if ((ptr == NULL) || (ptr[0]) == 0) ptr = NOTFOUND;
542 mateuszvis 115
  output_internal(ptr, nl, handle);
538 mateuszvis 116
}
117
 
118
 
959 mateusz.vi 119
/* output DOS error e to stdout, if stdout is redirected then *additionally*
120
 * also to stderr */
538 mateuszvis 121
void nls_outputnl_doserr(unsigned short e) {
122
  static char errstr[16];
123
  const char *ptr = NULL;
959 mateusz.vi 124
  unsigned char redirflag = 0;
538 mateuszvis 125
  /* find string in nls block */
968 mateusz.vi 126
  if (e < 0xff) ptr = svarlang_strid(0xff00 | e);
538 mateuszvis 127
  /* if not found, use a fallback */
1046 mateusz.vi 128
  if ((ptr == NULL) || (ptr[0] == 0)) {
538 mateuszvis 129
    sprintf(errstr, "DOS ERR %u", e);
130
    ptr = errstr;
131
  }
959 mateusz.vi 132
 
133
  /* display to stdout */
134
  output_internal(ptr, 1, hSTDOUT);
135
 
136
  /* is stdout redirected? */
137
  _asm {
138
    push bx
139
    push dx
140
 
141
    mov ax, 0x4400   /* query device flags */
142
    mov bx, 1        /* stdout */
143
    int 0x21
144
    /* CF set on error and AX filled with DOS error,
145
     * returns flags in DX on succes:
146
     *  bit 7 reset if handle points to a file, set if handle points to a device  */
147
    jc FAIL
148
    mov redirflag, dl
149
    and redirflag, 128
150
 
151
    FAIL:
152
    pop dx
153
    pop bx
154
  }
155
 
156
  if (redirflag == 0) output_internal(ptr, 1, hSTDERR);
538 mateuszvis 157
}
158
 
159
 
388 mateuszvis 160
/* find first matching files using a FindFirst DOS call
161
 * returns 0 on success or a DOS err code on failure */
162
unsigned short findfirst(struct DTA *dta, const char *pattern, unsigned short attr) {
163
  unsigned short res = 0;
164
  _asm {
165
    /* set DTA location */
166
    mov ah, 0x1a
167
    mov dx, dta
168
    int 0x21
169
    /* */
170
    mov ah, 0x4e    /* FindFirst */
171
    mov dx, pattern
172
    mov cx, attr
173
    int 0x21        /* CF set on error + err code in AX, DTA filled with FileInfoRec on success */
174
    jnc DONE
175
    mov [res], ax
176
    DONE:
177
  }
178
  return(res);
179
}
180
 
181
 
182
/* find next matching, ie. continues an action intiated by findfirst() */
183
unsigned short findnext(struct DTA *dta) {
184
  unsigned short res = 0;
185
  _asm {
186
    mov ah, 0x4f    /* FindNext */
187
    mov dx, dta
188
    int 0x21        /* CF set on error + err code in AX, DTA filled with FileInfoRec on success */
189
    jnc DONE
190
    mov [res], ax
191
    DONE:
192
  }
193
  return(res);
194
}
392 mateuszvis 195
 
196
 
197
/* print s string and wait for a single key press from stdin. accepts only
198
 * key presses defined in the c ASCIIZ string. returns offset of pressed key
199
 * in string. keys in c MUST BE UPPERCASE! */
200
unsigned short askchoice(const char *s, const char *c) {
201
  unsigned short res;
1001 mateusz.vi 202
  char cstr[2] = {0,0};
392 mateuszvis 203
  char key = 0;
204
 
205
  AGAIN:
206
  output(s);
207
  output(" ");
1001 mateusz.vi 208
  output("(");
209
  for (res = 0; c[res] != 0; res++) {
210
    if (res != 0) output("/");
211
    cstr[0] = c[res];
212
    output(cstr);
213
  }
214
  output(") ");
392 mateuszvis 215
 
216
  _asm {
217
    push ax
218
    push dx
219
 
220
    mov ax, 0x0c01 /* clear input buffer and execute getchar (INT 21h,AH=1) */
221
    int 0x21
222
    /* if AL == 0 then this is an extended character */
223
    test al, al
224
    jnz GOTCHAR
225
    mov ah, 0x08   /* read again to flush extended char from input buffer */
226
    int 0x21
227
    xor al, al     /* all extended chars are ignored */
228
    GOTCHAR:       /* received key is in AL now */
229
    mov [key], al  /* save key */
230
 
231
    /* print a cr/lf */
232
    mov ah, 0x02
233
    mov dl, 0x0D
234
    int 0x21
235
    mov dl, 0x0A
236
    int 0x21
237
 
238
    pop dx
239
    pop ax
240
  }
241
 
242
  /* ucase() result */
243
  if ((key >= 'a') && (key <= 'z')) key -= ('a' - 'A');
244
 
245
  /* is there a match? */
246
  for (res = 0; c[res] != 0; res++) if (c[res] == key) return(res);
247
 
248
  goto AGAIN;
249
}
250
 
251
 
399 mateuszvis 252
/* converts a path to its canonic representation, returns 0 on success
253
 * or DOS err on failure (invalid drive) */
254
unsigned short file_truename(const char *src, char *dst) {
255
  unsigned short res = 0;
392 mateuszvis 256
  _asm {
399 mateuszvis 257
    push es
392 mateuszvis 258
    mov ah, 0x60  /* query truename, DS:SI=src, ES:DI=dst */
259
    push ds
260
    pop es
261
    mov si, src
262
    mov di, dst
263
    int 0x21
399 mateuszvis 264
    jnc DONE
265
    mov [res], ax
266
    DONE:
267
    pop es
392 mateuszvis 268
  }
399 mateuszvis 269
  return(res);
392 mateuszvis 270
}
271
 
272
 
273
/* returns DOS attributes of file, or -1 on error */
274
int file_getattr(const char *fname) {
275
  int res = -1;
276
  _asm {
277
    mov ax, 0x4300  /* query file attributes, fname at DS:DX */
278
    mov dx, fname
279
    int 0x21        /* CX=attributes if CF=0, otherwise AX=errno */
280
    jc DONE
281
    mov [res], cx
282
    DONE:
283
  }
284
  return(res);
285
}
396 mateuszvis 286
 
287
 
288
/* returns screen's width (in columns) */
289
unsigned short screen_getwidth(void) {
290
  /* BIOS 0040:004A = word containing screen width in text columns */
291
  unsigned short far *scrw = MK_FP(0x40, 0x4a);
292
  return(*scrw);
293
}
294
 
295
 
296
/* returns screen's height (in rows) */
297
unsigned short screen_getheight(void) {
298
  /* BIOS 0040:0084 = byte containing maximum valid row value (EGA ONLY) */
299
  unsigned char far *scrh = MK_FP(0x40, 0x84);
300
  if (*scrh == 0) return(25);  /* pre-EGA adapter */
301
  return(*scrh + 1);
302
}
303
 
304
 
305
/* displays the "Press any key to continue" msg and waits for a keypress */
306
void press_any_key(void) {
437 mateuszvis 307
  nls_output(15, 1); /* Press any key to continue... */
396 mateuszvis 308
  _asm {
309
    mov ah, 0x08  /* no echo console input */
310
    int 0x21      /* pressed key in AL now (0 for extended keys) */
311
    test al, al
312
    jnz DONE
313
    int 0x21      /* executed ah=8 again to read the rest of extended key */
314
    DONE:
315
    /* output CR/LF */
316
    mov ah, 0x02
317
    mov dl, 0x0D
318
    int 0x21
319
    mov dl, 0x0A
320
    int 0x21
321
  }
322
}
399 mateuszvis 323
 
324
 
325
/* validate a drive (A=0, B=1, etc). returns 1 if valid, 0 otherwise */
326
int isdrivevalid(unsigned char drv) {
327
  _asm {
328
    mov ah, 0x19  /* query default (current) disk */
329
    int 0x21      /* drive in AL (0=A, 1=B, etc) */
330
    mov ch, al    /* save current drive to ch */
331
    /* try setting up the drive as current */
332
    mov ah, 0x0E   /* select default drive */
333
    mov dl, [drv]  /* 0=A, 1=B, etc */
334
    int 0x21
335
    /* this call does not set CF on error, I must check cur drive to look for success */
336
    mov ah, 0x19  /* query default (current) disk */
337
    int 0x21      /* drive in AL (0=A, 1=B, etc) */
338
    mov [drv], 1  /* preset result as success */
339
    cmp al, dl    /* is eq? */
340
    je DONE
341
    mov [drv], 0  /* fail */
342
    jmp FAILED
343
    DONE:
344
    /* set current drive back to what it was initially */
345
    mov ah, 0x0E
346
    mov dl, ch
347
    int 0x21
348
    FAILED:
349
  }
350
  return(drv);
351
}
406 mateuszvis 352
 
353
 
354
/* converts a 8+3 filename into 11-bytes FCB format (MYFILE  EXT) */
355
void file_fname2fcb(char *dst, const char *src) {
356
  unsigned short i;
357
 
358
  /* fill dst with 11 spaces and a NULL terminator */
420 mateuszvis 359
  for (i = 0; i < 11; i++) dst[i] = ' ';
360
  dst[11] = 0;
406 mateuszvis 361
 
362
  /* copy fname until dot (.) or 8 characters */
363
  for (i = 0; i < 8; i++) {
364
    if ((src[i] == '.') || (src[i] == 0)) break;
365
    dst[i] = src[i];
366
  }
367
 
368
  /* advance src until extension or end of string */
369
  src += i;
370
  for (;;) {
371
    if (*src == '.') {
372
      src++; /* next character is extension */
373
      break;
374
    }
375
    if (*src == 0) break;
376
  }
377
 
378
  /* copy extension to dst (3 chars max) */
379
  dst += 8;
380
  for (i = 0; i < 3; i++) {
381
    if (src[i] == 0) break;
382
    dst[i] = src[i];
383
  }
384
}
385
 
386
 
387
/* converts a 11-bytes FCB filename (MYFILE  EXT) into 8+3 format (MYFILE.EXT) */
388
void file_fcb2fname(char *dst, const char *src) {
389
  unsigned short i, end = 0;
390
 
391
  for (i = 0; i < 8; i++) {
392
    dst[i] = src[i];
393
    if (dst[i] != ' ') end = i + 1;
394
  }
395
 
396
  /* is there an extension? */
397
  if (src[8] == ' ') {
398
    dst[end] = 0;
399
  } else { /* found extension: copy it until first space */
400
    dst[end++] = '.';
401
    for (i = 8; i < 11; i++) {
402
      if (src[i] == ' ') break;
403
      dst[end++] = src[i];
404
    }
405
    dst[end] = 0;
406
  }
407
}
410 mateuszvis 408
 
409
 
430 mateuszvis 410
/* converts an ASCIIZ string into an unsigned short. returns 0 on success.
411
 * on error, result will contain all valid digits that were read until
412
 * error occurred (0 on overflow or if parsing failed immediately) */
426 mateuszvis 413
int atous(unsigned short *r, const char *s) {
410 mateuszvis 414
  int err = 0;
415
 
416
  _asm {
417
    mov si, s
418
    xor ax, ax  /* general purpose register */
419
    xor cx, cx  /* contains the result */
420
    mov bx, 10  /* used as a multiplicative step */
421
 
422
    NEXTBYTE:
423
    xchg cx, ax /* move result into cx temporarily */
424
    lodsb  /* AL = DS:[SI++] */
425
    /* is AL 0? if so we're done */
426
    test al, al
427
    jz DONE
428
    /* validate that AL is in range '0'-'9' */
429
    sub al, '0'
430 mateuszvis 430
    jc FAIL   /* invalid character detected */
410 mateuszvis 431
    cmp al, 9
430 mateuszvis 432
    jg FAIL   /* invalid character detected */
410 mateuszvis 433
    /* restore result into AX (CX contains the new digit) */
434
    xchg cx, ax
435
    /* multiply result by 10 and add cl */
436
    mul bx    /* DX AX = AX * BX(10) */
430 mateuszvis 437
    jc OVERFLOW  /* overflow */
410 mateuszvis 438
    add ax, cx
430 mateuszvis 439
    /* if CF is set then overflow occurred (overflow part lands in DX) */
410 mateuszvis 440
    jnc NEXTBYTE
441
 
430 mateuszvis 442
    OVERFLOW:
443
    xor cx, cx  /* make sure result is zeroed in case overflow occured */
444
 
410 mateuszvis 445
    FAIL:
446
    inc [err]
447
 
448
    DONE: /* save result (CX) into indirect memory address r */
449
    mov bx, [r]
450
    mov [bx], cx
451
  }
452
  return(err);
453
}
415 mateuszvis 454
 
455
 
456
/* appends a backslash if path is a directory
457
 * returns the (possibly updated) length of path */
458
unsigned short path_appendbkslash_if_dir(char *path) {
459
  unsigned short len;
460
  int attr;
461
  for (len = 0; path[len] != 0; len++);
462
  if (len == 0) return(0);
463
  if (path[len - 1] == '\\') return(len);
464
  /* */
465
  attr = file_getattr(path);
466
  if ((attr > 0) && (attr & DOS_ATTR_DIR)) {
467
    path[len++] = '\\';
468
    path[len] = 0;
469
  }
470
  return(len);
471
}
416 mateuszvis 472
 
473
 
474
/* get current path drive d (A=1, B=2, etc - 0 is "current drive")
475
 * returns 0 on success, doserr otherwise */
476
unsigned short curpathfordrv(char *buff, unsigned char d) {
477
  unsigned short r = 0;
478
 
479
  _asm {
480
    /* is d == 0? then I need to resolve current drive */
481
    cmp byte ptr [d], 0
482
    jne GETCWD
483
    /* resolve cur drive */
484
    mov ah, 0x19  /* get current default drive */
485
    int 0x21      /* al = drive (00h = A:, 01h = B:, etc) */
486
    inc al        /* convert to 1=A, 2=B, etc */
487
    mov [d], al
488
 
489
    GETCWD:
490
    /* prepend buff with drive:\ */
491
    mov si, buff
492
    mov dl, [d]
493
    mov [si], dl
494
    add byte ptr [si], 'A' - 1
495
    inc si
496
    mov [si], ':'
497
    inc si
498
    mov [si], '\\'
499
    inc si
500
 
501
    mov ah, 0x47      /* get current directory of drv DL into DS:SI */
502
    int 0x21
503
    jnc DONE
504
    mov [r], ax       /* copy result from ax */
505
 
506
    DONE:
507
  }
508
 
509
  return(r);
510
}
420 mateuszvis 511
 
512
 
513
/* fills a nls_patterns struct with current NLS patterns, returns 0 on success, DOS errcode otherwise */
514
unsigned short nls_getpatterns(struct nls_patterns *p) {
515
  unsigned short r = 0;
516
 
517
  _asm {
518
    mov ax, 0x3800  /* DOS 2+ -- Get Country Info for current country */
519
    mov dx, p       /* DS:DX points to the CountryInfoRec buffer */
520
    int 0x21
521
    jnc DONE
522
    mov [r], ax     /* copy DOS err code to r */
523
    DONE:
524
  }
525
 
526
  return(r);
527
}
528
 
529
 
530
/* computes a formatted date based on NLS patterns found in p
531
 * returns length of result */
532
unsigned short nls_format_date(char *s, unsigned short yr, unsigned char mo, unsigned char dy, const struct nls_patterns *p) {
533
  unsigned short items[3];
534
  /* preset date/month/year in proper order depending on date format */
535
  switch (p->dateformat) {
536
    case 0:  /* USA style: m d y */
537
      items[0] = mo;
538
      items[1] = dy;
539
      items[2] = yr;
540
      break;
541
    case 1:  /* EU style: d m y */
542
      items[0] = dy;
543
      items[1] = mo;
544
      items[2] = yr;
545
      break;
546
    case 2:  /* Japan-style: y m d */
547
    default:
548
      items[0] = yr;
549
      items[1] = mo;
550
      items[2] = dy;
551
      break;
552
  }
553
  /* compute the string */
554
  return(sprintf(s, "%02u%s%02u%s%02u", items[0], p->datesep, items[1], p->datesep, items[2]));
555
}
556
 
557
 
426 mateuszvis 558
/* computes a formatted time based on NLS patterns found in p, sc are ignored if set 0xff
420 mateuszvis 559
 * returns length of result */
426 mateuszvis 560
unsigned short nls_format_time(char *s, unsigned char ho, unsigned char mn, unsigned char sc, const struct nls_patterns *p) {
561
  char ampm = 0;
562
  unsigned short res;
563
 
420 mateuszvis 564
  if (p->timefmt == 0) {
565
    if (ho == 12) {
426 mateuszvis 566
      ampm = 'p';
420 mateuszvis 567
    } else if (ho > 12) {
568
      ho -= 12;
426 mateuszvis 569
      ampm = 'p';
420 mateuszvis 570
    } else { /* ho < 12 */
571
      if (ho == 0) ho = 12;
426 mateuszvis 572
      ampm = 'a';
420 mateuszvis 573
    }
426 mateuszvis 574
    res = sprintf(s, "%2u", ho);
575
  } else {
576
    res = sprintf(s, "%02u", ho);
420 mateuszvis 577
  }
426 mateuszvis 578
 
579
  /* append separator and minutes */
580
  res += sprintf(s + res, "%s%02u", p->timesep, mn);
581
 
582
  /* if seconds provided, append them, too */
583
  if (sc != 0xff) res += sprintf(s + res, "%s%02u", p->timesep, sc);
584
 
585
  /* finally append AM/PM char */
586
  if (ampm != 0) s[res++] = ampm;
587
  s[res] = 0;
588
 
589
  return(res);
420 mateuszvis 590
}
591
 
592
 
593
/* computes a formatted integer number based on NLS patterns found in p
594
 * returns length of result */
423 mateuszvis 595
unsigned short nls_format_number(char *s, unsigned long num, const struct nls_patterns *p) {
596
  unsigned short sl = 0, i;
420 mateuszvis 597
  unsigned char thcount = 0;
598
 
423 mateuszvis 599
  /* write the value (reverse) with thousand separators (if any defined) */
420 mateuszvis 600
  do {
601
    if ((thcount == 3) && (p->thousep[0] != 0)) {
602
      s[sl++] = p->thousep[0];
603
      thcount = 0;
604
    }
605
    s[sl++] = '0' + num % 10;
606
    num /= 10;
607
    thcount++;
608
  } while (num > 0);
609
 
423 mateuszvis 610
  /* terminate the string */
420 mateuszvis 611
  s[sl] = 0;
612
 
423 mateuszvis 613
  /* reverse the string now (has been built in reverse) */
614
  for (i = sl / 2 + (sl & 1); i < sl; i++) {
420 mateuszvis 615
    thcount = s[i];
423 mateuszvis 616
    s[i] = s[sl - (i + 1)];   /* abc'de  if i=3 then ' <-> c */
420 mateuszvis 617
    s[sl - (i + 1)] = thcount;
618
  }
619
 
423 mateuszvis 620
  return(sl);
420 mateuszvis 621
}
437 mateuszvis 622
 
623
 
1137 mateusz.vi 624
/* capitalize an ASCIZ string following country-dependent rules */
625
void nls_strtoup(char *buff) {
626
  unsigned short errcode = 0;
627
  /* requires DOS 4+ */
628
  _asm {
629
    push ax
630
    push dx
631
 
632
    mov ax, 0x6522 /* country-dependent capitalize string (DOS 4+) */
633
    mov dx, buff   /* DS:DX -> string to capitalize */
634
    int 0x21
635
    jnc DONE
636
 
637
    mov errcode, ax /* set errcode on failure */
638
    DONE:
639
 
640
    pop dx
641
    pop ax
642
  }
643
 
644
  /* rely on OpenWatcom's strupr() if DOS has no NLS support */
645
  if (errcode != 0) strupr(buff);
646
}
647
 
648
 
965 mateusz.vi 649
/* reload nls ressources from svarcom.lng into svarlang_mem */
437 mateuszvis 650
void nls_langreload(char *buff, unsigned short env) {
651
  const char far *nlspath;
968 mateusz.vi 652
  const char far *lang;
965 mateusz.vi 653
  static unsigned short lastlang;
437 mateuszvis 654
 
655
  /* look up the LANG env variable, upcase it and copy to lang */
968 mateusz.vi 656
  lang = env_lookup_val(env, "LANG");
657
  if ((lang == NULL) || (lang[0] == 0)) return;
658
  _fmemcpy(buff, lang, 2);
437 mateuszvis 659
  buff[2] = 0;
660
 
661
  /* check if there is need to reload at all */
968 mateusz.vi 662
  if (memcmp(&lastlang, buff, 2) == 0) return;
437 mateuszvis 663
 
968 mateusz.vi 664
  buff[4] = 0;
437 mateuszvis 665
  nlspath = env_lookup_val(env, "NLSPATH");
968 mateusz.vi 666
  if (nlspath != NULL) _fstrcpy(buff + 4, nlspath);
437 mateuszvis 667
 
968 mateusz.vi 668
  if (svarlang_load("SVARCOM", buff, buff + 4) != 0) return;
437 mateuszvis 669
 
968 mateusz.vi 670
  _fmemcpy(&lastlang, lang, 2);
437 mateuszvis 671
}
571 mateuszvis 672
 
673
 
674
/* locates executable fname in path and fill res with result. returns 0 on success,
675
 * -1 on failed match and -2 on failed match + "don't even try with other paths"
676
 * extptr is filled with a ptr to the extension in fname (NULL if no extension) */
677
int lookup_cmd(char *res, const char *fname, const char *path, const char **extptr) {
678
  unsigned short lastbslash = 0;
679
  unsigned short i, len;
680
  unsigned char explicitpath = 0;
1072 mateusz.vi 681
  const char *exec_ext[] = {"COM", "EXE", "BAT", NULL};
571 mateuszvis 682
 
683
  /* does the original fname has an explicit path prefix or explicit ext? */
684
  *extptr = NULL;
685
  for (i = 0; fname[i] != 0; i++) {
686
    switch (fname[i]) {
687
      case ':':
688
      case '\\':
689
        explicitpath = 1;
690
        *extptr = NULL; /* extension is the last dot AFTER all path delimiters */
691
        break;
692
      case '.':
693
        *extptr = fname + i + 1;
694
        break;
695
    }
696
  }
697
 
1072 mateusz.vi 698
  /* if explicit ext found, make sure it is executable */
699
  if (*extptr != NULL) {
700
    for (i = 0; exec_ext[i] != NULL; i++) if (imatch(*extptr, exec_ext[i])) break;
701
    if (exec_ext[i] == NULL) return(-2); /* bad extension - don't try running it ever */
702
  }
703
 
571 mateuszvis 704
  /* normalize filename */
705
  if (file_truename(fname, res) != 0) return(-2);
706
 
707
  /* printf("truename: %s\r\n", res); */
708
 
1072 mateusz.vi 709
  /* figure out where the command starts */
571 mateuszvis 710
  for (len = 0; res[len] != 0; len++) {
711
    switch (res[len]) {
712
      case '?':   /* abort on any wildcard character */
713
      case '*':
714
        return(-2);
715
      case '\\':
716
        lastbslash = len;
717
        break;
718
    }
719
  }
720
 
721
  /* printf("lastbslash=%u\r\n", lastbslash); */
722
 
723
  /* if no path prefix was found in fname (no colon or backslash) AND we have
724
   * a path arg, then assemble path+filename */
725
  if ((!explicitpath) && (path != NULL) && (path[0] != 0)) {
726
    i = strlen(path);
727
    if (path[i - 1] != '\\') i++; /* add a byte for inserting a bkslash after path */
728
    /* move the filename at the place where path will end */
729
    memmove(res + i, res + lastbslash + 1, len - lastbslash);
730
    /* copy path in front of the filename and make sure there is a bkslash sep */
731
    memmove(res, path, i);
732
    res[i - 1] = '\\';
733
  }
734
 
735
  /* if no extension was initially provided, try matching COM, EXE, BAT */
736
  if (*extptr == NULL) {
1072 mateusz.vi 737
    int attr;
571 mateuszvis 738
    len = strlen(res);
1072 mateusz.vi 739
    res[len++] = '.';
740
    for (i = 0; exec_ext[i] != NULL; i++) {
741
      strcpy(res + len, exec_ext[i]);
571 mateuszvis 742
      /* printf("? '%s'\r\n", res); */
1072 mateusz.vi 743
      *extptr = exec_ext[i];
744
      attr = file_getattr(res);
745
      if (attr < 0) continue; /* file not found */
746
      if (attr & DOS_ATTR_DIR) continue; /* this is a directory */
747
      if (attr & DOS_ATTR_VOL) continue; /* this is a volume */
748
      return(0);
571 mateuszvis 749
    }
750
  } else { /* try finding it as-is */
751
    /* printf("? '%s'\r\n", res); */
1072 mateusz.vi 752
    int attr = file_getattr(res);
753
    if ((attr >= 0) &&  /* file exists */
754
        ((attr & DOS_ATTR_DIR) == 0) && /* is not a directory */
755
        ((attr & DOS_ATTR_VOL) == 0)) { /* is not a volume */
756
      return(0);
757
    }
571 mateuszvis 758
  }
759
 
760
  /* not found */
761
  if (explicitpath) return(-2); /* don't bother trying other paths, the caller had its own path preset anyway */
762
  return(-1);
763
}
764
 
765
 
766
/* fills fname with the path and filename to the linkfile related to the
767
 * executable link "linkname". returns 0 on success. */
768
int link_computefname(char *fname, const char *linkname, unsigned short env_seg) {
1044 mateusz.vi 769
  unsigned short pathlen, doserr = 0;
571 mateuszvis 770
 
771
  /* fetch %DOSDIR% */
772
  pathlen = env_lookup_valcopy(fname, 128, env_seg, "DOSDIR");
773
  if (pathlen == 0) {
1043 mateusz.vi 774
    nls_outputnl(29,5); /* "%DOSDIR% not defined" */
571 mateuszvis 775
    return(-1);
776
  }
777
 
778
  /* prep filename: %DOSDIR%\LINKS\PKG.LNK */
779
  if (fname[pathlen - 1] == '\\') pathlen--;
1043 mateusz.vi 780
  pathlen += sprintf(fname + pathlen, "\\LINKS");
1044 mateusz.vi 781
  /* create \LINKS if not exists */
782
  if (file_getattr(fname) < 0) {
783
    _asm {
784
      push dx
785
      mov ah, 0x39
786
      mov dx, fname
787
      int 0x21
788
      jnc DONE
789
      mov doserr, ax
790
      DONE:
791
      pop dx
792
    }
793
    if (doserr) {
794
      output(fname);
795
      output(" - ");
796
      nls_outputnl(255, doserr);
797
      return(-1);
798
    }
799
  }
800
  /* quit early if dir does not exist (or is not a dir) */
1043 mateusz.vi 801
  if (file_getattr(fname) != DOS_ATTR_DIR) {
802
    output(fname);
803
    output(" - ");
804
    nls_outputnl(255,3); /* path not found */
805
    return(-1);
806
  }
807
  sprintf(fname + pathlen, "\\%s.LNK", linkname);
571 mateuszvis 808
 
809
  return(0);
810
}