Ejemplo n.º 1
0
/** 
 * The ARGP parser function.
 * 
 * @param key The key that maps to an option.
 * @param arg The argument supplied to the option (or NULL).
 * @param state A pointer describing the state of the parser.
 * 
 * @return Error code as described by the ARGP info docs.
 */
error_t
arg_parse (int key, char *arg, struct argp_state *state)
{
  switch (key)
    {
    case 'o':
      outfile_name = arg;
      break;

    case 'v':
      debug = -1;
      break;
      
    case 'd':
      yydebug = -1;
      break;

    case 'O':
      if (arg == NULL)
	optimize = 1;
      else
	optimize = strtol (arg, NULL, 0);
      break;

    case 'e':
      debug = -1;
      break;

    case 'c':
      stop = 'o';
      break;

    case 'S':
      stop = 's';
      break;

    case 'E':
      stop = 'i';
      break;

    case 'q':
      debug = 0;
      yydebug = 0;
      break;

    case ARGP_KEY_ARG:
      gl_list_add_last (infile_name, arg);
      break;

    case ARGP_KEY_NO_ARGS:
      argp_usage (state);
      break;

    default:
      return ARGP_ERR_UNKNOWN;
    }
  return 0;
}
Ejemplo n.º 2
0
/** 
 * @see free_tmpfiles
 * @see tmpfiles
 *
 */
const char *
tmpfile_name (void)
{
  /* If this is the first time that this routine is run, set up the
     list and add the destructors to the cleanup functions. */
  if (tmpfiles == NULL)
    {
      /** @note @parblock Incorperate GL_LINKED_LIST's feature to
	  make all actions on it signal safe.  This is turned on in
	  configure.ac by invoking:

	  @code
	  AC_DEFINE([SIGNAL_SAFE_LIST], [1],
	            [Define if lists must be signal-safe.])
	  @endcode

	  Thus this can be safely cleaned up while catching a fatal
	  signal.  @endparblock 
      */
      tmpfiles = gl_list_create_empty (GL_LINKED_LIST, NULL, NULL, NULL, 1);
      /* Register the free_tmpfiles cleanup function so that it is
	 called when the program exits and whenever the program
	 recieves a fatal signal. */
      atexit (free_tmpfiles);
      at_fatal_signal (free_tmpfiles);
    }

  /* Determine the name of the temporary file. */
  char *out = xstrdup ("compilerXXXXXX");
  int fd = gen_tempname (out, 0, 0, GT_FILE);
  if (fd < 0)
    error (1, errno, _("FATAL: failed to create temporary file"));
  else if (close (fd))
    error (1, errno, _("FATAL: failed to close the temporary file"));

  /* Add the entry to the list of temporary files. */
  gl_list_add_last (tmpfiles, out);

  return out;
}
Ejemplo n.º 3
0
int
main (int argc, char *argv[])
{
  gl_list_t list1, list2;

  set_program_name (argv[0]);

  /* Allow the user to provide a non-default random seed on the command line.  */
  if (argc > 1)
    srand (atoi (argv[1]));

  {
    size_t initial_size = RANDOM (50);
    const void **contents =
      (const void **) malloc (initial_size * sizeof (const void *));
    size_t i;
    unsigned int repeat;

    for (i = 0; i < initial_size; i++)
      contents[i] = RANDOM_OBJECT ();

    /* Create list1.  */
    list1 = gl_list_create (GL_ARRAY_LIST, NULL, NULL, NULL, true,
                            initial_size, contents);
    /* Create list2.  */
    list2 = gl_list_create_empty (GL_ARRAY_LIST, NULL, NULL, NULL, true);
    for (i = 0; i < initial_size; i++)
      gl_list_add_last (list2, contents[i]);

    check_equals (list1, list2);

    for (repeat = 0; repeat < 10000; repeat++)
      {
        unsigned int operation = RANDOM (16);
        switch (operation)
          {
          case 0:
            if (gl_list_size (list1) > 0)
              {
                size_t index = RANDOM (gl_list_size (list1));
                const char *obj = RANDOM_OBJECT ();
                gl_list_node_t node1, node2;

                node1 = gl_list_set_at (list1, index, obj);
                ASSERT (gl_list_get_at (list1, index) == obj);
                ASSERT (gl_list_node_value (list1, node1) == obj);

                node2 = gl_list_set_at (list2, index, obj);
                ASSERT (gl_list_get_at (list2, index) == obj);
                ASSERT (gl_list_node_value (list2, node2) == obj);

                if (index > 0)
                  {
                    ASSERT (gl_list_node_value (list1, gl_list_previous_node (list1, node1))
                            == gl_list_get_at (list1, index - 1));
                  }
                if (index + 1 < gl_list_size (list1))
                  {
                    ASSERT (gl_list_node_value (list1, gl_list_next_node (list1, node1))
                            == gl_list_get_at (list1, index + 1));
                  }
              }
            break;
          case 1:
            {
              const char *obj = RANDOM_OBJECT ();
              gl_list_node_t node1, node2;
              node1 = gl_list_search (list1, obj);
              node2 = gl_list_search (list2, obj);
              if (node1 == NULL)
                {
                  ASSERT (node2 == NULL);
                }
              else
                {
                  ASSERT (node2 != NULL);
                  ASSERT (gl_list_node_value (list1, node1) == obj);
                  ASSERT (gl_list_node_value (list2, node2) == obj);
                }
            }
            break;
          case 2:
            {
              const char *obj = RANDOM_OBJECT ();
              size_t index1, index2;
              index1 = gl_list_indexof (list1, obj);
              index2 = gl_list_indexof (list2, obj);
              if (index1 == (size_t)(-1))
                {
                  ASSERT (index2 == (size_t)(-1));
                }
              else
                {
                  ASSERT (index2 != (size_t)(-1));
                  ASSERT (gl_list_get_at (list1, index1) == obj);
                  ASSERT (gl_list_get_at (list2, index2) == obj);
                  ASSERT (index2 == index1);
                }
            }
            break;
          case 3: /* add 1 element */
            {
              const char *obj = RANDOM_OBJECT ();
              gl_list_node_t node1, node2;
              node1 = gl_list_add_first (list1, obj);
              node2 = gl_list_add_first (list2, obj);
              ASSERT (gl_list_node_value (list1, node1) == obj);
              ASSERT (gl_list_node_value (list2, node2) == obj);
              ASSERT (gl_list_get_at (list1, 0) == obj);
              ASSERT (gl_list_get_at (list2, 0) == obj);
            }
            break;
          case 4: /* add 1 element */
            {
              const char *obj = RANDOM_OBJECT ();
              gl_list_node_t node1, node2;
              node1 = gl_list_add_last (list1, obj);
              node2 = gl_list_add_last (list2, obj);
              ASSERT (gl_list_node_value (list1, node1) == obj);
              ASSERT (gl_list_node_value (list2, node2) == obj);
              ASSERT (gl_list_get_at (list1, gl_list_size (list1) - 1) == obj);
              ASSERT (gl_list_get_at (list2, gl_list_size (list2) - 1) == obj);
            }
            break;
          case 5: /* add 3 elements */
            {
              const char *obj0 = RANDOM_OBJECT ();
              const char *obj1 = RANDOM_OBJECT ();
              const char *obj2 = RANDOM_OBJECT ();
              gl_list_node_t node1, node2;
              node1 = gl_list_add_first (list1, obj2);
              node1 = gl_list_add_before (list1, node1, obj0);
              node1 = gl_list_add_after (list1, node1, obj1);
              node2 = gl_list_add_first (list2, obj2);
              node2 = gl_list_add_before (list2, node2, obj0);
              node2 = gl_list_add_after (list2, node2, obj1);
              ASSERT (gl_list_node_value (list1, node1) == obj1);
              ASSERT (gl_list_node_value (list2, node2) == obj1);
              ASSERT (gl_list_get_at (list1, 0) == obj0);
              ASSERT (gl_list_get_at (list1, 1) == obj1);
              ASSERT (gl_list_get_at (list1, 2) == obj2);
              ASSERT (gl_list_get_at (list2, 0) == obj0);
              ASSERT (gl_list_get_at (list2, 1) == obj1);
              ASSERT (gl_list_get_at (list2, 2) == obj2);
            }
            break;
          case 6: /* add 1 element */
            {
              size_t index = RANDOM (gl_list_size (list1) + 1);
              const char *obj = RANDOM_OBJECT ();
              gl_list_node_t node1, node2;
              node1 = gl_list_add_at (list1, index, obj);
              node2 = gl_list_add_at (list2, index, obj);
              ASSERT (gl_list_get_at (list1, index) == obj);
              ASSERT (gl_list_node_value (list1, node1) == obj);
              ASSERT (gl_list_get_at (list2, index) == obj);
              ASSERT (gl_list_node_value (list2, node2) == obj);
              if (index > 0)
                {
                  ASSERT (gl_list_node_value (list1, gl_list_previous_node (list1, node1))
                          == gl_list_get_at (list1, index - 1));
                }
              if (index + 1 < gl_list_size (list1))
                {
                  ASSERT (gl_list_node_value (list1, gl_list_next_node (list1, node1))
                          == gl_list_get_at (list1, index + 1));
                }
            }
            break;
          case 7: case 8: /* remove 1 element */
            if (gl_list_size (list1) > 0)
              {
                size_t n = gl_list_size (list1);
                const char *obj = gl_list_get_at (list1, RANDOM (n));
                gl_list_node_t node1, node2;
                node1 = gl_list_search (list1, obj);
                node2 = gl_list_search (list2, obj);
                ASSERT (node1 != NULL);
                ASSERT (node2 != NULL);
                ASSERT (gl_list_remove_node (list1, node1));
                ASSERT (gl_list_remove_node (list2, node2));
                ASSERT (gl_list_size (list1) == n - 1);
              }
            break;
          case 9: case 10: /* remove 1 element */
            if (gl_list_size (list1) > 0)
              {
                size_t n = gl_list_size (list1);
                size_t index = RANDOM (n);
                ASSERT (gl_list_remove_at (list1, index));
                ASSERT (gl_list_remove_at (list2, index));
                ASSERT (gl_list_size (list1) == n - 1);
              }
            break;
          case 11: case 12: /* remove 1 element */
            if (gl_list_size (list1) > 0)
              {
                size_t n = gl_list_size (list1);
                const char *obj = gl_list_get_at (list1, RANDOM (n));
                ASSERT (gl_list_remove (list1, obj));
                ASSERT (gl_list_remove (list2, obj));
                ASSERT (gl_list_size (list1) == n - 1);
              }
            break;
          case 13:
            if (gl_list_size (list1) > 0)
              {
                size_t n = gl_list_size (list1);
                const char *obj = "xyzzy";
                ASSERT (!gl_list_remove (list1, obj));
                ASSERT (!gl_list_remove (list2, obj));
                ASSERT (gl_list_size (list1) == n);
              }
            break;
          case 14:
            {
              size_t n = gl_list_size (list1);
              gl_list_iterator_t iter1, iter2;
              const void *elt;
              iter1 = gl_list_iterator (list1);
              iter2 = gl_list_iterator (list2);
              for (i = 0; i < n; i++)
                {
                  ASSERT (gl_list_iterator_next (&iter1, &elt, NULL));
                  ASSERT (gl_list_get_at (list1, i) == elt);
                  ASSERT (gl_list_iterator_next (&iter2, &elt, NULL));
                  ASSERT (gl_list_get_at (list2, i) == elt);
                }
              ASSERT (!gl_list_iterator_next (&iter1, &elt, NULL));
              ASSERT (!gl_list_iterator_next (&iter2, &elt, NULL));
              gl_list_iterator_free (&iter1);
              gl_list_iterator_free (&iter2);
            }
            break;
          case 15:
            {
              size_t end = RANDOM (gl_list_size (list1) + 1);
              size_t start = RANDOM (end + 1);
              gl_list_iterator_t iter1, iter2;
              const void *elt;
              iter1 = gl_list_iterator_from_to (list1, start, end);
              iter2 = gl_list_iterator_from_to (list2, start, end);
              for (i = start; i < end; i++)
                {
                  ASSERT (gl_list_iterator_next (&iter1, &elt, NULL));
                  ASSERT (gl_list_get_at (list1, i) == elt);
                  ASSERT (gl_list_iterator_next (&iter2, &elt, NULL));
                  ASSERT (gl_list_get_at (list2, i) == elt);
                }
              ASSERT (!gl_list_iterator_next (&iter1, &elt, NULL));
              ASSERT (!gl_list_iterator_next (&iter2, &elt, NULL));
              gl_list_iterator_free (&iter1);
              gl_list_iterator_free (&iter2);
            }
            break;
          }
        check_equals (list1, list2);
      }

    gl_list_free (list1);
    gl_list_free (list2);
    free (contents);
  }

  return 0;
}
Ejemplo n.º 4
0
/*
 * oprintf()
 *
 * Opcode printf
 */
static void oprintf(disasm_t *d, const char *format)
{
    uint32_t	i	= 0;
    const char 	*fstart, *fend;

    if (format == NULL)
        return;

    fstart	= fend	= format;

    while (*fend) {
        if (*fend != '%') {
            i++;
            fend++;
        } else {
            if (i)
                fprintf(d->fp, "%.*s", i, fstart);

            /* Skip past % */
            fend++;

            switch (*fend) {
            case 'b':
                fprintf(d->fp, "%d", d->code->buf[d->offset++]);
                break;
            case 'B':	/* Bigpic image */
                printBigpic(d->fp, d->code->buf[d->offset++]);
                break;
            case 'c':	/* Class */
                printClass(d);
                break;
            case 'C':	/* Spell */
                printSpell(d->fp, d->code->buf[d->offset++]);
                break;
            case 'D':	/* Direction */
            {
                uint8_t		dir;

                dir = d->code->buf[d->offset++];

                if (dir == 0) {
                    fprintf(d->fp, "north");
                } else if (dir == 1) {
                    fprintf(d->fp, "east");
                } else if (dir == 2) {
                    fprintf(d->fp, "south");
                } else if (dir == 3) {
                    fprintf(d->fp, "west");
                } else {
                    fprintf(d->fp, "unknown");
                }
                break;
            }
            case 'f':	/* Flag */
            {
                uint8_t		flag;
                uint8_t		mask;

                flag	= d->code->buf[d->offset] >> 3;
                mask	= d->code->buf[d->offset] & 7;
                fprintf(d->fp, "%d", (flag * 8) + mask);
                d->offset++;
                break;
            }
            case 'I':	/* Item */
                printItem(d->fp, d->code->buf[d->offset++]);
                break;
            case 'L':
                printLiquid(d->fp, d->code->buf[d->offset++]);
                break;
            case 'M':	/* Monster */
                printMonster(d->fp, d->code->buf[d->offset++]);
                break;
            case 'O':	/* String at offset */
            {
                uint16_t	savedOffset;
                range_t		*r;

                r = (range_t *)xzalloc(sizeof(range_t));

                savedOffset = d->offset + 2;

                d->offset = str_read16le(&d->code->buf[d->offset]) - currentLevel.dataStartOffset;
                r->start	= d->offset;
                printPackedString(d);
                r->end		= d->offset;
                gl_list_add_last(rangeSkipList, r);
                d->offset	= savedOffset;
                break;
            }
            case 'o':	/* offset */
                fprintf(d->fp, "%04x",
                        str_read16le(&d->code->buf[d->offset])
                       );
                d->offset += 2;
                break;
            case 'S':	/* Masked String */
                fprintf(d->fp, "\"");
                fflush(d->fp);
                printMaskedString(d);
                fprintf(d->fp, "\"");
                break;
            case 's':	/* Packed String */
                fprintf(d->fp, "\"");
                printPackedString(d);
                fprintf(d->fp, "\"");
                break;
            case 'w':	/* Word */
                fprintf(d->fp, "%d",
                        str_read16le(&d->code->buf[d->offset])
                       );
                d->offset	+= 2;
                break;
            case 'x':	/* Hex byte */
                fprintf(d->fp, "0x%02x", d->code->buf[d->offset++]);
                break;
            }

            fend++;
            fstart	= fend;
            i	= 0;
        }
    }

    if (i)
        fprintf(d->fp, "%.*s", i, fstart);
}