Bitu readw(PhysPt addr) {
addr = PAGING_GetPhysicalAddress(addr) & vgapages.mask;
addr += vga.svga.bank_read_full;
addr = CHECKED2(addr);
return
(readHandler(addr+0) << 0) |
(readHandler(addr+1) << 8);
}
Bitu readd(PhysPt addr) {
addr = PAGING_GetPhysicalAddress(addr) & 0xffff;
return
(readHandler(addr+0) << 0) |
(readHandler(addr+1) << 8) |
(readHandler(addr+2) << 16) |
(readHandler(addr+3) << 24);
}
Bitu readd(PhysPt addr) {
addr = PAGING_GetPhysicalAddress(addr) & vgapages.mask;
addr += vga.svga.bank_read_full;
addr = CHECKED2(addr);
Bitu ret = (readHandler(addr+0) << 0);
ret |= (readHandler(addr+1) << 8);
ret |= (readHandler(addr+2) << 16);
ret |= (readHandler(addr+3) << 24);
return ret;
}
void AsyncMockStreamFactory::MockStream::read(asio::mutable_buffer buf,
StreamHandler&& readHandler) {
// Suspend execution before data is read.
_defer(kBlockedBeforeRead,
[this, buf, readHandler]() {
stdx::unique_lock<stdx::mutex> lk(_mutex);
auto nextRead = std::move(_readQueue.front());
_readQueue.pop();
auto beginDst = asio::buffer_cast<uint8_t*>(buf);
auto nToCopy = std::min(nextRead.size(), asio::buffer_size(buf));
auto endSrc = std::begin(nextRead);
std::advance(endSrc, nToCopy);
auto endDst = std::copy(std::begin(nextRead), endSrc, beginDst);
invariant((endDst - beginDst) == static_cast<std::ptrdiff_t>(nToCopy));
log() << "read " << nToCopy << " bytes, " << (nextRead.size() - nToCopy)
<< " remaining in buffer";
lk.unlock();
_io_service->post(
[readHandler, nToCopy] { readHandler(std::error_code(), nToCopy); });
});
}
void AsyncMockStreamFactory::MockStream::read(asio::mutable_buffer buf,
StreamHandler&& readHandler) {
// Suspend execution before data is read.
_defer(kBlockedBeforeRead,
[this, buf, readHandler]() {
stdx::unique_lock<stdx::mutex> lk(_mutex);
int nToCopy = 0;
// If we've set an error, return that instead of a read.
if (!_error) {
auto nextRead = std::move(_readQueue.front());
_readQueue.pop();
auto beginDst = asio::buffer_cast<uint8_t*>(buf);
nToCopy = std::min(nextRead.size(), asio::buffer_size(buf));
auto endSrc = std::begin(nextRead);
std::advance(endSrc, nToCopy);
auto endDst = std::copy(std::begin(nextRead), endSrc, beginDst);
invariant((endDst - beginDst) == static_cast<std::ptrdiff_t>(nToCopy));
log() << "read " << nToCopy << " bytes, " << (nextRead.size() - nToCopy)
<< " remaining in buffer";
}
auto handler = readHandler;
// If we did not receive all the bytes, we should return an error
if (static_cast<size_t>(nToCopy) < asio::buffer_size(buf)) {
handler = [readHandler](std::error_code ec, size_t len) {
// If we have an error here we've been canceled, and that takes precedence
if (ec)
return readHandler(ec, len);
// Call the original handler with an error
readHandler(make_error_code(ErrorCodes::InvalidLength), len);
};
}
checkCanceled(_io_service, &_state, std::move(handler), nToCopy, _error);
_error.clear();
});
}
/**
@return Returns a boolean for whether the handler is currently suspended or not.
*/
v8::Handle<v8::Value> _isSuspended(const v8::Arguments& args)
{
EmersonScript* caller;
JSEventHandlerStruct* handler;
readHandler(args,caller,handler);
if (handler == NULL)
return v8::ThrowException( v8::Exception::Error(v8::String::New("Cannot suspend: handler has already been cleared.")));
return v8::Boolean::New(handler->getIsSuspended());
}
/**
Resuming a suspended handler allows it to be triggered in response to message events.
*/
v8::Handle<v8::Value> _resume(const v8::Arguments& args)
{
EmersonScript* caller;
JSEventHandlerStruct* handler;
readHandler(args,caller,handler);
if (handler == NULL)
return v8::ThrowException( v8::Exception::Error(v8::String::New("Cannot resume: handler has already been cleared.")));
handler->resume();
return v8::Undefined();
}
/**
For debugging mostly. Prints the pattern that this message handler matches
*/
v8::Handle<v8::Value> _printContents(const v8::Arguments& args)
{
//get the target object whose context owns it.
//and the pattern and the callback associated with this
EmersonScript* caller;
JSEventHandlerStruct* handler;
readHandler(args,caller,handler);
if (handler == NULL)
return v8::ThrowException( v8::Exception::Error(v8::String::New("Cannot print contents: handler has already been cleared.")));
//print all handler stuff
handler->printHandler();
return v8::Undefined();
}
/**
When clear a handler, handler will never be triggered again (even if call
resume on it).
*/
v8::Handle<v8::Value> _clear(const v8::Arguments& args)
{
EmersonScript* caller;
JSEventHandlerStruct* handler;
readHandler(args,caller,handler);
if (handler == NULL)
return v8::ThrowException( v8::Exception::Error(v8::String::New("Cannot clear: handler has already been cleared.")));
//handler has not been deleted, and we need to do so now inside of
//JSObjectScript (so can also remove from event handler vector).
caller->deleteHandler(handler);
//set the internal field of the vector to be null
setNullHandler(args);
return v8::Undefined();
}
void TCPConnection::startInternal() {
beetle.readers.add(sockfd, [this] {
if (stopped) {
return;
}
uint8_t buf[256];
uint8_t len;
// read length of ATT message
int bytesRead = SSL_read(ssl, &len, sizeof(len));
if (bytesRead <= 0) {
if (debug_socket) {
std::stringstream ss;
ss << "socket errno: " << strerror(errno);
pdebug(ss.str());
}
stopInternal();
} else {
assert(bytesRead == 1);
if (debug_socket) {
pdebug("tcp expecting " + std::to_string(len) + " bytes");
}
time_t startTime = time(NULL);
struct timeval defaultTimeout;
defaultTimeout.tv_sec = 0;
defaultTimeout.tv_usec = 100000;
fd_set fdSet;
FD_ZERO(&fdSet);
FD_SET(sockfd, &fdSet);
// read payload ATT message
bytesRead = 0;
while (!stopped && bytesRead < len) {
if (difftime(time(NULL), startTime) > TIMEOUT_PAYLOAD) {
if (debug_socket) {
pdebug("timed out reading payload");
}
stopInternal();
break;
}
int result = SSL_pending(ssl);
if (result <= 0) {
struct timeval timeout = defaultTimeout;
fd_set readFds = fdSet;
fd_set exceptFds = fdSet;
result = select(sockfd + 1, &readFds, NULL, &exceptFds, &timeout);
if (result < 0) {
if (debug_socket) {
std::stringstream ss;
ss << "select failed : " << strerror(errno);
pdebug(ss.str());
}
stopInternal();
break;
}
}
if (result > 0) {
int n = SSL_read(ssl, buf + bytesRead, len - bytesRead);
if (n < 0) {
if (debug_socket) {
std::cerr << "socket errno: " << strerror(errno) << std::endl;
}
stopInternal();
break;
} else {
bytesRead += n;
}
}
}
if (bytesRead < len) {
return;
}
if (debug_socket) {
phex(buf, bytesRead);
pdebug("read " + std::to_string(bytesRead) + " bytes from " + getName());
}
readHandler(buf, bytesRead);
}
});
}
Bitu readb(PhysPt addr) {
addr = PAGING_GetPhysicalAddress(addr) & 0xffff;
return readHandler(addr);
}
void X86AsmGenerator::run(){
genX86Asm(".intel_syntax noprefix");
//设置writeExpr_16
genX86Asm(WRITE_EXPR_HEX":");
genX86Asm(".string \"%x\"");
// genX86Asm(".string \"%x\\n\"");
//设置writeExpr_10
genX86Asm(WRITE_EXPR_DEC":");
genX86Asm(".string \"%d\"");
// genX86Asm(".string \"%d\\n\"");
//设置读语句
genX86Asm(READ_STAT":");
genX86Asm(".string \"%d\\0\"");
genX86Asm("");
genX86Asm(".text");
genX86Asm(".globl "MAIN_FUNC_NAME);
genX86Asm(".def "MAIN_FUNC_NAME);
genX86Asm("");
//prehandle write
for (auto it = midCodes.begin(); it != midCodes.end(); ++it) {
curMidCode = *it;
if (curMidCode.op == writeLnString) {
++writeStringCount;
genX86Asm(STRING_AREA_NAME + intToString(writeStringCount) + ":");
genX86Asm(" .string \"" + curMidCode.arg1 + "\"");
}
}
genX86Asm("");
writeStringCount = 0;
//设置SET_DYNAMIC_BASE_ADDR_REG函数
genX86Asm(SET_DYNAMIC_BASE_ADDR_REG ":");
genX86Asm("mov ecx, 0"); //2015.12.13
genX86Asm("mov eax, DWORD ptr [esp+4]");
genX86Asm("mov ebx, ebp");
genX86Asm(PUSH_STATIC_CHAIN_LOOP_TARGET_NAME + intToString(0) + ":");
genX86Asm("mov ebx, DWORD ptr [ebx+" + intToString(STATIC_CHAIN_ADDR) + "]");
genX86Asm("add ecx, 1");
genX86Asm("cmp ecx, eax");
genX86Asm("jl " PUSH_STATIC_CHAIN_LOOP_TARGET_NAME + intToString(0));
genX86Asm("ret\n");
//all handle
for (auto it = midCodes.begin(); it != midCodes.end(); ++it) {
curMidCode = *it;
if (curMidCode.symbolTableIndex != -1) {
curSymbolTable = &(symbolTables.at(curMidCode.symbolTableIndex));
curLevel = curSymbolTable->size() - 1;
}
switch(curMidCode.op) {
case genTarget: genTargetHandler(); break;
case initialCallee: initialCalleeHandler(); break;
case endCallee: endCalleeHandler(); break;
case callFunc: callFuncOrProcHandler(); genX86Asm("push eax"); break;
case callProc: callFuncOrProcHandler(); break;
case storeVar: storeVarHandler(); break;
case storeArrayItem: storeArrayIemHandler(); break;
case writeLnString: writeLnStringHandler(); break;
case writeLnExpr: writeLnExprHandler(); break;
case writeChar: writeCharHandler(); break;
case read: readHandler(); break;
case arr: arrHandler(); break;
case push: pushHandler(); break;
case pushRef: pushRefHandler(); break;
case jmp:
case je:
case jne:
case jl:
case jle:
case jg:
case jge: jStatesHandler();break;
case opAdd:
case opSub:
case opMul:
case opDiv: opCalcHandler(); break;
case selfAddOne:
case selfSubOne: selfOpOneHandler(); break;
default: break;
}
genX86Asm("");
}
genX86Asm("leave");
genX86Asm("ret");
}
/** @brief check select pool and process client reqeusts
*
* @param pool select pool
* @return void
*/
void SelPool::check_clients()
{
int connfd;
vector<ClientConnection*>::iterator it = clients.begin();
while ( it != clients.end() )
{
ClientConnection *client = *it;
connfd = client->getFd();
printf("Handling %d\n", connfd);
/* Client Connection State Machine */
switch ( client->getState() )
{
case ClientConnection::Ready_ForRead:
{
printf("Client State: Ready_ForRead\n");
/* read ready client socket */
if (FD_ISSET(connfd, &read_set))
{
readHandler(client);
if (client->getState() == ClientConnection::Request_Parsed)
{
processHandler(client);
/* if the client is closed after processing */
if (client->getState() == ClientConnection::Closed)
{
Socket::Close_Socket(connfd);
FD_CLR(connfd, &read_set);
delete client;
clients.erase(it);
continue;
}
writeHandler(client);
}
}
break;
}
case ClientConnection::Request_Parsed: {
printf("Client State: Request_Parsed\n");
break;
}
case ClientConnection::Writing_Response:
{
printf("Client State: Writing_Response\n");
if (FD_ISSET(connfd, &write_set))
{
if (!client->getRequest()->isCGIRequest())
{
processHandler(client);
writeHandler(client);
}
else if (FD_ISSET(client->getResponse()->getCGIout(), &read_set))
{
/* CGI request : if CGIout is also ready for reading */
pipeHandler(client);
writeHandler(client);
}
}
break;
}
case ClientConnection::Done_Response: {
printf("Client State: Done_Response\n");
break;
}
default: {
break;
}
}
it++;
}
}
