dcerpc: remove use-after-free (found by clang).
[metze/wireshark/wip.git] / epan / except.h
index 68fa58e7fcc940c42a3b8b315185a6faba84b8e2..45ce069c72dd7170c4009283372a2adc6efa83e1 100644 (file)
@@ -14,8 +14,6 @@
  * into proprietary software; there is no requirement for such software to
  * contain a copyright notice related to this source.
  *
- * $Id$
- * $Name:  $
  */
 
 /**
 #include <setjmp.h>
 #include <stdlib.h>
 #include <assert.h>
+#include "ws_symbol_export.h"
+#include "ws_attributes.h"
 
-#define XCEPT_GROUP_ANY        0
-#define XCEPT_CODE_ANY 0
+#define XCEPT_GROUP_ANY 0
+#define XCEPT_CODE_ANY  0
 #define XCEPT_BAD_ALLOC 1
 
 #ifdef __cplusplus
@@ -78,34 +78,35 @@ struct except_stacknode {
     struct except_stacknode *except_down;
     enum except_stacktype except_type;
     union {
-       struct except_catch *except_catcher;
-       struct except_cleanup *except_cleanup;
+        struct except_catch *except_catcher;
+        struct except_cleanup *except_cleanup;
     } except_info;
 };
 
 /* private functions made external so they can be used in macros */
 extern void except_setup_clean(struct except_stacknode *,
-       struct except_cleanup *, void (*)(void *), void *);
-extern void except_setup_try(struct except_stacknode *,
-       struct except_catch *, const except_id_t [], size_t);
-extern struct except_stacknode *except_pop(void);
+        struct except_cleanup *, void (*)(void *), void *);
+WS_DLL_PUBLIC void except_setup_try(struct except_stacknode *,
+        struct except_catch *, const except_id_t [], size_t);
+WS_DLL_PUBLIC struct except_stacknode *except_pop(void);
 
 /* public interface functions */
-extern int except_init(void);
-extern void except_deinit(void);
-extern WS_MSVC_NORETURN void except_rethrow(except_t *) G_GNUC_NORETURN;
-extern WS_MSVC_NORETURN void except_throw(long, long, const char *) G_GNUC_NORETURN;
-extern WS_MSVC_NORETURN void except_throwd(long, long, const char *, void *) G_GNUC_NORETURN;
-extern WS_MSVC_NORETURN void except_throwf(long, long, const char *, ...) G_GNUC_NORETURN;
-extern void (*except_unhandled_catcher(void (*)(except_t *)))(except_t *);
+WS_DLL_PUBLIC int except_init(void);
+WS_DLL_PUBLIC void except_deinit(void);
+WS_DLL_PUBLIC WS_NORETURN void except_rethrow(except_t *);
+WS_DLL_PUBLIC WS_NORETURN void except_throw(long, long, const char *);
+WS_DLL_PUBLIC WS_NORETURN void except_throwd(long, long, const char *, void *);
+WS_DLL_PUBLIC WS_NORETURN void except_throwf(long, long, const char *, ...)
+    G_GNUC_PRINTF(3, 4);
+WS_DLL_PUBLIC void (*except_unhandled_catcher(void (*)(except_t *)))(except_t *);
 extern unsigned long except_code(except_t *);
 extern unsigned long except_group(except_t *);
 extern const char *except_message(except_t *);
 extern void *except_data(except_t *);
-extern void *except_take_data(except_t *);
-extern void except_set_allocator(void *(*)(size_t), void (*)(void *));
-extern void *except_alloc(size_t);
-extern void except_free(void *);
+WS_DLL_PUBLIC void *except_take_data(except_t *);
+WS_DLL_PUBLIC void except_set_allocator(void *(*)(size_t), void (*)(void *));
+WS_DLL_PUBLIC void *except_alloc(size_t);
+WS_DLL_PUBLIC void except_free(void *);
 
 #define except_code(E) ((E)->except_id.except_code)
 #define except_group(E) ((E)->except_id.except_group)
@@ -124,61 +125,74 @@ extern void except_free(void *);
  * void except_try_pop(void);
  */
 
-#define except_cleanup_push(F, C)                              \
-    {                                                          \
-       struct except_stacknode except_sn;                      \
-       struct except_cleanup except_cl;                        \
-       except_setup_clean(&except_sn, &except_cl, F, C)
+#define except_cleanup_push(F, C)                               \
+    {                                                           \
+        struct except_stacknode except_sn;                      \
+        struct except_cleanup except_cl;                        \
+        except_setup_clean(&except_sn, &except_cl, F, C)
 
-#define except_cleanup_pop(E)                                  \
-       except_pop();                                           \
-       if (E)                                                  \
-           except_cl.except_func(except_cl.except_context);    \
+#define except_cleanup_pop(E)                                   \
+        except_pop();                                           \
+        if (E)                                                  \
+            except_cl.except_func(except_cl.except_context);    \
     }
 
-#define except_checked_cleanup_pop(F, E)                       \
-       except_pop();                                           \
-       assert (except_cl.except_func == (F));                  \
-       if (E)                                                  \
-           except_cl.except_func(except_cl.except_context);    \
+#define except_checked_cleanup_pop(F, E)                        \
+            except_pop();                                       \
+        assert (except_cl.except_func == (F));                  \
+        if (E)                                                  \
+            except_cl.except_func(except_cl.except_context);    \
     }
 
 
 /* --- Variants to allow nesting of except_cleanup_push w/o "shadowing" variables */
-#define except_cleanup_push_pfx(pfx, F, C)                             \
-    {                                                                  \
-       struct except_stacknode pfx##_except_sn;                        \
-       struct except_cleanup pfx##_except_cl;                          \
-       except_setup_clean(&pfx##_except_sn, &pfx##_except_cl, F, C)
-
-#define except_cleanup_pop_pfx(pfx, E)                                 \
-       except_pop();                                                   \
-       if (E)                                                          \
-           pfx##_except_cl.except_func(pfx##_except_cl.except_context);\
+#define except_cleanup_push_pfx(pfx, F, C)                      \
+    {                                                           \
+        struct except_stacknode pfx##_except_sn;                \
+        struct except_cleanup pfx##_except_cl;                  \
+        except_setup_clean(&pfx##_except_sn, &pfx##_except_cl, F, C)
+
+#define except_cleanup_pop_pfx(pfx, E)                          \
+        except_pop();                                           \
+        if (E)                                                  \
+            pfx##_except_cl.except_func(pfx##_except_cl.except_context);\
     }
 
-#define except_checked_cleanup_pop_pfx(pfx, F, E)                      \
-       except_pop();                                                   \
-       assert (pfx##_except_cl.except_func == (F));                    \
-       if (E)                                                          \
-           pfx##_except_cl.except_func(pfx##_except_cl.except_context);\
+#define except_checked_cleanup_pop_pfx(pfx, F, E)               \
+            except_pop();                                       \
+        assert (pfx##_except_cl.except_func == (F));            \
+        if (E)                                                  \
+            pfx##_except_cl.except_func(pfx##_except_cl.except_context);\
     }
 /* ---------- */
 
 
-#define except_try_push(ID, NUM, PPE)                          \
-     {                                                         \
-       struct except_stacknode except_sn;                      \
-       struct except_catch except_ch;                          \
-       except_setup_try(&except_sn, &except_ch, ID, NUM);      \
-       if (setjmp(except_ch.except_jmp))                       \
-           *(PPE) = &except_ch.except_obj;                     \
-       else                                                    \
-           *(PPE) = 0
+#define except_try_push(ID, NUM, PPE)                           \
+     {                                                          \
+        struct except_stacknode except_sn;                      \
+        struct except_catch except_ch;                          \
+        except_setup_try(&except_sn, &except_ch, ID, NUM);      \
+        if (setjmp(except_ch.except_jmp))                       \
+            *(PPE) = &except_ch.except_obj;                     \
+        else                                                    \
+            *(PPE) = 0
 
-#define except_try_pop()                                       \
-       except_free(except_ch.except_obj.except_dyndata);       \
-       except_pop();                                           \
+#define except_try_pop()                                        \
+        except_free(except_ch.except_obj.except_dyndata);       \
+        except_pop();                                           \
     }
 
-#endif
+#endif /* XCEPT_H */
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */