/* begincopyright Copyright (c) 1988 Xerox Corporation. All rights reserved. Use and copying of this software and preparation of derivative works based upon this software are permitted. Any distribution of this software or derivative works must comply with all applicable United States export control laws. This software is made available AS IS, and Xerox Corporation makes no warranty about the software, its performance or its conformity to any specification. Any person obtaining a copy of this software is requested to send their name and post office or electronic mail address to: PCR Coordinator Xerox PARC 3333 Coyote Hill Rd. Palo Alto, CA 94304 endcopyright */ /* * CedarCirioNubProcs.c * * A collection of procs to examine Cedar Typecodes * * Demers, March 3, 1992 5:09:57 pm PST * Horton, March 5, 1992 4:50:30 pm PST * Horton, March 9, 1992 1:02:13 pm PST */ #define CCNP←DEBUG 0 #define DYNAMIC←C←LOOKUP 0 /* #include "xr/CirioNubProtocol.h" */ #include "xr/CirioNubMarshall.h" #include "CedarCirioNubProcs.h" /* #include "xr/CirioNubEnvironment.h" */ #include "xr/CirioNubInstall.h" #if DYNAMIC←C←LOOKUP # include "xr/IncrementalLoad.h" #endif #if CCNP←DEBUG # include "xr/ThreadsMsg.h" /* for XR←ConsoleMsg debug msgs */ #endif /* * The following two utilities are stolen directly from Interp.c ... * call from thread only. */ #if DYNAMIC←C←LOOKUP int CedarCirioNubLookupCProc(name, valp) char *name; unsigned *valp; { XR←ILSymEntry ilse; char *altText; ilse = XR←ILGetMatchingSymEntryByName( NIL, name, TRUE, WANT←ALL←TYPES, IGNORE←INTERNAL, 0 ); if( ilse == NIL ) { ilse = XR←ILGetMatchingSymEntryByName( NIL, name, TRUE, WANT←ALL←TYPES, IGNORE←NONE, 0 ); } if( (ilse == NIL) && (name[0] != '←') ) { altText = (char *)XR←malloc(2+strlen(name)); altText[0] = '←'; (void)strcpy(&(altText[1]), name); ilse = XR←ILGetMatchingSymEntryByName( NIL, altText, TRUE, WANT←ALL←TYPES, IGNORE←INTERNAL, 0 ); if( ilse == NIL ) { ilse = XR←ILGetMatchingSymEntryByName( NIL, altText, TRUE, WANT←ALL←TYPES, IGNORE←NONE, 0 ); } } if( ilse == NIL ) { return (-1); } *valp = ((unsigned)(ilse->ilse←value)); return 0; } #endif int CedarCirioNubLookupCedarProc(interfaceName, procName, procp) char *interfaceName; char *procName; XR←MesaProc *procp; { static XR←MesaProc ((*procFromNamedInterface)()) = NIL; int ans; char *tailP, *dotP; XR←MesaProc cedarProcValue; # if CCNP←DEBUG XR←ConsoleMsg("CirioNubBinding to %s %s ... ", interfaceName, procName); # endif if( (interfaceName == NIL) || (procName == NIL) ) return (-1); # if DYNAMIC←C←LOOKUP if( procFromNamedInterface == NIL ) { ans = CedarCirioNubLookupCProc( "XR←ProcFromNamedInterface", &procFromNamedInterface ); if( ans < 0 ) return ans; } # else { extern XR←MesaProc XR←ProcFromNamedInterface(); procFromNamedInterface = XR←ProcFromNamedInterface; } # endif cedarProcValue = (*procFromNamedInterface)(interfaceName, procName, NIL, 0); # if CCNP←DEBUG XR←ConsoleMsg("result 0x%x ", cedarProcValue); if( cedarProcValue ) XR←ConsoleMsg( "(0x%x 0x%x)", cedarProcValue->mp←proc, cedarProcValue->mp←x ); XR←ConsoleMsg("\n"); # endif if( cedarProcValue == NIL ) { return(-1); } (*procp) = cedarProcValue; return 0; } /* * Binding to MesaLoadState ... * * This initialization must be called from a thread before the debug nub * starts running in its slave IOP. */ static XR←MesaProc mpGetTypestring = NIL; static XR←MesaProc mpGetTypecode = NIL; static XR←MesaProc mpGetConcreteTypecode = NIL; static void CedarCirioNubBindToLoadStateProcs() { (void)CedarCirioNubLookupCedarProc( "MesaLoadStateBackdoor", "UnmonitoredTypeStringFromType", &mpGetTypestring ); (void)CedarCirioNubLookupCedarProc( "MesaLoadStateBackdoor", "UnmonitoredFindTypeFromTypeString", &mpGetTypecode ); (void)CedarCirioNubLookupCedarProc( "MesaLoadState", "ConcreteTypeFromAbstractType", &mpGetConcreteTypecode ); } /* * Exported Cirio Nub Procs ... */ #define MESA←STRING←MAXLEN 4000 typedef struct MesaStringRep { unsigned short ms←len; unsigned short ms←maxLen; char ms←data[MESA←STRING←MAXLEN]; } * MesaString; CirioNubRetCode CedarCirioNubServeGetTypestring(argc, args) int argc; unsigned *args; { XR←MesaProc mp = mpGetTypestring; int ans; CirioNubRetCode rc; struct CirioNubCedarTypeCodeRep tc; MesaString ms; # if CCNP←DEBUG XR←ConsoleMsg("CirioNub GetTypestring argc %d\n", argc); # endif if( argc != 1 ) return( cnrc←badArgs ); tc.typeCode = (unsigned long)(args[0]); if( mp == NIL ) return cnrc←noProc; ms = (MesaString) ((*(mp->mp←proc))(tc.typeCode, mp)); if( ms == NIL ) { # if CCNP←DEBUG XR←ConsoleMsg("GetTypestring fails ms == NIL\n"); # endif return cnrc←badArgs; /* ??? */ } # if CCNP←DEBUG XR←ConsoleMsg("GetTypestring res len %d\n", ms->ms←len); # endif if( (rc = CirioNubPutBlock8(ms->ms←data, ms->ms←len)) != cnrc←ok ) return rc; return cnrc←ok; } CirioNubRetCode CedarCirioNubServeGetTypecode(argc, args) int argc; unsigned *args; { int ans, len; CirioNubRetCode rc; XR←MesaProc mp = mpGetTypecode; struct { long fnd; struct CirioNubCedarTypeCodeRep tc; } resultRec; struct MesaStringRep ms; # if CCNP←DEBUG XR←ConsoleMsg("CirioNub GetTypecode argc %d ", argc); if( argc >= 1 ) XR←ConsoleMsg("len %d", (int)(args[0])); XR←ConsoleMsg("\n"); # endif if( argc != 2 ) return cnrc←badArgs; len = (int)(args[0]); if( len > MESA←STRING←MAXLEN ) return cnrc←badArgs; ms.ms←len = len; ms.ms←maxLen = MESA←STRING←MAXLEN; bcopy( (char *)(args[1]), ms.ms←data, len); if( mp == NIL ) return cnrc←noProc; (*(mp->mp←proc))(&resultRec, &ms, mp); # if CCNP←DEBUG XR←ConsoleMsg("CirioNub GetTypecode res %d 0x%x\n", resultRec.fnd, resultRec.tc.typeCode ); # endif if( (rc = CirioNubPutCard32(resultRec.fnd)) != cnrc←ok ) return rc; if( (rc = CirioNubPutCard32(resultRec.tc.typeCode)) != cnrc←ok ) return rc; return cnrc←ok; } CirioNubRetCode CedarCirioNubServeGetConcreteTypecode(argc, args) int argc; unsigned *args; { XR←MesaProc mp = mpGetConcreteTypecode; int ans; CirioNubRetCode rc; struct CirioNubCedarTypeCodeRep abs; struct CirioNubCedarTypeCodeRep conc; # if CCNP←DEBUG XR←ConsoleMsg("CirioNub GetConcrete argc %d ", argc); if( argc >= 1 ) XR←ConsoleMsg("arg 0x%x", args[0]); XR←ConsoleMsg("\n"); # endif if( argc != 1 ) return cnrc←badArgs; abs.typeCode = (unsigned long)(args[0]); if( mp == NIL ) return cnrc←noProc; conc.typeCode = (*(mp->mp←proc))(abs.typeCode, mp); # if CCNP←DEBUG XR←ConsoleMsg("GetConcrete res 0x%x\n", conc.typeCode); # endif if( (rc = CirioNubPutCard32(conc.typeCode)) != cnrc←ok ) return rc; return cnrc←ok; } static CirioNubRetCode CedarCirioNubServeNull(argc, args) int argc; unsigned *args; { unsigned v; CirioNubRetCode rc; v = ((argc >= 1) ? args[0] : CEDAR←CIRIO←NUB←PROCS←VERSION); if( v < CEDAR←CIRIO←NUB←PROCS←LOW←VERSION ) { v = CEDAR←CIRIO←NUB←PROCS←LOW←VERSION; } else if( v > CEDAR←CIRIO←NUB←PROCS←VERSION ) { v = CEDAR←CIRIO←NUB←PROCS←VERSION; } if( (rc = CirioNubPutCard32(v)) != cnrc←ok ) return rc; return cnrc←ok; } int XR←run←CedarCirioNub() { CirioNubHandle h; if( (h = CirioNubGetDefaultHandle(0, 0)) == NIL ) return (-1); CedarCirioNubBindToLoadStateProcs(); (void)CirioNubRegisterCProc(h, CedarCirioNubProcID←Null, CedarCirioNubServeNull); (void)CirioNubRegisterCProc(h, CedarCirioNubProcID←GetTypestring, CedarCirioNubServeGetTypestring); (void)CirioNubRegisterCProc(h, CedarCirioNubProcID←GetTypecode, CedarCirioNubServeGetTypecode); (void)CirioNubRegisterCProc(h, CedarCirioNubProcID←GetConcreteTypecode, CedarCirioNubServeGetConcreteTypecode); return 0; }