/ - Diff - qemu - Greek Research and Technology Network's projects

         va_end(ap);
+    }
     static Location std_loc = {
         .kind = LOC_NONE
     };
     static Location *cur_loc = &std_loc;
     /*
      * Push location saved in LOC onto the location stack, return it.
      * The top of that stack is the current location.
      * Needs a matching loc_pop().
      */
     Location *loc_push_restore(Location *loc)
+    {
         assert(!loc->prev);
         loc->prev = cur_loc;
         cur_loc = loc;
         return loc;
+    }
     /*
      * Initialize *LOC to "nowhere", push it onto the location stack.
      * The top of that stack is the current location.
      * Needs a matching loc_pop().
      * Return LOC.
      */
     Location *loc_push_none(Location *loc)
+    {
         loc->kind = LOC_NONE;
         loc->prev = NULL;
         return loc_push_restore(loc);
+    }
     /*
      * Pop the location stack.
      * LOC must be the current location, i.e. the top of the stack.
      */
     Location *loc_pop(Location *loc)
+    {
         assert(cur_loc == loc && loc->prev);
         cur_loc = loc->prev;
         loc->prev = NULL;
         return loc;
+    }
     /*
      * Save the current location in LOC, return LOC.
      */
     Location *loc_save(Location *loc)
+    {
         *loc = *cur_loc;
         loc->prev = NULL;
         return loc;
+    }
     /*
      * Change the current location to the one saved in LOC.
      */
     void loc_restore(Location *loc)
+    {
         Location *prev = cur_loc->prev;
         assert(!loc->prev);
         *cur_loc = *loc;
         cur_loc->prev = prev;
+    }
     /*
      * Change the current location to "nowhere in particular".
      */
     void loc_set_none(void)
+    {
         cur_loc->kind = LOC_NONE;
+    }
     /*
      * Print current location to current monitor if we have one, else to stderr.
      */
     void error_print_loc(void)
+    {
         switch (cur_loc->kind) {
         default: ;
+        }
+    }
     /*
      * Print an error message to current monitor if we have one, else to stderr.
      * Appends a newline to the message.
      * Prepend the current location and append a newline.
      * It's wrong to call this in a QMP monitor.  Use qerror_report() there.
      */
     void error_report(const char *fmt, ...)
+    {
         va_list ap;
         error_print_loc();
         va_start(ap, fmt);
         error_vprintf(fmt, ap);
         va_end(ap);

     #ifndef QEMU_ERROR_H
     #define QEMU_ERROR_H
     typedef struct Location {
         /* all members are private to qemu-error.c */
         enum { LOC_NONE } kind;
         int num;
         const void *ptr;
         struct Location *prev;
     } Location;
     Location *loc_push_restore(Location *loc);
     Location *loc_push_none(Location *loc);
     Location *loc_pop(Location *loc);
     Location *loc_save(Location *loc);
     void loc_restore(Location *loc);
     void loc_set_none(void);
     void error_vprintf(const char *fmt, va_list ap);
     void error_printf(const char *fmt, ...) __attribute__ ((format(printf, 1, 2)));
     void error_print_loc(void);
     void error_report(const char *fmt, ...) __attribute__ ((format(printf, 1, 2)));
     void qerror_report_internal(const char *file, int linenr, const char *func,
                                 const char *fmt, ...)

     #include <string.h>
     #include "qemu-common.h"
     #include "qemu-error.h"
     #include "qemu-option.h"
     /*
-...
     struct QemuOpts {
         char *id;
         QemuOptsList *list;
         Location loc;
         QTAILQ_HEAD(QemuOptHead, QemuOpt) head;
         QTAILQ_ENTRY(QemuOpts) next;
     };
-...
             opts->id = qemu_strdup(id);
+        }
         opts->list = list;
         loc_save(&opts->loc);
         QTAILQ_INIT(&opts->head);
         QTAILQ_INSERT_TAIL(&list->head, opts, next);
         return opts;
-...
     int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,
                           int abort_on_failure)
+    {
         Location loc;
         QemuOpts *opts;
         int rc = 0;
         loc_push_none(&loc);
         QTAILQ_FOREACH(opts, &list->head, next) {
             loc_restore(&opts->loc);
             rc |= func(opts, opaque);
             if (abort_on_failure  &&  rc != 0)
                 break;
+        }
         loc_pop(&loc);
         return rc;
+    }

         return (tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000)) / 1000000;
+    }
     Location *loc_push_restore(Location *loc)
+    {
         return loc;
+    }
     Location *loc_push_none(Location *loc)
+    {
         return loc;
+    }
     Location *loc_pop(Location *loc)
+    {
         return loc;
+    }
     Location *loc_save(Location *loc)
+    {
         return loc;
+    }
     void loc_restore(Location *loc)
+    {
+    }
     void error_report(const char *fmt, ...)
+    {
         va_list args;

         QError *qerr;
         qerr = qerror_new();
         loc_save(&qerr->loc);
         qerr->linenr = linenr;
         qerr->file = file;
         qerr->func = func;
-...
      * it uses error_report() for this, so that the output is routed to the right
      * place (ie. stderr or Monitor's device).
      */
     void qerror_print(const QError *qerror)
     void qerror_print(QError *qerror)
+    {
         QString *qstring = qerror_human(qerror);
         loc_push_restore(&qerror->loc);
         error_report("%s", qstring_get_str(qstring));
         loc_pop(&qerror->loc);
         QDECREF(qstring);
+    }

     #include "qdict.h"
     #include "qstring.h"
     #include "qemu-error.h"
     #include <stdarg.h>
     typedef struct QErrorStringTable {
-...
     typedef struct QError {
         QObject_HEAD;
         QDict *error;
         Location loc;
         int linenr;
         const char *file;
         const char *func;
-...
     QError *qerror_from_info(const char *file, int linenr, const char *func,
                              const char *fmt, va_list *va);
     QString *qerror_human(const QError *qerror);
     void qerror_print(const QError *qerror);
     void qerror_print(QError *qerror);
     QError *qobject_to_qerror(const QObject *obj);
     /*

Archipelago » qemu

Revision 827b0813