env.c 75 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298
  1. #include "aFunCore.h"
  2. #include "__env.h"
  3. #include "__global_obj.h"
  4. #include "__run.h"
  5. #include "__sig.h"
  6. /* Activity 创建和释放 */
  7. static af_Activity *makeActivity(af_Message *msg_up, af_VarSpaceListNode *varlist, af_Object *belong);
  8. static af_Activity *makeFuncActivity(af_Code *bt_top, af_Code *bt_start, bool return_first, af_Message *msg_up,
  9. af_VarSpaceListNode *out_varlist, af_Object *belong, af_Object *func);
  10. static af_Activity *makeTopActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong);
  11. static af_Activity *makeTopImportActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong, char *mark);
  12. static af_Activity *makeGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env);
  13. static af_Activity *freeActivity(af_Activity *activity, af_Environment *env);
  14. static void freeActivityTop(af_Activity *activity);
  15. static void freeAllActivity(af_Activity *activity, af_Environment *env);
  16. /* Activity 相关处理函数 */
  17. static void clearFuncActivity(af_Activity *activity);
  18. static void pushActivity(af_Activity *activity, af_Environment *env);
  19. static void freeMark(af_Activity *activity);
  20. static void newFuncActivity(af_Code *bt, const af_Code *next, bool return_first, af_Environment *env);
  21. /* ActivityTrackBack 创建与释放 */
  22. static af_ActivityTrackBack *makeActivityTrackBack(af_Activity *activity);
  23. static af_ActivityTrackBack *freeActivityTrackBack(af_ActivityTrackBack *atb);
  24. static void freeAllActivityTrackBack(af_ActivityTrackBack *atb);
  25. /* 环境变量 创建与释放 */
  26. static af_EnvVar *makeEnvVar(char *name);
  27. static af_EnvVar *freeEnvVar(af_EnvVar *var);
  28. static void freeAllEnvVar(af_EnvVar *var);
  29. static void freeEnvVarSpace(af_EnvVarSpace *evs);
  30. /* 顶层消息处理器 创建与释放 */
  31. static af_TopMsgProcess *makeTopMsgProcess(char *type, DLC_SYMBOL(TopMsgProcessFunc) func);
  32. static af_TopMsgProcess *freeTopMsgProcess(af_TopMsgProcess *mp);
  33. static void freeAllTopMsgProcess(af_TopMsgProcess *mp);
  34. /* 顶层消息处理器 处理函数 */
  35. static af_TopMsgProcess *findTopMsgProcessFunc(char *type, af_Environment *env);
  36. /* 守护器 创建与释放 */
  37. static af_Guardian *makeGuardian(char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
  38. DLC_SYMBOL(GuardianDestruct) destruct);
  39. static af_Guardian *freeGuardian(af_Guardian *gd, af_Environment *env);
  40. static void freeAllGuardian(af_Guardian *gd, af_Environment *env);
  41. /* 守护器 处理函数 */
  42. static af_Guardian *findGuardian(char *type, af_Environment *env);
  43. /* LiteralData 创建与释放 */
  44. static af_LiteralDataList *makeLiteralDataList(char *data);
  45. static af_LiteralDataList *freeLiteralData_Pri(af_LiteralDataList *ld);
  46. /* LiteralRegex 创建与释放 */
  47. static af_LiteralRegex *makeLiteralRegex(char *pattern, char *func, bool in_protect);
  48. static af_LiteralRegex *freeLiteralRegex(af_LiteralRegex *lr);
  49. static void freeAllLiteralRegex(af_LiteralRegex *lr);
  50. /* EnvironmentList 创建与释放 */
  51. static af_EnvironmentList *makeEnvironmentList(af_Environment *env);
  52. static bool freeEnvironmentList(af_EnvironmentList *envl, af_Environment *base);
  53. /* af_ErrorBacktracking 创建与释放 */
  54. static af_ErrorBacktracking *makeErrorBacktracking(FileLine line, FilePath file, char *note);
  55. static af_ErrorBacktracking *freeErrorBacktracking(af_ErrorBacktracking *ebt);
  56. static void freeAllErrorBacktracking(af_ErrorBacktracking *ebt);
  57. /* af_ErrorBacktracking 相关函数 */
  58. static char *getActivityInfoToBacktracking(af_Activity *activity);
  59. static char *getActivityTrackBackInfoToBacktracking(af_ActivityTrackBack *atb);
  60. static void fprintfNote(FILE *file, char *note);
  61. static void fprintfNoteStderr(char *note);
  62. static void fprintfNoteStdout(char *note);
  63. /* af_GuardianList 创建与释放 */
  64. static af_GuardianList *makeGuardianList(af_Object *obj, af_Object *func, af_Environment *env);
  65. static af_GuardianList *freeGuardianList(af_GuardianList *gl, af_Environment *env);
  66. static void freeAllGuardianList(af_GuardianList *gl, af_Environment *env);
  67. /* 内置顶层消息处理器 */
  68. static void mp_NORMAL(af_Message *msg, bool is_top, af_Environment *env);
  69. static void mp_ERROR(af_Message *msg, bool is_top, af_Environment *env);
  70. static void mp_IMPORT(af_Message *msg, bool is_top, af_Environment *env);
  71. /* 内置守护器 */
  72. static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char err[], af_Environment *env);
  73. static af_GuardianList *guardian_GC(char *type, bool is_guard, void *data, af_Environment *env);
  74. static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, af_Environment *env);
  75. /* 变量检查函数 */
  76. static bool isInfixFunc(af_Code *code, af_Environment *env);
  77. char setPrefix(size_t name, char prefix, af_Environment *env) {
  78. if (name >= PREFIX_SIZE)
  79. return '-'; // 表示未获取到prefix (NUL在Code中表示无prefix)
  80. pthread_rwlock_wrlock(&env->esv->lock);
  81. char *prefix_ = env->prefix->data;
  82. if (prefix_ == NULL || strlen(prefix_) < PREFIX_SIZE) {
  83. pthread_rwlock_unlock(&env->esv->lock);
  84. return '-';
  85. }
  86. switch (name) {
  87. case E_QUOTE:
  88. if (prefix == NUL && strchr(E_PREFIX, prefix) == NULL)
  89. prefix = '-';
  90. break;
  91. case B_EXEC:
  92. case B_EXEC_FIRST:
  93. if (prefix == NUL && strchr(B_PREFIX, prefix) == NULL)
  94. prefix = '-';
  95. break;
  96. default:
  97. break;
  98. }
  99. char old = prefix_[name];
  100. prefix_[name] = prefix;
  101. pthread_rwlock_unlock(&env->esv->lock);
  102. return old;
  103. }
  104. char getPrefix(size_t name, af_Environment *env) {
  105. if (name >= PREFIX_SIZE)
  106. return '-'; // 表示未获取到prefix (NUL在Code中表示无prefix)
  107. pthread_rwlock_rdlock(&env->esv->lock);
  108. char *prefix = env->prefix->data;
  109. pthread_rwlock_unlock(&env->esv->lock);
  110. if (prefix == NULL || strlen(prefix) < PREFIX_SIZE)
  111. return '-';
  112. return prefix[name];
  113. }
  114. af_VarSpace *getProtectVarSpace(af_Environment *env) {
  115. return env->protect;
  116. }
  117. /*
  118. * 函数名: getBaseObject
  119. * 目标: getBaseObjectFromCore的对外接口
  120. */
  121. af_Object *getBaseObject(char *name, af_Environment *env) {
  122. af_Var *var = findVarFromVarSpace(name, NULL, env->protect);
  123. if (var != NULL)
  124. return findVarNode(var, NULL);
  125. return NULL;
  126. }
  127. void setCoreStop(af_Environment *env) {
  128. pthread_mutex_lock(&env->status_lock);
  129. if (env->status != core_exit)
  130. env->status = core_stop;
  131. pthread_mutex_unlock(&env->status_lock);
  132. }
  133. void setCoreExit(int exit_code, af_Environment *env) {
  134. pthread_rwlock_wrlock(&env->esv->lock);
  135. env->exit_code_->num = exit_code;
  136. pthread_rwlock_unlock(&env->esv->lock);
  137. setCoreExitNotExitCode(env);
  138. }
  139. void setCoreExitNotExitCode(af_Environment *env) {
  140. pthread_mutex_lock(&env->status_lock);
  141. env->status = core_exit;
  142. pthread_mutex_unlock(&env->status_lock);
  143. if (!env->is_derive) { // 若是主线程, 通知所有次线程
  144. pthread_mutex_lock(&env->thread_lock);
  145. for (af_EnvironmentList *envl = env->env_list; envl != NULL; envl = envl->next) {
  146. pthread_mutex_lock(&envl->env->thread_lock);
  147. if (envl->env->monitor != NULL)
  148. pthread_cond_signal(&envl->env->monitor->cond);
  149. pthread_mutex_unlock(&envl->env->thread_lock);
  150. }
  151. pthread_mutex_lock(&env->thread_lock);
  152. }
  153. }
  154. void setCoreNormal(af_Environment *env) {
  155. pthread_mutex_lock(&env->status_lock);
  156. if (env->status == core_exit || env->status == core_stop)
  157. env->status = core_normal;
  158. pthread_mutex_unlock(&env->status_lock);
  159. pthread_rwlock_wrlock(&env->esv->lock);
  160. env->exit_code_->num = 0;
  161. pthread_rwlock_unlock(&env->esv->lock);
  162. }
  163. static af_Activity *makeActivity(af_Message *msg_up, af_VarSpaceListNode *varlist, af_Object *belong) {
  164. af_Activity *activity = calloc(1, sizeof(af_Activity));
  165. activity->msg_up = msg_up;
  166. activity->msg_up_count = 0;
  167. activity->run_varlist = varlist;
  168. activity->count_run_varlist = 0;
  169. activity->belong = belong;
  170. activity->line = 1;
  171. pthread_rwlock_init(&activity->gc_lock, NULL);
  172. return activity;
  173. }
  174. static af_Activity *makeFuncActivity(af_Code *bt_top, af_Code *bt_start, bool return_first, af_Message *msg_up,
  175. af_VarSpaceListNode *out_varlist, af_Object *belong, af_Object *func) {
  176. af_Activity *activity = makeActivity(msg_up, out_varlist, belong);
  177. activity->type = act_func;
  178. activity->status = act_func_get;
  179. activity->func = func;
  180. activity->out_varlist = out_varlist;
  181. activity->func_varlist = NULL;
  182. setActivityBtTop(bt_top, activity); // 非NORMAL期间, bt_top被设定
  183. setActivityBtStart(bt_start, activity);
  184. activity->return_first = return_first;
  185. return activity;
  186. }
  187. static af_Activity *makeTopActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong) {
  188. af_Activity *activity = makeActivity(NULL, NULL, belong);
  189. activity->type = act_top;
  190. activity->status = act_func_normal;
  191. activity->count_run_varlist = 2;
  192. activity->run_varlist = makeVarSpaceList(getObjectVarSpace(belong));
  193. activity->run_varlist->next = makeVarSpaceList(protect);
  194. setActivityBtTop(NULL, activity); // top-activity直接就在normal, bt_top将不被设定
  195. setActivityBtStart(bt_start, activity);
  196. return activity;
  197. }
  198. static af_Activity *makeTopImportActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong, char *mark) {
  199. af_Activity *activity = makeTopActivity(bt_top, bt_start, protect, belong);
  200. activity->type = act_top_import;
  201. if (mark != NULL)
  202. activity->import_mark = strCopy(mark);
  203. return activity;
  204. }
  205. static af_Activity *makeGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env) {
  206. af_Activity *activity = makeActivity(NULL, NULL, env->global);
  207. activity->type = act_guardian;
  208. activity->run_varlist = makeVarSpaceList(getProtectVarSpace(env));
  209. activity->count_run_varlist = 1;
  210. activity->file = strCopy("guardian.aun.sys");
  211. activity->line = 1;
  212. activity->gl = gl;
  213. activity->pgl = pgl;
  214. activity->gl_next = gl;
  215. activity->is_guard = true;
  216. return activity;
  217. }
  218. static af_Activity *freeActivity(af_Activity *activity, af_Environment *env){
  219. pthread_rwlock_wrlock(&activity->gc_lock);
  220. af_Activity *prev = activity->prev;
  221. freeAllMessage(activity->msg_down); // msg转移后需要将对应成员设置为NULL
  222. freeMessageCount(activity->msg_up_count, activity->msg_up);
  223. free(activity->file);
  224. freeVarSpaceListCount(activity->count_run_varlist, activity->run_varlist);
  225. if (activity->type == act_guardian) {
  226. if (activity->gl != NULL)
  227. freeAllGuardianList(activity->gl, env);
  228. } else {
  229. freeVarSpaceListCount(activity->count_out_varlist, activity->out_varlist);
  230. freeVarSpaceListCount(activity->count_macro_varlist, activity->macro_varlist);
  231. freeAllArgCodeList(activity->acl_start, env);
  232. if (activity->fi != NULL)
  233. freeFuncInfo(activity->fi);
  234. freeAllLiteralData(activity->ld);
  235. freeAllActivityTrackBack(activity->tb);
  236. free(activity->import_mark);
  237. }
  238. pthread_rwlock_unlock(&activity->gc_lock);
  239. pthread_rwlock_destroy(&activity->gc_lock);
  240. free(activity);
  241. return prev;
  242. }
  243. static void freeActivityTop(af_Activity *activity) {
  244. freeAllMessage(activity->msg_down); // msg转移后需要将对应成员设置为NULL
  245. freeMessageCount(activity->msg_up_count, activity->msg_up);
  246. setActivityBtTop(NULL, activity);
  247. setActivityBtStart(NULL, activity);
  248. free(activity->file);
  249. }
  250. static void freeAllActivity(af_Activity *activity, af_Environment *env){
  251. while (activity != NULL)
  252. activity = freeActivity(activity, env);
  253. }
  254. static void pushActivity(af_Activity *activity, af_Environment *env) {
  255. if (env->activity->is_guard)
  256. activity->is_guard = true;
  257. activity->prev = env->activity;
  258. env->activity = activity;
  259. }
  260. /*
  261. * 函数名: clearActivity
  262. * 目标: 尾调用优化时用于清理Activity.
  263. * file和line都遗留
  264. * 清空 varlist (除 run_varlist)
  265. */
  266. static void clearFuncActivity(af_Activity *activity) {
  267. /* acl在runArgList之后就被释放了 */
  268. /* acl在FuncBody暂时不释放 */
  269. pthread_rwlock_wrlock(&activity->gc_lock);
  270. activity->out_varlist = activity->run_varlist;
  271. activity->count_out_varlist = activity->count_run_varlist;
  272. activity->count_run_varlist = 0;
  273. activity->macro_varlist = NULL;
  274. activity->count_macro_varlist = 0;
  275. activity->func_varlist = NULL;
  276. /* mark在setFuncActivityToNormal被清理*/
  277. /* 只有FuncBody执行到最后一个(意味着Mark被清理)后才会有尾调用优化 */
  278. activity->mark = NULL;
  279. activity->func = NULL;
  280. pthread_rwlock_unlock(&activity->gc_lock);
  281. setActivityBtTop(NULL, activity);
  282. setActivityBtStart(NULL, activity);
  283. /* acl_start 在 setFuncActivityAddVar 时被释放 */
  284. activity->acl_start = NULL;
  285. activity->acl_done = NULL;
  286. /* activity->fi 暂时不清理, 直到setFuncActivityAddVar时才清理 */
  287. activity->body_next = NULL;
  288. }
  289. /*
  290. * 函数名: af_ActivityTrackBack
  291. * 目标: 把 activity 上的内容转移到新的 af_ActivityTrackBack 上
  292. */
  293. static af_ActivityTrackBack *makeActivityTrackBack(af_Activity *activity) {
  294. af_ActivityTrackBack *atb = calloc(1, sizeof(af_ActivityTrackBack));
  295. #define EXCHANGE(name) (atb->name = activity->name)
  296. EXCHANGE(file);
  297. atb->file = strCopy(activity->file);
  298. EXCHANGE(status);
  299. EXCHANGE(line);
  300. EXCHANGE(return_first);
  301. EXCHANGE(run_in_func);
  302. EXCHANGE(is_macro_call);
  303. EXCHANGE(is_gc_call);
  304. EXCHANGE(is_literal);
  305. EXCHANGE(is_obj_func);
  306. EXCHANGE(is_execution);
  307. EXCHANGE(optimization);
  308. #undef EXCHANGE
  309. return atb;
  310. }
  311. static af_ActivityTrackBack *freeActivityTrackBack(af_ActivityTrackBack *atb) {
  312. af_ActivityTrackBack *next = atb->next;
  313. free(atb->file);
  314. free(atb);
  315. return next;
  316. }
  317. static void freeAllActivityTrackBack(af_ActivityTrackBack *atb) {
  318. while (atb != NULL)
  319. atb = freeActivityTrackBack(atb);
  320. }
  321. /*
  322. * 函数名: tailCallActivity
  323. * 目标: 记录ActivityTrackBack然后清除Activity
  324. */
  325. static void tailCallActivity(af_Object *func, af_Activity *activity) {
  326. af_ActivityTrackBack *atb = makeActivityTrackBack(activity);
  327. atb->next = activity->tb;
  328. clearFuncActivity(activity);
  329. activity->tb = atb;
  330. pthread_rwlock_wrlock(&activity->gc_lock);
  331. activity->func = func;
  332. pthread_rwlock_unlock(&activity->gc_lock);
  333. }
  334. /*
  335. * 函数名: setActivityBtTop
  336. * 目标: 设置activity的bt_top, 并且设置行号
  337. * bt_start和bt_next会被设置为NULL
  338. */
  339. void setActivityBtTop(af_Code *bt_top, af_Activity *activity) {
  340. activity->bt_top = bt_top;
  341. activity->bt_start = NULL;
  342. activity->bt_next = NULL;
  343. if (bt_top != NULL) {
  344. activity->line = bt_top->line;
  345. if (bt_top->path != NULL) {
  346. free(activity->file);
  347. activity->file = strCopy(bt_top->path);
  348. }
  349. } else
  350. activity->line = 1;
  351. }
  352. /*
  353. * 函数名: setActivityBtStart
  354. * 目标: 设置activity的bt_start, 并且设置行号
  355. * bt_next会被设置为NULL
  356. */
  357. void setActivityBtStart(af_Code *bt_start, af_Activity *activity) {
  358. activity->bt_start = bt_start;
  359. activity->bt_next = bt_start;
  360. if (bt_start != NULL) {
  361. activity->line = bt_start->line;
  362. if (bt_start->path != NULL) {
  363. free(activity->file);
  364. activity->file = strCopy(bt_start->path);
  365. }
  366. } else
  367. activity->line = 1;
  368. }
  369. /*
  370. * 函数名: setActivityBtNext
  371. * 目标: 设置activity的bt_next, 并且设置行号
  372. */
  373. void setActivityBtNext(af_Code *bt_next, af_Activity *activity) {
  374. activity->bt_next = bt_next;
  375. if (bt_next != NULL) {
  376. activity->line = bt_next->line;
  377. if (bt_next->path != NULL) {
  378. free(activity->file);
  379. activity->file = strCopy(bt_next->path);
  380. }
  381. } else
  382. activity->line = 1;
  383. }
  384. /*
  385. * 函数名: makeLiteralDataList
  386. * 目标: 生成一个 af_LiteralDataList
  387. * 注意: char *data 要求传入一个已经被复制的data值
  388. * makeLiteralDataList是内部函数, 属于可控函数, 因此data在函数内部不再复制
  389. */
  390. static af_LiteralDataList *makeLiteralDataList(char *data) {
  391. af_LiteralDataList *ld = calloc(1, sizeof(af_LiteralDataList));
  392. ld->literal_data = data;
  393. return ld;
  394. }
  395. static af_LiteralDataList *freeLiteralData_Pri(af_LiteralDataList *ld) {
  396. af_LiteralDataList *next = ld->next;
  397. free(ld->literal_data);
  398. free(ld);
  399. return next;
  400. }
  401. void freeAllLiteralData(af_LiteralDataList *ld) {
  402. while (ld != NULL)
  403. ld = freeLiteralData_Pri(ld);
  404. }
  405. void pushLiteralData(char *data, af_Environment *env) {
  406. af_LiteralDataList *ld = makeLiteralDataList(data);
  407. ld->next = env->activity->ld;
  408. env->activity->ld = ld;
  409. }
  410. af_Message *makeMessage(char *type, size_t size) {
  411. af_Message *msg = calloc(1, sizeof(af_Message));
  412. msg->type = strCopy(type);
  413. if (size != 0)
  414. msg->msg = calloc(1, size);
  415. msg->size = size;
  416. return msg;
  417. }
  418. af_Message *freeMessage(af_Message *msg) {
  419. af_Message *next = msg->next;
  420. free(msg->type);
  421. free(msg->msg);
  422. free(msg);
  423. return next;
  424. }
  425. void freeAllMessage(af_Message *msg) {
  426. while (msg != NULL)
  427. msg = freeMessage(msg);
  428. }
  429. bool freeMessageCount(size_t count, af_Message *msg) {
  430. for (size_t i = count; i > 0; i--) {
  431. if (msg == NULL) // 发生了错误
  432. return false;
  433. msg = freeMessage(msg);
  434. }
  435. return true;
  436. }
  437. void pushMessageUp(af_Message *msg, af_Environment *env) {
  438. msg->next = env->activity->msg_up;
  439. env->activity->msg_up = msg;
  440. env->activity->msg_up_count++;
  441. }
  442. void pushMessageDown(af_Message *msg, af_Environment *env) {
  443. msg->next = env->activity->msg_down;
  444. env->activity->msg_down = msg;
  445. }
  446. void *popMessageUpData(char *type, af_Environment *env) {
  447. for (af_Message **pmsg = &env->activity->msg_up; *pmsg != NULL; pmsg = &((*pmsg)->next)) {
  448. if (EQ_STR((*pmsg)->type, type))
  449. return (*pmsg)->msg; // msg_up是只读的
  450. }
  451. return NULL;
  452. }
  453. af_Message *popMessageUp(af_Environment *env) {
  454. if (env->activity->msg_up_count == 0 || env->activity->msg_up == NULL)
  455. return NULL;
  456. af_Message *msg = env->activity->msg_up;
  457. env->activity->msg_up = msg->next;
  458. msg->next = NULL;
  459. env->activity->msg_up_count--;
  460. return msg;
  461. }
  462. /*
  463. * 函数名: getMessageData
  464. * 目标: 获取`msg`的数据, 对外API
  465. */
  466. void *getMessageData(af_Message *msg) {
  467. return msg->msg;
  468. }
  469. af_Message *popMessageDown(char *type, af_Environment *env) {
  470. for (af_Message **pmsg = &env->activity->msg_down; *pmsg != NULL; pmsg = &((*pmsg)->next)) {
  471. if (EQ_STR((*pmsg)->type, type)) {
  472. af_Message *msg = *pmsg;
  473. *pmsg = msg->next;
  474. msg->next = NULL;
  475. return msg;
  476. }
  477. }
  478. return NULL;
  479. }
  480. af_Message *getFirstMessage(af_Environment *env) {
  481. af_Message *msg = env->activity->msg_down;
  482. env->activity->msg_down = msg->next;
  483. msg->next = NULL;
  484. return msg;
  485. }
  486. void connectMessage(af_Message **base, af_Message *msg) {
  487. while (*base != NULL)
  488. base = &((*base)->next);
  489. *base = msg;
  490. }
  491. af_Message *makeNORMALMessage(af_Object *obj, af_Environment *env){
  492. af_Message *msg = makeMessage("NORMAL", sizeof(af_Object *));
  493. *(af_Object **)msg->msg = obj;
  494. gc_addReference(obj, env);
  495. return msg;
  496. }
  497. af_Message *makeERRORMessage(char *type, char *error, af_Environment *env) {
  498. char *info = NULL;
  499. af_ErrorInfo *ei = NULL;
  500. for (af_Activity *activity = env->activity; activity != NULL; activity = activity->prev) {
  501. info = getActivityInfoToBacktracking(activity);
  502. if (ei == NULL)
  503. ei = makeErrorInfo(type, error, info, env->activity->line, env->activity->file);
  504. else
  505. pushErrorBacktracking(activity->line, activity->file, info, ei);
  506. free(info);
  507. for (af_ActivityTrackBack *atb = activity->tb; atb != NULL; atb = atb->next) {
  508. info = getActivityTrackBackInfoToBacktracking(atb);
  509. pushErrorBacktracking(atb->line, atb->file, info, ei);
  510. free(info);
  511. }
  512. }
  513. af_Message *msg = makeMessage("ERROR", sizeof(af_ErrorInfo *));
  514. *(af_ErrorInfo **)msg->msg = ei;
  515. return msg;
  516. }
  517. af_Message *makeERRORMessageFormat(char *type, af_Environment *env, const char *format, ...) {
  518. char buf[1024];
  519. va_list ap;
  520. va_start(ap, format);
  521. vsnprintf(buf, 1024, format, ap);
  522. va_end(ap);
  523. return makeERRORMessage(type, buf, env);;
  524. }
  525. af_Message *makeIMPORTMessage(char *mark, af_Object *obj, af_Environment *env){
  526. af_Message *msg = makeMessage("IMPORT", sizeof(af_ImportInfo *));
  527. *(af_ImportInfo **)msg->msg = makeImportInfo(mark, obj, env);
  528. return msg;
  529. }
  530. static af_EnvVar *makeEnvVar(char *name) {
  531. af_EnvVar *var = calloc(1, sizeof(af_EnvVar));
  532. var->name = strCopy(name);
  533. return var;
  534. }
  535. static af_EnvVar *freeEnvVar(af_EnvVar *var) {
  536. af_EnvVar *next = var->next;
  537. free(var->data);
  538. free(var->name);
  539. free(var);
  540. return next;
  541. }
  542. static void freeAllEnvVar(af_EnvVar *var) {
  543. while (var != NULL)
  544. var = freeEnvVar(var);
  545. }
  546. static af_EnvVarSpace *makeEnvVarSpace(void) {
  547. af_EnvVarSpace *evs = calloc(1, sizeof(af_EnvVarSpace));
  548. pthread_rwlock_init(&evs->lock, NULL);
  549. return evs;
  550. }
  551. static void freeEnvVarSpace(af_EnvVarSpace *evs) {
  552. for (int i = 0; i < ENV_VAR_HASH_SIZE; i++)
  553. freeAllEnvVar(evs->var[i]);
  554. pthread_rwlock_destroy(&evs->lock);
  555. free(evs);
  556. }
  557. af_EnvVar *setEnvVarData_(char *name, char *data, af_Environment *env) {
  558. time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
  559. pthread_rwlock_wrlock(&env->esv->lock);
  560. af_EnvVar **pvar = &env->esv->var[index];
  561. env->esv->count++;
  562. for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
  563. if (EQ_STR((*pvar)->name, name)) {
  564. free((*pvar)->data);
  565. (*pvar)->data = strCopy(data);
  566. pthread_rwlock_unlock(&env->esv->lock);
  567. return *pvar;
  568. }
  569. }
  570. *pvar = makeEnvVar(name);
  571. (*pvar)->data = strCopy(data);
  572. pthread_rwlock_unlock(&env->esv->lock);
  573. return *pvar;
  574. }
  575. af_EnvVar *setEnvVarNumber_(char *name, int32_t data, af_Environment *env) {
  576. time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
  577. pthread_rwlock_wrlock(&env->esv->lock);
  578. af_EnvVar **pvar = &env->esv->var[index];
  579. env->esv->count++;
  580. for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
  581. if (EQ_STR((*pvar)->name, name)) {
  582. free((*pvar)->data);
  583. (*pvar)->num = data;
  584. pthread_rwlock_unlock(&env->esv->lock);
  585. return *pvar;
  586. }
  587. }
  588. *pvar = makeEnvVar(name);
  589. (*pvar)->num = data;
  590. pthread_rwlock_unlock(&env->esv->lock);
  591. return *pvar;
  592. }
  593. void setEnvVarData(char *name, char *data, af_Environment *env) {
  594. setEnvVarData_(name, data, env);
  595. }
  596. void setEnvVarNumber(char *name, int32_t data, af_Environment *env) {
  597. setEnvVarNumber_(name, data, env);
  598. }
  599. char *findEnvVarData(char *name, af_Environment *env) {
  600. time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
  601. pthread_rwlock_rdlock(&env->esv->lock);
  602. af_EnvVar **pvar = &env->esv->var[index];
  603. for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
  604. if (EQ_STR((*pvar)->name, name)) {
  605. char *data = (*pvar)->data;
  606. pthread_rwlock_unlock(&env->esv->lock);
  607. return data;
  608. }
  609. }
  610. pthread_rwlock_unlock(&env->esv->lock);
  611. return NULL;
  612. }
  613. int32_t *findEnvVarNumber(char *name, af_Environment *env) {
  614. time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
  615. pthread_rwlock_rdlock(&env->esv->lock);
  616. af_EnvVar **pvar = &env->esv->var[index];
  617. for (NULL; *pvar != NULL; pvar = &((*pvar)->next)) {
  618. if (EQ_STR((*pvar)->name, name)) {
  619. int32_t *data = &(*pvar)->num; // 返回指针, NULL表示没找到
  620. pthread_rwlock_unlock(&env->esv->lock);
  621. return data;
  622. }
  623. }
  624. pthread_rwlock_unlock(&env->esv->lock);
  625. return NULL;
  626. }
  627. static void mp_NORMAL(af_Message *msg, bool is_top, af_Environment *env) {
  628. if (msg->msg == NULL || *(af_Object **)msg->msg == NULL) {
  629. writeErrorLog(aFunCoreLogger, "NORMAL msg: %p error", msg->msg);
  630. return;
  631. }
  632. gc_delReference(*(af_Object **)msg->msg, env);
  633. if (is_top)
  634. writeDebugLog(aFunCoreLogger, "NORMAL Point: %p", *(af_Object **)msg->msg);
  635. }
  636. static void mp_NORMALThread(af_Message *msg, bool is_top, af_Environment *env) {
  637. if (msg->msg == NULL || *(af_Object **)msg->msg == NULL) {
  638. writeErrorLog(aFunCoreLogger, "Thread-NORMAL msg: %p error", msg->msg);
  639. return;
  640. }
  641. pthread_mutex_lock(&env->thread_lock);
  642. env->result = *(af_Object **)msg->msg;
  643. gc_delReference(env->result, env);
  644. pthread_mutex_unlock(&env->thread_lock);
  645. if (is_top)
  646. writeDebugLog(aFunCoreLogger, "Thread-NORMAL Point: %p", *(af_Object **)msg->msg);
  647. }
  648. static void mp_ERROR(af_Message *msg, bool is_top, af_Environment *env) {
  649. if (msg->msg == NULL || *(af_ErrorInfo **)msg->msg == NULL) {
  650. writeErrorLog(aFunCoreLogger, "ERROR msg: %p error", msg->msg);
  651. return;
  652. }
  653. if (is_top) {
  654. if (getErrorStd(env) == 0)
  655. fprintfErrorInfoStdout(*(af_ErrorInfo **) msg->msg);
  656. else
  657. fprintfErrorInfoStderr(*(af_ErrorInfo **) msg->msg);
  658. }
  659. freeErrorInfo(*(af_ErrorInfo **) msg->msg, env);
  660. }
  661. static void mp_IMPORT(af_Message *msg, bool is_top, af_Environment *env) {
  662. if (msg->msg == NULL || *(af_ImportInfo **)msg->msg == NULL) {
  663. writeErrorLog(aFunCoreLogger, "IMPORT msg: %p error", msg->msg);
  664. return;
  665. }
  666. af_ImportInfo *ii = *(af_ImportInfo **)msg->msg;
  667. if (ii->obj == NULL) {
  668. writeErrorLog(aFunCoreLogger, "IMPORT msg: %p do not get obj", msg->msg);
  669. return;
  670. }
  671. if (ii->mark != NULL) {
  672. makeVarToProtectVarSpace(ii->mark, 3, 3, 3, ii->obj, env);
  673. writeDebugLog(aFunCoreLogger, "IMPORT point: [%s] %p", ii->mark, ii->obj);
  674. } else
  675. writeDebugLog(aFunCoreLogger, "IMPORT point: <no-name> %p", ii->obj);
  676. freeImportInfo(ii, env);
  677. }
  678. static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char err[], af_Environment *env) {
  679. bool re = aFunGetSignal(signum);
  680. if (!re)
  681. return false;
  682. int32_t *p_cfg = findEnvVarNumber(sigcfg, env);
  683. int32_t cfg = 0;
  684. if (p_cfg != NULL)
  685. cfg = *p_cfg;
  686. if (cfg == 0) { // 诱发错误
  687. strncat(err, sigerr, 218);
  688. setEnvVarNumber(sig, 0, env);
  689. } else if (cfg == 1) { // 设置环境变量
  690. setEnvVarNumber(sig, 1, env);
  691. } else // 忽略
  692. setEnvVarNumber(sig, 0, env);
  693. writeDebugLog(aFunCoreLogger, "Get %s as cfg %d", sig, cfg);
  694. return true;
  695. }
  696. /*
  697. * 函数名: checkRunGC
  698. * 目标: 检查是否该运行gc, 若是则返回true并运行gc, 否则返回false
  699. */
  700. static af_GuardianList *guardian_GC(char *type, bool is_guard, void *data, af_Environment *env) {
  701. af_GuardianList *gl = NULL;
  702. enum GcRunTime grt = getGcRun(env);
  703. if (grt == grt_always || grt == grt_count && getGcCount(env) >= getGcMax(env)) {
  704. GcCountToZero(env); // 清零
  705. gl = gc_RunGC(env);
  706. if (gl != NULL)
  707. writeDebugLog(aFunCoreLogger, "GC destruct");
  708. }
  709. return gl;
  710. }
  711. static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, af_Environment *env) {
  712. char error_msg[218] = {NUL};
  713. checkSignal(SIGINT, ev_sigint, ev_sigint_cfg, SIGNAL_INT, error_msg, env);
  714. checkSignal(SIGTERM, ev_sigterm, ev_sigterm_cfg, SIGNAL_TERM, error_msg, env);
  715. #if (defined SIGUSR1 && defined SIGUSR2)
  716. checkSignal(SIGUSR1, ev_sigu1, ev_sigu1_cfg, SIGNAL_U1, error_msg, env);
  717. checkSignal(SIGUSR2, ev_sigu2, ev_sigu2_cfg, SIGNAL_U2, error_msg, env);
  718. #endif
  719. if (*error_msg != NUL) {
  720. // error_msg 有内容写入, 需要处理
  721. if (env->activity->msg_down != NULL) {
  722. af_Message *msg;
  723. if (EQ_STR("NORMAL", env->activity->msg_down->type)) {
  724. msg = getFirstMessage(env);
  725. gc_delReference(*(af_Object **)msg->msg, env);
  726. freeMessage(msg);
  727. } else if (EQ_STR("ERROR", env->activity->msg_down->type)) {
  728. msg = getFirstMessage(env);
  729. freeErrorInfo(*(af_ErrorInfo **) msg->msg, env);
  730. freeMessage(msg);
  731. }
  732. }
  733. pushMessageDown(makeERRORMessage(SIGNAL_EXCEPTION, error_msg, env), env);
  734. }
  735. return NULL;
  736. }
  737. af_Environment *makeEnvironment(enum GcRunTime grt) {
  738. af_Environment *env = calloc(1, sizeof(af_Environment));
  739. pthread_mutexattr_t attr;
  740. pthread_mutexattr_init(&attr);
  741. pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
  742. pthread_mutex_init(&env->in_run, &attr); // 检测锁
  743. pthread_mutexattr_destroy(&attr);
  744. pthread_mutex_init(&env->thread_lock, NULL);
  745. pthread_mutex_init(&env->status_lock, NULL);
  746. env->is_derive = false;
  747. env->base = env;
  748. env->gc_factory = makegGcFactory();
  749. env->esv = makeEnvVarSpace();
  750. /* 设置默认prefix */
  751. char prefix[PREFIX_SIZE + 1] = "";
  752. prefix[E_QUOTE] = '\'';
  753. prefix[B_EXEC] = '\'';
  754. prefix[B_EXEC_FIRST] = '$';
  755. env->prefix = setEnvVarData_(ev_sys_prefix, prefix, env);
  756. env->gc_runtime = setEnvVarNumber_(ev_grt, grt, env);
  757. env->gc_max = setEnvVarNumber_(ev_gcmax, DEFAULT_GC_COUNT_MAX, env);
  758. env->gc_count = setEnvVarNumber_(ev_gccount, 0, env);
  759. env->exit_code_ = setEnvVarNumber_(ev_exit_code, 0, env);
  760. env->argc = setEnvVarNumber_(ev_argc, 0, env);
  761. env->error_std = setEnvVarNumber_(ev_error_std, 0, env);
  762. /* 创建保护空间 */
  763. env->protect = makeVarSpace(NULL, 3, 3, 3, env);
  764. /* 生成global对象 */
  765. env->global = makeGlobalObject(env);
  766. addVarToProtectVarSpace(makeVar("global", 3, 3, 3, env->global, env), env);
  767. /* 设置NORMAL顶级处理器 */
  768. DLC_SYMBOL(TopMsgProcessFunc) func1 = MAKE_SYMBOL(mp_NORMAL, TopMsgProcessFunc);
  769. addTopMsgProcess("NORMAL", func1, env);
  770. FREE_SYMBOL(func1);
  771. DLC_SYMBOL(TopMsgProcessFunc) func2 = MAKE_SYMBOL(mp_ERROR, TopMsgProcessFunc);
  772. addTopMsgProcess("ERROR", func2, env);
  773. FREE_SYMBOL(func2);
  774. DLC_SYMBOL(TopMsgProcessFunc) func3 = MAKE_SYMBOL(mp_IMPORT, TopMsgProcessFunc);
  775. addTopMsgProcess("IMPORT", func3, env);
  776. FREE_SYMBOL(func3);
  777. /* 设置守护器 */
  778. DLC_SYMBOL(GuardianFunc) func4 = MAKE_SYMBOL(guardian_Signal, GuardianFunc);
  779. addGuardian("SIGNAL", false, false, 0, func4, NULL, NULL, env);
  780. FREE_SYMBOL(func4);
  781. DLC_SYMBOL(GuardianFunc) func5 = MAKE_SYMBOL(guardian_GC, GuardianFunc);
  782. addGuardian("GC", true, false, 0, func5, NULL, NULL, env);
  783. FREE_SYMBOL(func5);
  784. env->status = core_init;
  785. env->activity = makeTopActivity(NULL, NULL, env->protect, env->global);
  786. return env;
  787. }
  788. af_Environment *deriveEnvironment(bool derive_tmp, bool derive_guardian, bool derive_lr, bool enable,
  789. af_Environment *base) {
  790. af_Environment *env = calloc(1, sizeof(af_Environment));
  791. pthread_mutexattr_t attr;
  792. pthread_mutexattr_init(&attr);
  793. pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
  794. pthread_mutex_init(&env->in_run, &attr); // 检测锁
  795. pthread_mutexattr_destroy(&attr);
  796. pthread_mutex_init(&env->thread_lock, NULL);
  797. pthread_mutex_init(&env->status_lock, NULL);
  798. env->is_derive = true;
  799. env->base = base->base;
  800. pushEnvironmentList(env, base);
  801. #define D(v) env->v = (env->base)->v
  802. D(gc_factory);
  803. D(esv);
  804. D(prefix);
  805. D(gc_runtime);
  806. D(gc_max);
  807. D(gc_count);
  808. D(exit_code_);
  809. D(argc);
  810. D(error_std);
  811. D(protect);
  812. D(global);
  813. #undef D
  814. if (derive_tmp) {
  815. for (af_TopMsgProcess *tmp = base->process; tmp != NULL; tmp = tmp->next)
  816. addTopMsgProcess(tmp->type, tmp->func, env);
  817. }
  818. DLC_SYMBOL(TopMsgProcessFunc) func1 = MAKE_SYMBOL(mp_NORMALThread, TopMsgProcessFunc);
  819. af_TopMsgProcess *tmp = findTopMsgProcessFunc("NORMAL", env);
  820. if (tmp == NULL) {
  821. addTopMsgProcess("NORMAL", func1, env);
  822. FREE_SYMBOL(func1);
  823. } else {
  824. FREE_SYMBOL(tmp->func);
  825. tmp->func = func1;
  826. }
  827. if (derive_guardian) {
  828. for (af_Guardian *gu = base->guardian; gu != NULL; gu = gu->next) {
  829. if (gu->derive)
  830. addGuardian(gu->type, gu->always, true, gu->size, gu->func, gu->destruct, NULL, env);
  831. }
  832. }
  833. if (derive_lr) {
  834. for (af_LiteralRegex *lr = base->lr; lr != NULL; lr = lr->next)
  835. pushLiteralRegex(lr->pattern, lr->func, lr->in_protect, env);
  836. }
  837. if (enable)
  838. env->status = core_normal;
  839. else
  840. env->status = core_init;
  841. env->activity = makeTopActivity(NULL, NULL, env->protect, env->global);
  842. return env;
  843. }
  844. void enableEnvironment(af_Environment *env) {
  845. setVarSpaceProtect(NULL, env->protect, true);
  846. env->status = core_normal;
  847. }
  848. bool freeEnvironment(af_Environment *env) {
  849. bool res = true;
  850. if (!env->is_derive && getEnviromentSonCount(env) != 0)
  851. return false;
  852. if (!env->is_derive && env->status != core_creat)
  853. res = iterDestruct(10, env);
  854. freeAllActivity(env->activity, env);
  855. freeAllTopMsgProcess(env->process);
  856. freeAllGuardian(env->guardian, env);
  857. freeAllLiteralRegex(env->lr);
  858. if (!env->is_derive) {
  859. freeEnvVarSpace(env->esv);
  860. gc_freeAllValueData(env); // 先释放ObjectData的void *data
  861. printGCByCore(env);
  862. gc_freeAllValue(env); // 再完全释放Object
  863. freeGcFactory(env->gc_factory);
  864. } else
  865. freeEnvironmentListByEnv(env, env->base);
  866. pthread_mutex_destroy(&env->in_run);
  867. pthread_mutex_destroy(&env->thread_lock);
  868. if (!res)
  869. writeErrorLog(aFunCoreLogger, "Run iterDestruct error.");
  870. free(env);
  871. return true;
  872. }
  873. static af_TopMsgProcess *makeTopMsgProcess(char *type, DLC_SYMBOL(TopMsgProcessFunc) func) {
  874. af_TopMsgProcess *mp = calloc(1, sizeof(af_TopMsgProcess));
  875. mp->type = strCopy(type);
  876. mp->func = COPY_SYMBOL(func, TopMsgProcessFunc);
  877. return mp;
  878. }
  879. static af_TopMsgProcess *freeTopMsgProcess(af_TopMsgProcess *mp) {
  880. af_TopMsgProcess *next = mp->next;
  881. free(mp->type);
  882. FREE_SYMBOL(mp->func);
  883. free(mp);
  884. return next;
  885. }
  886. static void freeAllTopMsgProcess(af_TopMsgProcess *mp) {
  887. while (mp != NULL)
  888. mp = freeTopMsgProcess(mp);
  889. }
  890. static af_TopMsgProcess *findTopMsgProcessFunc(char *type, af_Environment *env) {
  891. af_TopMsgProcess *mp = env->process;
  892. for (NULL; mp != NULL; mp = mp->next) {
  893. if (EQ_STR(type, mp->type))
  894. return mp;
  895. }
  896. return NULL;
  897. }
  898. bool addTopMsgProcess(char *type, DLC_SYMBOL(TopMsgProcessFunc) func, af_Environment *env) {
  899. af_TopMsgProcess *mp = findTopMsgProcessFunc(type, env);
  900. if (mp != NULL)
  901. return false;
  902. mp = makeTopMsgProcess(type, func);
  903. mp->next = env->process;
  904. env->process = mp;
  905. return true;
  906. }
  907. static af_Guardian *makeGuardian(char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
  908. DLC_SYMBOL(GuardianDestruct) destruct){
  909. af_Guardian *gd = calloc(1, sizeof(af_Guardian));
  910. gd->type = strCopy(type);
  911. gd->always = always;
  912. gd->derive = derive;
  913. if (size != 0) {
  914. gd->data = calloc(1, size);
  915. gd->size = size;
  916. }
  917. gd->func = COPY_SYMBOL(func, GuardianFunc);
  918. if (destruct != NULL)
  919. gd->destruct = COPY_SYMBOL(destruct, GuardianDestruct);
  920. return gd;
  921. }
  922. static af_Guardian *freeGuardian(af_Guardian *gd, af_Environment *env) {
  923. af_Guardian *next = gd->next;
  924. if (gd->data != NULL && gd->destruct != NULL)
  925. GET_SYMBOL(gd->destruct)(gd->type, gd->data, env);
  926. free(gd->data);
  927. free(gd->type);
  928. FREE_SYMBOL(gd->func);
  929. FREE_SYMBOL(gd->destruct);
  930. free(gd);
  931. return next;
  932. }
  933. static void freeAllGuardian(af_Guardian *gd, af_Environment *env) {
  934. while (gd != NULL)
  935. gd = freeGuardian(gd, env);
  936. }
  937. static af_Guardian *findGuardian(char *type, af_Environment *env) {
  938. af_Guardian *gd = env->guardian;
  939. for (NULL; gd != NULL; gd = gd->next) {
  940. if (EQ_STR(type, gd->type))
  941. return gd;
  942. }
  943. return NULL;
  944. }
  945. bool addGuardian(char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
  946. DLC_SYMBOL(GuardianDestruct) destruct, void **pdata, af_Environment *env){
  947. af_Guardian *gd = findGuardian(type, env);
  948. if (gd != NULL)
  949. return false;
  950. gd = makeGuardian(type, always, derive, size, func, destruct);
  951. gd->next = env->guardian;
  952. env->guardian = gd;
  953. if (pdata != NULL)
  954. *pdata = gd->data;
  955. return true;
  956. }
  957. bool popGuardian(char *type, af_Environment *env) {
  958. af_Guardian **gd = &env->guardian;
  959. for (NULL; *gd != NULL; gd = &((*gd)->next)) {
  960. if (EQ_STR(type, (*gd)->type)) {
  961. *gd = freeGuardian(*gd, env);
  962. return true;
  963. }
  964. }
  965. return false;
  966. }
  967. static void newFuncActivity(af_Code *bt, const af_Code *next, bool return_first, af_Environment *env){
  968. if (next == NULL && env->activity->body_next == NULL &&
  969. env->activity->type == act_func && env->activity->macro_varlist == NULL) {
  970. writeTrackLog(aFunCoreLogger, "Tail call optimization");
  971. tailCallActivity(getActivityFunc(env), env->activity);
  972. setActivityBtTop(bt, env->activity);
  973. env->activity->optimization = true;
  974. if (!env->activity->return_first) // 若原本就有设置 return_first 则没有在设置的必要了, 因为该执行不会被返回
  975. env->activity->return_first = return_first;
  976. } else {
  977. af_Activity *activity = makeFuncActivity(bt, NULL, return_first, env->activity->msg_up,
  978. env->activity->run_varlist, env->activity->belong,
  979. getActivityFunc(env));
  980. pushActivity(activity, env);
  981. }
  982. }
  983. /*
  984. * 函数名: isInfixFunc
  985. * 目标: 检查是否中缀调用函数
  986. */
  987. static bool isInfixFunc(af_Code *code, af_Environment *env) {
  988. if (code == NULL || code->type != code_element || code->prefix == getPrefix(E_QUOTE, env)) // 检查是否element, 且无引用前缀
  989. return false;
  990. if (checkLiteralCode(code->element.data, NULL, NULL, env)) // 检查是否字面量
  991. return false;
  992. printf("isInfixFunc: %s\n", code->element.data);
  993. af_Var *var = findVarFromVarList(code->element.data, env->activity->belong, env->activity->run_varlist);
  994. if (var == NULL)
  995. return false;
  996. af_Object *obj = findVarNode(var, NULL);
  997. obj_isInfixFunc *func = findAPI("obj_isInfixFunc", getObjectAPI(obj));
  998. if (func == NULL)
  999. return false;
  1000. return func(getObjectID(obj), obj);
  1001. }
  1002. bool pushExecutionActivity(af_Code *bt, bool return_first, af_Environment *env) {
  1003. af_Code *next;
  1004. next = getCodeNext(bt);
  1005. writeTrackLog(aFunCoreLogger, "Run execution");
  1006. if (bt->type != code_block || bt->block.is_empty) {
  1007. pushMessageDown(makeERRORMessage(SYNTAX_ERROR, NOT_CODE_INFO, env), env);
  1008. return false;
  1009. }
  1010. setActivityBtNext(next, env->activity);
  1011. newFuncActivity(bt, next, return_first, env);
  1012. setActivityBtStart(bt->next, env->activity);
  1013. env->activity->status = act_func_normal;
  1014. env->activity->is_execution = true;
  1015. return true;
  1016. }
  1017. bool pushFuncActivity(af_Code *bt, af_Environment *env) {
  1018. af_Code *next;
  1019. af_Code *func;
  1020. af_Object *parentheses_call = env->activity->parentheses_call;
  1021. pthread_rwlock_wrlock(&env->activity->gc_lock);
  1022. env->activity->parentheses_call = NULL;
  1023. pthread_rwlock_unlock(&env->activity->gc_lock);
  1024. writeTrackLog(aFunCoreLogger, "Run func");
  1025. next = getCodeNext(bt);
  1026. switch (bt->block.type) {
  1027. case curly:
  1028. if (bt->block.is_empty) {
  1029. pushMessageDown(makeERRORMessage(CALL_ERROR, CURLY_FUNC_BODY_INFO, env), env);
  1030. return false;
  1031. }
  1032. func = bt->next;
  1033. break;
  1034. case brackets:
  1035. func = NULL;
  1036. for (af_Code *code = bt->next; code != NULL; code = getCodeNext(code)) {
  1037. if (isInfixFunc(code, env)) {
  1038. func = code;
  1039. break;
  1040. }
  1041. }
  1042. if (func == NULL) {
  1043. pushMessageDown(makeERRORMessage(CALL_ERROR, BRACKETS_FUNC_BODY_INFO, env), env);
  1044. return false;
  1045. }
  1046. break;
  1047. case parentheses:
  1048. func = NULL; // 小括号则不在需要匹配
  1049. break;
  1050. default:
  1051. break;
  1052. }
  1053. setActivityBtNext(next, env->activity); // 设置当前Activity的bt_next
  1054. newFuncActivity(bt, next, false, env); // 添加新的Activity或尾调用优化
  1055. setActivityBtStart(func, env->activity);
  1056. env->activity->call_type = env->activity->bt_top->block.type; // newActivity时会设置bt_top
  1057. env->activity->status = act_func_get;
  1058. if (env->activity->call_type == parentheses) { // 对于类前缀调用, 已经获得func的实际值了
  1059. if (parentheses_call == NULL) {
  1060. pushMessageDown(makeERRORMessage(CALL_ERROR, PARENTHESES_FUNC_BODY_INFO, env), env);
  1061. return false;
  1062. }
  1063. return setFuncActivityToArg(parentheses_call, env);
  1064. }
  1065. return true;
  1066. }
  1067. bool pushLiteralActivity(af_Code *bt, char *data, af_Object *func, af_Environment *env) {
  1068. setActivityBtNext(bt->next, env->activity);
  1069. writeTrackLog(aFunCoreLogger, "Run literal");
  1070. newFuncActivity(bt, bt->next, false, env);
  1071. env->activity->is_literal = true;
  1072. pushLiteralData(strCopy(data), env); // FuncBody的释放导致code和literal_data释放, 所以要复制
  1073. return setFuncActivityToArg(func, env);
  1074. }
  1075. bool pushVariableActivity(af_Code *bt, af_Object *func, af_Environment *env) {
  1076. setActivityBtNext(bt->next, env->activity);
  1077. writeTrackLog(aFunCoreLogger, "Run variable");
  1078. newFuncActivity(bt, bt->next, false, env);
  1079. env->activity->is_obj_func = true;
  1080. return setFuncActivityToArg(func, env);
  1081. }
  1082. bool pushMacroFuncActivity(af_Object *func, af_Environment *env) {
  1083. /* Macro是隐式调用, bt不移动 */
  1084. /* 沿用activity */
  1085. af_VarSpaceListNode *macro_varlist = env->activity->macro_varlist;
  1086. ActivityCount count = env->activity->count_macro_varlist;
  1087. env->activity->count_macro_varlist = 0;
  1088. pthread_rwlock_wrlock(&env->activity->gc_lock);
  1089. af_VarSpaceListNode *tmp = env->activity->run_varlist;
  1090. env->activity->run_varlist = NULL;
  1091. pthread_rwlock_unlock(&env->activity->gc_lock);
  1092. writeTrackLog(aFunCoreLogger, "Run macro");
  1093. if (!freeVarSpaceListCount(env->activity->count_run_varlist, tmp)) { // 释放外部变量空间
  1094. env->activity->count_run_varlist = 0;
  1095. pushMessageDown(makeERRORMessage(RUN_ERROR, FREE_VARSPACE_INFO, env), env);
  1096. return false;
  1097. }
  1098. env->activity->count_run_varlist = 0;
  1099. tailCallActivity(func, env->activity); /* 隐式调用不设置 bt_top */
  1100. /* tailCallActivity 会清除 out_varlist 的设定 */
  1101. pthread_rwlock_wrlock(&env->activity->gc_lock);
  1102. env->activity->out_varlist = macro_varlist;
  1103. env->activity->count_out_varlist = count;
  1104. env->activity->is_macro_call = true;
  1105. pthread_rwlock_unlock(&env->activity->gc_lock);
  1106. return setFuncActivityToArg(func, env);
  1107. }
  1108. void pushGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env) {
  1109. for (af_Activity *tmp = env->activity; tmp != NULL; tmp = tmp->prev) {
  1110. if (tmp->type == act_guardian) {
  1111. *(tmp->pgl) = gl;
  1112. tmp->pgl = pgl;
  1113. if (tmp->gl_next == NULL) // 原dl_next已经运行到末端
  1114. tmp->gl_next = gl;
  1115. return;
  1116. }
  1117. }
  1118. /* gc Activity 可能创建为顶层 activity, 故信息不能继承上一级(可能没有上一级) */
  1119. af_Activity *activity = makeGuardianActivity(gl, pgl, env);
  1120. pushActivity(activity, env);
  1121. }
  1122. bool pushImportActivity(af_Code *bt, af_Object **obj, char *mark, af_Environment *env) {
  1123. af_Object *tmp = NULL;
  1124. if (obj == NULL)
  1125. obj = &tmp;
  1126. if (*obj == NULL)
  1127. *obj = makeGlobalObject(env);
  1128. if (*obj == NULL)
  1129. return false;
  1130. af_Activity *activity = makeTopImportActivity(bt, bt, env->protect, *obj, mark);
  1131. pushActivity(activity, env);
  1132. return true;
  1133. }
  1134. bool pushGuadianFuncActivity(af_GuardianList *gl, af_Environment *env) {
  1135. env->activity->gl_next = gl->next;
  1136. af_Object *belong = gl->obj != NULL ? gl->obj : env->global;
  1137. /* 隐式调用不设置 bt_top */
  1138. af_Activity *activity = makeFuncActivity(NULL, NULL, false, env->activity->msg_up,
  1139. env->activity->run_varlist, belong, NULL);
  1140. activity->is_guard_call = true;
  1141. pushActivity(activity, env);
  1142. return setFuncActivityToArg(gl->func, env);
  1143. }
  1144. void setArgCodeListToActivity(af_ArgCodeList *acl, af_Environment *env) {
  1145. if (acl != NULL) {
  1146. setActivityBtStart(acl->code, env->activity);
  1147. env->activity->run_in_func = acl->run_in_func;
  1148. } else {
  1149. setActivityBtStart(NULL, env->activity);
  1150. env->activity->run_in_func = false;
  1151. }
  1152. }
  1153. bool setFuncActivityToArg(af_Object *func, af_Environment *env) {
  1154. af_ObjectAPI *api = getObjectAPI(func);
  1155. obj_funcGetArgCodeList *get_acl = findAPI("obj_funcGetArgCodeList", api);
  1156. obj_funcGetVarList *get_var_list = findAPI("obj_funcGetVarList", api);
  1157. af_VarSpaceListNode *func_varlist = NULL;
  1158. af_Object *belong = getBelongObject(func);
  1159. if (get_var_list == NULL) {
  1160. pushMessageDown(makeERRORMessage(TYPE_ERROR, API_NOT_FOUND_INFO(obj_funcGetVarList), env), env);
  1161. return false;
  1162. }
  1163. pthread_rwlock_wrlock(&env->activity->gc_lock);
  1164. env->activity->func = func;
  1165. env->activity->belong = belong;
  1166. env->activity->status = act_func_arg;
  1167. pthread_rwlock_unlock(&env->activity->gc_lock);
  1168. /* 遇到错误时 get_acl 和 get_var_list 要自行设定msg */
  1169. if (get_acl != NULL) {
  1170. if (!get_acl(getObjectID(func), func, &env->activity->acl_start, env->activity->bt_top, &env->activity->mark, env)) // 设置acl
  1171. return false;
  1172. } else
  1173. env->activity->acl_start = NULL;
  1174. if (!get_var_list(getObjectID(func), func, &env->activity->func_varlist, env->activity->mark, env)) // 设置 func_var_list
  1175. return false;
  1176. env->activity->acl_done = env->activity->acl_start;
  1177. setArgCodeListToActivity(env->activity->acl_start, env);
  1178. return true;
  1179. }
  1180. bool setFuncActivityAddVar(af_Environment *env){
  1181. af_ObjectAPI *api = getObjectAPI(env->activity->func);
  1182. obj_funcGetInfo *get_info = findAPI("obj_funcGetInfo", api);
  1183. obj_funcGetArgList *get_arg_list = findAPI("obj_funcGetArgList", api);
  1184. af_FuncInfo *fi = NULL;
  1185. if (get_info == NULL) {
  1186. pushMessageDown(makeERRORMessage(TYPE_ERROR, API_NOT_FOUND_INFO(obj_funcGetInfo), env), env);
  1187. return false;
  1188. }
  1189. /* env->activity->fi可能还存储着旧的FuncInfo(尾调用优化), 因此不能直接保存到 env->activity->fi 中 */
  1190. if (!get_info(getObjectID(env->activity->func), env->activity->func, &fi, env->activity->bt_top, env->activity->mark, env))
  1191. return false;
  1192. if (fi == NULL) {
  1193. pushMessageDown(makeERRORMessage(API_RUN_ERROR, API_DONOT_GIVE(FuncInfo), env), env);
  1194. return false;
  1195. }
  1196. if (fi->scope == super_pure_scope && env->activity->fi->scope == super_embedded) {
  1197. /* 超纯函数和超内嵌函数不得搭配使用 */
  1198. pushMessageDown(makeERRORMessage(RUN_ERROR, PURE_EMBEDDED_INFO, env), env);
  1199. return false;
  1200. }
  1201. af_VarSpaceListNode *tmp = NULL; // 临时变量, 存放内容见代码注释
  1202. pthread_rwlock_wrlock(&env->activity->gc_lock);
  1203. if (fi->is_macro) { // 是宏函数则保存变量空间
  1204. env->activity->macro_varlist = env->activity->out_varlist;
  1205. env->activity->count_macro_varlist = env->activity->count_out_varlist;
  1206. env->activity->count_out_varlist = 0;
  1207. }
  1208. if (fi->scope != inline_scope) {
  1209. env->activity->count_run_varlist = env->activity->count_out_varlist;
  1210. env->activity->count_out_varlist = 0;
  1211. env->activity->run_varlist = env->activity->out_varlist;
  1212. } else if (fi->scope == normal_scope) { // 使用函数变量空间
  1213. env->activity->count_run_varlist = 0;
  1214. env->activity->run_varlist = env->activity->func_varlist;
  1215. } else if (fi->scope == pure_scope) { // 纯函数只有 protect 变量空间
  1216. env->activity->count_run_varlist = 1;
  1217. pthread_rwlock_unlock(&env->activity->gc_lock);
  1218. tmp = makeVarSpaceList(env->protect); // 该过程不加gc锁, 避免死锁
  1219. pthread_rwlock_wrlock(&env->activity->gc_lock);
  1220. env->activity->run_varlist = tmp;
  1221. } else if (fi->scope == super_pure_scope) { // 超纯函数没有变量空间, 因此不得为超内嵌函数(否则var_list就为NULL了)
  1222. env->activity->count_run_varlist = 0;
  1223. env->activity->run_varlist = NULL;
  1224. }
  1225. env->activity->func_varlist = NULL;
  1226. tmp = env->activity->out_varlist;
  1227. env->activity->out_varlist = NULL;
  1228. pthread_rwlock_unlock(&env->activity->gc_lock);
  1229. freeVarSpaceListCount(env->activity->count_out_varlist, tmp); // freeVarSpaceListCount 前释放, 避免死锁
  1230. env->activity->count_out_varlist = 0;
  1231. if (fi->embedded != super_embedded) { // 不是超内嵌函数则引入一层新的变量空间
  1232. /* 新层的变量空间应该属于belong而不是func */
  1233. tmp = pushNewVarList(env->activity->belong, env->activity->run_varlist, env);
  1234. pthread_rwlock_wrlock(&env->activity->gc_lock);
  1235. env->activity->run_varlist = tmp;
  1236. env->activity->count_run_varlist++;
  1237. pthread_rwlock_unlock(&env->activity->gc_lock);
  1238. }
  1239. if (fi->var_this && env->activity->belong != NULL) {
  1240. if (!makeVarToVarSpaceList("this", 3, 3, 3, env->activity->belong,
  1241. env->activity->run_varlist, env->activity->belong, env)) {
  1242. pushMessageDown(makeERRORMessage(RUN_ERROR, IMPLICIT_SET_INFO(this), env), env);
  1243. return false;
  1244. }
  1245. }
  1246. if (fi->var_func && env->activity->func != NULL) {
  1247. if (!makeVarToVarSpaceList("func", 3, 3, 3, env->activity->func,
  1248. env->activity->run_varlist, env->activity->belong, env)) {
  1249. pushMessageDown(makeERRORMessage(RUN_ERROR, IMPLICIT_SET_INFO(func), env), env);
  1250. return false;
  1251. }
  1252. }
  1253. /* 计算参数 */
  1254. if (get_arg_list != NULL) {
  1255. af_ArgList *al;
  1256. if (!get_arg_list(getObjectID(env->activity->func), env->activity->func, &al, env->activity->acl_start,
  1257. env->activity->mark, env))
  1258. return false;
  1259. runArgList(al, env->activity->run_varlist, env);
  1260. freeAllArgList(al, env);
  1261. }
  1262. if (fi->embedded == protect_embedded)
  1263. setVarSpaceProtect(env->activity->belong, env->activity->run_varlist->vs, true);
  1264. /* ArgCodeList 在此处被清理 */
  1265. freeAllArgCodeList(env->activity->acl_start, env);
  1266. env->activity->acl_start = NULL;
  1267. env->activity->acl_done = NULL;
  1268. /* 此处检查fi是否为NULL, 不为(通常为尾调用优化)则释放fi */
  1269. /* 旧的FuncBody延迟到此处才释放(freeFuncInfo释放FuncBody), 是因为获取函数参数的相关运算中可能会使用旧FuncBody中的代码 */
  1270. /* 因为调用函数的代码是在旧FuncBody中的, 因此参数计算的相关代码也可能在旧FuncBody中 */
  1271. /* 也就是说ArgCodeList, bt_top, bt_start中的代码可能是来自旧FuncBody的 */
  1272. /* 所以他们要延迟到现在才被释放 */
  1273. /* 而get_arg_list是最后一次使用旧FuncBody中的代码(bt_top), 因此此处可以释放 */
  1274. if (env->activity->fi != NULL)
  1275. freeFuncInfo(env->activity->fi); // 延迟到这里再释放, 主要是FuncBody中的bt可能会被使用
  1276. env->activity->fi = fi;
  1277. env->activity->body_next = fi->body;
  1278. /* bt_top等的相关设定会在 setFuncActivityToNormal 中被进行 */
  1279. if (setFuncActivityToNormal(env) == 0)
  1280. return false; // 运行结束, 且已写入msg
  1281. return true;
  1282. }
  1283. static void initCallFuncInfo(af_CallFuncInfo *cfi, af_Environment *env) {
  1284. cfi->mark = env->activity->mark;
  1285. cfi->body_next = env->activity->body_next;
  1286. cfi->belong = env->activity->belong;
  1287. cfi->func = env->activity->func;
  1288. cfi->var_list = env->activity->run_varlist;
  1289. cfi->call_type = env->activity->call_type;
  1290. cfi->is_gc_call = env->activity->is_gc_call;
  1291. cfi->is_literal = env->activity->is_literal;
  1292. cfi->is_obj_func = env->activity->is_obj_func;
  1293. cfi->is_macro_call = env->activity->is_macro_call;
  1294. }
  1295. /*
  1296. * 函数名: setFuncActivityToNormal
  1297. * 目标: 获取下一步需要运行的结果
  1298. * 返回 (0) 表示无下一步
  1299. * 返回 (-1) 表示运行C函数, 并且设置了 process_msg_first
  1300. * 返回 (1) 表示下一步运行Code
  1301. * 返回 (2) 表示遇到未被替换的动态代码块
  1302. */
  1303. int setFuncActivityToNormal(af_Environment *env){ // 获取函数的函数体
  1304. int re;
  1305. af_FuncBody *body = env->activity->body_next;
  1306. env->activity->status = act_func_normal;
  1307. setActivityBtTop(NULL, env->activity); // NORMAL期, bt_top将不被设定
  1308. setActivityBtNext(NULL, env->activity);
  1309. if (body == NULL) // 已经没有下一步了 (原msg不释放)
  1310. return 0;
  1311. af_Activity *activity = env->activity; // 防止在函数调用期间env->activity被修改
  1312. env->activity->body_next = body->next;
  1313. switch (body->type) {
  1314. case func_body_c: {
  1315. af_CallFuncInfo cfi;
  1316. initCallFuncInfo(&cfi, env);
  1317. af_FuncBody *new = GET_SYMBOL(body->c_func)(&cfi, env);
  1318. activity->process_msg_first++; // 处理C函数通过msg_down返回的结果
  1319. if (cfi.body_next != env->activity->body_next) {
  1320. env->activity->body_next = cfi.body_next;
  1321. freeAllFuncBody(new); // 不再允许设定 FuncBody
  1322. } else {
  1323. pushDynamicFuncBody(new, body);
  1324. activity->body_next = body->next; // 添加新元素后要重新设定body_next的位置
  1325. }
  1326. re = -1;
  1327. break;
  1328. }
  1329. case func_body_import:
  1330. if (!pushImportActivity(body->code, NULL, NULL, env)) {
  1331. pushMessageDown(makeERRORMessage(IMPORT_ERROR, IMPORT_OBJ_ERROR, env), env);
  1332. activity->process_msg_first++;
  1333. re = 2;
  1334. break;
  1335. }
  1336. re = 1;
  1337. break;
  1338. case func_body_code:
  1339. setActivityBtStart(body->code, env->activity);
  1340. re = 1;
  1341. break;
  1342. default:
  1343. case func_body_dynamic:
  1344. pushMessageDown(makeERRORMessage(RUN_ERROR, FUNCBODY_ERROR_INFO, env), env);
  1345. activity->process_msg_first++;
  1346. re = 2;
  1347. break;
  1348. }
  1349. /* 在最后一个aFunBody完毕后, mark被释放(因为此后不会再有函数需要使用Mark) */
  1350. if (activity->body_next == NULL) // 最后一个aFunBody
  1351. freeMark(activity);
  1352. return re;
  1353. }
  1354. /*
  1355. * 函数名: runTopMessageProcess
  1356. * 目标: 运行顶层信息处理器
  1357. */
  1358. void runTopMessageProcess(bool is_top, af_Environment *env) {
  1359. af_Message **pmsg = &env->activity->msg_down;
  1360. while (*pmsg != NULL) {
  1361. af_TopMsgProcess *mp = findTopMsgProcessFunc((*pmsg)->type, env);
  1362. if (mp != NULL) {
  1363. GET_SYMBOL(mp->func)(*pmsg, is_top, env);
  1364. *pmsg = freeMessage(*pmsg);
  1365. } else
  1366. pmsg = &((*pmsg)->next);
  1367. }
  1368. }
  1369. static void freeMark(af_Activity *activity) {
  1370. if (activity->type == act_func && activity->func != NULL && activity->mark != NULL) {
  1371. obj_funcFreeMask *func = findAPI("obj_funcFreeMask", getObjectAPI(activity->func));
  1372. if (func != NULL)
  1373. func(getObjectID(activity->func), activity->func, activity->mark);
  1374. activity->mark = NULL;
  1375. }
  1376. }
  1377. /*
  1378. * 函数名: popActivity
  1379. * 目标: 释放Activity
  1380. * 只有is_normal为false时才会检查释放mark
  1381. */
  1382. void popActivity(bool is_normal, af_Message *msg, af_Environment *env) {
  1383. if (env->activity->type == act_func || env->activity->type == act_top || env->activity->type == act_top_import) {
  1384. if (msg != NULL && env->activity->return_first) { // msg有内容, 并且设定了返回首位, 则清除msg内容, 并压入首位(压入的代码在下面)
  1385. if (EQ_STR(msg->type, "NORMAL")) {
  1386. gc_delReference(*(af_Object **) msg->msg, env);
  1387. freeMessage(msg);
  1388. msg = NULL;
  1389. }
  1390. } else if (env->activity->return_first) { // msg无内容, 并且设定了返回首位, 则检查msg_down是否有normal, 有则清除
  1391. if (env->activity->msg_down != NULL && EQ_STR(env->activity->msg_down->type, "NORMAL")) {
  1392. af_Message *tmp = getFirstMessage(env);
  1393. gc_delReference(*(af_Object **) (tmp->msg), env);
  1394. freeMessage(tmp);
  1395. }
  1396. }
  1397. if (msg == NULL && env->activity->return_first) { // 如果首位
  1398. if (env->activity->return_obj == NULL)
  1399. msg = makeERRORMessage(RUN_ERROR, RETURN_OBJ_NOT_FOUND_INFO, env);
  1400. else
  1401. msg = makeNORMALMessage(env->activity->return_obj, env);
  1402. }
  1403. }
  1404. if (msg != NULL)
  1405. pushMessageDown(msg, env);
  1406. if (env->activity->type == act_top_import && /* import模式, 并且msg_down中有normal, 则把normal替换为belong */
  1407. env->activity->msg_down != NULL && EQ_STR(env->activity->msg_down->type, "NORMAL")) {
  1408. af_Message *tmp = getFirstMessage(env);
  1409. pushMessageDown(makeIMPORTMessage(env->activity->import_mark, env->activity->belong, env), env); // 压入belong作为msg
  1410. pushMessageDown(tmp, env);
  1411. }
  1412. /* 正常情况下在执行完最后一个FuncBody后释放mark, 非正常情况(即最后一个FuncBody可能还没执行)则需要在此释放mark */
  1413. if (!is_normal)
  1414. freeMark(env->activity); // 遇到非正常退出时, 释放`mark`
  1415. if (env->activity->type == act_top || env->activity->type == act_guardian) {// 顶层或gc/guardian层
  1416. runTopMessageProcess((env->activity->type == act_top), env);
  1417. } else {
  1418. connectMessage(&(env->activity->msg_down), env->activity->prev->msg_down);
  1419. env->activity->prev->msg_down = env->activity->msg_down;
  1420. env->activity->msg_down = NULL;
  1421. /* popActivity必然设定process_msg_first */
  1422. env->activity->prev->process_msg_first++;
  1423. }
  1424. if (env->activity->type != act_top)
  1425. env->activity = freeActivity(env->activity, env);
  1426. else
  1427. freeActivityTop(env->activity); // activity不被释放
  1428. }
  1429. static af_LiteralRegex *makeLiteralRegex(char *pattern, char *func, bool in_protect) {
  1430. af_Regex *rg = makeRegex(pattern, NULL);
  1431. if (rg == NULL)
  1432. return NULL;
  1433. af_LiteralRegex *lr = calloc(1, sizeof(af_LiteralRegex));
  1434. lr->rg = rg;
  1435. lr->pattern = strCopy(pattern);
  1436. lr->func = strCopy(func);
  1437. lr->in_protect = in_protect;
  1438. return lr;
  1439. }
  1440. static af_LiteralRegex *freeLiteralRegex(af_LiteralRegex *lr) {
  1441. af_LiteralRegex *next = lr->next;
  1442. freeRegex(lr->rg);
  1443. free(lr->func);
  1444. free(lr->pattern);
  1445. free(lr);
  1446. return next;
  1447. }
  1448. static void freeAllLiteralRegex(af_LiteralRegex *lr) {
  1449. while (lr != NULL)
  1450. lr = freeLiteralRegex(lr);
  1451. }
  1452. bool pushLiteralRegex(char *pattern, char *func, bool in_protect, af_Environment *env) {
  1453. af_LiteralRegex *lr = makeLiteralRegex(pattern, func, in_protect);
  1454. if (lr == NULL)
  1455. return false;
  1456. lr->next = env->lr;
  1457. env->lr = lr;
  1458. return true;
  1459. }
  1460. /*
  1461. * 函数名: checkLiteralCode
  1462. * 目标: 检查对象是否为字面量
  1463. * 注意: func被写入函数名, 但不是复制式写入
  1464. */
  1465. bool checkLiteralCode(char *literal, char **func, bool *in_protect, af_Environment *env) {
  1466. for (af_LiteralRegex *lr = env->lr; lr != NULL; lr = lr->next) {
  1467. if (matchRegex(literal, lr->rg, NULL) == 1) {
  1468. if (func != NULL)
  1469. *func = lr->func; // 不使用复制
  1470. if (in_protect != NULL)
  1471. *in_protect = lr->in_protect;
  1472. return true;
  1473. }
  1474. }
  1475. return false;
  1476. }
  1477. static af_EnvironmentList *makeEnvironmentList(af_Environment *env) {
  1478. static size_t id = 0;
  1479. static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  1480. af_EnvironmentList *envl = calloc(1, sizeof(af_EnvironmentList));
  1481. envl->env = env;
  1482. pthread_mutex_lock(&mutex);
  1483. envl->id = id;
  1484. id++;
  1485. pthread_mutex_unlock(&mutex);
  1486. return envl;
  1487. }
  1488. static bool freeEnvironmentList(af_EnvironmentList *envl, af_Environment *base) {
  1489. pthread_mutex_lock(&base->thread_lock);
  1490. if (envl->prev == NULL) {
  1491. base->env_list = envl->next;
  1492. } else
  1493. envl->prev->next = envl->next;
  1494. if (envl->next != NULL)
  1495. envl->next->prev = envl->prev;
  1496. free(envl);
  1497. pthread_mutex_unlock(&base->thread_lock);
  1498. pthread_cond_signal(&base->thread_cond); // 通知主线程
  1499. return true;
  1500. }
  1501. bool freeEnvironmentListByEnv(af_Environment *env, af_Environment *base) {
  1502. pthread_mutex_lock(&base->thread_lock);
  1503. for (af_EnvironmentList *envl = base->env_list; envl != NULL; envl = envl->next) {
  1504. if (envl->env == env) {
  1505. pthread_mutex_unlock(&base->thread_lock);
  1506. return freeEnvironmentList(envl, base);
  1507. }
  1508. }
  1509. pthread_mutex_unlock(&base->thread_lock);
  1510. return false;
  1511. }
  1512. void pushEnvironmentList(af_Environment *env, af_Environment *base) {
  1513. af_EnvironmentList *envl = makeEnvironmentList(env);
  1514. pthread_mutex_lock(&base->thread_lock);
  1515. envl->next = base->env_list;
  1516. base->env_list = envl;
  1517. pthread_mutex_unlock(&base->thread_lock);
  1518. }
  1519. af_ErrorInfo *makeErrorInfo(char *type, char *error, char *note, FileLine line, FilePath path) {
  1520. af_ErrorInfo *ei = calloc(1, sizeof(af_ErrorInfo));
  1521. ei->error_type = strCopy(type);
  1522. ei->error = strCopy(error);
  1523. pushErrorBacktracking(line, path, note, ei);
  1524. return ei;
  1525. }
  1526. void freeErrorInfo(af_ErrorInfo *ei, af_Environment *env){
  1527. free(ei->error_type);
  1528. free(ei->error);
  1529. if (ei->obj != NULL)
  1530. gc_delReference(ei->obj, env);
  1531. freeAllErrorBacktracking(ei->track);
  1532. free(ei);
  1533. }
  1534. static void fprintfNote(FILE *file, char *note) {
  1535. char *ent = NULL;
  1536. while(true) {
  1537. ent = strchr(note, '\n');
  1538. if (ent != NULL)
  1539. *ent = NUL;
  1540. fprintf(file, " #note %s\n", note);
  1541. if (ent == NULL) // 意味着是最后一部分`note`
  1542. break;
  1543. *ent = '\n';
  1544. note = ent + 1;
  1545. }
  1546. }
  1547. void fprintfErrorInfo(FILE *file, af_ErrorInfo *ei) {
  1548. fprintf(file, "Error Traceback (most recent call last):\n");
  1549. for (af_ErrorBacktracking *ebt = ei->track; ebt != NULL; ebt = ebt->next) {
  1550. fprintf(file, " File \"%s\", line %d\n", ebt->file, ebt->line);
  1551. if (ebt->note != NULL)
  1552. fprintfNote(file, ebt->note);
  1553. }
  1554. fprintf(file, "%s: \"%s\"\n", ei->error_type, ei->error);
  1555. fflush(file);
  1556. }
  1557. static void fprintfNoteStderr(char *note) {
  1558. char *ent = NULL;
  1559. while(true) {
  1560. ent = strchr(note, '\n');
  1561. if (ent != NULL)
  1562. *ent = NUL;
  1563. printf_stderr(0, " #note %s\n", note);
  1564. if (ent == NULL) // 意味着是最后一部分`note`
  1565. break;
  1566. *ent = '\n';
  1567. note = ent + 1;
  1568. }
  1569. }
  1570. void fprintfErrorInfoStderr(af_ErrorInfo *ei) {
  1571. printf_stderr(0, "Error Traceback (most recent call last):\n");
  1572. for (af_ErrorBacktracking *ebt = ei->track; ebt != NULL; ebt = ebt->next) {
  1573. printf_stderr(0, " File \"%s\", line %d\n", ebt->file, ebt->line);
  1574. if (ebt->note != NULL)
  1575. fprintfNoteStderr(ebt->note);
  1576. }
  1577. printf_stderr(0, "%s: \"%s\"\n", ei->error_type, ei->error);
  1578. fflush(stderr);
  1579. }
  1580. static void fprintfNoteStdout(char *note) {
  1581. char *ent = NULL;
  1582. while(true) {
  1583. ent = strchr(note, '\n');
  1584. if (ent != NULL)
  1585. *ent = NUL;
  1586. printf_stdout(0, " #note %s\n", note);
  1587. if (ent == NULL) // 意味着是最后一部分`note`
  1588. break;
  1589. *ent = '\n';
  1590. note = ent + 1;
  1591. }
  1592. }
  1593. void fprintfErrorInfoStdout(af_ErrorInfo *ei) {
  1594. printf_stdout(0, "Error Traceback (most recent call last):\n");
  1595. for (af_ErrorBacktracking *ebt = ei->track; ebt != NULL; ebt = ebt->next) {
  1596. printf_stdout(0, " File \"%s\", line %d\n", ebt->file, ebt->line);
  1597. if (ebt->note != NULL)
  1598. fprintfNoteStdout(ebt->note);
  1599. }
  1600. printf_stdout(0, "%s: \"%s\"\n", ei->error_type, ei->error);
  1601. fflush(stdout);
  1602. }
  1603. static af_ErrorBacktracking *makeErrorBacktracking(FileLine line, FilePath file, char *note) {
  1604. af_ErrorBacktracking *ebt = calloc(1, sizeof(af_ErrorBacktracking));
  1605. ebt->line = line;
  1606. if (file == NULL)
  1607. ebt->file = strCopy("unknown.aun.sys");
  1608. else
  1609. ebt->file = strCopy(file);
  1610. if (note != NULL)
  1611. ebt->note = strCopy(note);
  1612. return ebt;
  1613. }
  1614. static af_ErrorBacktracking *freeErrorBacktracking(af_ErrorBacktracking *ebt) {
  1615. af_ErrorBacktracking *next = ebt->next;
  1616. free(ebt->note);
  1617. free(ebt->file);
  1618. free(ebt);
  1619. return next;
  1620. }
  1621. static void freeAllErrorBacktracking(af_ErrorBacktracking *ebt) {
  1622. while(ebt != NULL) {
  1623. ebt = freeErrorBacktracking(ebt);
  1624. }
  1625. }
  1626. void pushErrorBacktracking(FileLine line, FilePath file, char *note, af_ErrorInfo *ei) {
  1627. af_ErrorBacktracking *ebt = makeErrorBacktracking(line, file, note);
  1628. ebt->next = ei->track;
  1629. ei->track = ebt;
  1630. }
  1631. static char *getActivityInfoToBacktracking(af_Activity *activity){
  1632. char info[512 + CODE_STR_MAX_SIZE] = "";
  1633. /* strcat拼接的字符是可控的, 因此不需要使用安全函数 */
  1634. if (activity->type == act_guardian) {
  1635. strcat(info, "guardian-activity;");
  1636. return strCopy(info);
  1637. } else if (activity->type == act_top)
  1638. strcat(info, "top-activity;");
  1639. else if (activity->type == act_top_import)
  1640. strcat(info, "top-import-activity;");
  1641. else if (activity->is_execution)
  1642. strcat(info, "execution-activity;");
  1643. else if (activity->is_gc_call)
  1644. strcat(info, "gc-destruct-function-call-activity;");
  1645. else
  1646. strcat(info, "function-call-activity;");
  1647. switch (activity->status) {
  1648. case act_func_get:
  1649. strcat(info, "\nfunc-get;");
  1650. break;
  1651. case act_func_arg:
  1652. strcat(info, "\nfunc-arg;");
  1653. if (activity->run_in_func)
  1654. strcat(info, " run-in-function-var-space;");
  1655. break;
  1656. case act_func_normal:
  1657. strcat(info, "\nrun-code;");
  1658. if (activity->return_first)
  1659. strcat(info, " return-first-result;");
  1660. break;
  1661. default:
  1662. break;
  1663. }
  1664. if (activity->is_macro_call)
  1665. strcat(info, "\nmacro-call;");
  1666. if (activity->is_literal)
  1667. strcat(info, "\nliteral-call;");
  1668. if (activity->is_obj_func)
  1669. strcat(info, "\nobject-function-call;");
  1670. if (activity->optimization)
  1671. strcat(info, "\ntail-call-optimization;");
  1672. if (activity->bt_done != NULL) {
  1673. char *code = codeToStr(activity->bt_done, 1);
  1674. if (code != NULL) {
  1675. strcat(info, "\ncode: ");
  1676. strcat(info, code);
  1677. free(code);
  1678. }
  1679. }
  1680. return strCopy(info);
  1681. }
  1682. static char *getActivityTrackBackInfoToBacktracking(af_ActivityTrackBack *atb) {
  1683. char info[512] = "backtracking;";
  1684. /* strcat拼接的字符是可控的, 因此不需要使用安全函数 */
  1685. if (atb->is_execution)
  1686. strcat(info, "\nexecution-activity;");
  1687. else if (atb->is_gc_call)
  1688. strcat(info, "\ngc-destruct-function-call-activity;");
  1689. else
  1690. strcat(info, "\nfunction-call-activity;");
  1691. switch (atb->status) {
  1692. case act_func_get:
  1693. strcat(info, "\nfunc-get;");
  1694. break;
  1695. case act_func_arg:
  1696. strcat(info, "\nfunc-arg;");
  1697. if (atb->run_in_func)
  1698. strcat(info, " run-in-function-var-space;");
  1699. break;
  1700. case act_func_normal:
  1701. strcat(info, "\nrun-code;");
  1702. if (atb->return_first)
  1703. strcat(info, " return-first-result;");
  1704. break;
  1705. default:
  1706. break;
  1707. }
  1708. if (atb->is_macro_call)
  1709. strcat(info, "\nmacro-call;");
  1710. if (atb->is_literal)
  1711. strcat(info, "\nliteral-call;");
  1712. if (atb->is_obj_func)
  1713. strcat(info, "\nobject-function-call;");
  1714. if (atb->optimization)
  1715. strcat(info, "\ntail-call-optimization;");
  1716. return strCopy(info);
  1717. }
  1718. af_ImportInfo *makeImportInfo(char *mark, af_Object *obj, af_Environment *env){
  1719. af_ImportInfo *ii = calloc(1, sizeof(af_ImportInfo));
  1720. if (mark != NULL)
  1721. ii->mark = strCopy(mark);
  1722. ii->obj = obj;
  1723. gc_addReference(obj, env);
  1724. return ii;
  1725. }
  1726. void freeImportInfo(af_ImportInfo *ii, af_Environment *env){
  1727. free(ii->mark);
  1728. if (ii->obj != NULL)
  1729. gc_delReference(ii->obj, env);
  1730. free(ii);
  1731. }
  1732. static af_GuardianList *makeGuardianList(af_Object *obj, af_Object *func, af_Environment *env){
  1733. af_GuardianList *gl = calloc(1, sizeof(af_GuardianList));
  1734. gl->obj = obj;
  1735. gl->func = func;
  1736. if (obj != NULL)
  1737. gc_addReference(obj, env);
  1738. gc_addReference(func, env);
  1739. return gl;
  1740. }
  1741. static af_GuardianList *freeGuardianList(af_GuardianList *gl, af_Environment *env){
  1742. af_GuardianList *next = gl->next;
  1743. if (gl->obj != NULL)
  1744. gc_delReference(gl->obj, env);
  1745. gc_delReference(gl->func, env);
  1746. free(gl);
  1747. return next;
  1748. }
  1749. static void freeAllGuardianList(af_GuardianList *gl, af_Environment *env){
  1750. while (gl != NULL)
  1751. gl = freeGuardianList(gl, env);
  1752. }
  1753. af_GuardianList **pushGuardianList(af_Object *obj, af_Object *func, af_GuardianList **pgl, af_Environment *env){
  1754. *pgl = makeGuardianList(obj, func, env);
  1755. return &((*pgl)->next);
  1756. }
  1757. af_GuardianList **contectGuardianList(af_GuardianList *new, af_GuardianList **base) {
  1758. while ((*base) != NULL)
  1759. base = &((*base)->next);
  1760. *base = new;
  1761. while ((*base) != NULL)
  1762. base = &((*base)->next);
  1763. return base;
  1764. }
  1765. void setGcMax(int32_t max, af_Environment *env) {
  1766. pthread_rwlock_wrlock(&env->esv->lock);
  1767. env->gc_max->num = max;
  1768. pthread_rwlock_unlock(&env->esv->lock);
  1769. }
  1770. void setGcRun(enum GcRunTime grt, af_Environment *env) {
  1771. pthread_rwlock_wrlock(&env->esv->lock);
  1772. env->gc_runtime->num = grt;
  1773. pthread_rwlock_unlock(&env->esv->lock);
  1774. }
  1775. int32_t getGcCount(af_Environment *env) {
  1776. pthread_rwlock_rdlock(&env->esv->lock);
  1777. int32_t res = env->gc_count->num;
  1778. pthread_rwlock_unlock(&env->esv->lock);
  1779. return res;
  1780. }
  1781. void GcCountAdd1(af_Environment *env) {
  1782. pthread_rwlock_wrlock(&env->esv->lock);
  1783. env->gc_count->num++;
  1784. pthread_rwlock_unlock(&env->esv->lock);
  1785. }
  1786. void GcCountToZero(af_Environment *env) {
  1787. pthread_rwlock_wrlock(&env->esv->lock);
  1788. env->gc_count->num = 0;
  1789. pthread_rwlock_unlock(&env->esv->lock);
  1790. }
  1791. void setArgc(int argc, af_Environment *env) {
  1792. pthread_rwlock_wrlock(&env->esv->lock);
  1793. env->argc->num = argc;
  1794. pthread_rwlock_unlock(&env->esv->lock);
  1795. }
  1796. int32_t getGcMax(af_Environment *env) {
  1797. pthread_rwlock_rdlock(&env->esv->lock);
  1798. int32_t res = env->gc_max->num;
  1799. pthread_rwlock_unlock(&env->esv->lock);
  1800. return res;
  1801. }
  1802. enum GcRunTime getGcRun(af_Environment *env) {
  1803. pthread_rwlock_rdlock(&env->esv->lock);
  1804. enum GcRunTime res = env->gc_runtime->num;
  1805. pthread_rwlock_unlock(&env->esv->lock);
  1806. return res;
  1807. }
  1808. int getArgc(af_Environment *env) {
  1809. pthread_rwlock_rdlock(&env->esv->lock);
  1810. int res = env->argc->num;
  1811. pthread_rwlock_unlock(&env->esv->lock);
  1812. return res;
  1813. }
  1814. af_Object *getCoreGlobal(af_Environment *env) {
  1815. return env->global;
  1816. }
  1817. af_Object *getGlobal(af_Environment *env) {
  1818. af_Activity *activity = env->activity;
  1819. for (NULL; activity != NULL; activity = activity->prev) {
  1820. if (activity->type == act_top || activity->type == act_top_import)
  1821. return activity->belong;
  1822. }
  1823. return env->global;
  1824. }
  1825. af_Object *getBelong(af_Environment *env) {
  1826. if (env == NULL || env->activity == NULL)
  1827. return NULL;
  1828. return env->activity->belong;
  1829. }
  1830. FilePath getActivityFile(af_Environment *env){
  1831. if (env == NULL || env->activity == NULL)
  1832. return NULL;
  1833. return env->activity->file;
  1834. }
  1835. FileLine getActivityLine(af_Environment *env){
  1836. if (env == NULL || env->activity == NULL)
  1837. return 0;
  1838. return env->activity->line;
  1839. }
  1840. af_Object *getMsgNormalData(af_Message *msg, af_Environment *env){
  1841. if (!EQ_STR("NORMAL", msg->type))
  1842. return NULL;
  1843. af_Object *obj = *(af_Object **)msg->msg;
  1844. gc_delReference(obj, env);
  1845. *(af_Object **)msg->msg = NULL;
  1846. return obj;
  1847. }
  1848. af_ErrorInfo *getMsgErrorInfo(af_Message *msg) {
  1849. if (!EQ_STR("ERROR", msg->type))
  1850. return NULL;
  1851. af_ErrorInfo *ei = *(af_ErrorInfo **)msg->msg;
  1852. return ei;
  1853. }
  1854. af_ImportInfo *getMsgImportInfo(af_Message *msg) {
  1855. if (!EQ_STR("IMPORT", msg->type))
  1856. return NULL;
  1857. af_ImportInfo *ii = *(af_ImportInfo **)msg->msg;
  1858. return ii;
  1859. }
  1860. char *getErrorType(af_ErrorInfo *ei) {
  1861. return ei->error_type;
  1862. }
  1863. char *getError(af_ErrorInfo *ei) {
  1864. return ei->error;
  1865. }
  1866. char *getImportMark(af_ImportInfo *ii) {
  1867. return ii->mark;
  1868. }
  1869. af_Object *getImportObject(af_ImportInfo *ii, af_Environment *env){
  1870. af_Object *obj = ii->obj;
  1871. if (obj == NULL)
  1872. return NULL;
  1873. ii->obj = NULL;
  1874. gc_delReference(obj, env);
  1875. return obj;
  1876. }
  1877. af_VarSpaceListNode *getRunVarSpaceList(af_Environment *env) {
  1878. return env->activity->run_varlist;
  1879. }
  1880. int isCoreExit(af_Environment *env) {
  1881. enum af_CoreStatus status = getCoreStatus(env);
  1882. if (status == core_exit)
  1883. return 1;
  1884. else if (status == core_stop)
  1885. return -1;
  1886. return 0;
  1887. }
  1888. bool getErrorStd(af_Environment *env) {
  1889. pthread_rwlock_rdlock(&env->esv->lock);
  1890. bool res = env->error_std->num != 0; // true-stderr, false-stdout
  1891. pthread_rwlock_unlock(&env->esv->lock);
  1892. return res;
  1893. }
  1894. int32_t getCoreExitCode(af_Environment *env) {
  1895. pthread_rwlock_rdlock(&env->esv->lock);
  1896. int res = env->exit_code_->num;
  1897. pthread_rwlock_unlock(&env->esv->lock);
  1898. return res;
  1899. }
  1900. af_Object *getActivityFunc(af_Environment *env) {
  1901. if (env->activity == NULL || env->activity->type == act_guardian)
  1902. return NULL;
  1903. return env->activity->func;
  1904. }
  1905. size_t getEnviromentSonCount(af_Environment *env) {
  1906. pthread_mutex_lock(&env->thread_lock);
  1907. size_t res = 0;
  1908. for (af_EnvironmentList *envl = env->env_list; envl != NULL; envl = envl->next)
  1909. res++;
  1910. pthread_mutex_unlock(&env->thread_lock);
  1911. return res;
  1912. }
  1913. enum af_CoreStatus getCoreStatus(af_Environment *env) {
  1914. pthread_mutex_lock(&env->status_lock);
  1915. enum af_CoreStatus res = env->status;
  1916. pthread_mutex_unlock(&env->status_lock);
  1917. return res;
  1918. }
  1919. /**
  1920. * 线程外部 指示线程结束
  1921. * @param env
  1922. */
  1923. void setEnviromentExit_out(af_Environment *env) {
  1924. pthread_mutex_lock(&env->thread_lock);
  1925. env->son_exit = true;
  1926. if (env->monitor != NULL)
  1927. pthread_cond_signal(&env->monitor->cond);
  1928. pthread_mutex_unlock(&env->thread_lock);
  1929. }
  1930. bool isEnviromentExit(af_Environment *env) {
  1931. pthread_mutex_lock(&env->thread_lock);
  1932. bool res = env->son_exit == true; // 线程外部指示线程结束
  1933. af_Environment *base = env->base;
  1934. pthread_mutex_unlock(&env->thread_lock);
  1935. if (res)
  1936. return true;
  1937. else if (env == base)
  1938. return false;
  1939. enum af_CoreStatus status = getCoreStatus(base);
  1940. res = status == core_exit || status == core_normal_gc; // 主线程结束
  1941. return res;
  1942. }
  1943. /**
  1944. * 等待次线程结束
  1945. * @param env
  1946. */
  1947. void waitForEnviromentExit(af_Environment *env) {
  1948. pthread_mutex_lock(&env->status_lock);
  1949. env->status = core_exit; // 不需要设置 exit_code
  1950. pthread_mutex_unlock(&env->status_lock);
  1951. pthread_mutex_lock(&env->thread_lock);
  1952. while (env->env_list != NULL)
  1953. pthread_cond_wait(&env->thread_cond, &env->thread_lock);
  1954. pthread_mutex_unlock(&env->thread_lock);
  1955. }