STDMETHODIMP CPyMFC_CustomProtocol::Start(
LPCWSTR szUrl,
IInternetProtocolSink *pIProtSink,
IInternetBindInfo *pIBindInfo,
DWORD grfSTI,
DWORD dwReserved)
{
HRESULT hr = S_OK;
bool ret = doCallback(szUrl);
if (!ret) {
return INET_E_CANNOT_CONNECT;
}
pIProtSink->ReportProgress(BINDSTATUS_FINDINGRESOURCE, szUrl);
pIProtSink->ReportProgress(BINDSTATUS_CONNECTING, szUrl);
pIProtSink->ReportProgress(BINDSTATUS_SENDINGREQUEST, szUrl);
pIProtSink->ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, m_mimetype);
pIProtSink->ReportData(BSCF_FIRSTDATANOTIFICATION, 0, 1000);
pIProtSink->ReportData(BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE, 1000, 1000);
/* }
else
{
if (grfSTI & PI_PARSE_URL)
hr = S_FALSE;
}
*/
return hr;
}
void
DCMsg::callMessageReceiveFailed( DCMessenger *messenger )
{
deliveryStatus( DELIVERY_FAILED );
messageReceiveFailed( messenger );
doCallback();
}
virtual void handleMIDIEvent(AUMIDIEvent const& midiEvent) override {
if (midiEvent.length != 3) return;
uint8_t status = midiEvent.data[0];
uint8_t data1 = midiEvent.data[1];
uint8_t data2 = midiEvent.data[2];
doCallback(status, data1, data2);
}
void disposePacket(BCSPStack * stack,Packet *pkt)
{
if (!pkt) return ;
doCallback(pkt->request,transferCancelled) ;
//it doesn't matter which mode we use since they're all
//going to be freed anyway
returnPacketToPool(stack,pkt,modeRCV) ;
}
void Loop::doSubmit(Ref<Future> fut, Ref<Object> f, Ref<Tuple> args, Ref<Dict> kw){
f->py_check_callable();
doCallback([fut=std::move(fut), f=std::move(f), args=std::move(args), kw=std::move(kw)](){
fut->set_from3(f, args, kw);
return;
});
return;
}
void ScriptTcl::runController(int task) {
scriptBarrier.publish(barrierStep++,task);
suspend();
#ifdef NAMD_TCL
if ( task == SCRIPT_RUN || task == SCRIPT_CONTINUE || task == SCRIPT_MINIMIZE ) {
doCallback(state->callback_labelstring.c_str(),
state->callback_valuestring.c_str());
}
#endif
}
AlarmNode* AlarmNode::findNow(int N, time_t time) {
if (N==0) {
return this;
} else if (next->getNextTrigger() > time && next!=this) {
doCallback();
return next;
} else {
return findNow(N-1,time);
}
}
DCMsg::MessageClosureEnum
DCMsg::callMessageReceived(
DCMessenger *messenger, Sock *sock )
{
deliveryStatus( DELIVERY_SUCCEEDED );
MessageClosureEnum closure = messageReceived( messenger, sock );
if( closure == MESSAGE_FINISHED ) {
doCallback();
}
return closure;
}
void disposeTransferRequestQueue(BCSPStack * stack,BCTransferRequestQueue * q)
{
BCTransferRequest * req ;
while ((req = ASYNCBLKgetTransferRequestFromQueue(stack,q)))
{
// originally we got a packet here and used disposePacket to do the
// appropriate callback but that led to problems with pool accounting
// causing a block and thus exception. So it's easier (and safer)
//just to call the callback directly
doCallback(req,transferCancelled) ;
}
}
bool IRC::receiveMessage(uint8_t MSG_ID, uint8_t callingThreadID, void* cdata) {
bool lRetval = false;
//std::cerr << "IRCthread msg received." << std::endl;
if(MSG_THREAD_START_WORK == MSG_ID) {
std::cerr << "Begin connect to server." << std::endl;
lRetval = connectToServer();
std::cerr << "Connected to server as \"" << mMyNick << "\"" << std::endl;
if(cdata) delete(static_cast<ClientQueryData*>(cdata));
} else if(MSG_QUERY_REPLY == MSG_ID) {
//handleReply(static_cast<ClientQueryData*>(cdata));
doCallback(cdata);
//delete(cdata);
}
return(lRetval);
}
int getStrokeman(void) {
int (*getRandCallBack)(void) = getRand; // pointer to function callbackFun
return doCallback(getRandCallBack); // pass pointer to function as an argument to function
}
// feed the parser with a char
// return value:
// 1 if needs more chars
// 0 if finished
// -1 if error
uint8_t JSONStreamingParser::feed(char c)
{
switch(state)
{
// on error, just drop chars and return state
case PARSER_ERROR:
case PARSER_FINISHED:
return state;
// on idle, espect { opening character, skipping blanks
case PARSER_IDLE:
if(isspace(c))
return state;
if(c != '{')
{
state = PARSER_ERROR;
return state;
}
state = PARSER_WAIT_NAME;
flags = 0;
return state;
case PARSER_WAIT_NAME:
// skip spaces
if(isspace(c))
return state;
// we can have quotes or double quotes here
if(c != '"' && c != '\'')
{
state = PARSER_ERROR;
return state;
}
if(c == '"')
flags = IN_DQUOTES;
else
flags = IN_QUOTES;
// switch to reading name
clearName();
state = PARSER_NAME;
return state;
case PARSER_NAME:
// first, look at special state after a backslash
if(flags & IN_BACKSLASH)
{
appendName(c);
flags &= ~IN_BACKSLASH;
return state;
}
else if(c == '\\')
{
flags |= IN_BACKSLASH;
return state;
}
switch(c)
{
case '"':
if((flags & IN_QUOTES))
{
appendName(c);
return state;
}
// switch to semicolon state
state = PARSER_WAIT_SEMICOLON;
flags = 0;
return state;
case '\'':
if((flags & IN_DQUOTES))
{
appendName(c);
return state;
}
// switch to semicolon state
state = PARSER_WAIT_SEMICOLON;
flags = 0;
return state;
case ':':
if( (flags & IN_QUOTES) || (flags & IN_DQUOTES))
{
appendName(c);
return state;
}
state = PARSER_WAIT_VALUE;
flags = 0;
return state;
case 0:
state = PARSER_ERROR;
return state;
default:
appendName(c);
return state;
} // switch(c)
case PARSER_WAIT_SEMICOLON:
if(isspace(c))
return state;
if(c != ':')
{
state = PARSER_ERROR;
return state;
}
state = PARSER_WAIT_VALUE;
flags = 0;
return state;
case PARSER_WAIT_VALUE:
if(isspace(c))
return state;
// value can be a simple type, a list or an array
// check latter 2 before
if(c == '{')
{
doCallback("<LIST>");
level++;
// mark current level as list
levels = levels << 1;
clearName();
state = PARSER_WAIT_NAME;
flags = 0;
return state;
}
else if(c == '[')
{
doCallback("<ARRAY>");
level++;
// mark current level as array
levels = (levels << 1) | 0x01;
clearName();
state = PARSER_WAIT_VALUE;
flags = 0;
return state;
}
else if(c == '"')
{
flags = IN_DQUOTES;
clearValue();
appendValue(c);
state = PARSER_VALUE;
return state;
}
else if(c == '\'')
{
flags = IN_QUOTES;
clearValue();
appendValue(c);
state = PARSER_VALUE;
return state;
}
else if(c == '}' || c == ']')
{
if(level <= 0)
{
if(c == '}')
state = PARSER_FINISHED;
else
state = PARSER_ERROR;
return state;
}
level--;
levels >>= 1;
state = PARSER_WAIT_SEPARATOR;
return state;
}
else
{
flags = 0;
clearValue();
appendValue(c);
state = PARSER_VALUE;
return state;
}
case PARSER_VALUE:
if(flags & IN_BACKSLASH)
{
flags &= ~IN_BACKSLASH;
appendValue(c);
return state;
}
else if(c == '\\')
{
flags |= IN_BACKSLASH;
return state;
}
else if( ((c == '"') && (flags & IN_DQUOTES)) || ((c == '\'') && (flags & IN_QUOTES)))
{
flags = 0;
appendValue(c);
doCallback();
state = PARSER_WAIT_SEPARATOR;
return state;
}
else if( (flags & IN_QUOTES) || (flags & IN_DQUOTES))
{
appendValue(c);
return state;
}
else if(isalnum(c) || c == '_' || c == '.' || c == '-')
{
appendValue(c);
return state;
}
else if(c == ',')
{
flags = 0;
doCallback();
if(levels &0x01)
state = PARSER_WAIT_VALUE;
else
state = PARSER_WAIT_NAME;
return state;
}
else if(isspace(c))
{
flags = 0;
doCallback();
state = PARSER_WAIT_SEPARATOR;
return state;
}
else if(c == '}' || c == ']')
{
if(level <= 0)
{
if(c == '}')
state = PARSER_FINISHED;
else
state = PARSER_ERROR;
return state;
}
doCallback();
level--;
levels = levels >> 1;
state = PARSER_WAIT_SEPARATOR;
return state;
}
else
{
void stopNote(int note) {
doCallback(0x80, note, 0);
}
void startNote(int note, int velocity) {
doCallback(0x90, note, velocity);
}
