00001
00005 #include <malloc.h>
00006 #include <string.h>
00007
00008 #include "libmgk.h"
00009
00010 unsigned int
00011 mgk_node_input_count(mgk_nodep node)
00012 {
00013 if (__mgk_check_remnode(node)) {
00014 mgk_remnode *rn = (mgk_remnode *) node;
00015 mgk_value *args[1];
00016 mgk_value *rargs[2];
00017 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00018 if (__mgk_remote_call(rn->host,
00019 cmd_node_input_count,
00020 1, args,
00021 2, rargs)) {
00022 mgk_data_type t1, t2;
00023 mgk_scalar s1, s2;
00024 int *ninp = __mgk_extract_value(rargs[0], &t1, &s1);
00025 int *errp = __mgk_extract_value(rargs[1], &t2, &s2);
00026 if ((t1 == T_INTEGER) && (t2 == T_INTEGER)) {
00027 mgk_errno = *errp;
00028 return (*ninp);
00029 }
00030 }
00031 mgk_errno = E_COMM;
00032 return (MGK_U_BADVAL);
00033 }
00034 if (!__mgk_check_node(node)) {
00035 mgk_errno = E_NOTNODE;
00036 return (MGK_U_BADVAL);
00037 }
00038 mgk_errno = E_SUCCESS;
00039 return (node->nin);
00040 }
00041
00042 unsigned int
00043 mgk_node_output_count(mgk_nodep node)
00044 {
00045 if (__mgk_check_remnode(node)) {
00046 mgk_remnode *rn = (mgk_remnode *) node;
00047 mgk_value *args[1];
00048 mgk_value *rargs[2];
00049 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00050 if (__mgk_remote_call(rn->host,
00051 cmd_node_output_count,
00052 1, args,
00053 2, rargs)) {
00054 mgk_data_type t1, t2;
00055 mgk_scalar s1, s2;
00056 int *noutp = __mgk_extract_value(rargs[0], &t1, &s1);
00057 int *errp = __mgk_extract_value(rargs[1], &t2, &s2);
00058 if ((t1 == T_INTEGER) && (t2 == T_INTEGER)) {
00059 mgk_errno = *errp;
00060 return (*noutp);
00061 }
00062 }
00063 mgk_errno = E_COMM;
00064 return (MGK_U_BADVAL);
00065 }
00066 if (!__mgk_check_node(node)) {
00067 mgk_errno = E_NOTNODE;
00068 return (MGK_U_BADVAL);
00069 }
00070 mgk_errno = E_SUCCESS;
00071 return (node->nout);
00072 }
00073
00074 DEFSVC(node_input_count)
00075 {
00076 if ((argc == 1) && (rargc == 2)) {
00077 mgk_data_type t;
00078 long *idp = __mgk_parse_value(argv[0], &t);
00079 if (t == T_LONGINT) {
00080 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00081 int cnt = mgk_node_input_count(np);
00082 rargv[0] = __mgk_build_value(&cnt, T_INTEGER);
00083 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00084 return (TRUE);
00085 }
00086 }
00087 return (FALSE);
00088 }
00089
00090 DEFSVC(node_output_count)
00091 {
00092 if ((argc == 1) && (rargc == 2)) {
00093 mgk_data_type t;
00094 long *idp = __mgk_parse_value(argv[0], &t);
00095 if (t == T_LONGINT) {
00096 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00097 int cnt = mgk_node_output_count(np);
00098 rargv[0] = __mgk_build_value(&cnt, T_INTEGER);
00099 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00100 return (TRUE);
00101 }
00102 }
00103 return (FALSE);
00104 }
00105
00106 unsigned int
00107 mgk_node_input_connection_count(mgk_nodep node,
00108 unsigned int port)
00109 {
00110 mgk_link *lp;
00111 unsigned int count;
00112 if (__mgk_check_remnode(node)) {
00113 mgk_remnode *rn = (mgk_remnode *) node;
00114 mgk_value *args[2];
00115 mgk_value *rargs[2];
00116 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00117 args[1] = __mgk_build_value(&port, T_INTEGER);
00118 if (__mgk_remote_call(rn->host,
00119 cmd_node_input_connection_count,
00120 2, args,
00121 2, rargs)) {
00122 mgk_data_type t1, t2;
00123 mgk_scalar s1, s2;
00124 int *nump = __mgk_extract_value(rargs[0], &t1, &s1);
00125 int *errp = __mgk_extract_value(rargs[1], &t2, &s2);
00126 if ((t1 == T_INTEGER) && (t2 == T_INTEGER)) {
00127 mgk_errno = *errp;
00128 return (*nump);
00129 }
00130 }
00131 mgk_errno = E_COMM;
00132 return (MGK_U_BADVAL);
00133 }
00134 if (!__mgk_check_node(node)) {
00135 mgk_errno = E_NOTNODE;
00136 return (MGK_U_BADVAL);
00137 }
00138 if (port >= node->nin) {
00139 mgk_errno = E_BADPORTIX;
00140 return (MGK_U_BADVAL);
00141 }
00142 for (lp = node->ins[port].links, count = 0;
00143 lp;
00144 lp = lp->l.l2l.nextin, count++);
00145 mgk_errno = E_SUCCESS;
00146 return (count);
00147 }
00148
00149 unsigned int
00150 mgk_node_output_connection_count(mgk_nodep node,
00151 unsigned int port)
00152 {
00153 mgk_link *lp;
00154 unsigned int count;
00155 if (__mgk_check_remnode(node)) {
00156 mgk_remnode *rn = (mgk_remnode *) node;
00157 mgk_value *args[2];
00158 mgk_value *rargs[2];
00159 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00160 args[1] = __mgk_build_value(&port, T_INTEGER);
00161 if (__mgk_remote_call(rn->host,
00162 cmd_node_output_connection_count,
00163 2, args,
00164 2, rargs)) {
00165 mgk_data_type t1, t2;
00166 mgk_scalar s1, s2;
00167 int *nump = __mgk_extract_value(rargs[0], &t1, &s1);
00168 int *errp = __mgk_extract_value(rargs[1], &t2, &s2);
00169 if ((t1 == T_INTEGER) && (t2 == T_INTEGER)) {
00170 mgk_errno = *errp;
00171 return (*nump);
00172 }
00173 }
00174 mgk_errno = E_COMM;
00175 return (MGK_U_BADVAL);
00176 }
00177 if (!__mgk_check_node(node)) {
00178 mgk_errno = E_NOTNODE;
00179 return (MGK_U_BADVAL);
00180 }
00181 if (port >= node->nout) {
00182 mgk_errno = E_BADPORTIX;
00183 return (MGK_U_BADVAL);
00184 }
00185 for (lp = node->outs[port].links, count = 0;
00186 lp;
00187 lp = lp->l.l2l.nextout, count++);
00188 mgk_errno = E_SUCCESS;
00189 return (count);
00190 }
00191
00192 DEFSVC(node_input_connection_count)
00193 {
00194 if ((argc == 2) && (rargc == 2)) {
00195 mgk_data_type t1, t2;
00196 long *idp = __mgk_parse_value(argv[0], &t1);
00197 int *idxp = __mgk_parse_value(argv[1], &t2);
00198 if ((t1 == T_LONGINT) && (t2 == T_INTEGER)) {
00199 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00200 int cnt = mgk_node_input_connection_count(np, *idxp);
00201 rargv[0] = __mgk_build_value(&cnt, T_INTEGER);
00202 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00203 return (TRUE);
00204 }
00205 }
00206 return (FALSE);
00207 }
00208
00209 DEFSVC(node_output_connection_count)
00210 {
00211 if ((argc == 2) && (rargc == 2)) {
00212 mgk_data_type t1, t2;
00213 long *idp = __mgk_parse_value(argv[0], &t1);
00214 int *idxp = __mgk_parse_value(argv[1], &t2);
00215 if ((t1 == T_LONGINT) && (t2 == T_INTEGER)) {
00216 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00217 int cnt = mgk_node_output_connection_count(np, *idxp);
00218 rargv[0] = __mgk_build_value(&cnt, T_INTEGER);
00219 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00220 return (TRUE);
00221 }
00222 }
00223 return (FALSE);
00224 }
00225
00226 mgk_nodep
00227 mgk_node_input_connection(mgk_nodep node, unsigned int port,
00228 unsigned int which, unsigned int *connport)
00229 {
00230 mgk_link *lp;
00231 unsigned int count;
00232 if (__mgk_check_remnode(node)) {
00233 mgk_remnode *rn = (mgk_remnode *) node;
00234 mgk_value *args[3];
00235 mgk_value *rargs[4];
00236 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00237 args[1] = __mgk_build_value(&port, T_INTEGER);
00238 args[2] = __mgk_build_value(&which, T_INTEGER);
00239 if (__mgk_remote_call(rn->host,
00240 cmd_node_input_connection,
00241 3, args,
00242 4, rargs)) {
00243 mgk_data_type t1, t2, t3, t4;
00244 mgk_scalar s1, s2, s3, s4;
00245 long *idp = __mgk_extract_value(rargs[0], &t1, &s1);
00246 int *hixp = __mgk_extract_value(rargs[1], &t2, &s2);
00247 int *prtp = __mgk_extract_value(rargs[2], &t3, &s3);
00248 int *errp = __mgk_extract_value(rargs[3], &t4, &s4);
00249 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) &&
00250 (t3 == T_INTEGER) && (t4 == T_INTEGER)) {
00251 mgk_errno = *errp;
00252 *connport = *prtp;
00253 return (__mgk_locate_node(*hixp, *idp));
00254 }
00255 }
00256 mgk_errno = E_COMM;
00257 return (MGK_P_BADVAL);
00258 }
00259 if (!__mgk_check_node(node)) {
00260 mgk_errno = E_NOTNODE;
00261 return (NULL);
00262 }
00263 if (port >= node->nin) {
00264 mgk_errno = E_BADPORTIX;
00265 return (NULL);
00266 }
00267 mgk_errno = E_SUCCESS;
00268 for (lp = node->ins[port].links, count = 0;
00269 lp;
00270 lp = lp->l.l2l.nextin, count++) {
00271 if (count == which) {
00272 *connport = lp->srcidx;
00273 switch (lp->type) {
00274 case LINK_L2L:
00275 return (lp->l.l2l.src);
00276 case LINK_R2L:
00277 return ((mgk_nodep) lp->l.r2l.src);
00278 default:
00279 mgk_errno = E_GENERROR;
00280 return (NULL);
00281 }
00282 }
00283 }
00284 mgk_errno = E_BADPORTIX;
00285 return (NULL);
00286 }
00287
00288 mgk_nodep
00289 mgk_node_output_connection(mgk_nodep node, unsigned int port,
00290 unsigned int which, unsigned int *connport)
00291 {
00292 mgk_link *lp;
00293 unsigned int count;
00294 if (__mgk_check_remnode(node)) {
00295 mgk_remnode *rn = (mgk_remnode *) node;
00296 mgk_value *args[3];
00297 mgk_value *rargs[4];
00298 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00299 args[1] = __mgk_build_value(&port, T_INTEGER);
00300 args[2] = __mgk_build_value(&which, T_INTEGER);
00301 if (__mgk_remote_call(rn->host,
00302 cmd_node_output_connection,
00303 3, args,
00304 4, rargs)) {
00305 mgk_data_type t1, t2, t3, t4;
00306 mgk_scalar s1, s2, s3, s4;
00307 long *idp = __mgk_extract_value(rargs[0], &t1, &s1);
00308 int *hixp = __mgk_extract_value(rargs[1], &t2, &s2);
00309 int *prtp = __mgk_extract_value(rargs[2], &t3, &s3);
00310 int *errp = __mgk_extract_value(rargs[3], &t4, &s4);
00311 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) &&
00312 (t3 == T_INTEGER) && (t4 == T_INTEGER)) {
00313 mgk_errno = *errp;
00314 *connport = *prtp;
00315 return (__mgk_locate_node(*hixp, *idp));
00316 }
00317 }
00318 mgk_errno = E_COMM;
00319 return (MGK_P_BADVAL);
00320 }
00321 if (!__mgk_check_node(node)) {
00322 mgk_errno = E_NOTNODE;
00323 return (NULL);
00324 }
00325 if (port >= node->nout) {
00326 mgk_errno = E_BADPORTIX;
00327 return (NULL);
00328 }
00329 mgk_errno = E_SUCCESS;
00330 for (lp = node->outs[port].links, count = 0;
00331 lp;
00332 lp = lp->l.l2l.nextout, count++) {
00333 if (count == which) {
00334 *connport = lp->dstidx;
00335 switch (lp->type) {
00336 case LINK_L2L:
00337 return (lp->l.l2l.dst);
00338 case LINK_L2R:
00339 return ((mgk_nodep) lp->l.l2r.dst);
00340 default:
00341 mgk_errno = E_GENERROR;
00342 return (NULL);
00343 }
00344 }
00345 }
00346 mgk_errno = E_BADPORTIX;
00347 return (NULL);
00348 }
00349
00350 DEFSVC(node_input_connection)
00351 {
00352 if ((argc == 3) && (rargc == 4)) {
00353 mgk_data_type t1, t2, t3;
00354 long *idp = __mgk_parse_value(argv[0], &t1);
00355 int *idxp = __mgk_parse_value(argv[1], &t2);
00356 int *cntp = __mgk_parse_value(argv[2], &t3);
00357 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) && (t3 == T_INTEGER)) {
00358 unsigned int connidx = 0;
00359 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00360 mgk_node *conn = mgk_node_input_connection(np, *idxp, *cntp, &connidx);
00361 if (__mgk_check_node(conn)) {
00362 rargv[0] = __mgk_build_value(&conn->ID, T_LONGINT);
00363 rargv[1] = __mgk_build_value(&__mgk_local_host->index, T_INTEGER);
00364 }
00365 else if (__mgk_check_remnode(conn)) {
00366 mgk_remnode *rconn = (mgk_remnode *) conn;
00367 rargv[0] = __mgk_build_value(&rconn->ID, T_LONGINT);
00368 rargv[1] = __mgk_build_value(&rconn->host->index, T_INTEGER);
00369 }
00370 else {
00371 long ID = 0;
00372 int hix = -1;
00373 rargv[0] = __mgk_build_value(&ID, T_LONGINT);
00374 rargv[1] = __mgk_build_value(&hix, T_INTEGER);
00375 }
00376 rargv[2] = __mgk_build_value(&connidx, T_INTEGER);
00377 rargv[3] = __mgk_build_value(&mgk_errno, T_INTEGER);
00378 return (TRUE);
00379 }
00380 }
00381 return (FALSE);
00382 }
00383
00384 DEFSVC(node_output_connection)
00385 {
00386 if ((argc == 3) && (rargc == 4)) {
00387 mgk_data_type t1, t2, t3;
00388 long *idp = __mgk_parse_value(argv[0], &t1);
00389 int *idxp = __mgk_parse_value(argv[1], &t2);
00390 int *cntp = __mgk_parse_value(argv[2], &t3);
00391 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) && (t3 == T_INTEGER)) {
00392 unsigned int connidx = 0;
00393 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00394 mgk_node *conn = mgk_node_output_connection(np, *idxp, *cntp, &connidx);
00395 if (__mgk_check_node(conn)) {
00396 rargv[0] = __mgk_build_value(&conn->ID, T_LONGINT);
00397 rargv[1] = __mgk_build_value(&__mgk_local_host->index, T_INTEGER);
00398 }
00399 else if (__mgk_check_remnode(conn)) {
00400 mgk_remnode *rconn = (mgk_remnode *) conn;
00401 rargv[0] = __mgk_build_value(&rconn->ID, T_LONGINT);
00402 rargv[1] = __mgk_build_value(&rconn->host->index, T_INTEGER);
00403 }
00404 else {
00405 long ID = 0;
00406 int hix = -1;
00407 rargv[0] = __mgk_build_value(&ID, T_LONGINT);
00408 rargv[1] = __mgk_build_value(&hix, T_INTEGER);
00409 }
00410 rargv[2] = __mgk_build_value(&connidx, T_INTEGER);
00411 rargv[3] = __mgk_build_value(&mgk_errno, T_INTEGER);
00412 return (TRUE);
00413 }
00414 }
00415 return (FALSE);
00416 }
