// 聲明信號和發(fā)送宏
#define signal void
#define emit

// 槽列表
typedef struct _slot_list{
  struct _slot_list *next;// 下一個槽
  void *fun;// 槽函數(shù)
  void *mb;// 槽函數(shù)運行的線程
  void *obj;// 槽函數(shù)所在類
}slot_list;

// 信號
typedef struct{
  const char *name;// 信號名
  const char *file;// 信號所在文件
  void *signal_;// 信號
  slot_list *head;// 槽列表
}signal_def;

// 消息
typedef struct{
  void *fun;// 要執(zhí)行的函數(shù)
  void *src;// 消息源
  int param_num;// 參數(shù)個數(shù)
  uint32_t param[0];// 參數(shù)列表
}slot_msg_def;

// 異步調用
typedef struct{
  void *mb;
  int run;
}slot_run_def;

// 線程
typedef void * sig_thread;

// 這個宏用于聲明信號,聲明了之后系統(tǒng)就能找到這個信號
// 這個宏用戶編程時不需要使用
#define signal_export(name_) \
  const static char __sig_##name_##_name[] SECTION(".rodata.sigstr") = #name_; \
  const static char __sig_##name_##_file[] SECTION(".rodata.sigstr") = __FILE__; \
  RT_USED static signal_def _signal_##name_ SECTION("signalstruct")= \
  {\
    .name=__sig_##name_##_name,\
    .file=__sig_##name_##_file,\
    .signal_=name_,\
    .head=0,\
  };

#include "signal.h"

signal pmcu_test_signal(int *a,int b);

#include "stdlib.h"
#include "signal.h"

void pmcu_test_signal(int *a,int b)
{
  uint32_t *param=malloc(sizeof(uint32_t)*2);
  param[0]=(uint32_t)a;
  param[1]=(uint32_t)b;
  _signal_emit(pmcu_test_signal,param,2);
  free(param);
}
signal_export(pmcu_test_signal);

#include "signal.h"
#include "board.h"
#include "stdlib.h"
#include "stdio.h"

typedef struct{
  void *mutex;
}self_def;

static self_def g_self;

// 在系統(tǒng)啟動時初始化信號量系統(tǒng)
int signal_init(void)
{
  self_def *s=&g_self;
  if(s->mutex==0)
  {
    s->mutex=rt_mutex_create("signal_",RT_IPC_FLAG_FIFO);
  }
  return 0;
}

// 4字節(jié)拷貝
static void cpy4byte(uint32_t *dst,uint32_t *src,int num_4byte)
{
  for(int i=0;i<num_4byte;i++)
  {
    dst[i]=src[i];
  }
}

// 調用這個宏執(zhí)行槽函數(shù)
#define SLOT_FUN_RUN(fun,param) \
  ((slot_fun_def)(fun))(param[0],param[1],param[2],\
    param[3],param[4],param[5],param[6],param[7])

// 槽函數(shù)定義
typedef void (*slot_fun_def)(uint32_t a,uint32_t b,uint32_t c,uint32_t d,uint32_t e,uint32_t f,uint32_t g,uint32_t h);

// 異步調用線程
static void slot_run(void *t)
{
  param_check(t);
  slot_run_def *s=t;
  int msg_size=sizeof(slot_msg_def)+sizeof(uint32_t)*8;
  slot_msg_def *msg=malloc(msg_size);
  while(s->run)
  {
    rt_mq_recv(s->mb,msg,msg_size,RT_WAITING_FOREVER);
    SLOT_FUN_RUN(msg->fun,msg->param);
  }
  free(msg);
}

// 創(chuàng)建一個線程
sig_thread thread_creat(int pro)
{
  static int count=0;
  char name[20]={0};
  slot_run_def *run=malloc(sizeof(slot_run_def));
  run->run=1;
  sprintf(name,"sig_mq#%d",count);
  run->mb=rt_mq_create(name,(sizeof(slot_msg_def)+sizeof(uint32_t)*8),20,RT_IPC_FLAG_FIFO);
  sprintf(name,"sig_t#%d",count);
  rt_thread_t rt_t=rt_thread_create(name,slot_run,run,2048,pro,20);
  rt_thread_startup(rt_t);
  count++;
  return run->mb;
}

void thread_delete(sig_thread t)
{
  // 刪除線程需要刪除與此線程相關的所有信號槽
  // 刪除消息隊列
  param_check(0);
}

// 連接信號和槽參數(shù)分別為:信號,槽線程,槽所在類,槽函數(shù)
int connect(void *signal_,sig_thread t,void *slot_obj,void *slot)
{
  self_def *s=&g_self;
  signal_def *sig;
  sig=signal_find(signal_);
  if(sig==0) return -1;
  rt_mutex_take(s->mutex,RT_WAITING_FOREVER);
  slot_list *slo=malloc(sizeof(slot_list));
  param_check(slo);
  slo->fun=slot;
  slo->mb=t;
  slo->next=0;
  slo->obj=slot_obj;
  if(sig->head==0)
  {
    sig->head=slo;
  }
  else{
    slot_list *next=sig->head;
    while(next->next!=0)
    {
      next=next->next;
    }
    next->next=slo;
  }
  rt_mutex_release(s->mutex);
  return 0;
}

// 信號和槽斷開連接,參數(shù)同上
int disconnect(void *signal_,sig_thread t,void *slot_obj,void *slot)
{
  self_def *s=&g_self;
  signal_def *sig;
  sig=signal_find(signal_);
  if(sig==0) return -1;
  rt_mutex_take(s->mutex,RT_WAITING_FOREVER);
  slot_list *next=sig->head;
  slot_list *prev=0;
  while(next!=0)
  {
    if(next->fun==slot&&next->mb==t&&next->obj==slot_obj)
    {
      if(prev) prev->next=next->next;
      else sig->head=next->next;
      free(next);
    }
    prev=next;
    next=next->next;
  }
  rt_mutex_release(s->mutex);
  return -1;
}

// 查找信號結構體
signal_def *signal_find(void *signal_)
{
  extern const int signalstruct$$Base;
  extern const int signalstruct$$Limit;
  signal_def *start=(signal_def *)&signalstruct$$Base;
  signal_def *end=(signal_def *)&signalstruct$$Limit;
  for(signal_def *t=start;t<end;t++)
  {
    if(t->signal_==signal_)
    {
      return t;
    }
  }
  return 0;
}

// 發(fā)送信號,這個函數(shù)用戶無需關心
// 用戶編程發(fā)送信號使用 emit signal_fun(); 語法即可
int _signal_emit(void *signal_,uint32_t *param,int param_num)
{
  self_def *s=&g_self;
  signal_def *sig=signal_find(signal_);
  if(sig==0) return -1;
  if(param_num>7) return -2;
  int size=sizeof(slot_msg_def)+sizeof(uint32_t)*(8);
  slot_msg_def *m=malloc(size);
  rt_mutex_take(s->mutex,RT_WAITING_FOREVER);
  slot_list *h=sig->head;
  m->param_num=param_num;
  m->src=signal_;
  while(h)
  {
    m->fun=h->fun;
    if(h->obj)
    {
      cpy4byte(m->param+1,param,param_num);
      m->param[0]=(uint32_t)h->obj;
    }else{
      cpy4byte(m->param,param,param_num);
    }
    if(h->mb){
      rt_mq_send(h->mb,m,size);
    }else{
      SLOT_FUN_RUN(m->fun,m->param);
    }
    h=h->next;
  }
  rt_mutex_release(s->mutex);
  free(m);
  return 0;
}

sig_thread thread_creat(int pro);
void thread_delete(sig_thread t);
signal_def *signal_find(void *signal_);
int connect(void *signal_,sig_thread t,void *slot_obj,void *slot);
int disconnect(void *signal_,sig_thread t,void *slot_obj,void *slot);
int signal_init(void);

// 這個函數(shù)用戶無需關心
int _signal_emit(void *signal_,uint32_t *param,int param_num);

import os

MOD_FILE="mod_signals.c"
MOD_PATH="./source/task/"

def find_file(path:str,fix:str):
    file_list=[]
    for file_name in os.listdir(path):
        if file_name.endswith(fix):
            file_list.append(os.path.join(path, file_name))
    return file_list

def find_signal_def(file):
    list_signal=[]
    with open(file) as f:
        list_str=f.readlines()
        for i in list_str:
            if(i[0:6]=="signal"):
                list_signal.append(i)
    return list_signal

# 截取變量名
def split_par_name(par_str:str):
    ret_str=""
    if(par_str.count('*')>0):
        ret_str=par_str.split("*")[1].strip()
    else:
        ret_str=par_str.split(" ")[1]
    return ret_str

def def_signal_fun(line:str):
    # 刪除多余空格
    line=' '.join(line.split())
    # print(line)
    list_str=line.split('(')
    fun_name=list_str[0].split(' ')[1]
    param_str=list_str[1].split(')')[0]
    params=[]
    # 有","則至少有兩個參數(shù)否則可能有一個參數(shù),可能沒有
    if(param_str.count(',')>0):
        params=param_str.split(',')
        for i in range(len(params)):
            params[i]=params[i].strip()
    else:
        t_str=param_str.strip()
        if(len(t_str)>0)and(t_str!="void"):
            params.append(t_str)
    # print(fun_name,params)
    params_num=len(params)
    fun_str=""
    fun_str+="void "+fun_name+"("
    for i in range(params_num):
        fun_str+=params[i]
        if(i<len(params)-1):
            fun_str+=","
    fun_str+=")\n{\n"
    fun_str+="  uint32_t *param=malloc(sizeof(uint32_t)*wppm3vysvbp);\n".format(d=params_num)
    for i in range(params_num):
        fun_str+="  param[{d1}]=(uint32_t){d2};\n".format(d1=i,d2=split_par_name(params[i]))
    fun_str+="  _signal_emit({d1},param,{d2});\n".format(d1=fun_name,d2=params_num)
    fun_str+="  free(param);\n}\n"
    fun_str+="signal_export(wppm3vysvbp);\r\n\r\n\r\n\r\n".format(d=fun_name)
    # print(fun_str)
    return fun_str

def ergodic_signal_fun(path):
    fun_str=""
    list_file=find_file(path,".h")
    for i in list_file:
        list_signal=find_signal_def(i)
        for j in list_signal:
            fun_str+=def_signal_fun(j)
    return fun_str

def mod_fine_creat(file_path):
    with open(file_path,"w+") as f:
        f.write("#include \"stdlib.h\"\n")
        f.write("#include \"signal.h\"\r\n\r\n\r\n\r\n")
        f.write(ergodic_signal_fun(MOD_PATH))

mod_fine_creat(MOD_PATH+MOD_FILE)
print("mod_file creat success.\n")

// 使用信號槽功能需要包含此文件
#include "signal.h"
// 此文件聲明了pmcu_test_signal 信號,如前文所述
#include "prot_mcu.h"

// 定義槽函數(shù)
void slot_test(int *a,int b)
{
  int int_array[20]={0};
  int_array[0]=a[0];
  int_array[1]=a[1];
  int_array[2]=a[2];
  int_array[3]=a[3];
  int_array[4]=a[4];
  int_array[5]=b;
}
// 定義槽函數(shù),假設a是函數(shù)所在類
void slot_test2(int *a,int *b,int c)
{
  int int_array[20]={0};
  int_array[0]=a[0];
  int_array[1]=a[1];
  int_array[2]=a[2];
  int_array[3]=a[3];
  int_array[4]=a[4];
  int_array[5]=c;
}

int main()
{
  // 定義數(shù)據(jù),異步調用時需保證數(shù)據(jù)在函數(shù)執(zhí)行時還有效
  int int_array[20]={4,3,5,2,1};
  // 創(chuàng)建異步調用線程,如不需要異步調用,則無需創(chuàng)建線程
  sig_thread t=thread_creat(20);
  // 連接信號和槽,異步調用,這個槽將在線程t中運行
  connect(pmcu_test_signal,t,0,slot_test);
  // 同步調用,這個槽將在調用信號的線程中運行
  connect(pmcu_test_signal,0,0,slot_test);
  // 異步調用,假設int_array是槽函數(shù)所在類
  connect(pmcu_test_signal,t,int_array,slot_test2);
  while(1)
  {
    rt_thread_mdelay(1000);
    // 發(fā)送信號,emit不是必須的,但出于可讀性要求,還是加上比較好
    emit pmcu_test_signal(int_array,8);
  }
  
}