morse/morse.c

   1 /*      $NetBSD: morse.c,v 1.10 2000/07/03 03:57:42 matt Exp $  */
   2
   3 /*
   4  * Copyright (c) 1988, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 #ifndef lint
  38 __COPYRIGHT("@(#) Copyright (c) 1988, 1993\n\
  39         The Regents of the University of California.  All rights reserved.\n");
  40 #endif /* not lint */
  41
  42 #ifndef lint
  43 #if 0
  44 static char sccsid[] = "@(#)morse.c     8.1 (Berkeley) 5/31/93";
  45 #else
  46 __RCSID("$NetBSD: morse.c,v 1.10 2000/07/03 03:57:42 matt Exp $");
  47 #endif
  48 #endif /* not lint */
  49
  50 #include <ctype.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <unistd.h>
  55
  56 #define MORSE_COLON     "--..--"
  57 #define MORSE_PERIOD    ".-.-.-"
  58
  59
  60 static const char
  61         *const digit[] = {
  62         "-----",
  63         ".----",
  64         "..---",
  65         "...--",
  66         "....-",
  67         ".....",
  68         "-....",
  69         "--...",
  70         "---..",
  71         "----.",
  72 },
  73         *const alph[] = {
  74         ".-",
  75         "-...",
  76         "-.-.",
  77         "-..",
  78         ".",
  79         "..-.",
  80         "--.",
  81         "....",
  82         "..",
  83         ".---",
  84         "-.-",
  85         ".-..",
  86         "--",
  87         "-.",
  88         "---",
  89         ".--.",
  90         "--.-",
  91         ".-.",
  92         "...",
  93         "-",
  94         "..-",
  95         "...-",
  96         ".--",
  97         "-..-",
  98         "-.--",
  99         "--..",
 100 };
 101
 102 int     main __P((int, char *[]));
 103 void    morse __P((int));
 104 void    decode __P((const char *));
 105 void    show __P((const char *));
 106
 107 static int sflag;
 108 static int dflag;
 109
 110 int
 111 main(argc, argv)
 112         int argc;
 113         char **argv;
 114 {
 115         int ch;
 116         char *s, *p;
 117
 118         /* Revoke setgid privileges */
 119         setgid(getgid());
 120
 121         while ((ch = getopt(argc, argv, "ds")) != -1)
 122                 switch((char)ch) {
 123                 case 'd':
 124                         dflag = 1;
 125                         break;
 126                 case 's':
 127                         sflag = 1;
 128                         break;
 129                 case '?':
 130                 default:
 131                         fprintf(stderr, "usage: morse [-ds] [string ...]\n");
 132                         exit(1);
 133                 }
 134         argc -= optind;
 135         argv += optind;
 136
 137         if (dflag) {
 138                 if (*argv) {
 139                         do {
 140                                 s=strchr(*argv, ',');
 141
 142                                 if (s)
 143                                         *s='\0';
 144
 145                                 decode(*argv);
 146                         } while (*++argv);
 147                 }else{
 148                         char buf[1024];
 149
 150                         while (fgets(buf, 1024, stdin)) {
 151                                 s=buf;
 152
 153                                 while (*s && isspace(*s))
 154                                         s++;
 155
 156                                 if (*s) {
 157                                         p=strtok(s, " \n\t");
 158
 159                                         while (p) {
 160                                                 s=strchr(p, ',');
 161
 162                                                 if (s)
 163                                                         *s='\0';
 164
 165                                                 decode(p);
 166                                                 p=strtok(NULL, " \n\t");
 167                                         }
 168                                 }
 169                         }
 170                 }
 171                 putchar('\n');
 172         }else{
 173                 if (*argv)
 174                         do {
 175                                 for (p = *argv; *p; ++p)
 176                                         morse((int)*p);
 177                         } while (*++argv);
 178                 else while ((ch = getchar()) != EOF)
 179                         morse(ch);
 180         }
 181
 182         return 0;
 183 }
 184
 185 void
 186 decode(s)
 187         const char *s;
 188 {
 189         if (strcmp(s, MORSE_COLON) == 0){
 190                 putchar(',');
 191         } else if (strcmp(s, MORSE_PERIOD) == 0){
 192                 putchar('.');
 193         } else {
 194                 int found;
 195                 const char *const *a;
 196                 int size;
 197                 int i;
 198
 199                 found=0;
 200                 a=digit;
 201                 size=sizeof(digit)/sizeof(digit[0]);
 202                 for (i=0; i<size; i++) {
 203                         if (strcmp(a[i], s) == 0) {
 204                                 found = 1;
 205                                 break;
 206                         }
 207                 }
 208
 209                 if (found) {
 210                         putchar('0'+i);
 211                         return;
 212                 }
 213
 214                 found=0;
 215                 a=alph;
 216                 size=sizeof(alph)/sizeof(alph[0]);
 217                 for (i=0; i<size; i++) {
 218                         if (strcmp(a[i], s) == 0) {
 219                                 found = 1;
 220                                 break;
 221                         }
 222                 }
 223
 224                 if (found)
 225                         putchar('a'+i);
 226                 else
 227                         putchar(' ');
 228         }
 229 }
 230
 231 void
 232 morse(c)
 233         int c;
 234 {
 235         if (isalpha(c))
 236                 show(alph[c - (isupper(c) ? 'A' : 'a')]);
 237         else if (isdigit(c))
 238                 show(digit[c - '0']);
 239         else if (c == ',')
 240                 show(MORSE_COLON);
 241         else if (c == '.')
 242                 show(MORSE_PERIOD);
 243         else if (isspace(c))
 244                 show(" ...\n");
 245 }
 246
 247 void
 248 show(s)
 249         const char *s;
 250 {
 251         if (sflag)
 252                 printf(" %s", s);
 253         else for (; *s; ++s)
 254                 printf(" %s", *s == '.' ? "dit" : "daw");
 255         printf(",\n");
 256 }