← Back to branch summary

~ubuntu-branches/debian/sid/ncurses/sid-200908151543

« back to all changes in this revision

Viewing changes to progs/tic.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2008-12-14 21:06:00 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20081214210600-2rdjwvpplgvh3zeb
Tags: 5.7+20081213-1
Merging upstream version 5.7+20081213.

Show diffs side-by-side

added added

removed removed

Lines of Context:
progs/tic.c
1
1
/****************************************************************************
2
 
 * Copyright (c) 1998-2004,2005 Free Software Foundation, Inc.              *
 
2
 * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
3
3
 *                                                                          *
4
4
 * Permission is hereby granted, free of charge, to any person obtaining a  *
5
5
 * copy of this software and associated documentation files (the            *
29
29
/****************************************************************************
30
30
 *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
31
31
 *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
32
 
 *     and: Thomas E. Dickey 1996 on                                        *
 
32
 *     and: Thomas E. Dickey                        1996 on                 *
33
33
 ****************************************************************************/
34
34
 
35
35
/*
44
44
#include <dump_entry.h>
45
45
#include <transform.h>
46
46
 
47
 
MODULE_ID("$Id: tic.c,v 1.125 2005/09/25 00:39:43 tom Exp $")
 
47
MODULE_ID("$Id: tic.c,v 1.137 2008/09/13 16:59:24 tom Exp $")
48
48
 
49
49
const char *_nc_progname = "tic";
50
50
 
85
85
] \
86
86
source-file\n";
87
87
 
88
 
static void
89
 
cleanup(void)
90
 
{
 
88
#if NO_LEAKS
 
89
static void
 
90
free_namelist(char **src)
 
91
{
 
92
    if (src != 0) {
 
93
        int n;
 
94
        for (n = 0; src[n] != 0; ++n)
 
95
            free(src[n]);
 
96
        free(src);
 
97
    }
 
98
}
 
99
#endif
 
100
 
 
101
static void
 
102
cleanup(char **namelst GCC_UNUSED)
 
103
{
 
104
#if NO_LEAKS
 
105
    free_namelist(namelst);
 
106
#endif
91
107
    if (tmp_fp != 0)
92
108
        fclose(tmp_fp);
93
109
    if (to_remove != 0) {
103
119
failed(const char *msg)
104
120
{
105
121
    perror(msg);
106
 
    cleanup();
 
122
    cleanup((char **) 0);
107
123
    ExitProgram(EXIT_FAILURE);
108
124
}
109
125
 
178
194
            d = result;
179
195
            t = s;
180
196
            while ((ch = *t++) != 0) {
181
 
                *d++ = ch;
 
197
                *d++ = (char) ch;
182
198
                if (ch == '\\') {
183
199
                    *d++ = *t++;
184
200
                } else if ((ch == '%')
192
208
                        && value < 127
193
209
                        && isprint((int) value)) {
194
210
                        *d++ = S_QUOTE;
195
 
                        *d++ = (int) value;
 
211
                        *d++ = (char) value;
196
212
                        *d++ = S_QUOTE;
197
213
                        t = (v + 1);
198
214
                    }
280
296
            putchar(c);
281
297
            in_name = FALSE;
282
298
        } else if (c != '>') {
283
 
            namebuf[used++] = c;
 
299
            namebuf[used++] = (char) c;
284
300
        } else {                /* ah! candidate name! */
285
301
            char *up;
286
302
            NCURSES_CONST char *tp;
354
370
}
355
371
 
356
372
/* Parse the "-e" option-value into a list of names */
357
 
static const char **
 
373
static char **
358
374
make_namelist(char *src)
359
375
{
360
 
    const char **dst = 0;
 
376
    char **dst = 0;
361
377
 
362
378
    char *s, *base;
363
379
    unsigned pass, n, nn;
374
390
                if ((s = stripped(buffer)) != 0) {
375
391
                    if (dst != 0)
376
392
                        dst[nn] = s;
 
393
                    else
 
394
                        free(s);
377
395
                    nn++;
378
396
                }
379
397
            }
380
398
            if (pass == 1) {
381
 
                dst = typeCalloc(const char *, nn + 1);
 
399
                dst = typeCalloc(char *, nn + 1);
382
400
                rewind(fp);
383
401
            }
384
402
        }
401
419
                    break;
402
420
            }
403
421
            if (pass == 1)
404
 
                dst = typeCalloc(const char *, nn + 1);
 
422
                dst = typeCalloc(char *, nn + 1);
405
423
        }
406
424
    }
407
 
    if (showsummary) {
 
425
    if (showsummary && (dst != 0)) {
408
426
        fprintf(log_fp, "Entries that will be compiled:\n");
409
427
        for (n = 0; dst[n] != 0; n++)
410
428
            fprintf(log_fp, "%u:%s\n", n + 1, dst[n]);
413
431
}
414
432
 
415
433
static bool
416
 
matches(const char **needle, const char *haystack)
 
434
matches(char **needle, const char *haystack)
417
435
/* does entry in needle list match |-separated field in haystack? */
418
436
{
419
437
    bool code = FALSE;
468
486
    bool limited = TRUE;
469
487
    char *tversion = (char *) NULL;
470
488
    const char *source_file = "terminfo";
471
 
    const char **namelst = 0;
 
489
    char **namelst = 0;
472
490
    char *outdir = (char *) NULL;
473
491
    bool check_only = FALSE;
474
492
    bool suppress_untranslatable = FALSE;
495
513
     * be optional.
496
514
     */
497
515
    while ((this_opt = getopt(argc, argv,
498
 
                              "0123456789CILNR:TUVace:fGgo:rstvwx")) != EOF) {
 
516
                              "0123456789CILNR:TUVace:fGgo:rstvwx")) != -1) {
499
517
        if (isdigit(this_opt)) {
500
518
            switch (last_opt) {
501
519
            case 'v':
543
561
            break;
544
562
        case 'V':
545
563
            puts(curses_version());
546
 
            return EXIT_SUCCESS;
 
564
            cleanup(namelst);
 
565
            ExitProgram(EXIT_SUCCESS);
547
566
        case 'c':
548
567
            check_only = TRUE;
549
568
            break;
613
632
    if (namelst && (!infodump && !capdump)) {
614
633
        (void) fprintf(stderr,
615
634
                       "Sorry, -e can't be used without -I or -C\n");
616
 
        cleanup();
 
635
        cleanup(namelst);
617
636
        ExitProgram(EXIT_FAILURE);
618
637
    }
619
638
#endif /* HAVE_BIG_CORE */
656
675
                    _nc_progname,
657
676
                    _nc_progname,
658
677
                    usage_string);
659
 
            cleanup();
 
678
            cleanup(namelst);
660
679
            ExitProgram(EXIT_FAILURE);
661
680
        }
662
681
    }
690
709
    /* do use resolution */
691
710
    if (check_only || (!infodump && !capdump) || forceresolve) {
692
711
        if (!_nc_resolve_uses2(TRUE, literal) && !check_only) {
693
 
            cleanup();
 
712
            cleanup(namelst);
694
713
            ExitProgram(EXIT_FAILURE);
695
714
        }
696
715
    }
731
750
                    _nc_set_type(_nc_first_name(qp->tterm.term_names));
732
751
 
733
752
                    (void) fseek(tmp_fp, qp->cstart, SEEK_SET);
734
 
                    while (j--) {
 
753
                    while (j-- > 0) {
735
754
                        if (infodump)
736
755
                            (void) putchar(fgetc(tmp_fp));
737
756
                        else
738
757
                            put_translate(fgetc(tmp_fp));
739
758
                    }
740
759
 
741
 
                    len = dump_entry(&qp->tterm, suppress_untranslatable,
742
 
                                     limited, 0, numbers, NULL);
743
 
                    for (j = 0; j < qp->nuses; j++)
744
 
                        len += dump_uses(qp->uses[j].name, !capdump);
745
 
                    (void) putchar('\n');
 
760
                    dump_entry(&qp->tterm, suppress_untranslatable,
 
761
                               limited, numbers, NULL);
 
762
                    for (j = 0; j < (int) qp->nuses; j++)
 
763
                        dump_uses(qp->uses[j].name, !capdump);
 
764
                    len = show_entry();
746
765
                    if (debug_level != 0 && !limited)
747
766
                        printf("# length=%d\n", len);
748
767
                }
784
803
        else
785
804
            fprintf(log_fp, "No entries written\n");
786
805
    }
787
 
    cleanup();
 
806
    cleanup(namelst);
788
807
    ExitProgram(EXIT_SUCCESS);
789
808
}
790
809
 
793
812
 * references to locations in the arrays Booleans, Numbers, and Strings ---
794
813
 * precisely what's needed (see comp_parse.c).
795
814
 */
796
 
 
797
 
TERMINAL *cur_term;             /* tweak to avoid linking lib_cur_term.c */
798
 
 
799
815
#undef CUR
800
816
#define CUR tp->
801
817
 
820
836
            }
821
837
            mapped[UChar(p[0])] = p[1];
822
838
        }
 
839
 
823
840
        if (mapped[UChar('I')] && !mapped[UChar('i')]) {
824
841
            _nc_warning("acsc refers to 'I', which is probably an error");
825
842
        }
 
843
 
826
844
        for (p = boxes, q = missing; *p != '\0'; ++p) {
827
845
            if (!mapped[UChar(p[0])]) {
828
846
                *q++ = p[0];
829
847
            }
830
 
            *q = '\0';
831
848
        }
 
849
        *q = '\0';
 
850
 
 
851
        assert(strlen(missing) <= strlen(boxes));
832
852
        if (*missing != '\0' && strcmp(missing, boxes)) {
833
853
            _nc_warning("acsc is missing some line-drawing mapping: %s", missing);
834
854
        }
872
892
    }
873
893
}
874
894
 
875
 
static int
 
895
static char
876
896
keypad_final(const char *string)
877
897
{
878
 
    int result = '\0';
 
898
    char result = '\0';
879
899
 
880
900
    if (VALID_STRING(string)
881
901
        && *string++ == '\033'
903
923
    return result;
904
924
}
905
925
 
 
926
#define MAX_KP 5
906
927
/*
907
928
 * Do a quick sanity-check for vt100-style keypads to see if the 5-key keypad
908
929
 * is mapped inconsistently.
917
938
        VALID_STRING(key_b2) &&
918
939
        VALID_STRING(key_c1) &&
919
940
        VALID_STRING(key_c3)) {
920
 
        char final[6];
921
 
        int list[5];
 
941
        char final[MAX_KP + 1];
 
942
        int list[MAX_KP];
922
943
        int increase = 0;
923
944
        int j, k, kk;
924
945
        int last;
932
953
        final[5] = '\0';
933
954
 
934
955
        /* special case: legacy coding using 1,2,3,0,. on the bottom */
 
956
        assert(strlen(final) <= MAX_KP);
935
957
        if (!strcmp(final, "qsrpn"))
936
958
            return;
937
959
 
942
964
        list[4] = keypad_index(key_c3);
943
965
 
944
966
        /* check that they're all vt100 keys */
945
 
        for (j = 0; j < 5; ++j) {
 
967
        for (j = 0; j < MAX_KP; ++j) {
946
968
            if (list[j] < 0) {
947
969
                return;
948
970
            }
949
971
        }
950
972
 
951
973
        /* check if they're all in increasing order */
952
 
        for (j = 1; j < 5; ++j) {
 
974
        for (j = 1; j < MAX_KP; ++j) {
953
975
            if (list[j] > list[j - 1]) {
954
976
                ++increase;
955
977
            }
956
978
        }
957
 
        if (increase != 4) {
 
979
        if (increase != (MAX_KP - 1)) {
958
980
            show[0] = '\0';
959
981
 
960
 
            for (j = 0, last = -1; j < 5; ++j) {
 
982
            for (j = 0, last = -1; j < MAX_KP; ++j) {
961
983
                for (k = 0, kk = -1, test = 100; k < 5; ++k) {
962
984
                    if (list[k] > last &&
963
985
                        list[k] < test) {
966
988
                    }
967
989
                }
968
990
                last = test;
 
991
                assert(strlen(show) < (MAX_KP * 4));
969
992
                switch (kk) {
970
993
                case 0:
971
994
                    strcat(show, " ka1");
1276
1299
    char *test;
1277
1300
 
1278
1301
    _nc_tparm_err = 0;
1279
 
    test = tparm(set_attributes,
1280
 
                 num == 1,
1281
 
                 num == 2,
1282
 
                 num == 3,
1283
 
                 num == 4,
1284
 
                 num == 5,
1285
 
                 num == 6,
1286
 
                 num == 7,
1287
 
                 num == 8,
1288
 
                 num == 9);
 
1302
    test = TPARM_9(set_attributes,
 
1303
                   num == 1,
 
1304
                   num == 2,
 
1305
                   num == 3,
 
1306
                   num == 4,
 
1307
                   num == 5,
 
1308
                   num == 6,
 
1309
                   num == 7,
 
1310
                   num == 8,
 
1311
                   num == 9);
1289
1312
    if (test != 0) {
1290
1313
        if (PRESENT(cap)) {
1291
1314
            if (!similar_sgr(num, test, cap)) {
1317
1340
static void
1318
1341
show_where(unsigned level)
1319
1342
{
1320
 
    if (_nc_tracing >= level) {
 
1343
    if (_nc_tracing >= DEBUG_LEVEL(level)) {
1321
1344
        char my_name[256];
1322
1345
        _nc_get_type(my_name);
1323
1346
        fprintf(stderr, "\"%s\", line %d, '%s' ",
1327
1350
}
1328
1351
 
1329
1352
#else
1330
 
#define show_where(level) /* nothing */
 
1353
#define show_where(level)       /* nothing */
1331
1354
#endif
1332
1355
 
1333
1356
/* other sanity-checks (things that we don't want in the normal
1416
1439
        if (PRESENT(exit_attribute_mode)) {
1417
1440
            zero = strdup(CHECK_SGR(0, exit_attribute_mode));
1418
1441
        } else {
1419
 
            zero = strdup(tparm(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0));
 
1442
            zero = strdup(TPARM_9(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0));
1420
1443
        }
1421
1444
        if (_nc_tparm_err)
1422
1445
            _nc_warning("stack error in sgr(0) string");