TUM-Logo

libRASCH

 

Home
 

General

About libRASCH/News
Design
Screen shots
Sample programs (with source code)
License
 

Download

libRASCH
Tools
 

Documentation

User
Developer
 

Resources

Mailing list
Supported Formats
Plugins
Status
Links
 
Contact
About this site
 
Last updated
Tue Mar 27 23:03:52 2007
libRASCH: pl_comm.c Source File

pl_comm.c

Go to the documentation of this file.
00001 
00009 /*----------------------------------------------------------------------------
00010  *
00011  * Copyright (C) 2002-2004, Raphael Schneider
00012  * See the file COPYING for information on usage and redistribution.
00013  *
00014  * $Header: /home/cvs_repos.bak/librasch/src/pl_comm.c,v 1.6 2004/06/22 13:43:45 rasch Exp $
00015  *
00016  *--------------------------------------------------------------------------*/
00017 
00018 #include <stdlib.h>
00019 #include <string.h>
00020 #include <stdio.h>
00021 
00022 #define _LIBRASCH_BUILD
00023 #include <ra_pl_comm.h>
00024 #include <ra_priv.h>
00025 
00026 
00027 /* for debugging */
00028 void _trace_signame(int level, const char *sender, const char *sig_name, int num_para, struct comm_para *para);
00029 void _trace_sigdest(int level, const char *dest);
00030 
00031 
00043 LIBRAAPI int
00044 ra_comm_add(meas_handle mh, plugin_handle p, dest_handle dh, const char *sig_name)
00045 {
00046         struct ra_meas *mm = (struct ra_meas *) mh;
00047         struct signal *sig = find_signal(&(mm->plc), sig_name);
00048 
00049         if (!sig)
00050         {
00051                 if ((sig = add_signal(&(mm->plc), sig_name)) == NULL)
00052                         return -1;
00053         }
00054 
00055         sig->num_slots++;
00056         sig->slot = realloc(sig->slot, sizeof(struct slot_info) * sig->num_slots);
00057         sig->slot[sig->num_slots - 1].plugin = p;
00058         sig->slot[sig->num_slots - 1].dest = dh;
00059 
00060         return 0;
00061 } /* ra_comm_add() */
00062 
00063 
00072 LIBRAAPI void
00073 ra_comm_del(meas_handle mh, dest_handle dh, const char *sig_name)
00074 {
00075         int idx;
00076         struct ra_meas *mm = (struct ra_meas *) mh;
00077         struct signal *sig;
00078 
00079         if (mh == NULL)
00080                 return;
00081 
00082         if (sig_name == NULL)
00083         {
00084                 int i;
00085                 for (i = 0; i < mm->plc.num_signals; i++)
00086                         ra_comm_del(mh, dh, mm->plc.sig[i].name);
00087 
00088                 return;
00089         }
00090 
00091         sig = find_signal(&(mm->plc), sig_name);
00092         if (!sig)
00093                 return;
00094 
00095         idx = find_slot(sig, dh);
00096         if (idx < 0)
00097                 return;
00098 
00099         if (idx < (sig->num_slots - 1))
00100                 memmove(&(sig->slot[idx]), &(sig->slot[idx + 1]),
00101                         sizeof(struct slot_info) * (sig->num_slots - idx - 1));
00102         sig->num_slots--;
00103         sig->slot = realloc(sig->slot, sizeof(struct slot_info) * sig->num_slots);
00104 } /* ra_comm_del() */
00105 
00106 
00117 LIBRAAPI void
00118 ra_comm_emit(meas_handle mh, const char *sender, const char *sig_name, int num_para, struct comm_para *para)
00119 {
00120         int i;
00121         struct ra_meas *mm = (struct ra_meas *) mh;
00122         struct signal *sig = find_signal(&(mm->plc), sig_name);
00123         static int level = 0;
00124 
00125         if (!sig)
00126                 return;
00127 
00128         level++;
00129         _trace_signame(level, sender, sig_name, num_para, para);
00130 
00131         for (i = 0; i < sig->num_slots; i++)
00132         {
00133                 struct plugin_struct *p = (struct plugin_struct *) (sig->slot[i].plugin);
00134                 if (!p)
00135                         continue;
00136 
00137                 if (p->handle_signal)
00138                 {
00139                         _trace_sigdest(level, p->info.name);
00140                         (*p->handle_signal) (mh, sig->slot[i].dest, sig_name, num_para, para);
00141                 }
00142         }
00143         level--;
00144 
00145         return;
00146 } /* ra_comm_emit() */
00147 
00148 
00157 struct signal *
00158 find_signal(struct plugin_comm *plc, const char *sig_name)
00159 {
00160         int i;
00161         struct signal *sig = NULL;
00162 
00163         for (i = 0; i < plc->num_signals; i++)
00164         {
00165                 if (strcmp(plc->sig[i].name, sig_name) == 0)
00166                 {
00167                         sig = &(plc->sig[i]);
00168                         break;
00169                 }
00170         }
00171 
00172         return sig;
00173 } /* find_signal() */
00174 
00175 
00183 struct signal *
00184 add_signal(struct plugin_comm *plc, const char *sig_name)
00185 {
00186         /* first be sure that signal is not already created */
00187         struct signal *sig = find_signal(plc, sig_name);
00188         if (sig)
00189                 return sig;
00190 
00191         plc->num_signals++;
00192         plc->sig = realloc(plc->sig, sizeof(struct signal) * plc->num_signals);
00193         sig = &(plc->sig[plc->num_signals - 1]);
00194         strncpy(sig->name, sig_name, MAX_SIGNAL_NAME);
00195         sig->num_slots = 0;
00196         sig->slot = NULL;
00197 
00198         return sig;
00199 } /* add_signal() */
00200 
00201 
00209 int
00210 find_slot(struct signal *sig, dest_handle dh)
00211 {
00212         int idx = -1;
00213         int i;
00214 
00215         for (i = 0; i < sig->num_slots; i++)
00216         {
00217                 if (sig->slot[i].dest == dh)
00218                 {
00219                         idx = i;
00220                         break;
00221                 }
00222         }
00223 
00224         return idx;
00225 } /* find_slot() */
00226 
00227 
00239 void
00240 _trace_signame(int level, const char *sender, const char *sig_name, int num_para, struct comm_para *para)
00241 {
00242         int i;
00243         char *sender_locale;
00244         char *sig_name_locale;
00245         char *temp;
00246 
00247         if (!ra_print_debug_infos)
00248                 return;
00249 
00250         for (i = 0; i < (level - 1); i++)
00251                 fprintf(stderr, "  ");
00252 
00253         if (sender != NULL)
00254         {
00255                 sender_locale = malloc(strlen(sender) * 2);
00256                 utf8_to_local(sender, sender_locale, strlen(sender) * 2);
00257                 fprintf(stderr, "%s->", sender_locale);
00258                 free(sender_locale);
00259         }
00260 
00261         sig_name_locale = malloc(strlen(sig_name) * 2);
00262         utf8_to_local(sig_name, sig_name_locale, strlen(sig_name) * 2);
00263         fprintf(stderr, "signal %s: ", sig_name_locale);
00264         free(sig_name_locale);
00265 
00266         for (i = 0; i < num_para; i++)
00267         {
00268                 switch (para[i].type)
00269                 {
00270                 case PARA_CHAR:
00271                         fprintf(stderr, "%c  ", para[i].v.c);
00272                         break;
00273                 case PARA_BYTE:
00274                         fprintf(stderr, "%c  ", para[i].v.b);
00275                         break;
00276                 case PARA_SHORT:
00277                         fprintf(stderr, "%d  ", para[i].v.sn);
00278                         break;
00279                 case PARA_UNSIGNED_SHORT:
00280                         fprintf(stderr, "%d  ", para[i].v.usn);
00281                         break;
00282                 case PARA_INT:
00283                         fprintf(stderr, "%d  ", para[i].v.n);
00284                         break;
00285                 case PARA_UNSIGNED_INT:
00286                         fprintf(stderr, "%d  ", para[i].v.un);
00287                         break;
00288                 case PARA_LONG:
00289                         fprintf(stderr, "%ld  ", para[i].v.l);
00290                         break;
00291                 case PARA_UNSIGNED_LONG:
00292                         fprintf(stderr, "%ld  ", para[i].v.ul);
00293                         break;
00294                 case PARA_FLOAT:
00295                         fprintf(stderr, "%f  ", para[i].v.f);
00296                         break;
00297                 case PARA_DOUBLE:
00298                         fprintf(stderr, "%f  ", para[i].v.d);
00299                         break;
00300                 case PARA_CHAR_POINTER:
00301                         temp = malloc(strlen(para[i].v.pc) * 2);
00302                         utf8_to_local(para[i].v.pc, temp, strlen(para[i].v.pc) * 2);
00303                         fprintf(stderr, "%s  ", temp);
00304                         free(temp);
00305                         break;
00306                 }
00307         }
00308         fprintf(stderr, "\n");
00309 } /* _trace_signame() */
00310 
00311 
00319 void
00320 _trace_sigdest(int level, const char *dest)
00321 {
00322         int i;
00323         char *dest_locale;
00324 
00325         if (!ra_print_debug_infos)
00326                 return;
00327 
00328         for (i = 0; i < (level - 1); i++)
00329                 fprintf(stderr, "  ");
00330 
00331         dest_locale = malloc(strlen(dest) * 2);
00332         utf8_to_local(dest, dest_locale, strlen(dest) * 2);
00333         fprintf(stderr, "-> %s\n", dest_locale);
00334         free(dest_locale);
00335 } /* _trace_sigdest() */

Generated on Fri May 27 11:32:38 2005 for libRASCH by  doxygen 1.4.2