games/morse/morse.c

   1 /*
   2  * Copyright (c) 1988, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#) Copyright (c) 1988, 1993 The Regents of the University of California.  All rights reserved.
  34  * @(#)morse.c  8.1 (Berkeley) 5/31/93
  35  * $FreeBSD: src/games/morse/morse.c,v 1.12.2.2 2002/03/12 17:45:15 phantom Exp $
  36  * $DragonFly: src/games/morse/morse.c,v 1.3 2005/04/25 16:10:24 liamfoy Exp $
  37  */
  38
  39 /*
  40  * Taught to send *real* morse by Lyndon Nerenberg (VE7TCP/VE6BBM)
  41  * <lyndon@orthanc.com>
  42  */
  43
  44 #include <sys/time.h>
  45
  46 #include <ctype.h>
  47 #include <fcntl.h>
  48 #include <langinfo.h>
  49 #include <locale.h>
  50 #include <signal.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <termios.h>
  55 #include <unistd.h>
  56
  57 #ifdef SPEAKER
  58 #include <machine/speaker.h>
  59 #endif
  60
  61 struct morsetab {
  62         char            inchar;
  63         const char      *morse;
  64 };
  65
  66 static const struct morsetab mtab[] = {
  67
  68         /* letters */
  69
  70         {'a', ".-"},
  71         {'b', "-..."},
  72         {'c', "-.-."},
  73         {'d', "-.."},
  74         {'e', "."},
  75         {'f', "..-."},
  76         {'g', "--."},
  77         {'h', "...."},
  78         {'i', ".."},
  79         {'j', ".---"},
  80         {'k', "-.-"},
  81         {'l', ".-.."},
  82         {'m', "--"},
  83         {'n', "-."},
  84         {'o', "---"},
  85         {'p', ".--."},
  86         {'q', "--.-"},
  87         {'r', ".-."},
  88         {'s', "..."},
  89         {'t', "-"},
  90         {'u', "..-"},
  91         {'v', "...-"},
  92         {'w', ".--"},
  93         {'x', "-..-"},
  94         {'y', "-.--"},
  95         {'z', "--.."},
  96
  97         /* digits */
  98
  99         {'0', "-----"},
 100         {'1', ".----"},
 101         {'2', "..---"},
 102         {'3', "...--"},
 103         {'4', "....-"},
 104         {'5', "....."},
 105         {'6', "-...."},
 106         {'7', "--..."},
 107         {'8', "---.."},
 108         {'9', "----."},
 109
 110         /* punctuation */
 111
 112         {',', "--..--"},
 113         {'.', ".-.-.-"},
 114         {'?', "..--.."},
 115         {'/', "-..-."},
 116         {'-', "-....-"},
 117         {'=', "-...-"},         /* BT */
 118         {':', "---..."},
 119         {';', "-.-.-."},
 120         {'(', "-.--."},         /* KN */
 121         {')', "-.--.-"},
 122         {'$', "...-..-"},
 123         {'+', ".-.-."},         /* AR */
 124
 125         /* prosigns without already assigned values */
 126
 127         {'#', ".-..."},         /* AS */
 128         {'@', "...-.-"},        /* SK */
 129         {'*', "...-."},         /* VE */
 130         {'%', "-...-.-"},       /* BK */
 131
 132         {'\0', ""}
 133 };
 134
 135
 136 static const struct morsetab iso8859tab[] = {
 137         {'á', ".--.-"},
 138         {'à', ".--.-"},
 139         {'â', ".--.-"},
 140         {'ä', ".-.-"},
 141         {'ç', "-.-.."},
 142         {'é', "..-.."},
 143         {'è', "..-.."},
 144         {'ê', "-..-."},
 145         {'ö', "---."},
 146         {'ü', "..--"},
 147
 148         {'\0', ""}
 149 };
 150
 151 static const struct morsetab koi8rtab[] = {
 152         /*
 153          * the cyrillic alphabet; you'll need a KOI8R font in order
 154          * to see the actual characters
 155          */
 156         {'Á', ".-"},            /* a */
 157         {'Â', "-..."},  /* be */
 158         {'×', ".--"},   /* ve */
 159         {'Ç', "--."},   /* ge */
 160         {'Ä', "-.."},   /* de */
 161         {'Å', "."},             /* ye */
 162         {'£', "."},             /* yo, the same as ye */
 163         {'Ö', "...-"},  /* she */
 164         {'Ú', "--.."},  /* ze */
 165         {'É', ".."},            /* i */
 166         {'Ê', ".---"},  /* i kratkoye */
 167         {'Ë', "-.-"},   /* ka */
 168         {'Ì', ".-.."},  /* el */
 169         {'Í', "--"},            /* em */
 170         {'Î', "-."},            /* en */
 171         {'Ï', "---"},   /* o */
 172         {'Ð', ".--."},  /* pe */
 173         {'Ò', ".-."},   /* er */
 174         {'Ó', "..."},   /* es */
 175         {'Ô', "-"},             /* te */
 176         {'Õ', "..-"},   /* u */
 177         {'Æ', "..-."},  /* ef */
 178         {'È', "...."},  /* kha */
 179         {'Ã', "-.-."},  /* ce */
 180         {'Þ', "---."},  /* che */
 181         {'Û', "----"},  /* sha */
 182         {'Ý', "--.-"},  /* shcha */
 183         {'Ù', "-.--"},  /* yi */
 184         {'Ø', "-..-"},  /* myakhkij znak */
 185         {'Ü', "..-.."}, /* ae */
 186         {'À', "..--"},  /* yu */
 187         {'Ñ', ".-.-"},  /* ya */
 188
 189         {'\0', ""}
 190 };
 191
 192 void            show(const char *), play(const char *), morse(char);
 193 void            ttyout(const char *);
 194 void            sighandler(int);
 195
 196 #define GETOPTOPTS "d:ef:sw:"
 197 #define USAGE \
 198 "usage: morse [-s] [-e] [-d device] [-w speed] [-f frequency] [string ...]\n"
 199
 200 static int      pflag, sflag, eflag;
 201 static int      wpm = 20;       /* words per minute */
 202 #define FREQUENCY 600
 203 static int      freq = FREQUENCY;
 204 static char     *device;        /* for tty-controlled generator */
 205
 206 #define DASH_LEN 3
 207 #define CHAR_SPACE 3
 208 #define WORD_SPACE (7 - CHAR_SPACE - 1)
 209 static float    dot_clock;
 210 int             spkr, line;
 211 struct termios  otty, ntty;
 212 int             olflags;
 213
 214 #ifdef SPEAKER
 215 tone_t          sound;
 216 #undef GETOPTOPTS
 217 #define GETOPTOPTS "d:ef:psw:"
 218 #undef USAGE
 219 #define USAGE \
 220 "usage: morse [-s] [-p] [-e] [-d device] [-w speed] [-f frequency] [string ...]\n"
 221 #endif
 222
 223 static const struct morsetab *hightab;
 224
 225 int
 226 main(int argc, char **argv)
 227 {
 228         int    ch, lflags;
 229         char  *p, *codeset;
 230
 231         while ((ch = getopt(argc, argv, GETOPTOPTS)) != -1)
 232                 switch ((char) ch) {
 233                 case 'd':
 234                         device = optarg;
 235                         break;
 236                 case 'e':
 237                         eflag = 1;
 238                         setvbuf(stdout, 0, _IONBF, 0);
 239                         break;
 240                 case 'f':
 241                         freq = atoi(optarg);
 242                         break;
 243 #ifdef SPEAKER
 244                 case 'p':
 245                         pflag = 1;
 246                         break;
 247 #endif
 248                 case 's':
 249                         sflag = 1;
 250                         break;
 251                 case 'w':
 252                         wpm = atoi(optarg);
 253                         break;
 254                 case '?':
 255                 default:
 256                         fputs(USAGE, stderr);
 257                         exit(1);
 258                 }
 259         if ((pflag || device) && sflag) {
 260                 fputs("morse: only one of -p, -d and -s allowed\n", stderr);
 261                 exit(1);
 262         }
 263         if ((pflag || device) && ((wpm < 1) || (wpm > 60))) {
 264                 fputs("morse: insane speed\n", stderr);
 265                 exit(1);
 266         }
 267         if ((pflag || device) && (freq == 0))
 268                 freq = FREQUENCY;
 269
 270 #ifdef SPEAKER
 271         if (pflag) {
 272                 if ((spkr = open(SPEAKER, O_WRONLY, 0)) == -1) {
 273                         perror(SPEAKER);
 274                         exit(1);
 275                 }
 276         } else
 277 #endif
 278         if (device) {
 279                 if ((line = open(device, O_WRONLY | O_NONBLOCK)) == -1) {
 280                         perror("open tty line");
 281                         exit(1);
 282                 }
 283                 if (tcgetattr(line, &otty) == -1) {
 284                         perror("tcgetattr() failed");
 285                         exit(1);
 286                 }
 287                 ntty = otty;
 288                 ntty.c_cflag |= CLOCAL;
 289                 tcsetattr(line, TCSANOW, &ntty);
 290                 lflags = fcntl(line, F_GETFL);
 291                 lflags &= ~O_NONBLOCK;
 292                 fcntl(line, F_SETFL, &lflags);
 293                 ioctl(line, TIOCMGET, &lflags);
 294                 lflags &= ~TIOCM_RTS;
 295                 olflags = lflags;
 296                 ioctl(line, TIOCMSET, &lflags);
 297                 (void)signal(SIGHUP, sighandler);
 298                 (void)signal(SIGINT, sighandler);
 299                 (void)signal(SIGQUIT, sighandler);
 300                 (void)signal(SIGTERM, sighandler);
 301         }
 302         if (pflag || device) {
 303                 dot_clock = wpm / 2.4;          /* dots/sec */
 304                 dot_clock = 1 / dot_clock;      /* duration of a dot */
 305                 dot_clock = dot_clock / 2;      /* dot_clock runs at twice */
 306                                                 /* the dot rate */
 307                 dot_clock = dot_clock * 100;    /* scale for ioctl */
 308         }
 309
 310         argc -= optind;
 311         argv += optind;
 312
 313         if (setlocale(LC_CTYPE, "") != NULL &&
 314             *(codeset = nl_langinfo(CODESET)) != '\0') {
 315                 if (strcmp(codeset, "KOI8-R") == 0)
 316                         hightab = koi8rtab;
 317                 else if (strcmp(codeset, "ISO8859-1") == 0 ||
 318                          strcmp(codeset, "ISO8859-15") == 0)
 319                         hightab = iso8859tab;
 320         }
 321
 322         if (*argv) {
 323                 do {
 324                         for (p = *argv; *p; ++p) {
 325                                 if (eflag)
 326                                         putchar(*p);
 327                                 morse(*p);
 328                         }
 329                         if (eflag)
 330                                 putchar(' ');
 331                         morse(' ');
 332                 } while (*++argv);
 333         } else {
 334                 while ((ch = getchar()) != EOF) {
 335                         if (eflag)
 336                                 putchar(ch);
 337                         morse(ch);
 338                 }
 339         }
 340         if (device)
 341                 tcsetattr(line, TCSANOW, &otty);
 342         exit(0);
 343 }
 344
 345 void
 346 morse(char c)
 347 {
 348         const struct morsetab *m;
 349
 350         if (isalpha((unsigned char)c))
 351                 c = tolower((unsigned char)c);
 352         if ((c == '\r') || (c == '\n'))
 353                 c = ' ';
 354         if (c == ' ') {
 355                 if (pflag) {
 356                         play(" ");
 357                         return;
 358                 } else if (device) {
 359                         ttyout(" ");
 360                         return;
 361                 } else {
 362                         show("");
 363                         return;
 364                 }
 365         }
 366         for (m = ((unsigned char)c < 0x80? mtab: hightab);
 367              m != NULL && m->inchar != '\0';
 368              m++) {
 369                 if (m->inchar == c) {
 370                         if (pflag) {
 371                                 play(m->morse);
 372                         } else if (device) {
 373                                 ttyout(m->morse);
 374                         } else
 375                                 show(m->morse);
 376                 }
 377         }
 378 }
 379
 380 void
 381 show(const char *s)
 382 {
 383         if (sflag)
 384                 printf(" %s", s);
 385         else
 386                 for (; *s; ++s)
 387                         printf(" %s", *s == '.' ? "dit" : "dah");
 388         printf("\n");
 389 }
 390
 391 void
 392 play(const char *s)
 393 {
 394 #ifdef SPEAKER
 395         const char *c;
 396
 397         for (c = s; *c != '\0'; c++) {
 398                 switch (*c) {
 399                 case '.':
 400                         sound.frequency = freq;
 401                         sound.duration = dot_clock;
 402                         break;
 403                 case '-':
 404                         sound.frequency = freq;
 405                         sound.duration = dot_clock * DASH_LEN;
 406                         break;
 407                 case ' ':
 408                         sound.frequency = 0;
 409                         sound.duration = dot_clock * WORD_SPACE;
 410                         break;
 411                 default:
 412                         sound.duration = 0;
 413                 }
 414                 if (sound.duration) {
 415                         if (ioctl(spkr, SPKRTONE, &sound) == -1) {
 416                                 perror("ioctl play");
 417                                 exit(1);
 418                         }
 419                 }
 420                 sound.frequency = 0;
 421                 sound.duration = dot_clock;
 422                 if (ioctl(spkr, SPKRTONE, &sound) == -1) {
 423                         perror("ioctl rest");
 424                         exit(1);
 425                 }
 426         }
 427         sound.frequency = 0;
 428         sound.duration = dot_clock * CHAR_SPACE;
 429         ioctl(spkr, SPKRTONE, &sound);
 430 #endif
 431 }
 432
 433 void
 434 ttyout(const char *s)
 435 {
 436         const char *c;
 437         int duration, on, lflags;
 438
 439         for (c = s; *c != '\0'; c++) {
 440                 switch (*c) {
 441                 case '.':
 442                         on = 1;
 443                         duration = dot_clock;
 444                         break;
 445                 case '-':
 446                         on = 1;
 447                         duration = dot_clock * DASH_LEN;
 448                         break;
 449                 case ' ':
 450                         on = 0;
 451                         duration = dot_clock * WORD_SPACE;
 452                         break;
 453                 default:
 454                         on = 0;
 455                         duration = 0;
 456                 }
 457                 if (on) {
 458                         ioctl(line, TIOCMGET, &lflags);
 459                         lflags |= TIOCM_RTS;
 460                         ioctl(line, TIOCMSET, &lflags);
 461                 }
 462                 duration *= 10000;
 463                 if (duration)
 464                         usleep(duration);
 465                 ioctl(line, TIOCMGET, &lflags);
 466                 lflags &= ~TIOCM_RTS;
 467                 ioctl(line, TIOCMSET, &lflags);
 468                 duration = dot_clock * 10000;
 469                 usleep(duration);
 470         }
 471         duration = dot_clock * CHAR_SPACE * 10000;
 472         usleep(duration);
 473 }
 474
 475 void
 476 sighandler(int signo)
 477 {
 478
 479         ioctl(line, TIOCMSET, &olflags);
 480         tcsetattr(line, TCSANOW, &otty);
 481
 482         signal(signo, SIG_DFL);
 483         (void)kill(getpid(), signo);
 484 }