Logo Search packages:      
Sourcecode: libgsm version File versions  Download package

add_test.c

/*
 * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
 * Universitaet Berlin.  See the accompanying file "COPYRIGHT" for
 * details.  THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
 */

/* $Header: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/add_test.c,v 1.2 1994/05/10 20:18:17 jutta Exp $ */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "gsm.h"

#include "../src/add.c"

int         interactive = 1;

char        * opname;
longword    L_op1, L_op2, L_expect;
word        op1, op2, expect;
int         do_expect;

word M_gsm_add P((word op1, word op2));
word M_gsm_sub P((word op1, word op2));
word M_gsm_mult P((word op1, word op2));
word M_gsm_mult_r P((word op1, word op2));
word M_gsm_abs P((word op1));
longword M_gsm_L_mult P((word op1, word op2));
longword M_gsm_L_add P((longword op1, longword op2));

help()
{
puts( "  add a b      sub a b     mult a b   div    a b" );
puts( "L_add A B    L_sub A B   L_mult A B   mult_r a b" );
puts( "" );
puts( "abs   a      norm  a        >> a b      << a b" );
puts( "                          L_>> A B    L_<< A B" );

}

char * strtek P2((str, sep), char * str, char * sep) {

      static char     * S = (char *)0;
      char        * c, * base;

      if (str) S = str;

      if (!S || !*S) return (char *)0;

      /*  Skip delimiters.
       */
      while (*S) {
            for (c = sep; *c && *c != *S; c++) ;
            if (*c) *S++ = 0;
            else break;
      }

      base = S;

      /*   Skip non-delimiters.
       */
      for (base = S; *S; S++) {

            for (c = sep; *c; c++)
                  if (*c == *S) {
                        *S++ = 0;
                        return base;
                  }
      }

      return base == S ? (char *)0 : base;
}

long value P1((s), char * s)
{
      switch (*s) {
      case '-': switch (s[1]) {
              case '\0': return MIN_WORD;
              case '-':  return MIN_LONGWORD;
              default:   break;
              }
              break;

      case '+': switch (s[1]) {
              case '\0': return MAX_WORD;
              case '+':  return MAX_LONGWORD;
              default:   break;
              }
      default:  break;
      }

      return strtol(s, (char **)0, 0);
}

char * parse P1((buf), char * buf)
{
      char  * s, * a;
      long  l;

      if (a = strchr(buf, '=')) *a++ = 0;

      opname = s = strtek(buf, " \t("); 
      if (!s) return (char *)0;

      op1 = op2 = L_op1 = L_op2 = 0;

      if (s = strtek( (char *)0, "( \t,")) {
            op1 = L_op1 = value(s);
            if (s = strtek( (char *)0, ", \t)")) op2 = L_op2 = value(s);
      }

      if (a) {
            do_expect = 1;
            while (*a == ' ' || *a == '\t') a++;
            expect = L_expect = value(a);
      }

      return opname;
}

void fprint_word P2((f, w), FILE * f,  word w)
{
      if (!w) putc('0', f);
      else fprintf(f, "0x%4.4x (%d%s)",
            (unsigned int)w,
            (int)w,
            w == MIN_WORD? "/-" : (w == MAX_WORD ? "/+" : ""));
}

void print_word P1((w), word w)
{
      fprint_word( stdout, w );
}

void fprint_longword P2((f, w), FILE * f, longword w)
{
      if (!w) putc('0', f);
      else fprintf(f, "0x%8.8x (%ld%s)",
            w, w, w == MIN_WORD ? "/-"
            : (w == MAX_WORD ? "/+"
            : (w == MIN_LONGWORD ? "/--" 
            : (w == MAX_LONGWORD ? "/++" : ""))));
}

void print_longword P1((w),longword w)
{
      fprint_longword(stdout, w);
}

void do_longword P1((w), longword w)
{
      if (interactive) print_longword(w);
      if (do_expect) {
            if (w != L_expect) {
                  if (!interactive) fprint_longword(stderr, w);
                  fprintf(stderr, " != %s (%ld, %ld) -- expected ",
                        opname, L_op1, L_op2 );
                  fprint_longword(stderr, L_expect);
                  putc( '\n', stderr );
            }
      } else if (interactive) putchar('\n');
}

void do_word P1((w), word w )
{
      if (interactive) print_word(w);
      if (do_expect) {
            if (w != expect) {
                  if (!interactive) fprint_word(stderr, w);
                  fprintf(stderr, " != %s (%ld, %ld) -- expected ",
                        opname, L_op1, L_op2 );
                  fprint_word(stderr, expect);
                  putc('\n', stderr);
            }
      } else if (interactive) putchar('\n');
}

int main(ac, av) char ** av;
{
      char  buf[299];
      char  * c;
      FILE  * in;

      if (ac > 2) {
            fprintf(stderr, "Usage: %s [filename]\n", av[0]);
fail:
#ifdef EXIT_FAILURE
            exit(EXIT_FAILURE);
#else
            exit(1);
#endif
      }
      if (ac < 2) in = stdin;
      else if (!(in = fopen(av[1], "r"))) {
            perror(av[1]);
            fprintf(stderr, "%s: cannot open file \"%s\" for reading\n",
                  av[0], av[1]);
            goto fail;
      }

      interactive = isatty(fileno(in));

      for (;;) {
            if (interactive) fprintf(stderr, "? ");

            if (!fgets(buf, sizeof(buf), in)) exit(0);
            if (c = strchr(buf, '\n')) *c = 0;

            if (*buf == ';' || *buf == '#') continue;
            if (*buf == '\'') {
                  puts(buf + 1);
                  continue;
            }
            if (*buf == '\"') {
                  fprintf(stderr,  "%s\n", buf + 1);
                  continue;
            }

            c = parse(buf);

            if (!c) continue;
            if (!strcmp(c,   "add")) {
                  do_word(    gsm_add( op1, op2 ));
                  continue;
            }
            if (!strcmp(c,   "M_add")) {
                  do_word(    M_gsm_add( op1, op2 ));
                  continue;
            }
            if (!strcmp(c, "sub")) {
                  do_word(    gsm_sub( op1, op2 ));
                  continue;
            }
            if (!strcmp(c, "M_sub")) {
                  do_word(    M_gsm_sub( op1, op2 ));
                  continue;
            }
            if (!strcmp(c, "mult")) {
                  do_word(    gsm_mult( op1, op2 ));
                  continue;
            }
            if (!strcmp(c, "M_mult")) {
                  do_word(    M_gsm_mult( op1, op2 ));
                  continue;
            }
            if (!strcmp(c, "mult_r")) {
                  do_word(    gsm_mult_r(op1, op2));
                  continue;
            }
            if (!strcmp(c, "M_mult_r")) {
                  do_word(    M_gsm_mult_r(op1, op2));
                  continue;
            }
            if (!strcmp(c, "abs" )) {
                  do_word(    gsm_abs(op1) );
                  continue;
            } 
            if (!strcmp(c, "M_abs" )) {
                  do_word(    M_gsm_abs(op1) );
                  continue;
            } 
            if (!strcmp(c, "div" )) {
                  do_word(    gsm_div( op1, op2 ));
                  continue;
            }
            if (!strcmp(c,  "norm" )) {
                  do_word(    gsm_norm(L_op1));
                  continue;
            } 
            if (!strcmp(c,  "<<" )) {
                  do_word(    gsm_asl( op1, op2));
                  continue;
            } 
            if (!strcmp(c,  ">>" )) {
                  do_word(    gsm_asr( op1, op2 ));
                  continue;
            }
            if (!strcmp(c,  "L_mult")) {
                  do_longword( gsm_L_mult( op1, op2 ));
                  continue;
            }
            if (!strcmp(c,  "M_L_mult")) {
                  do_longword( M_gsm_L_mult( op1, op2 ));
                  continue;
            }
            if (!strcmp(c,  "L_add" )) {
                  do_longword( gsm_L_add( L_op1, L_op2 ));
                  continue;
            } 
            if (!strcmp(c,  "M_L_add" )) {
                  do_longword( M_gsm_L_add( L_op1, L_op2 ));
                  continue;
            } 
            if (!strcmp(c,  "L_sub" )) {
                  do_longword( gsm_L_sub( L_op1, L_op2 ));
                  continue;
            } 
            if (!strcmp(c,  "L_<<" )) {
                  do_longword(    gsm_L_asl( L_op1, L_op2 ));
                  continue;
            } 
            if (!strcmp(c,  "L_>>")) {
                  do_longword(    gsm_L_asr( L_op1, L_op2 ));
                  continue;
            }
            help();
      }
}

#include "private.h"

/*
 * Function stubs for macro implementations of commonly used
 * math functions
 */
word M_gsm_add P2((op1, op2),word op1, word op2)
{
      longword ltmp;
      return GSM_ADD(op1, op2);
}

word M_gsm_sub P2((op1, op2), word op1, word op2)
{
      longword ltmp;
      return GSM_SUB(op1, op2);
}

word M_gsm_mult P2((op1, op2), word op1, word op2)
{
      return GSM_MULT(op1, op2);
}

word M_gsm_mult_r P2((op1, op2), word op1, word op2)
{
      return GSM_MULT_R(op1, op2);
}

word M_gsm_abs P1((op1), word op1)
{
      return GSM_ABS(op1);
}

longword M_gsm_L_mult P2((op1, op2), word op1, word op2)
{
      return GSM_L_MULT(op1, op2);
}

longword M_gsm_L_add P2((op1, op2), longword op1, longword op2)
{
      ulongword utmp;
      return GSM_L_ADD(op1, op2);
}

Generated by  Doxygen 1.6.0   Back to index