谁能解释我在嵌入式编程中实际使用的确切位置setjmp()和功能？longjmp()我知道这些是用于错误处理的。但我想知道一些用例。
问问题
54867 次
8 回答
95
错误处理
假设嵌套在许多其他函数中的函数深处存在错误，并且错误处理仅在顶级函数中才有意义。
如果中间的所有函数都必须正常返回并评估返回值或全局错误变量以确定进一步的处理没有意义甚至是坏的，那将是非常乏味和尴尬的。
这是 setjmp/longjmp 有意义的情况。这些情况类似于其他语言（C++、Java）中的异常有意义的情况。
协程
除了错误处理之外，我还可以想到另一种情况，您需要在 C 中使用 setjmp/longjmp：
当您需要实现协程时就是这种情况。
这是一个小演示示例。我希望它满足 Sivaprasad Palas 对一些示例代码的要求，并回答 TheBlastOne 的问题 setjmp/longjmp 如何支持协同程序的实现（据我所知，它不基于任何非标准或新行为）。
编辑：
可能实际上是在调用堆栈中执行未定义的行为（请参阅longjmp MikeMB的评论；尽管我还没有机会验证这一点）。
#include <stdio.h>
#include <setjmp.h>
jmp_buf bufferA, bufferB;
void routineB(); // forward declaration
void routineA()
{
int r ;
printf("(A1)\n");
r = setjmp(bufferA);
if (r == 0) routineB();
printf("(A2) r=%d\n",r);
r = setjmp(bufferA);
if (r == 0) longjmp(bufferB, 20001);
printf("(A3) r=%d\n",r);
r = setjmp(bufferA);
if (r == 0) longjmp(bufferB, 20002);
printf("(A4) r=%d\n",r);
}
void routineB()
{
int r;
printf("(B1)\n");
r = setjmp(bufferB);
if (r == 0) longjmp(bufferA, 10001);
printf("(B2) r=%d\n", r);
r = setjmp(bufferB);
if (r == 0) longjmp(bufferA, 10002);
printf("(B3) r=%d\n", r);
r = setjmp(bufferB);
if (r == 0) longjmp(bufferA, 10003);
}
int main(int argc, char **argv)
{
routineA();
return 0;
}
下图展示了执行流程：
警告说明
使用 setjmp/longjmp 时请注意，它们对通常不考虑的局部变量的有效性有影响。
参照。我关于这个话题的问题。
于 2013-02-04T11:11:36.033 回答
21
理论上，您可以使用它们进行错误处理，这样您就可以跳出深度嵌套的调用链，而无需处理链中每个函数中的错误处理。
就像所有聪明的理论一样，当遇到现实时，它就会崩溃。您的中间函数将分配内存、获取锁、打开文件并执行各种需要清理的不同操作。所以在实践中setjmp/longjmp通常是一个坏主意，除非在非常有限的情况下你可以完全控制你的环境（一些嵌入式平台）。
根据我的经验，在大多数情况下，只要您认为使用setjmp/longjmp会起作用，您的程序就足够清晰和简单，以至于调用链中的每个中间函数调用都可以进行错误处理，或者它是如此混乱且无法修复，以至于您应该exit在遇到错误。
于 2013-02-04T11:42:14.613 回答
11
setjmp和的结合longjmp是“超强goto”。小心使用。但是，正如其他人所解释的那样longjmp，当您想要get me back to the beginning快速摆脱令人讨厌的错误情况时，a 非常有用，而不必为 18 层函数返回错误消息。
但是，就像goto，但更糟糕的是，您必须非常小心如何使用它。Alongjmp只会让您回到代码的开头。它不会影响在setjmp和 回到setjmp开始位置之间可能发生变化的所有其他状态。所以当你回到setjmp被调用的地方时，分配、锁、半初始化的数据结构等仍然被分配、锁定和半初始化。这意味着，您必须真正关心您执行此操作的地方，这样真的可以打电话longjmp而不会造成更多问题。当然，如果您接下来要做的是“重新启动”[在存储有关错误的消息之后，也许] - 例如，在您发现硬件处于错误状态的嵌入式系统中，那就没问题了。
我也见过setjmp/longjmp曾经提供非常基本的线程机制。但这是非常特殊的情况——绝对不是“标准”线程的工作方式。
编辑：当然可以添加代码来“处理清理”，就像 C++ 在编译代码中存储异常点然后知道什么给出了异常以及什么需要清理一样。这将涉及某种函数指针表并存储“如果我们从这里跳出，使用这个参数调用这个函数”。像这样的东西：
struct
{
void (*destructor)(void *ptr);
};
void LockForceUnlock(void *vlock)
{
LOCK* lock = vlock;
}
LOCK func_lock;
void func()
{
ref = add_destructor(LockForceUnlock, mylock);
Lock(func_lock)
...
func2(); // May call longjmp.
Unlock(func_lock);
remove_destructor(ref);
}
使用这个系统，您可以“像 C++ 一样完成异常处理”。但它非常混乱，并且依赖于编写良好的代码。
于 2013-02-04T11:48:22.530 回答
11
setjmp并且longjmp在单元测试中非常有用。
假设我们要测试以下模块：
#include <stdlib.h>
int my_div(int x, int y)
{
if (y==0) exit(2);
return x/y;
}
通常，如果要测试的函数调用另一个函数，您可以声明一个存根函数供它调用，该函数将模仿实际函数为测试某些流所做的工作。但是，在这种情况下，函数调用exit不会返回。存根需要以某种方式模拟这种行为。 setjmp并且longjmp可以为您做到这一点。
为了测试这个功能，我们可以创建以下测试程序：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <setjmp.h>
// redefine assert to set a boolean flag
#ifdef assert
#undef assert
#endif
#define assert(x) (rslt = rslt && (x))
// the function to test
int my_div(int x, int y);
// main result return code used by redefined assert
static int rslt;
// variables controling stub functions
static int expected_code;
static int should_exit;
static jmp_buf jump_env;
// test suite main variables
static int done;
static int num_tests;
static int tests_passed;
// utility function
void TestStart(char *name)
{
num_tests++;
rslt = 1;
printf("-- Testing %s ... ",name);
}
// utility function
void TestEnd()
{
if (rslt) tests_passed++;
printf("%s\n", rslt ? "success" : "fail");
}
// stub function
void exit(int code)
{
if (!done)
{
assert(should_exit==1);
assert(expected_code==code);
longjmp(jump_env, 1);
}
else
{
_exit(code);
}
}
// test case
void test_normal()
{
int jmp_rval;
int r;
TestStart("test_normal");
should_exit = 0;
if (!(jmp_rval=setjmp(jump_env)))
{
r = my_div(12,3);
}
assert(jmp_rval==0);
assert(r==4);
TestEnd();
}
// test case
void test_div0()
{
int jmp_rval;
int r;
TestStart("test_div0");
should_exit = 1;
expected_code = 2;
if (!(jmp_rval=setjmp(jump_env)))
{
r = my_div(2,0);
}
assert(jmp_rval==1);
TestEnd();
}
int main()
{
num_tests = 0;
tests_passed = 0;
done = 0;
test_normal();
test_div0();
printf("Total tests passed: %d\n", tests_passed);
done = 1;
return !(tests_passed == num_tests);
}
在这个例子中，你使用在输入函数之前进行测试，然后在你调用setjmp的存根中直接返回你的测试用例。exitlongjmp
还要注意，redefinedexit有一个特殊的变量，它会检查你是否真的想退出程序并调用_exit它。如果您不这样做，您的测试程序可能不会完全退出。
于 2016-07-24T23:50:33.217 回答
10
既然您提到嵌入式，我认为值得注意的是一个非用例：当您的编码标准禁止它时。例如 MISRA (MISRA-C:2004:Rule 20.7) 和JFS (AV Rule 20)：“不应使用 setjmp 宏和 longjmp 函数。”
于 2013-02-04T16:27:27.350 回答
8
我在 C 中使用和系统函数编写了一个类似 Java 的异常处理机制。它捕获自定义异常，但也捕获类似. 它具有异常处理块的无限嵌套，可以跨函数调用工作，并支持两种最常见的线程实现。它允许您定义具有链接时继承功能的异常类的树层次结构，并且该语句遍历该树以查看它是否需要捕获或传递。setjmp()longjmp()SIGSEGVcatch
这是使用此代码的示例：
try
{
*((int *)0) = 0; /* may not be portable */
}
catch (SegmentationFault, e)
{
long f[] = { 'i', 'l', 'l', 'e', 'g', 'a', 'l' };
((void(*)())f)(); /* may not be portable */
}
finally
{
return(1 / strcmp("", ""));
}
这是包含大量逻辑的包含文件的一部分：
#ifndef _EXCEPT_H
#define _EXCEPT_H
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <setjmp.h>
#include "Lifo.h"
#include "List.h"
#define SETJMP(env) sigsetjmp(env, 1)
#define LONGJMP(env, val) siglongjmp(env, val)
#define JMP_BUF sigjmp_buf
typedef void (* Handler)(int);
typedef struct _Class *ClassRef; /* exception class reference */
struct _Class
{
int notRethrown; /* always 1 (used by throw()) */
ClassRef parent; /* parent class */
char * name; /* this class name string */
int signalNumber; /* optional signal number */
};
typedef struct _Class Class[1]; /* exception class */
typedef enum _Scope /* exception handling scope */
{
OUTSIDE = -1, /* outside any 'try' */
INTERNAL, /* exception handling internal */
TRY, /* in 'try' (across routine calls) */
CATCH, /* in 'catch' (idem.) */
FINALLY /* in 'finally' (idem.) */
} Scope;
typedef enum _State /* exception handling state */
{
EMPTY, /* no exception occurred */
PENDING, /* exception occurred but not caught */
CAUGHT /* occurred exception caught */
} State;
typedef struct _Except /* exception handle */
{
int notRethrown; /* always 0 (used by throw()) */
State state; /* current state of this handle */
JMP_BUF throwBuf; /* start-'catching' destination */
JMP_BUF finalBuf; /* perform-'finally' destination */
ClassRef class; /* occurred exception class */
void * pData; /* exception associated (user) data */
char * file; /* exception file name */
int line; /* exception line number */
int ready; /* macro code control flow flag */
Scope scope; /* exception handling scope */
int first; /* flag if first try in function */
List * checkList; /* list used by 'catch' checking */
char* tryFile; /* source file name of 'try' */
int tryLine; /* source line number of 'try' */
ClassRef (*getClass)(void); /* method returning class reference */
char * (*getMessage)(void); /* method getting description */
void * (*getData)(void); /* method getting application data */
void (*printTryTrace)(FILE*);/* method printing nested trace */
} Except;
typedef struct _Context /* exception context per thread */
{
Except * pEx; /* current exception handle */
Lifo * exStack; /* exception handle stack */
char message[1024]; /* used by ExceptGetMessage() */
Handler sigAbrtHandler; /* default SIGABRT handler */
Handler sigFpeHandler; /* default SIGFPE handler */
Handler sigIllHandler; /* default SIGILL handler */
Handler sigSegvHandler; /* default SIGSEGV handler */
Handler sigBusHandler; /* default SIGBUS handler */
} Context;
extern Context * pC;
extern Class Throwable;
#define except_class_declare(child, parent) extern Class child
#define except_class_define(child, parent) Class child = { 1, parent, #child }
except_class_declare(Exception, Throwable);
except_class_declare(OutOfMemoryError, Exception);
except_class_declare(FailedAssertion, Exception);
except_class_declare(RuntimeException, Exception);
except_class_declare(AbnormalTermination, RuntimeException); /* SIGABRT */
except_class_declare(ArithmeticException, RuntimeException); /* SIGFPE */
except_class_declare(IllegalInstruction, RuntimeException); /* SIGILL */
except_class_declare(SegmentationFault, RuntimeException); /* SIGSEGV */
except_class_declare(BusError, RuntimeException); /* SIGBUS */
#ifdef DEBUG
#define CHECKED \
static int checked
#define CHECK_BEGIN(pC, pChecked, file, line) \
ExceptCheckBegin(pC, pChecked, file, line)
#define CHECK(pC, pChecked, class, file, line) \
ExceptCheck(pC, pChecked, class, file, line)
#define CHECK_END \
!checked
#else /* DEBUG */
#define CHECKED
#define CHECK_BEGIN(pC, pChecked, file, line) 1
#define CHECK(pC, pChecked, class, file, line) 1
#define CHECK_END 0
#endif /* DEBUG */
#define except_thread_cleanup(id) ExceptThreadCleanup(id)
#define try \
ExceptTry(pC, __FILE__, __LINE__); \
while (1) \
{ \
Context * pTmpC = ExceptGetContext(pC); \
Context * pC = pTmpC; \
CHECKED; \
\
if (CHECK_BEGIN(pC, &checked, __FILE__, __LINE__) && \
pC->pEx->ready && SETJMP(pC->pEx->throwBuf) == 0) \
{ \
pC->pEx->scope = TRY; \
do \
{
#define catch(class, e) \
} \
while (0); \
} \
else if (CHECK(pC, &checked, class, __FILE__, __LINE__) && \
pC->pEx->ready && ExceptCatch(pC, class)) \
{ \
Except *e = LifoPeek(pC->exStack, 1); \
pC->pEx->scope = CATCH; \
do \
{
#define finally \
} \
while (0); \
} \
if (CHECK_END) \
continue; \
if (!pC->pEx->ready && SETJMP(pC->pEx->finalBuf) == 0) \
pC->pEx->ready = 1; \
else \
break; \
} \
ExceptGetContext(pC)->pEx->scope = FINALLY; \
while (ExceptGetContext(pC)->pEx->ready > 0 || ExceptFinally(pC)) \
while (ExceptGetContext(pC)->pEx->ready-- > 0)
#define throw(pExceptOrClass, pData) \
ExceptThrow(pC, (ClassRef)pExceptOrClass, pData, __FILE__, __LINE__)
#define return(x) \
{ \
if (ExceptGetScope(pC) != OUTSIDE) \
{ \
void * pData = malloc(sizeof(JMP_BUF)); \
ExceptGetContext(pC)->pEx->pData = pData; \
if (SETJMP(*(JMP_BUF *)pData) == 0) \
ExceptReturn(pC); \
else \
free(pData); \
} \
return x; \
}
#define pending \
(ExceptGetContext(pC)->pEx->state == PENDING)
extern Scope ExceptGetScope(Context *pC);
extern Context *ExceptGetContext(Context *pC);
extern void ExceptThreadCleanup(int threadId);
extern void ExceptTry(Context *pC, char *file, int line);
extern void ExceptThrow(Context *pC, void * pExceptOrClass,
void *pData, char *file, int line);
extern int ExceptCatch(Context *pC, ClassRef class);
extern int ExceptFinally(Context *pC);
extern void ExceptReturn(Context *pC);
extern int ExceptCheckBegin(Context *pC, int *pChecked,
char *file, int line);
extern int ExceptCheck(Context *pC, int *pChecked, ClassRef class,
char *file, int line);
#endif /* _EXCEPT_H */
还有一个 C 模块，其中包含用于信号处理和一些簿记的逻辑。
我可以告诉你，实施起来非常棘手，我几乎放弃了。我真的努力让它尽可能接近 Java。我发现仅使用 C 就能走多远令人惊讶。
如果你有兴趣，请给我留言。
于 2017-12-23T21:21:29.783 回答
2
毫无疑问，setjmp/longjmp 最重要的用途是它充当“非本地 goto 跳转”。Goto 命令（在少数情况下您需要在 for 和 while 循环上使用 goto）在同一范围内最安全地使用。如果您使用 goto 跨范围（或跨自动分配）跳转，您很可能会破坏程序的堆栈。setjmp/longjmp 通过将堆栈信息保存在您要跳转到的位置来避免这种情况。然后，当您跳转时，它会加载此堆栈信息。如果没有这个特性，C 程序员很可能不得不转向汇编编程来解决只有 setjmp/longjmp 才能解决的问题。感谢上帝它存在。C 库中的所有内容都非常重要。你会知道什么时候需要它。
于 2020-02-14T18:44:58.607 回答
1
除了错误处理之外，您可以做的另一件之前没有提到的事情是以一种智能的方式在 C 中实现尾递归计算。
这实际上是如何在 C 中实现延续而不以延续传递样式转换输入代码。
于 2020-10-21T14:02:16.897 回答