00001
00006 #include "libmgk.h"
00007
00008 static mgk_value *last_peek_value = NULL;
00009
00010 mgk_error_code
00011 mgk_write_node_input_port(void *data,
00012 mgk_data_type type,
00013 mgk_nodep node,
00014 unsigned int port)
00015 {
00016 mgk_inport *ip;
00017 mgk_value *vp;
00018 if (__mgk_check_remnode(node)) {
00019 mgk_remnode *rn = (mgk_remnode *) node;
00020 mgk_value *args[3];
00021 mgk_value *rargs[1];
00022 if (!(vp = __mgk_build_value(data, type))) {
00023 return (mgk_errno);
00024 }
00025 args[0] = vp;
00026 args[1] = __mgk_build_value(&rn->ID, T_LONGINT);
00027 args[2] = __mgk_build_value(&port, T_INTEGER);
00028 if (__mgk_remote_call(rn->host,
00029 cmd_write_node_input_port,
00030 3, args,
00031 1, rargs)) {
00032 mgk_data_type t;
00033 mgk_scalar s;
00034 int *errp = __mgk_extract_value(rargs[0], &t, &s);
00035 if (t == T_INTEGER) {
00036 return (mgk_errno = *errp);
00037 }
00038 }
00039 return (mgk_errno = E_COMM);
00040 }
00041 if (!__mgk_check_node(node)) {
00042 return (mgk_errno = E_NOTNODE);
00043 }
00044 if (port >= node->nin) {
00045 return (mgk_errno = E_BADPORTIX);
00046 }
00047 ip = &node->ins[port];
00048 if (!(vp = __mgk_build_value(data, type))) {
00049 return (mgk_errno);
00050 }
00051 ip = &node->ins[port];
00052 if (ip->head) {
00053 ip->tail->next = vp;
00054 }
00055 else {
00056 ip->head = vp;
00057 }
00058 ip->tail = vp;
00059 vp->next = NULL;
00060 ip->qlen++;
00061 if ((ip->head == ip->tail) &&
00062 (node->status == WAITING) &&
00063 (node->priority > MGK_NODE_STOP_PRIORITY)) {
00064 __mgk_update(node);
00065 }
00066 return (mgk_errno = E_SUCCESS);
00067 }
00068
00069 DEFSVC(write_node_input_port)
00070 {
00071 if ((argc == 3) && (rargc == 1)) {
00072 mgk_data_type t1, t2;
00073 long *idp = __mgk_parse_value(argv[1], &t1);
00074 int *idxp = __mgk_parse_value(argv[2], &t2);
00075 if ((t1 == T_LONGINT) && (t2 == T_INTEGER)) {
00076 mgk_data_type type;
00077 mgk_scalar svalue;
00078 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00079 void *value = __mgk_extract_value(argv[0], &type, &svalue);
00080 int res = mgk_write_node_input_port(value, type, np, *idxp);
00081 if ((res != E_SUCCESS) && (type & T_BUFFER)) {
00082 __mgk_free_buffer(value);
00083 }
00084 argv[0] = NULL;
00085 rargv[0] = __mgk_build_value(&res, T_INTEGER);
00086 return (TRUE);
00087 }
00088 }
00089 return (FALSE);
00090 }
00091
00092 mgk_error_code
00093 mgk_write_node_output_port(void *data,
00094 mgk_data_type type,
00095 mgk_nodep node,
00096 unsigned int port,
00097 unsigned int whichconn)
00098 {
00099 mgk_link *lp;
00100 mgk_error_code res = E_SUCCESS;
00101 unsigned int done_any, idx;
00102 mgk_value *vp;
00103 if (__mgk_check_remnode(node)) {
00104 mgk_remnode *rn = (mgk_remnode *) node;
00105 mgk_value *args[4];
00106 mgk_value *rargs[1];
00107 if (!(args[0] = __mgk_build_value(data, type))) {
00108 return (mgk_errno);
00109 }
00110 args[1] = __mgk_build_value(&rn->ID, T_LONGINT);
00111 args[2] = __mgk_build_value(&port, T_INTEGER);
00112 args[3] = __mgk_build_value(&whichconn, T_INTEGER);
00113 if (__mgk_remote_call(rn->host,
00114 cmd_write_node_output_port,
00115 4, args,
00116 1, rargs)) {
00117 mgk_data_type t;
00118 mgk_scalar s;
00119 int *errp = __mgk_extract_value(rargs[0], &t, &s);
00120 if (t == T_INTEGER) {
00121 return (mgk_errno = *errp);
00122 }
00123 }
00124 return (mgk_errno = E_COMM);
00125 }
00126 if (!__mgk_check_node(node)) {
00127 return (mgk_errno = E_NOTNODE);
00128 }
00129 if (port >= node->nout) {
00130 return (mgk_errno = E_BADPORTIX);
00131 }
00132 for (lp = node->outs[port].links, idx = 0, done_any = 0;
00133 lp;
00134 lp = lp->l.l2l.nextout, idx++) {
00135 if ((whichconn == MGK_ALL_OUTPUT_CONNECTIONS) || (whichconn == idx)) {
00136 switch (lp->type) {
00137 case LINK_L2L:
00138 res = mgk_write_node_input_port(data, type,
00139 lp->l.l2l.dst, lp->dstidx);
00140 break;
00141 case LINK_L2R:
00142 if (!(vp = __mgk_build_value(data, type))) {
00143 return (mgk_errno);
00144 }
00145 if (lp->l.l2r.head) {
00146 lp->l.l2r.tail->next = vp;
00147 }
00148 else {
00149 lp->l.l2r.head = vp;
00150 }
00151 lp->l.l2r.tail = vp;
00152 vp->next = NULL;
00153 lp->l.l2r.qlen++;
00154 if (!lp->l.l2r.active) {
00155 __mgk_remote_propagate(lp);
00156 }
00157 res = E_SUCCESS;
00158 break;
00159 default:
00160 res = E_GENERROR;
00161 break;
00162 }
00163 if (res != E_SUCCESS) {
00164 return (mgk_errno = res);
00165 }
00166 done_any++;
00167 }
00168 }
00169 if (!done_any) {
00170 return (mgk_errno = E_PORTCONN);
00171 }
00172 return (mgk_errno = res);
00173 }
00174
00175 DEFSVC(write_node_output_port)
00176 {
00177 if ((argc == 4) && (rargc == 1)) {
00178 mgk_data_type t1, t2, t3;
00179 long *idp = __mgk_parse_value(argv[1], &t1);
00180 int *idxp = __mgk_parse_value(argv[2], &t2);
00181 int *selp = __mgk_parse_value(argv[3], &t3);
00182 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) && (t3 == T_INTEGER)) {
00183 mgk_data_type type;
00184 mgk_scalar svalue;
00185 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00186 void *value = __mgk_extract_value(argv[0], &type, &svalue);
00187 int res = mgk_write_node_output_port(value, type, np, *idxp, *selp);
00188 if ((res != E_SUCCESS) && (type & T_BUFFER)) {
00189 __mgk_free_buffer(value);
00190 }
00191 argv[0] = NULL;
00192 rargv[0] = __mgk_build_value(&res, T_INTEGER);
00193 return (TRUE);
00194 }
00195 }
00196 return (FALSE);
00197 }
00198
00199 mgk_error_code
00200 mgk_clear_node_input_port(mgk_nodep node,
00201 unsigned int port,
00202 unsigned int count)
00203 {
00204 mgk_inport *ip;
00205 mgk_value *vp;
00206 unsigned int i;
00207 if (__mgk_check_remnode(node)) {
00208 mgk_remnode *rn = (mgk_remnode *) node;
00209 mgk_value *args[3];
00210 mgk_value *rargs[1];
00211 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00212 args[1] = __mgk_build_value(&port, T_INTEGER);
00213 args[2] = __mgk_build_value(&count, T_INTEGER);
00214 if (__mgk_remote_call(rn->host,
00215 cmd_clear_node_input_port,
00216 3, args,
00217 1, rargs)) {
00218 mgk_data_type t;
00219 mgk_scalar s;
00220 int *errp = __mgk_extract_value(rargs[0], &t, &s);
00221 if (t == T_INTEGER) {
00222 return (mgk_errno = *errp);
00223 }
00224 }
00225 return (mgk_errno = E_COMM);
00226 }
00227 if (!__mgk_check_node(node)) {
00228 return (mgk_errno = E_NOTNODE);
00229 }
00230 if (port >= node->nin) {
00231 return (mgk_errno = E_BADPORTIX);
00232 }
00233 ip = &node->ins[port];
00234 for (i = 0; i < count; i++) {
00235 vp = ip->head;
00236 if (!vp) {
00237 break;
00238 }
00239 ip->head = vp->next;
00240 ip->qlen--;
00241 __mgk_free_value(vp);
00242 }
00243 if ((i > 0) && !ip->head) {
00244 __mgk_update(node);
00245 }
00246 return (mgk_errno = E_SUCCESS);
00247 }
00248
00249 DEFSVC(clear_node_input_port)
00250 {
00251 if ((argc == 3) && (rargc == 1)) {
00252 mgk_data_type t1, t2, t3;
00253 long *idp = __mgk_parse_value(argv[0], &t1);
00254 int *idxp = __mgk_parse_value(argv[1], &t2);
00255 int *cntp = __mgk_parse_value(argv[2], &t3);
00256 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) && (t3 == T_INTEGER)) {
00257 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00258 int res = mgk_clear_node_input_port(np, *idxp, *cntp);
00259 rargv[0] = __mgk_build_value(&res, T_INTEGER);
00260 return (TRUE);
00261 }
00262 }
00263 return (FALSE);
00264 }
00265
00266 mgk_error_code
00267 mgk_clear_node_output_port(mgk_nodep node,
00268 unsigned int port,
00269 unsigned int whichconn,
00270 unsigned int count)
00271 {
00272 mgk_link *lp;
00273 unsigned int i, idx, done_any;
00274 mgk_value *vp;
00275 if (__mgk_check_remnode(node)) {
00276 mgk_remnode *rn = (mgk_remnode *) node;
00277 mgk_value *args[4];
00278 mgk_value *rargs[1];
00279 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00280 args[1] = __mgk_build_value(&port, T_INTEGER);
00281 args[2] = __mgk_build_value(&whichconn, T_INTEGER);
00282 args[3] = __mgk_build_value(&count, T_INTEGER);
00283 if (__mgk_remote_call(rn->host,
00284 cmd_clear_node_output_port,
00285 4, args,
00286 1, rargs)) {
00287 mgk_data_type t;
00288 mgk_scalar s;
00289 int *errp = __mgk_extract_value(rargs[0], &t, &s);
00290 if (t == T_INTEGER) {
00291 return (mgk_errno = *errp);
00292 }
00293 }
00294 return (mgk_errno = E_COMM);
00295 }
00296 if (!__mgk_check_node(node)) {
00297 return (mgk_errno = E_NOTNODE);
00298 }
00299 if (port >= node->nout) {
00300 return (mgk_errno = E_BADPORTIX);
00301 }
00302 for (lp = node->outs[port].links, idx = 0, done_any = 0;
00303 lp;
00304 lp = lp->l.l2l.nextout, idx++) {
00305 if ((whichconn == MGK_ALL_OUTPUT_CONNECTIONS) || (whichconn == idx)) {
00306 switch (lp->type) {
00307 case LINK_L2L:
00308 break;
00309 case LINK_L2R:
00310 for (i = 0; i < count; i++) {
00311 if (!(vp = lp->l.l2r.head)) {
00312 break;
00313 }
00314 lp->l.l2r.head = vp->next;
00315 lp->l.l2r.qlen--;
00316 __mgk_free_value(vp);
00317 }
00318 break;
00319 default:
00320 return (mgk_errno = E_GENERROR);
00321 }
00322 done_any++;
00323 }
00324 }
00325 return (mgk_errno = (done_any ? E_SUCCESS : E_PORTCONN));
00326 }
00327
00328 DEFSVC(clear_node_output_port)
00329 {
00330 if ((argc == 4) && (rargc == 1)) {
00331 mgk_data_type t1, t2, t3, t4;
00332 long *idp = __mgk_parse_value(argv[0], &t1);
00333 int *idxp = __mgk_parse_value(argv[1], &t2);
00334 int *selp = __mgk_parse_value(argv[2], &t3);
00335 int *cntp = __mgk_parse_value(argv[3], &t4);
00336 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) &&
00337 (t3 == T_INTEGER) && (t4 == T_INTEGER)) {
00338 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00339 int res = mgk_clear_node_output_port(np, *idxp, *selp, *cntp);
00340 rargv[0] = __mgk_build_value(&res, T_INTEGER);
00341 return (TRUE);
00342 }
00343 }
00344 return (FALSE);
00345 }
00346
00347 unsigned int
00348 mgk_node_input_port_length(mgk_nodep node, unsigned int port)
00349 {
00350 mgk_inport *ip;
00351 if (__mgk_check_remnode(node)) {
00352 mgk_remnode *rn = (mgk_remnode *) node;
00353 mgk_value *args[2];
00354 mgk_value *rargs[2];
00355 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00356 args[1] = __mgk_build_value(&port, T_INTEGER);
00357 if (__mgk_remote_call(rn->host,
00358 cmd_node_input_port_length,
00359 2, args,
00360 2, rargs)) {
00361 mgk_data_type t1, t2;
00362 mgk_scalar s1, s2;
00363 int *lenp = __mgk_extract_value(rargs[0], &t1, &s1);
00364 int *errp = __mgk_extract_value(rargs[1], &t2, &s2);
00365 if ((t1 == T_INTEGER) && (t2 == T_INTEGER)) {
00366 mgk_errno = *errp;
00367 return (*lenp);
00368 }
00369 }
00370 return (mgk_errno = E_COMM);
00371 }
00372 if (!__mgk_check_node(node)) {
00373 mgk_errno = E_NOTNODE;
00374 return (MGK_U_BADVAL);
00375 }
00376 if (port >= node->nin) {
00377 mgk_errno = E_BADPORTIX;
00378 return (MGK_U_BADVAL);
00379 }
00380 ip = &node->ins[port];
00381 mgk_errno = E_SUCCESS;
00382 return (ip->qlen);
00383 }
00384
00385 DEFSVC(node_input_port_length)
00386 {
00387 if ((argc == 2) && (rargc == 2)) {
00388 mgk_data_type t1, t2;
00389 long *idp = __mgk_parse_value(argv[0], &t1);
00390 int *idxp = __mgk_parse_value(argv[1], &t2);
00391 if ((t1 == T_LONGINT) && (t2 == T_INTEGER)) {
00392 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00393 int res = mgk_node_input_port_length(np, *idxp);
00394 rargv[0] = __mgk_build_value(&res, T_INTEGER);
00395 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00396 return (TRUE);
00397 }
00398 }
00399 return (FALSE);
00400 }
00401
00402 unsigned int
00403 mgk_node_output_port_length(mgk_nodep node,
00404 unsigned int port,
00405 unsigned int whichconn)
00406 {
00407 mgk_link *lp;
00408 unsigned int len, idx, done_any;
00409 if (__mgk_check_remnode(node)) {
00410 mgk_remnode *rn = (mgk_remnode *) node;
00411 mgk_value *args[3];
00412 mgk_value *rargs[2];
00413 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00414 args[1] = __mgk_build_value(&port, T_INTEGER);
00415 args[2] = __mgk_build_value(&whichconn, T_INTEGER);
00416 if (__mgk_remote_call(rn->host,
00417 cmd_node_output_port_length,
00418 3, args,
00419 2, rargs)) {
00420 mgk_data_type t1, t2;
00421 mgk_scalar s1, s2;
00422 int *lenp = __mgk_extract_value(rargs[0], &t1, &s1);
00423 int *errp = __mgk_extract_value(rargs[1], &t2, &s2);
00424 if ((t1 == T_INTEGER) && (t2 == T_INTEGER)) {
00425 mgk_errno = *errp;
00426 return (*lenp);
00427 }
00428 }
00429 return (mgk_errno = E_COMM);
00430 }
00431 if (!__mgk_check_node(node)) {
00432 mgk_errno = E_NOTNODE;
00433 return (MGK_U_BADVAL);
00434 }
00435 if (port >= node->nout) {
00436 mgk_errno = E_BADPORTIX;
00437 return (MGK_U_BADVAL);
00438 }
00439 for (lp = node->outs[port].links, len = 0, idx = 0, done_any = 0;
00440 lp;
00441 lp = lp->l.l2l.nextout, idx++) {
00442 if ((whichconn == MGK_ALL_OUTPUT_CONNECTIONS) || (whichconn == idx)) {
00443 switch (lp->type) {
00444 case LINK_L2L:
00445 break;
00446 case LINK_L2R:
00447 len = max(len, lp->l.l2r.qlen);
00448 break;
00449 default:
00450 return (mgk_errno = E_GENERROR);
00451 }
00452 done_any++;
00453 }
00454 }
00455 mgk_errno = (done_any ? E_SUCCESS : E_PORTCONN);
00456 return (done_any ? len : MGK_U_BADVAL);
00457 }
00458
00459 DEFSVC(node_output_port_length)
00460 {
00461 if ((argc == 3) && (rargc == 2)) {
00462 mgk_data_type t1, t2, t3;
00463 long *idp = __mgk_parse_value(argv[0], &t1);
00464 int *idxp = __mgk_parse_value(argv[1], &t2);
00465 int *selp = __mgk_parse_value(argv[2], &t3);
00466 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) && (t3 == T_INTEGER)) {
00467 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00468 int res = mgk_node_output_port_length(np, *idxp, *selp);
00469 rargv[0] = __mgk_build_value(&res, T_INTEGER);
00470 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00471 return (TRUE);
00472 }
00473 }
00474 return (FALSE);
00475 }
00476
00477 void *
00478 mgk_peek_node_input_port(mgk_nodep node,
00479 unsigned int port,
00480 unsigned int streampos,
00481 mgk_data_type * typep)
00482 {
00483 mgk_inport *ip;
00484 mgk_value *vp;
00485 last_peek_value = NULL;
00486 if (__mgk_check_remnode(node)) {
00487 mgk_remnode *rn = (mgk_remnode *) node;
00488 mgk_value *args[3];
00489 mgk_value *rargs[2];
00490 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00491 args[1] = __mgk_build_value(&port, T_INTEGER);
00492 args[2] = __mgk_build_value(&streampos, T_INTEGER);
00493 if (__mgk_remote_call(rn->host,
00494 cmd_peek_node_input_port,
00495 3, args,
00496 2, rargs)) {
00497 mgk_data_type t;
00498 mgk_scalar s;
00499 int *errp = __mgk_extract_value(rargs[1], &t, &s);
00500 if (t == T_INTEGER) {
00501 static int rcnt = 0;
00502 static mgk_scalar sres[16];
00503 mgk_errno = *errp;
00504 return (__mgk_extract_value(rargs[0], typep, &sres[++rcnt & 15]));
00505 }
00506 __mgk_free_value(rargs[0]);
00507 }
00508 mgk_errno = E_COMM;
00509 *typep = T_NODATA;
00510 return (NULL);
00511 }
00512 if (!__mgk_check_node(node)) {
00513 mgk_errno = E_NOTNODE;
00514 *typep = T_NODATA;
00515 return (MGK_P_BADVAL);
00516 }
00517 if (port >= node->nin) {
00518 mgk_errno = E_BADPORTIX;
00519 *typep = T_NODATA;
00520 return (MGK_P_BADVAL);
00521 }
00522 ip = &node->ins[port];
00523 mgk_errno = E_SUCCESS;
00524 for (vp = ip->head; streampos > 0; streampos--, vp = vp->next) {
00525 if (!vp) {
00526 *typep = T_NODATA;
00527 return (NULL);
00528 }
00529 }
00530 last_peek_value = vp;
00531 return (__mgk_parse_value(vp, typep));
00532 }
00533
00534 DEFSVC(peek_node_input_port)
00535 {
00536 if ((argc == 3) && (rargc == 2)) {
00537 mgk_data_type t1, t2, t3;
00538 long *idp = __mgk_parse_value(argv[0], &t1);
00539 int *idxp = __mgk_parse_value(argv[1], &t2);
00540 int *posp = __mgk_parse_value(argv[2], &t3);
00541 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) && (t3 == T_INTEGER)) {
00542 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00543 void *value = mgk_peek_node_input_port(np, *idxp, *posp, &t1);
00544 if ((value) &&
00545 (last_peek_value) &&
00546 (mgk_errno == E_SUCCESS) &&
00547 (t1 != T_NODATA)) {
00548 rargv[0] = __mgk_alias_value(last_peek_value);
00549 }
00550 else {
00551 int dummy = 0;
00552 rargv[0] = __mgk_build_value(&dummy, T_INTEGER);
00553 rargv[0]->type = T_NODATA;
00554 }
00555 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00556 return (TRUE);
00557 }
00558 }
00559 return (FALSE);
00560 }
00561
00562
00563 void *
00564 mgk_peek_node_output_port(mgk_nodep node,
00565 unsigned int port,
00566 unsigned int whichconn,
00567 unsigned int streampos,
00568 mgk_data_type * typep)
00569 {
00570 mgk_link *lp;
00571 mgk_value *vp;
00572 unsigned int idx;
00573 last_peek_value = NULL;
00574 if (__mgk_check_remnode(node)) {
00575 mgk_remnode *rn = (mgk_remnode *) node;
00576 mgk_value *args[4];
00577 mgk_value *rargs[2];
00578 args[0] = __mgk_build_value(&rn->ID, T_LONGINT);
00579 args[1] = __mgk_build_value(&port, T_INTEGER);
00580 args[2] = __mgk_build_value(&whichconn, T_INTEGER);
00581 args[3] = __mgk_build_value(&streampos, T_INTEGER);
00582 if (__mgk_remote_call(rn->host,
00583 cmd_peek_node_output_port,
00584 4, args,
00585 2, rargs)) {
00586 mgk_data_type t;
00587 mgk_scalar s;
00588 int *errp = __mgk_extract_value(rargs[1], &t, &s);
00589 if (t == T_INTEGER) {
00590 static int rcnt = 0;
00591 static mgk_scalar sres[16];
00592 mgk_errno = *errp;
00593 return (__mgk_extract_value(rargs[0], typep, &sres[++rcnt & 15]));
00594 }
00595 __mgk_free_value(rargs[0]);
00596 }
00597 mgk_errno = E_COMM;
00598 *typep = T_NODATA;
00599 return (NULL);
00600 }
00601 if (!__mgk_check_node(node)) {
00602 mgk_errno = E_NOTNODE;
00603 *typep = T_NODATA;
00604 return (MGK_P_BADVAL);
00605 }
00606 if (port >= node->nout) {
00607 mgk_errno = E_BADPORTIX;
00608 *typep = T_NODATA;
00609 return (MGK_P_BADVAL);
00610 }
00611 for (lp = node->outs[port].links, vp = NULL, idx = 0;
00612 lp;
00613 lp = lp->l.l2l.nextout, idx++) {
00614 if (whichconn == idx) {
00615 switch (lp->type) {
00616 case LINK_L2L:
00617 break;
00618 case LINK_L2R:
00619 vp = lp->l.l2r.head;
00620 break;
00621 default:
00622 mgk_errno = E_GENERROR;
00623 *typep = T_NODATA;
00624 return (NULL);
00625 }
00626 break;
00627 }
00628 }
00629 if (!lp) {
00630 *typep = T_NODATA;
00631 mgk_errno = E_PORTCONN;
00632 return (NULL);
00633 }
00634 mgk_errno = E_SUCCESS;
00635 while (vp && (streampos > 0)) {
00636 vp = vp->next;
00637 streampos--;
00638 }
00639 if (!vp) {
00640 *typep = T_NODATA;
00641 return (NULL);
00642 }
00643 last_peek_value = vp;
00644 return (__mgk_parse_value(vp, typep));
00645 }
00646
00647 DEFSVC(peek_node_output_port)
00648 {
00649 if ((argc == 4) && (rargc == 2)) {
00650 mgk_data_type t1, t2, t3, t4;
00651 long *idp = __mgk_parse_value(argv[0], &t1);
00652 int *idxp = __mgk_parse_value(argv[1], &t2);
00653 int *selp = __mgk_parse_value(argv[2], &t3);
00654 int *posp = __mgk_parse_value(argv[3], &t4);
00655 if ((t1 == T_LONGINT) && (t2 == T_INTEGER) &&
00656 (t3 == T_INTEGER) && (t4 == T_INTEGER)) {
00657 mgk_node *np = __mgk_retrieve_node_by_ID(*idp);
00658 void *value = mgk_peek_node_output_port(np, *idxp, *selp, *posp, &t1);
00659 if ((value) &&
00660 (last_peek_value) &&
00661 (mgk_errno == E_SUCCESS) &&
00662 (t1 != T_NODATA)) {
00663 rargv[0] = __mgk_alias_value(last_peek_value);
00664 }
00665 else {
00666 int dummy = 0;
00667 rargv[0] = __mgk_build_value(&dummy, T_INTEGER);
00668 rargv[0]->type = T_NODATA;
00669 }
00670 rargv[1] = __mgk_build_value(&mgk_errno, T_INTEGER);
00671 return (TRUE);
00672 }
00673 }
00674 return (FALSE);
00675 }
