bool sprite_instance::can_handle_mouse_event() // Return true if we have any mouse event handlers. { static const tu_stringi FN_NAMES[] = { "onKeyPress", "onRelease", "onDragOver", "onDragOut", "onPress", "onReleaseOutside", "onRollout", "onRollover", }; if (is_enabled()) { for (size_t i = 0; i < TU_ARRAYSIZE(FN_NAMES); i++) { as_value dummy; if (get_member(FN_NAMES[i], &dummy)) { return true; } } } return false; }
void as_global_textformat_ctor(const fn_call& fn) { gc_ptr<as_textformat> obj = new as_textformat(fn.get_player()); assert(unsigned(fn.nargs) <= TU_ARRAYSIZE(as_global_textformat_ctor_paramnames)); // TODO: check parameters type for (int i = 0; i < fn.nargs; i++) { obj->set_member(as_global_textformat_ctor_paramnames[i], fn.arg(i)); } fn.result->set_as_object(obj.get_ptr()); }
static const char* lookup_content_type(const char* file_extension) // Given a file extension, determine the HTTP content type to return. { static stringi_hash<const char*> s_types; static bool s_inited = false; if (!s_inited) { s_inited = true; // A small table of well-known content types. struct type_pair { const char* extension; const char* type; } types[] = { { "txt", "text/plain" }, { "html", "text/html" }, { "htm", "text/html" }, { "jpg", "image/jpeg" }, { "jpeg", "image/jpeg" }, { "gif", "image/gif" }, { "png", "image/png" }, { "js", "text/javascript" }, // etc. }; // Register the types. for (int i = 0, n = TU_ARRAYSIZE(types); i < n; i++) { s_types.add(tu_stringi(types[i].extension), types[i].type); } } const char* type = NULL; if (s_types.get(tu_stringi(file_extension), &type)) { return type; } // No known type for this file extension. return "application/octet-stream"; }
/*static*/ void http_server::parse_test() { // Test the parsing of the request line (first line). static struct reqline_test_vector { const char* reqline; http_status status; const char* method; const char* uri; int version_x256; } tests[] = { { "GET http://tulrich.com/index.html HTTP/1.1", HTTP_OK, "GET", "http://tulrich.com/index.html", 0x0101 }, { "POST /index.html HTTP/1.1", HTTP_OK, "POST", "/index.html", 0x0101 }, { "PUT * HTTP/1.0", HTTP_OK, "PUT", "*", 0x0100 }, { "OPTIONS http://localhost/ HTTP/1.1", HTTP_OK, "OPTIONS", "http://tulrich.com/", 0x0101 }, { "HEAD * HTTP/1.2", HTTP_HTTP_VERSION_NOT_SUPPORTED, "HEAD", "*", 0x0102 }, { "nospaces", HTTP_BAD_REQUEST, "", "", 0 }, { "one spaces", HTTP_BAD_REQUEST, "", "", 0 }, { "too many spaces", HTTP_BAD_REQUEST, "", "", 0 }, { "too many spaces", HTTP_HTTP_VERSION_NOT_SUPPORTED, "", "", 0 }, }; for (int i = 0; i < TU_ARRAYSIZE(tests); i++) { http_server::http_request_state state; int status = state.parse_request_line(tests[i].reqline); if (status >= 400) { // Make sure test is expected to fail. assert(tests[i].status >= 400); printf("status = %d, expected = %d\n", status, int(tests[i].status)); } else { assert(state.m_req.m_method == tests[i].method); assert(state.m_req.m_uri == tests[i].uri); assert(state.m_req.m_http_version_x256 == tests[i].version_x256); printf("reqline = %s\n", tests[i].reqline); printf("Req method = %s\n", state.m_req.m_method.c_str()); printf("Req URI = %s\n", state.m_req.m_uri.c_str()); printf("Req version = 0x%X\n", state.m_req.m_http_version_x256); } printf("\n"); } // Test parsing of whole header. static struct header_test_vector { const char* headertext; http_status status; const char* path; const char* file; const char* arg_list; const char* argval_list; } tests2[] = { { "GET http://127.0.0.1/path/to/SomeJunk.html?a=1&b=2 HTTP/1.1\r\n" "Host: 127.0.0.1\r\n" "User-Agent: something or other\r\n" "\r\n" "" // Message body , HTTP_OK, "path/to", "SomeJunk.html", "a,b", "1,2" }; } int main() { http_server::parse_test(); return 0; }