Datasets:

---

iNeil77

/

the-vault-function

like 0

[ "MIT" ]

[ "Initialize", "pool", "allocator", "may", "return", "-", "1", "if", "the", "size", "is", "not", "suitable", "for", "the", "pool", "allocation", "." ]

[ "int", "pool_allocator_init", "(", "struct", "pool_allocator", "*", "a", ",", "unsigned", "size", ")", "{", "unsigned", "chunks", ";", "memset", "(", "a", ",", "0", ",", "sizeof", "(", "*", "a", ")", ")", ";", "if", "(", "!", "size", ")", "return", "-1", ";", "chunks", "=", "(", "PAGE_SIZE", "-", "POOL_ALIGN", "(", "sizeof", "(", "struct", "pool_page_hdr", ")", ")", ")", "/", "POOL_ALIGN", "(", "size", ")", ";", "if", "(", "chunks", "<", "MEM_POOL_MIN_ALLOCS_PER_PAGE", ")", "return", "-1", ";", "#ifdef", "MAX_CHUNKS_PER_PAGE", "if", "(", "chunks", ">", "MAX_CHUNKS_PER_PAGE", ")", "chunks", "=", "MAX_CHUNKS_PER_PAGE", ";", "#endif", "a", "->", "chunks_per_page", "=", "chunks", ";", "a", "->", "size", "=", "size", ";", "cd_list_init", "(", "&", "a", "->", "pgs_used", ")", ";", "cd_list_init", "(", "&", "a", "->", "pgs_full", ")", ";", "return", "0", ";", "}" ]

[ "Initialize", "pool", "allocator", "may", "return", "-", "1", "if", "the", "size", "is", "not", "suitable", "for", "the", "pool", "allocation", "." ]

[]

[ { "param": "a", "type": "struct pool_allocator" }, { "param": "size", "type": "unsigned" } ]

[ "MIT" ]

[ "Allocate", "the", "number", "of", "free", "pages" ]

[ "static", "unsigned", "prealloc_pages", "(", "struct", "mem_pool", "*", "p", ")", "{", "void", "*", "ptr", ";", "unsigned", "i", ",", "pgs", ";", "struct", "pool_page_hdr", "*", "pg", ";", "for", "(", "pgs", "=", "MEM_POOL_PREALLOC_PGS", ";", "pgs", ";", "pgs", "/=", "2", ")", "{", "unsigned", "sz", "=", "pgs", "*", "PAGE_SIZE", ";", "#ifndef", "__WINDOWS__", "int", "res", ";", "ptr", "=", "mmap", "(", "0", ",", "sz", ",", "PROT_READ", "|", "PROT_WRITE", ",", "MMAP_ATTR", ",", "-1", ",", "0", ")", ";", "if", "(", "!", "ptr", "||", "ptr", "==", "MAP_FAILED", ")", "continue", ";", "res", "=", "madvise", "(", "ptr", ",", "sz", ",", "MADV_RANDOM", ")", ";", "BUG_ON", "(", "res", ")", ";", "#else", "ptr", "=", "VirtualAlloc", "(", "0", ",", "sz", ",", "MEM_COMMIT", ",", "PAGE_EXECUTE_READWRITE", ")", ";", "if", "(", "!", "ptr", ")", "continue", ";", "#endif", "break", ";", "}", "if", "(", "!", "pgs", ")", "return", "0", ";", "BUG_ON", "(", "(", "long", ")", "ptr", "&", "(", "PAGE_SIZE", "-", "1", ")", ")", ";", "pg", "=", "(", "struct", "pool_page_hdr", "*", ")", "ptr", ";", "for", "(", "i", "=", "0", ";", "i", "<", "pgs", ";", "++", "i", ")", "{", "add_free_page", "(", "p", ",", "pg", ")", ";", "pg", "=", "(", "struct", "pool_page_hdr", "*", ")", "(", "(", "char", "*", ")", "pg", "+", "PAGE_SIZE", ")", ";", "}", "p", "->", "pgs_allocated", "+=", "pgs", ";", "return", "pgs", ";", "}" ]

[ "Allocate", "the", "number", "of", "free", "pages" ]

[]

[ { "param": "p", "type": "struct mem_pool" } ]

[ "MIT" ]

[ "Allocate", "chunk", "from", "the", "particular", "pool", "page" ]

[ "static", "void", "*", "alloc_from_page", "(", "struct", "pool_allocator", "*", "a", ",", "struct", "pool_page_hdr", "*", "pg", ")", "{", "struct", "pool_chunk_hdr", "*", "ch", ";", "BUG_ON", "(", "pg", "->", "chunks_used", ">=", "a", "->", "chunks_per_page", ")", ";", "BUG_ON", "(", "!", "pg", "->", "free_chunks", ")", ";", "ch", "=", "pg", "->", "free_chunks", ";", "pg", "->", "free_chunks", "=", "ch", "->", "next", ";", "++", "pg", "->", "chunks_used", ";", "if", "(", "!", "pg", "->", "free_chunks", ")", "{", "BUG_ON", "(", "pg", "->", "chunks_used", "!=", "a", "->", "chunks_per_page", ")", ";", "cd_list_del", "(", "&", "pg", "->", "node", ")", ";", "cd_list_add", "(", "&", "pg", "->", "node", ",", "&", "a", "->", "pgs_full", ")", ";", "}", "return", "ch", ";", "}" ]

[ "Allocate", "chunk", "from", "the", "particular", "pool", "page" ]

[ "/* No free chunks left */" ]

[ { "param": "a", "type": "struct pool_allocator" }, { "param": "pg", "type": "struct pool_page_hdr" } ]

[ "MIT" ]

[ "Calculate", "a", "*", "b", "/", "c", "avoiding", "overflow" ]

[ "static", "inline", "u64", "muldiv_safe", "(", "u64", "a", ",", "u64", "b", ",", "u64", "c", ")", "{", "u64", "v", ";", "s32", "const", "w", "=", "8", "*", "sizeof", "(", "v", ")", ",", "hw", "=", "w", "/", "2", ";", "s32", "a_", "=", "1", "+", "_log2l", "(", "a", ")", ",", "b_", "=", "1", "+", "_log2l", "(", "b", ")", ",", "c_", ",", "x_", ";", "if", "(", "a_", "+", "b_", "<=", "w", ")", "return", "a", "*", "b", "/", "c", ";", "c_", "=", "1", "+", "_log2l", "(", "c", ")", ";", "if", "(", "a_", "+", "b_", "-", "c_", ">", "w", ")", "return", "~", "0UL", ";", "x_", "=", "a_", "+", "b_", "-", "w", ";", "if", "(", "a_", ">", "hw", ")", "{", "if", "(", "b_", ">", "hw", ")", "{", "a", ">>=", "(", "a_", "-", "hw", ")", ";", "b", ">>=", "(", "b_", "-", "hw", ")", ";", "}", "else", "{", "a", ">>=", "x_", ";", "}", "}", "else", "{", "b", ">>=", "x_", ";", "}", "v", "=", "a", "*", "b", ";", "if", "(", "c_", ">", "hw", ")", "{", "s32", "sht", "=", "c_", "-", "hw", ";", "if", "(", "sht", ">", "x_", ")", "sht", "=", "x_", ";", "c", ">>=", "sht", ";", "x_", "-=", "sht", ";", "}", "return", "(", "v", "/", "c", ")", "<<", "x_", ";", "}" ]

[ "Calculate", "a", "*", "b", "/", "c", "avoiding", "overflow" ]

[ "/* The arithmetic width */", "/* How many bits are occupied by operands */", "/* No overflow, trivial case */", "/* Result overflow, returns max representable value */", "/* How many excessive bits the a*b has */", "/* Right shift a, b operands so a*b will occupy exactly w bits.\n\t * Note that we are loosing at most 2^-hw of precision here.\n\t */", "/* Now we can safely multiply. The result will occupy exactly w bits. */", "/* Right shift c to hw bits so the reminder will occupy hw bits as well.\n\t\t * So we are loosing at most 2^-hw of precision on deletion.\n\t\t */", "/* Calculate the ultimate result */" ]

[ { "param": "a", "type": "u64" }, { "param": "b", "type": "u64" }, { "param": "c", "type": "u64" } ]

[ "MIT" ]

[ "Fill", "in", "a", "CRC", "constants", "table", "." ]

[ "static", "void", "crc_table_init", "(", "crcfn64", "crcfn", ",", "uint64_t", "table", "[", "8", "]", "[", "256", "]", ")", "{", "uint64_t", "crc", ";", "int", "n", ",", "k", ";", "for", "(", "n", "=", "0", ";", "n", "<", "256", ";", "n", "++", ")", "{", "unsigned", "char", "c", "=", "(", "unsigned", "char", ")", "n", ";", "table", "[", "0", "]", "[", "n", "]", "=", "crcfn", "(", "0", ",", "&", "c", ",", "1", ")", ";", "}", "for", "(", "n", "=", "0", ";", "n", "<", "256", ";", "n", "++", ")", "{", "crc", "=", "table", "[", "0", "]", "[", "n", "]", ";", "for", "(", "k", "=", "1", ";", "k", "<", "8", ";", "k", "++", ")", "{", "crc", "=", "table", "[", "0", "]", "[", "crc", "&", "0xff", "]", "^", "(", "crc", ">>", "8", ")", ";", "table", "[", "k", "]", "[", "n", "]", "=", "crc", ";", "}", "}", "for", "(", "k", "=", "0", ";", "k", "<", "8", ";", "k", "++", ")", "for", "(", "n", "=", "0", ";", "n", "<", "256", ";", "n", "++", ")", "table", "[", "k", "]", "[", "n", "]", "=", "le64_to_cpu", "(", "table", "[", "k", "]", "[", "n", "]", ")", ";", "}" ]

[ "Fill", "in", "a", "CRC", "constants", "table", "." ]

[ "/* generate CRCs for all single byte sequences */", "/* generate nested CRC table for future slice-by-8 lookup */", "/* Transform to the big endian table if needed */" ]

[ { "param": "crcfn", "type": "crcfn64" }, { "param": "table", "type": "uint64_t" } ]

[ "MIT" ]

[ "Calculate", "a", "non", "-", "inverted", "CRC", "eight", "bytes", "at", "a", "time", "on", "a", "big", "-", "endian", "architecture", "." ]

[ "static", "uint64_t", "crcspeed64big", "(", "uint64_t", "big_table", "[", "8", "]", "[", "256", "]", ",", "uint64_t", "crc", ",", "void", "*", "buf", ",", "unsigned", "int", "len", ")", "{", "unsigned", "char", "*", "next", "=", "buf", ";", "crc", "=", "cpu_to_le64", "(", "crc", ")", ";", "while", "(", "len", "&&", "(", "(", "uintptr_t", ")", "next", "&", "7", ")", "!=", "0", ")", "{", "crc", "=", "big_table", "[", "0", "]", "[", "(", "crc", ">>", "56", ")", "^", "*", "next", "++", "]", "^", "(", "crc", "<<", "8", ")", ";", "len", "--", ";", "}", "while", "(", "len", ">=", "8", ")", "{", "crc", "^=", "*", "(", "uint64_t", "*", ")", "next", ";", "crc", "=", "big_table", "[", "0", "]", "[", "crc", "&", "0xff", "]", "^", "big_table", "[", "1", "]", "[", "(", "crc", ">>", "8", ")", "&", "0xff", "]", "^", "big_table", "[", "2", "]", "[", "(", "crc", ">>", "16", ")", "&", "0xff", "]", "^", "big_table", "[", "3", "]", "[", "(", "crc", ">>", "24", ")", "&", "0xff", "]", "^", "big_table", "[", "4", "]", "[", "(", "crc", ">>", "32", ")", "&", "0xff", "]", "^", "big_table", "[", "5", "]", "[", "(", "crc", ">>", "40", ")", "&", "0xff", "]", "^", "big_table", "[", "6", "]", "[", "(", "crc", ">>", "48", ")", "&", "0xff", "]", "^", "big_table", "[", "7", "]", "[", "crc", ">>", "56", "]", ";", "next", "+=", "8", ";", "len", "-=", "8", ";", "}", "while", "(", "len", ")", "{", "crc", "=", "big_table", "[", "0", "]", "[", "(", "crc", ">>", "56", ")", "^", "*", "next", "++", "]", "^", "(", "crc", "<<", "8", ")", ";", "len", "--", ";", "}", "return", "le64_to_cpu", "(", "crc", ")", ";", "}" ]

[ "Calculate", "a", "non", "-", "inverted", "CRC", "eight", "bytes", "at", "a", "time", "on", "a", "big", "-", "endian", "architecture", "." ]

[]

[ { "param": "big_table", "type": "uint64_t" }, { "param": "crc", "type": "uint64_t" }, { "param": "buf", "type": "void" }, { "param": "len", "type": "unsigned int" } ]

[ "MIT" ]

[ "This", "maybe", "needed", "to", "block", "profiler", "e", ".", "g", ".", "to", "give", "fork", "()", "a", "chance", "to", "complete", "w", "/", "o", "being", "interrupted", "by", "a", "timer", "signal", "and", "restarting", "constantly" ]

[ "void", "pcs_profiler_block", "(", "struct", "pcs_evloop", "*", "evloop", ",", "sigset_t", "*", "oldmask", ")", "{", "if", "(", "__pcs_profiler_enabled", ")", "{", "sigset_t", "mask", ";", "sigemptyset", "(", "&", "mask", ")", ";", "sigaddset", "(", "&", "mask", ",", "PROFILER_SIGNO", ")", ";", "pthread_sigmask", "(", "SIG_BLOCK", ",", "&", "mask", ",", "oldmask", ")", ";", "}", "}" ]

[ "This", "maybe", "needed", "to", "block", "profiler", "e", ".", "g", "." ]

[]

[ { "param": "evloop", "type": "struct pcs_evloop" }, { "param": "oldmask", "type": "sigset_t" } ]

[ "MIT" ]

[ "Fill", "buffer", "with", "pseudo", "random", "content", ".", "Returns", "0", "on", "success", "and", "-", "1", "otherwise" ]

[ "int", "pcs_get_urandom", "(", "void", "*", "buf", ",", "int", "sz", ")", "{", "#ifndef", "__WINDOWS__", "pcs_fd_t", "fd", ";", "int", "ret", "=", "pcs_sync_open", "(", "\"", "\"", ",", "O_RDONLY", ",", "0", ",", "&", "fd", ")", ";", "if", "(", "ret", ")", "{", "pcs_log_syserror", "(", "LOG_ERR", ",", "ret", ",", "\"", "\"", ")", ";", "return", "-1", ";", "}", "ret", "=", "pcs_sync_sread", "(", "fd", ",", "buf", ",", "sz", ")", ";", "pcs_sync_close", "(", "fd", ")", ";", "if", "(", "ret", "<", "0", ")", "{", "pcs_log_syserror", "(", "LOG_ERR", ",", "ret", ",", "\"", "\"", ")", ";", "return", "-1", ";", "}", "if", "(", "ret", "!=", "sz", ")", "{", "pcs_log", "(", "LOG_ERR", ",", "\"", "\"", ")", ";", "return", "-1", ";", "}", "#else", "if", "(", "!", "RtlGenRandom", "(", "buf", ",", "sz", ")", ")", "{", "pcs_log", "(", "LOG_ERR", ",", "\"", "\"", ")", ";", "return", "-1", ";", "}", "#endif", "return", "0", ";", "}" ]

[ "Fill", "buffer", "with", "pseudo", "random", "content", "." ]

[]

[ { "param": "buf", "type": "void" }, { "param": "sz", "type": "int" } ]

[ "MIT" ]

[ "We", "use", "_fixed_", "hashing", "of", "client", "'", "s", "iocontext", "to", "threads", ".", "No", "balancing", ".", "The", "goal", "of", "executing", "aio", "from", "threads", "is", "to", "get", "proper", "CFQ", "iocontext", "if", "we", "switch", "between", "threads", "we", "would", "lose", "idle", "state", "." ]

[ "static", "inline", "struct", "pcs_aio_worker", "*", "route", "(", "struct", "pcs_aio", "*", "aio", ",", "struct", "pcs_aioreq", "*", "req", ")", "{", "u32", "hash", ";", "hash", "=", "jhash3", "(", "req", "->", "client", ".", "val", ">>", "32", ",", "req", "->", "client", ".", "val", "&", "0xFFFFFFFF", ",", "req", "->", "iocontext", ",", "aio", "->", "salt", ")", ";", "return", "aio", "->", "workers", "+", "(", "hash", "&", "(", "aio", "->", "threads", "-", "1", ")", ")", ";", "}" ]

[ "We", "use", "_fixed_", "hashing", "of", "client", "'", "s", "iocontext", "to", "threads", "." ]

[]

[ { "param": "aio", "type": "struct pcs_aio" }, { "param": "req", "type": "struct pcs_aioreq" } ]

[ "MIT" ]

[ "Split", "path", "on", "filesystem", "'", "path", "'", "into", "directory", "name", "and", "file", "name", ".", "'", "path", "'", "may", "be", "modified", "." ]

[ "static", "void", "parse_file_path", "(", "char", "*", "path", ",", "char", "*", "*", "dname", ",", "char", "*", "*", "fname", ")", "{", "*", "fname", "=", "strrchr", "(", "path", ",", "PCS_PATH_SEP", ")", ";", "if", "(", "*", "fname", ")", "{", "*", "*", "fname", "=", "'", "\\0", "'", ";", "(", "*", "fname", ")", "++", ";", "*", "dname", "=", "*", "path", "?", "path", ":", "\"", "\"", ";", "}", "else", "{", "*", "fname", "=", "path", ";", "*", "dname", "=", "\"", "\"", ";", "}", "}" ]

[ "Split", "path", "on", "filesystem", "'", "path", "'", "into", "directory", "name", "and", "file", "name", "." ]

[]

[ { "param": "path", "type": "char" }, { "param": "dname", "type": "char" }, { "param": "fname", "type": "char" } ]

[ "MIT" ]

[ "add", "accounted", "bytes", "to", "existing", "allocation" ]

[ "void", "__pcs_alloc_account", "(", "void", "*", "block", ",", "ptrdiff_t", "size", ")", "{", "if", "(", "!", "pcs_malloc_enabled", ")", "return", ";", "if", "(", "block", "==", "NULL", ")", "return", ";", "struct", "mem_header", "*", "hdr", "=", "(", "struct", "mem_header", "*", ")", "block", "-", "1", ";", "struct", "malloc_item", "*", "mi", "=", "hdr", "->", "caller", ";", "pthread_mutex_lock", "(", "&", "mi", "->", "mutex", ")", ";", "BUG_ON", "(", "size", "<", "0", "&&", "hdr", "->", "size", "<", "-", "size", ")", ";", "hdr", "->", "size", "+=", "size", ";", "pcs_account_alloc_locked", "(", "mi", ",", "size", ")", ";", "pthread_mutex_unlock", "(", "&", "mi", "->", "mutex", ")", ";", "}" ]

[ "add", "accounted", "bytes", "to", "existing", "allocation" ]

[]

[ { "param": "block", "type": "void" }, { "param": "size", "type": "ptrdiff_t" } ]

[ "MIT" ]

[ "relies", "on", "MR_HASH_SIZE", "to", "be", "2048" ]

[ "static", "int", "mr_hash", "(", "size_t", "size", ")", "{", "size_t", "kb", "=", "size", ">>", "10", ";", "size_t", "mb", "=", "kb", ">>", "10", ";", "if", "(", "mb", ")", "return", "1024", "+", "(", "mb", "&", "1023", ")", ";", "else", "return", "kb", "&", "1023", ";", "}" ]

[ "relies", "on", "MR_HASH_SIZE", "to", "be", "2048" ]

[]

[ { "param": "size", "type": "size_t" } ]

[ "MIT" ]

[ "Receive", "data", "from", "socket", "/", "pipe", "/", "chardev", "to", "splice", "buffer" ]

[ "int", "pcs_splice_buf_recv", "(", "struct", "pcs_splice_buf", "*", "b", ",", "int", "fd", ",", "int", "size", ")", "{", "int", "total", "=", "0", ";", "while", "(", "size", ">", "0", ")", "{", "ssize_t", "n", ";", "n", "=", "splice", "(", "fd", ",", "NULL", ",", "b", "->", "desc", ",", "NULL", ",", "size", ",", "SPLICE_F_NONBLOCK", ")", ";", "if", "(", "n", "<", "0", ")", "{", "if", "(", "errno", "==", "EINTR", ")", "continue", ";", "return", "total", "?", "", ":", "-", "errno", ";", "}", "if", "(", "n", "==", "0", ")", "break", ";", "size", "-=", "n", ";", "BUG_ON", "(", "size", "<", "0", ")", ";", "b", "->", "bytes", "+=", "n", ";", "total", "+=", "n", ";", "}", "return", "total", ";", "}" ]

[ "Receive", "data", "from", "socket", "/", "pipe", "/", "chardev", "to", "splice", "buffer" ]

[]

[ { "param": "b", "type": "struct pcs_splice_buf" }, { "param": "fd", "type": "int" }, { "param": "size", "type": "int" } ]

[ "MIT" ]

[ "Send", "data", "from", "splice", "buffer", "to", "socket", "/", "pipe", "/", "chardev" ]

[ "int", "pcs_splice_buf_send", "(", "int", "fd", ",", "struct", "pcs_splice_buf", "*", "b", ",", "int", "size", ")", "{", "int", "total", "=", "0", ";", "while", "(", "size", ">", "0", ")", "{", "ssize_t", "n", ";", "BUG_ON", "(", "size", ">", "b", "->", "bytes", ")", ";", "n", "=", "splice", "(", "b", "->", "desc", ",", "NULL", ",", "fd", ",", "NULL", ",", "size", ",", "SPLICE_F_NONBLOCK", ")", ";", "if", "(", "n", "<", "0", ")", "{", "if", "(", "errno", "==", "EINTR", ")", "continue", ";", "return", "total", "?", "", ":", "-", "errno", ";", "}", "if", "(", "n", "==", "0", ")", "break", ";", "b", "->", "bytes", "-=", "n", ";", "size", "-=", "n", ";", "b", "->", "tag", "+=", "n", ";", "total", "+=", "n", ";", "}", "return", "total", ";", "}" ]

[ "Send", "data", "from", "splice", "buffer", "to", "socket", "/", "pipe", "/", "chardev" ]

[]

[ { "param": "fd", "type": "int" }, { "param": "b", "type": "struct pcs_splice_buf" }, { "param": "size", "type": "int" } ]

[ "MIT" ]

[ "Write", "data", "from", "splice", "buffer", "to", "seekable", "file" ]

[ "int", "pcs_splice_buf_pwrite", "(", "int", "fd", ",", "off_t", "pos", ",", "struct", "pcs_splice_buf", "*", "b", ")", "{", "int", "total", "=", "0", ";", "while", "(", "b", "->", "bytes", ")", "{", "ssize_t", "n", ";", "n", "=", "splice", "(", "b", "->", "desc", ",", "NULL", ",", "fd", ",", "&", "pos", ",", "b", "->", "bytes", ",", "SPLICE_F_NONBLOCK", ")", ";", "if", "(", "n", "<", "0", ")", "{", "if", "(", "errno", "==", "EINTR", ")", "continue", ";", "return", "total", "?", "", ":", "-", "errno", ";", "}", "if", "(", "n", "==", "0", ")", "break", ";", "b", "->", "bytes", "-=", "n", ";", "b", "->", "tag", "+=", "n", ";", "pos", "+=", "n", ";", "total", "+=", "n", ";", "}", "return", "total", ";", "}" ]

[ "Write", "data", "from", "splice", "buffer", "to", "seekable", "file" ]

[]

[ { "param": "fd", "type": "int" }, { "param": "pos", "type": "off_t" }, { "param": "b", "type": "struct pcs_splice_buf" } ]

[ "MIT" ]

[ "Read", "data", "from", "seekable", "file", "to", "splice", "buffer" ]

[ "int", "pcs_splice_buf_pread", "(", "struct", "pcs_splice_buf", "*", "b", ",", "int", "fd", ",", "off_t", "pos", ",", "int", "size", ")", "{", "int", "total", "=", "0", ";", "while", "(", "size", ">", "0", ")", "{", "ssize_t", "n", ";", "n", "=", "splice", "(", "fd", ",", "&", "pos", ",", "b", "->", "desc", ",", "NULL", ",", "size", ",", "SPLICE_F_NONBLOCK", ")", ";", "if", "(", "n", "<", "0", ")", "{", "if", "(", "errno", "==", "EINTR", ")", "continue", ";", "return", "total", "?", "", ":", "-", "errno", ";", "}", "if", "(", "n", "==", "0", ")", "break", ";", "size", "-=", "n", ";", "b", "->", "bytes", "+=", "n", ";", "pos", "+=", "n", ";", "total", "+=", "n", ";", "}", "return", "total", ";", "}" ]

[ "Read", "data", "from", "seekable", "file", "to", "splice", "buffer" ]

[]

[ { "param": "b", "type": "struct pcs_splice_buf" }, { "param": "fd", "type": "int" }, { "param": "pos", "type": "off_t" }, { "param": "size", "type": "int" } ]

[ "MIT" ]

[ "Transfer", "data", "from", "splice", "buffer", "to", "user", "memory", "buffer" ]

[ "int", "pcs_splice_buf_getbytes", "(", "struct", "pcs_splice_buf", "*", "b", ",", "char", "*", "buf", ",", "int", "size", ")", "{", "int", "total", "=", "0", ";", "BUG_ON", "(", "size", ">", "b", "->", "bytes", ")", ";", "while", "(", "size", ")", "{", "ssize_t", "n", ";", "n", "=", "read", "(", "b", "->", "desc", ",", "buf", ",", "size", ")", ";", "if", "(", "n", "<", "0", ")", "{", "if", "(", "errno", "==", "EINTR", ")", "continue", ";", "return", "total", "?", "", ":", "-", "errno", ";", "}", "if", "(", "n", "==", "0", ")", "break", ";", "size", "-=", "n", ";", "b", "->", "bytes", "-=", "n", ";", "b", "->", "tag", "+=", "n", ";", "buf", "+=", "n", ";", "total", "+=", "n", ";", "}", "return", "total", ";", "}" ]

[ "Transfer", "data", "from", "splice", "buffer", "to", "user", "memory", "buffer" ]

[]

[ { "param": "b", "type": "struct pcs_splice_buf" }, { "param": "buf", "type": "char" }, { "param": "size", "type": "int" } ]

[ "MIT" ]

[ "Get", "long", "description", "of", "the", "error" ]

[ "const", "char", "*", "pcs_strerror", "(", "pcs_err_t", "errnum", ")", "{", "if", "(", "(", "int", ")", "errnum", "<", "0", "||", "errnum", ">=", "ARR_SZ", "(", "prot_err_list", ")", ")", "return", "\"", "\"", ";", "return", "prot_err_list", "[", "errnum", "]", ";", "}" ]

[ "Get", "long", "description", "of", "the", "error" ]

[]

[ { "param": "errnum", "type": "pcs_err_t" } ]

[ "MIT" ]

[ "pass", "units", "through", "shaper", "return", "non", "zero", "value", "if", "units", "are", "allowed", "to", "processing" ]

[ "static", "inline", "int", "pcs_tba_shaper_pass", "(", "struct", "pcs_tba_shaper", "*", "s", ",", "u64", "units", ")", "{", "if", "(", "!", "s", "->", "out_rate", ")", "return", "1", ";", "BUG_ON", "(", "units", ">", "s", "->", "cbs", ")", ";", "if", "(", "s", "->", "capacity", "<", "units", ")", "return", "0", ";", "s", "->", "capacity", "-=", "units", ";", "return", "1", ";", "}" ]

[ "pass", "units", "through", "shaper", "return", "non", "zero", "value", "if", "units", "are", "allowed", "to", "processing" ]

[ "/* no limit to apply */" ]

[ { "param": "s", "type": "struct pcs_tba_shaper" }, { "param": "units", "type": "u64" } ]

[ "MIT" ]

[ "It", "seems", "that", "there", "is", "no", "other", "way", "to", "place", "dialog", "window", "in", "the", "system", "default", "location", "than", "creating", "temporary", "invisible", "window", "and", "then", "fetching", "its", "position", "." ]

[ "BOOL", "useDefaultPosition", "(", ")", "{", "WNDCLASS", "wc", "=", "{", "0", "}", ";", "WINDOWPLACEMENT", "wp", "=", "{", "0", "}", ";", "wc", ".", "lpfnWndProc", "=", "DefWindowProc", ";", "wc", ".", "lpszClassName", "=", "TEXT", "(", "\"", "\"", ")", ";", "wp", ".", "length", "=", "sizeof", "(", "WINDOWPLACEMENT", ")", ";", "RegisterClass", "(", "&", "wc", ")", ";", "HWND", "hWnd", "=", "CreateWindow", "(", "wc", ".", "lpszClassName", ",", "NULL", ",", "WS_OVERLAPPED", ",", "CW_USEDEFAULT", ",", "CW_USEDEFAULT", ",", "350", ",", "150", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", ";", "GetWindowPlacement", "(", "hWnd", ",", "&", "wp", ")", ";", "DestroyWindow", "(", "hWnd", ")", ";", "UnregisterClass", "(", "wc", ".", "lpszClassName", ",", "NULL", ")", ";", "return", "SetWindowPos", "(", "hDlg", ",", "0", ",", "wp", ".", "rcNormalPosition", ".", "left", ",", "wp", ".", "rcNormalPosition", ".", "top", ",", "0", ",", "0", ",", "SWP_NOSIZE", "|", "SWP_NOZORDER", ")", ";", "}" ]

[ "It", "seems", "that", "there", "is", "no", "other", "way", "to", "place", "dialog", "window", "in", "the", "system", "default", "location", "than", "creating", "temporary", "invisible", "window", "and", "then", "fetching", "its", "position", "." ]

[]

[]

[ "Apache-2.0" ]

[ "can", "'", "t", "use", "hex", "namespace", "because", "it", "conflicts", "with", "hex", "iostream", "function" ]

[ "inline", "int", "fromHex", "(", "char", "c", ")", "{", "if", "(", "'", "'", "<=", "c", "&&", "c", "<=", "'", "'", ")", "return", "c", "-", "'", "'", ";", "if", "(", "'", "'", "<=", "c", "&&", "c", "<=", "'", "'", ")", "return", "c", "-", "'", "'", "+", "10", ";", "if", "(", "'", "'", "<=", "c", "&&", "c", "<=", "'", "'", ")", "return", "c", "-", "'", "'", "+", "10", ";", "verify", "(", "false", ")", ";", "return", "0xff", ";", "}" ]

[ "can", "'", "t", "use", "hex", "namespace", "because", "it", "conflicts", "with", "hex", "iostream", "function" ]

[]

[ { "param": "c", "type": "char" } ]

[ "MIT" ]

[ "This", "function", "deletes", "Media", "from", "CobbleVision", "@sync", "@function", "deleteMediaFile", "()", "@param", "{", "array", "}", "IDArray", "Array", "of", "ID", "'", "s", "as", "Strings", "@returns", "{", "Response", "}", "This", "return", "the", "DeleteMediaResponse", ".", "The", "body", "is", "in", "JSON", "format", "." ]

[ "char", "deleteMediaFile", "(", "char", "IDArray", "[", "]", ")", "{", "char", "endpoint", "=", "\"", "\"", "", "if", "(", "BaseURL", ".", "charAt", "(", "sizeOf", "(", "BaseURL", ")", "-", "1", ")", "!=", "\"", "\"", ")", "{", "printf", "(", "\"", "\"", ")", ";", "exit", "(", "0", ")", "", "}", "bool", "validResult", "=", "checkIDArrayForInvalidIDs", "(", "IDArray", ")", "", "if", "(", "validResult", "==", "false", ")", "{", "printf", "(", "\"", "\"", ")", "", "exit", "(", "0", ")", "", "}", "cJSONArray", "json_idArray", "=", "cJSON_Parse", "(", "IDArray", ")", "", "char", "response", "=", "sendRequestToAPI", "(", "\"", "\"", ",", "null", ",", "BaseURL", "+", "endpoint", "+", "\"", "\"", "+", "cJSON_Print", "(", "json_idArray", ")", ")", "", "return", "response", "", "}" ]

[ "This", "function", "deletes", "Media", "from", "CobbleVision", "@sync", "@function", "deleteMediaFile", "()", "@param", "{", "array", "}", "IDArray", "Array", "of", "ID", "'", "s", "as", "Strings", "@returns", "{", "Response", "}", "This", "return", "the", "DeleteMediaResponse", "." ]

[]

[ { "param": "IDArray", "type": "char" } ]

[ "MIT" ]

[ "Launch", "a", "calculation", "with", "CobbleVision", "'", "s", "Web", "API", "." ]

[ "char", "launchCalculation", "(", "char", "algorithms", "[", "]", ",", "char", "media", "[", "]", ",", "char", "type", ",", "char", "notificationURL", ")", "{", "char", "endpoint", "=", "\"", "\"", "", "if", "(", "BaseURL", ".", "charAt", "(", "sizeOf", "(", "BaseURL", ")", "-", "1", ")", "!=", "\"", "\"", ")", "{", "printf", "(", "\"", "\"", ")", ";", "exit", "(", "0", ")", "", "}", "bool", "validMedia", "=", "checkIDArrayForInvalidIDs", "(", "media", ")", "", "if", "(", "validMedia", "==", "false", ")", "{", "printf", "(", "\"", "\"", ")", "", "exit", "(", "0", ")", "", "}", "bool", "validAlgorithms", "=", "checkIDArrayForInvalidIDs", "(", "algorithms", ")", "", "if", "(", "validMedia", "==", "false", ")", "{", "printf", "(", "\"", "\"", ")", "", "exit", "(", "0", ")", "", "}", "if", "(", "!", "strchar", "(", "valid_job_types", ",", "type", ")", ")", "{", "printf", "(", "\"", "\"", ")", "", "exit", "(", "0", ")", "", "}", "cJSON", "jsonObject", "=", "CJSON_CreateObject", "(", ")", "", "cJSON_AddArrayToObject", "(", "jsonObject", ",", "\"", "\"", ",", "algorithms", ")", "", "cJSON_AddArrayToObject", "(", "jsonObject", ",", "\"", "\"", ",", "media", ")", "", "cJSON_AddStringToObject", "(", "jsonObject", ",", "\"", "\"", ",", "type", ")", "", "cJSON_AddStringToObject", "(", "jsonObject", ",", "\"", "\"", ",", "notificationURL", ")", "", "char", "response", "=", "sendRequestToAPI", "(", "\"", "\"", ",", "jsonObject", ",", "BaseURL", "+", "endpoint", ")", "", "return", "response", "", "}" ]

[ "Launch", "a", "calculation", "with", "CobbleVision", "'", "s", "Web", "API", "." ]

[ "//Verify the strchar function on char []. usually used on chars, not char []." ]

[ { "param": "algorithms", "type": "char" }, { "param": "media", "type": "char" }, { "param": "type", "type": "char" }, { "param": "notificationURL", "type": "char" } ]

[ "MIT" ]

[ "This", "function", "waits", "until", "the", "given", "calculation", "ID", "'", "s", "are", "ready", "to", "be", "downloaded", ".", "@sync", "@function", "waitForCalculationCompletion", "()", "@param", "{", "array", "}", "calculationIDArray", "Array", "of", "Calculation", "ID", "'", "s", "@returns", "{", "Response", "}", "This", "returns", "the", "WaitForCalculationResponse", ".", "The", "body", "is", "in", "JSON", "format", "." ]

[ "char", "waitForCalculationCompletion", "(", "char", "IDArray", "[", "]", ")", "{", "char", "endpoint", "=", "\"", "\"", "", "if", "(", "BaseURL", ".", "charAt", "(", "sizeOf", "(", "BaseURL", ")", "-", "1", ")", "!=", "\"", "\"", ")", "{", "printf", "(", "\"", "\"", ")", ";", "exit", "(", "0", ")", "", "}", "bool", "validResult", "=", "checkIDArrayForInvalidIDs", "(", "IDArray", ")", "", "if", "(", "validResult", "==", "false", ")", "{", "printf", "(", "\"", "\"", ")", "", "exit", "(", "0", ")", "", "}", "cJSONArray", "json_idArray", "=", "cJSON_Parse", "(", "IDArray", ")", "", "bool", "calculationFinishedBool", "=", "false", ";", "while", "(", "!", "calculationFinishedBool", "(", ")", "", "{", "char", "response", "=", "sendRequestToAPI", "(", "\"", "\"", ",", "null", ",", "BaseURL", "+", "endpoint", "+", "\"", "\"", "+", "cJSON_print", "(", "json_idArray", ")", ",", "+", "\"", "\"", ")", "", "cJSONArray", "responseArray", "=", "cJSON_Parse", "(", "response", ")", "", "if", "(", "cJSON_IsArray", "(", "responseArray", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "cJSON_GetArraySize", "(", "responseArray", ")", ";", "i", "++", ")", "{", "if", "(", "responseArray", "[", "i", "]", ".", "status", ")", "{", "if", "(", "responseArray", "[", "i", "]", ".", "status", "!=", "\"", "\"", ")", "{", "calculationFinishedBool", "=", "false", "", "}", "}", "else", "{", "calculationFinishedBool", "=", "false", ";", "break", ";", "}", "}", "}", "else", "{", "responseJSON", "=", "cJSON_Parse", "(", "response", ")", "", "if", "(", "responseJSON", ".", "error", ")", "{", "calculationFinishedBool", "=", "true", "", "}", "}", "}", "return", "response", "", "}" ]

[ "This", "function", "waits", "until", "the", "given", "calculation", "ID", "'", "s", "are", "ready", "to", "be", "downloaded!" ]

[]

[ { "param": "IDArray", "type": "char" } ]

[ "MIT" ]

[ "This", "function", "deletes", "Result", "Files", "or", "calculations", "in", "status", "\"", "waiting", "\"", "from", "CobbleVision", ".", "You", "cannot", "delete", "finished", "jobs", "beyond", "their", "result", "files", "as", "we", "keep", "them", "for", "billing", "purposes", ".", "@sync", "@function", "deleteCalculation", "()", "@param", "{", "array", "}", "IDArray", "Array", "of", "ID", "'", "s", "as", "Strings", "@returns", "{", "Response", "}", "This", "returns", "the", "DeleteCalculationResponse", ".", "The", "body", "is", "in", "JSON", "format", "." ]

[ "char", "deleteCalculation", "(", "char", "IDArray", "[", "]", ")", "{", "char", "endpoint", "=", "\"", "\"", "", "if", "(", "BaseURL", ".", "charAt", "(", "sizeOf", "(", "BaseURL", ")", "-", "1", ")", "!=", "\"", "\"", ")", "{", "printf", "(", "\"", "\"", ")", ";", "exit", "(", "0", ")", "", "}", "bool", "validResult", "=", "checkIDArrayForInvalidIDs", "(", "IDArray", ")", "", "if", "(", "validResult", "==", "false", ")", "{", "printf", "(", "\"", "\"", ")", "", "exit", "(", "0", ")", "", "}", "cJSONArray", "json_idArray", "=", "cJSON_Parse", "(", "IDArray", ")", "", "char", "response", "=", "sendRequestToAPI", "(", "\"", "\"", ",", "null", ",", "BaseURL", "+", "endpoint", "+", "\"", "\"", "+", "cJSON_Print", "(", "json_idArray", ")", ")", "", "return", "response", "", "}" ]

[ "This", "function", "deletes", "Result", "Files", "or", "calculations", "in", "status", "\"", "waiting", "\"", "from", "CobbleVision", "." ]

[]

[ { "param": "IDArray", "type": "char" } ]

[ "BSD-2-Clause" ]

[ "Free", "all", "storage", "used", "by", "queue" ]

[ "void", "q_free", "(", "queue_t", "*", "q", ")", "{", "if", "(", "!", "q", ")", "return", ";", "if", "(", "q", "->", "head", ")", "{", "list_ele_t", "*", "eleh", ",", "*", "elen", ";", "eleh", "=", "q", "->", "head", ";", "while", "(", "eleh", ")", "{", "elen", "=", "eleh", "->", "next", ";", "free", "(", "eleh", "->", "value", ")", ";", "free", "(", "eleh", ")", ";", "if", "(", "elen", ")", "eleh", "=", "elen", ";", "else", "eleh", "=", "NULL", ";", "}", "}", "free", "(", "q", ")", ";", "}" ]

[ "Free", "all", "storage", "used", "by", "queue" ]

[ "/* element head and next */", "/* Free queue structure */" ]

[ { "param": "q", "type": "queue_t" } ]

[ "BSD-2-Clause" ]

[ "Attempt", "to", "insert", "element", "at", "head", "of", "queue", ".", "Return", "true", "if", "successful", ".", "Return", "false", "if", "q", "is", "NULL", "or", "could", "not", "allocate", "space", ".", "Argument", "s", "points", "to", "the", "string", "to", "be", "stored", ".", "The", "function", "must", "explicitly", "allocate", "space", "and", "copy", "the", "string", "into", "it", "." ]

[ "bool", "q_insert_head", "(", "queue_t", "*", "q", ",", "char", "*", "s", ")", "{", "list_ele_t", "*", "newh", ";", "if", "(", "!", "q", ")", "return", "false", ";", "if", "(", "(", "newh", "=", "malloc", "(", "sizeof", "(", "list_ele_t", ")", ")", ")", "==", "NULL", ")", "return", "false", ";", "if", "(", "(", "newh", "->", "value", "=", "malloc", "(", "strlen", "(", "s", ")", "+", "1", ")", ")", "==", "NULL", ")", "{", "free", "(", "newh", ")", ";", "return", "false", ";", "}", "strncpy", "(", "newh", "->", "value", ",", "s", ",", "strlen", "(", "s", ")", "+", "1", ")", ";", "newh", "->", "value", "[", "strlen", "(", "s", ")", "]", "=", "'", "\\0", "'", ";", "newh", "->", "next", "=", "q", "->", "head", ";", "q", "->", "head", "=", "newh", ";", "if", "(", "q", "->", "size", "==", "0", ")", "q", "->", "tail", "=", "newh", ";", "q", "->", "size", "++", ";", "return", "true", ";", "}" ]

[ "Attempt", "to", "insert", "element", "at", "head", "of", "queue", "." ]

[ "/* Free this element if we allocat value space failed. */", "/* LIFO */", "/* Points tail to this element if this is the first element. */" ]

[ { "param": "q", "type": "queue_t" }, { "param": "s", "type": "char" } ]

[ "BSD-2-Clause" ]

[ "Attempt", "to", "insert", "element", "at", "tail", "of", "queue", ".", "Return", "true", "if", "successful", ".", "Return", "false", "if", "q", "is", "NULL", "or", "could", "not", "allocate", "space", ".", "Argument", "s", "points", "to", "the", "string", "to", "be", "stored", ".", "The", "function", "must", "explicitly", "allocate", "space", "and", "copy", "the", "string", "into", "it", "." ]

[ "bool", "q_insert_tail", "(", "queue_t", "*", "q", ",", "char", "*", "s", ")", "{", "list_ele_t", "*", "newh", ";", "if", "(", "!", "q", ")", "return", "false", ";", "if", "(", "(", "newh", "=", "malloc", "(", "sizeof", "(", "list_ele_t", ")", ")", ")", "==", "NULL", ")", "return", "false", ";", "if", "(", "(", "newh", "->", "value", "=", "malloc", "(", "strlen", "(", "s", ")", "+", "1", ")", ")", "==", "NULL", ")", "{", "free", "(", "newh", ")", ";", "return", "false", ";", "}", "strncpy", "(", "newh", "->", "value", ",", "s", ",", "strlen", "(", "s", ")", "+", "1", ")", ";", "newh", "->", "value", "[", "strlen", "(", "s", ")", "]", "=", "'", "\\0", "'", ";", "newh", "->", "next", "=", "NULL", ";", "if", "(", "q", "->", "size", "==", "0", ")", "{", "q", "->", "head", "=", "newh", ";", "}", "else", "q", "->", "tail", "->", "next", "=", "newh", ";", "q", "->", "tail", "=", "newh", ";", "q", "->", "size", "++", ";", "return", "true", ";", "}" ]

[ "Attempt", "to", "insert", "element", "at", "tail", "of", "queue", "." ]

[ "/* Free this element if we allocat value space failed. */", "/* FIFO */", "/* Points head to this element if this is the first element. */" ]

[ { "param": "q", "type": "queue_t" }, { "param": "s", "type": "char" } ]

[ "BSD-2-Clause" ]

[ "Attempt", "to", "remove", "element", "from", "head", "of", "queue", ".", "Return", "true", "if", "successful", ".", "Return", "false", "if", "queue", "is", "NULL", "or", "empty", ".", "If", "sp", "is", "non", "-", "NULL", "and", "an", "element", "is", "removed", "copy", "the", "removed", "string", "to", "*", "sp", "(", "up", "to", "a", "maximum", "of", "bufsize", "-", "1", "characters", "plus", "a", "null", "terminator", ".", ")", "The", "space", "used", "by", "the", "list", "element", "and", "the", "string", "should", "be", "freed", "." ]

[ "bool", "q_remove_head", "(", "queue_t", "*", "q", ",", "char", "*", "sp", ",", "size_t", "bufsize", ")", "{", "list_ele_t", "*", "ele", ";", "if", "(", "!", "q", "||", "!", "q", "->", "head", ")", "return", "false", ";", "ele", "=", "q", "->", "head", ";", "q", "->", "head", "=", "q", "->", "head", "->", "next", ";", "q", "->", "size", "--", ";", "if", "(", "q", "->", "size", "==", "0", ")", "q", "->", "tail", "=", "NULL", ";", "if", "(", "sp", ")", "{", "if", "(", "strlen", "(", "ele", "->", "value", ")", ">", "bufsize", ")", "{", "strncpy", "(", "sp", ",", "ele", "->", "value", ",", "bufsize", "-", "1", ")", ";", "sp", "[", "bufsize", "-", "1", "]", "=", "'", "\\0", "'", ";", "}", "else", "{", "strncpy", "(", "sp", ",", "ele", "->", "value", ",", "strlen", "(", "ele", "->", "value", ")", ")", ";", "sp", "[", "strlen", "(", "ele", "->", "value", ")", "]", "=", "'", "\\0", "'", ";", "}", "}", "free", "(", "ele", "->", "value", ")", ";", "free", "(", "ele", ")", ";", "return", "true", ";", "}" ]

[ "Attempt", "to", "remove", "element", "from", "head", "of", "queue", "." ]

[]

[ { "param": "q", "type": "queue_t" }, { "param": "sp", "type": "char" }, { "param": "bufsize", "type": "size_t" } ]

[ "BSD-2-Clause" ]

[ "Reverse", "elements", "in", "queue", "No", "effect", "if", "q", "is", "NULL", "or", "empty", "This", "function", "should", "not", "allocate", "or", "free", "any", "list", "elements", ".", "It", "should", "rearrange", "the", "existing", "ones", "." ]

[ "void", "q_reverse", "(", "queue_t", "*", "q", ")", "{", "list_ele_t", "*", "ele_prev", ",", "*", "ele_cur", ",", "*", "ele_next", ";", "if", "(", "!", "q", "||", "!", "q", "->", "head", ")", "return", ";", "ele_prev", "=", "NULL", ";", "q", "->", "tail", "=", "ele_cur", "=", "q", "->", "head", ";", "while", "(", "ele_cur", ")", "{", "ele_next", "=", "ele_cur", "->", "next", ";", "ele_cur", "->", "next", "=", "ele_prev", ";", "ele_prev", "=", "ele_cur", ";", "ele_cur", "=", "ele_next", ";", "}", "q", "->", "head", "=", "ele_prev", ";", "}" ]

[ "Reverse", "elements", "in", "queue", "No", "effect", "if", "q", "is", "NULL", "or", "empty", "This", "function", "should", "not", "allocate", "or", "free", "any", "list", "elements", "(", "e", ".", "g", ".", "by", "calling", "q_insert_head", "q_insert_tail", "or", "q_remove_head", ")", "." ]

[]

[ { "param": "q", "type": "queue_t" } ]

[ "BSD-2-Clause" ]

[ "Sort", "elements", "of", "queue", "in", "ascending", "order", "No", "effect", "if", "q", "is", "NULL", "or", "empty", ".", "In", "addition", "if", "q", "has", "only", "one", "element", "do", "nothing", "." ]

[ "void", "q_sort", "(", "queue_t", "*", "q", ")", "{", "if", "(", "!", "q", "||", "!", "q", "->", "head", ")", "return", ";", "if", "(", "q", "->", "size", "<=", "1", ")", "return", ";", "q", "->", "head", "=", "q_mergeSort", "(", "q", "->", "head", ")", ";", "q", "->", "tail", "=", "q", "->", "head", ";", "while", "(", "q", "->", "tail", "->", "next", ")", "{", "q", "->", "tail", "=", "q", "->", "tail", "->", "next", ";", "}", "}" ]

[ "Sort", "elements", "of", "queue", "in", "ascending", "order", "No", "effect", "if", "q", "is", "NULL", "or", "empty", "." ]

[]

[ { "param": "q", "type": "queue_t" } ]

[ "CC0-1.0" ]

[ "Read", "a", "file", "into", "malloc", "()", "ed", "storage" ]

[ "static", "int", "file_load", "(", "FILE", "*", "input", ",", "char", "*", "*", "memp", ",", "size_t", "*", "sizep", ")", "{", "int", "result", "=", "-", "ENOMEM", ";", "int", "ch", "=", "0", ";", "size_t", "i", "=", "0", ";", "size_t", "finish", "=", "-1", ";", "char", "*", "buffer", "=", "0", ";", "size_t", "buffer_size", "=", "0", ";", "while", "(", "i", "!=", "finish", ")", "{", "ch", "=", "fgetc", "(", "input", ")", ";", "if", "(", "ch", "==", "EOF", ")", "{", "result", "=", "ok", ";", "*", "memp", "=", "buffer", ";", "*", "sizep", "=", "i", ";", "finish", "=", "i", ";", "}", "else", "if", "(", "i", "<", "buffer_size", ")", "{", "buffer", "[", "i", "++", "]", "=", "ch", ";", "}", "else", "{", "size_t", "newsize", "=", "buffer_size", "?", "2", "*", "buffer_size", ":", "MALLOC_START", ";", "char", "*", "newbuf", "=", "realloc", "(", "buffer", ",", "newsize", ")", ";", "if", "(", "newbuf", ")", "{", "buffer_size", "=", "newsize", ";", "buffer", "=", "newbuf", ";", "buffer", "[", "i", "++", "]", "=", "ch", ";", "}", "else", "{", "i", "=", "finish", ";", "}", "}", "}", "return", "result", ";", "}" ]

[ "Read", "a", "file", "into", "malloc", "()", "ed", "storage" ]

[]

[ { "param": "input", "type": "FILE" }, { "param": "memp", "type": "char" }, { "param": "sizep", "type": "size_t" } ]

[ "CC0-1.0" ]

[ "Original", "size", "is", "in", "Intel", "little", "endian", "byte", "order", "ie", "LSB", "first" ]

[ "static", "uint32_t", "put_uint32_le_t", "(", "uint32_t", "le", ")", "{", "uint32_t", "result", "=", "0", ";", "unsigned", "char", "x", "[", "sizeof", "(", "result", ")", "]", ";", "x", "[", "0", "]", "=", "le", "&", "0xff", ";", "x", "[", "1", "]", "=", "(", "le", ">>", "8", ")", "&", "0xff", ";", "x", "[", "2", "]", "=", "(", "le", ">>", "8", "*", "2", ")", "&", "0xff", ";", "x", "[", "3", "]", "=", "(", "le", ">>", "8", "*", "3", ")", "&", "0xff", ";", "memcpy", "(", "&", "result", ",", "x", ",", "sizeof", "(", "x", ")", ")", ";", "return", "result", ";", "}" ]

[ "Original", "size", "is", "in", "Intel", "little", "endian", "byte", "order", "ie", "LSB", "first" ]

[]

[ { "param": "le", "type": "uint32_t" } ]

[ "CC0-1.0" ]

[ "Read", "a", "file", "into", "malloc", "()", "ed", "storage" ]

[ "static", "int", "file_load", "(", "FILE", "*", "input", ",", "char", "*", "*", "memp", ",", "size_t", "*", "sizep", ")", "{", "int", "result", "=", "-", "ENOMEM", ";", "int", "ch", "=", "0", ";", "size_t", "i", "=", "0", ";", "size_t", "finish", "=", "err", ";", "char", "*", "buffer", "=", "0", ";", "size_t", "buffer_size", "=", "0", ";", "while", "(", "i", "!=", "finish", ")", "{", "ch", "=", "fgetc", "(", "input", ")", ";", "if", "(", "ch", "==", "EOF", ")", "{", "result", "=", "ok", ";", "*", "memp", "=", "buffer", ";", "*", "sizep", "=", "i", ";", "finish", "=", "i", ";", "}", "else", "if", "(", "i", "<", "buffer_size", ")", "{", "buffer", "[", "i", "++", "]", "=", "ch", ";", "}", "else", "{", "size_t", "newsize", "=", "buffer_size", "?", "2", "*", "buffer_size", ":", "MALLOC_START", ";", "char", "*", "newbuf", "=", "realloc", "(", "buffer", ",", "newsize", ")", ";", "if", "(", "newbuf", ")", "{", "buffer_size", "=", "newsize", ";", "buffer", "=", "newbuf", ";", "buffer", "[", "i", "++", "]", "=", "ch", ";", "}", "else", "{", "i", "=", "finish", ";", "}", "}", "}", "return", "result", ";", "}" ]

[ "Read", "a", "file", "into", "malloc", "()", "ed", "storage" ]

[]

[ { "param": "input", "type": "FILE" }, { "param": "memp", "type": "char" }, { "param": "sizep", "type": "size_t" } ]

[ "CC0-1.0" ]

[ "MOZLZ4", "header", "load", "/", "verify", "magic", "/", "get", "original", "size" ]

[ "static", "int", "header_load", "(", "FILE", "*", "input", ",", "MOZLZ4_HDR", "*", "hdr", ",", "size_t", "hdrsize", ")", "{", "int", "result", "=", "err", ";", "if", "(", "fread", "(", "hdr", ",", "1", ",", "hdrsize", ",", "input", ")", "==", "hdrsize", ")", "result", "=", "ok", ";", "return", "result", ";", "}" ]

[ "MOZLZ4", "header", "load", "/", "verify", "magic", "/", "get", "original", "size" ]

[]

[ { "param": "input", "type": "FILE" }, { "param": "hdr", "type": "MOZLZ4_HDR" }, { "param": "hdrsize", "type": "size_t" } ]

[ "Apache-2.0" ]

[ "Create", "a", "git", "protocol", "request", "." ]

[ "static", "int", "gen_proto", "(", "git_buf", "*", "request", ",", "const", "char", "*", "cmd", ",", "const", "char", "*", "url", ")", "{", "char", "*", "delim", ",", "*", "repo", ";", "char", "host", "[", "]", "=", "\"", "\"", ";", "size_t", "len", ";", "delim", "=", "strchr", "(", "url", ",", "'", "'", ")", ";", "if", "(", "delim", "==", "NULL", ")", "{", "giterr_set", "(", "GITERR_NET", ",", "\"", "\"", ")", ";", "return", "-1", ";", "}", "repo", "=", "delim", ";", "delim", "=", "strchr", "(", "url", ",", "'", "'", ")", ";", "if", "(", "delim", "==", "NULL", ")", "delim", "=", "strchr", "(", "url", ",", "'", "'", ")", ";", "len", "=", "4", "+", "strlen", "(", "cmd", ")", "+", "1", "+", "strlen", "(", "repo", ")", "+", "1", "+", "strlen", "(", "host", ")", "+", "(", "delim", "-", "url", ")", "+", "1", ";", "git_buf_grow", "(", "request", ",", "len", ")", ";", "git_buf_printf", "(", "request", ",", "\"", "\"", ",", "(", "unsigned", "int", ")", "(", "len", "&", "0x0FFFF", ")", ",", "cmd", ",", "repo", ",", "0", ",", "host", ")", ";", "git_buf_put", "(", "request", ",", "url", ",", "delim", "-", "url", ")", ";", "git_buf_putc", "(", "request", ",", "'", "\\0", "'", ")", ";", "if", "(", "git_buf_oom", "(", "request", ")", ")", "return", "-1", ";", "return", "0", ";", "}" ]

[ "Create", "a", "git", "protocol", "request", "." ]

[]

[ { "param": "request", "type": "git_buf" }, { "param": "cmd", "type": "char" }, { "param": "url", "type": "char" } ]

[ "Apache-2.0" ]

[ "This", "is", "copy", "/", "pasted", "from", "network", "/", "remotelocal", ".", "c", "." ]

[ "static", "void", "build_local_file_url", "(", "git_buf", "*", "out", ",", "const", "char", "*", "fixture", ")", "{", "const", "char", "*", "in_buf", ";", "git_buf", "path_buf", "=", "GIT_BUF_INIT", ";", "cl_git_pass", "(", "git_path_prettify_dir", "(", "&", "path_buf", ",", "fixture", ",", "NULL", ")", ")", ";", "cl_git_pass", "(", "git_buf_puts", "(", "out", ",", "\"", "\"", ")", ")", ";", "#ifdef", "GIT_WIN32", "cl_git_pass", "(", "git_buf_putc", "(", "out", ",", "'", "'", ")", ")", ";", "#endif", "in_buf", "=", "git_buf_cstr", "(", "&", "path_buf", ")", ";", "while", "(", "*", "in_buf", ")", "{", "if", "(", "*", "in_buf", "==", "'", "'", ")", "cl_git_pass", "(", "git_buf_puts", "(", "out", ",", "\"", "\"", ")", ")", ";", "else", "cl_git_pass", "(", "git_buf_putc", "(", "out", ",", "*", "in_buf", ")", ")", ";", "in_buf", "++", ";", "}", "git_buf_free", "(", "&", "path_buf", ")", ";", "}" ]

[ "TODO", ":", "This", "is", "copy", "/", "pasted", "from", "network", "/", "remotelocal", ".", "c", "." ]

[ "/*\n\t * A FILE uri matches the following format: file://[host]/path\n\t * where \"host\" can be empty and \"path\" is an absolute path to the resource.\n\t *\n\t * In this test, no hostname is used, but we have to ensure the leading triple slashes:\n\t *\n\t * *nix: file:///usr/home/...\n\t * Windows: file:///C:/Users/...\n\t */", "/*\n\t * A very hacky Url encoding that only takes care of escaping the spaces\n\t */" ]

[ { "param": "out", "type": "git_buf" }, { "param": "fixture", "type": "char" } ]

[ "Apache-2.0" ]

[ "Entry", "is", "not", "guaranteed", "to", "be", "fully", "populated", ".", "For", "a", "tree", "iterator", "we", "will", "only", "populate", "the", "mode", "oid", "and", "path", "for", "example", ".", "For", "a", "workdir", "iterator", "we", "will", "not", "populate", "the", "oid", ".", "You", "do", "not", "need", "to", "free", "the", "entry", ".", "It", "is", "still", "\"", "owned", "\"", "by", "the", "iterator", ".", "Once", "you", "call", "`", "git_iterator_advance", "`", "then", "content", "of", "the", "old", "entry", "is", "no", "longer", "guaranteed", "to", "be", "valid", "." ]

[ "GIT_INLINE", "(", "int", ")", "git_iterator_current", "(", "git_iterator", "*", "iter", ",", "const", "git_index_entry", "*", "*", "entry", ")", "{", "return", "iter", "->", "current", "(", "iter", ",", "entry", ")", ";", "}" ]

[ "Entry", "is", "not", "guaranteed", "to", "be", "fully", "populated", "." ]

[]

[ { "param": "iter", "type": "git_iterator" }, { "param": "entry", "type": "git_index_entry" } ]

[ "Apache-2.0" ]

[ "Initialize", "SPI", "Master", "-", "note", "that", "ADXL345", "needs", "Mode", "3", "and", "uSD", "usually", "needs", "Mode", "0", "but", "most", "SD", "disk", "seem", "to", "to", "work", "fine", "with", "Mode", "3", "so", "leave", "as", "Mode", "3", ".", "Also", "note", "that", "uSD", "'", "s", "don", "'", "t", "like", "SPI", "receive", "with", "transmit", "register", "containing", "0x00", "-", "set", "to", "0xFF", "-", "otherwise", "CMD8", "returns", "0x82", "." ]

[ "void", "Init_SPI_Master", "(", "void", ")", "{", "DDRB", "|=", "(", "(", "1", "<<", "PB7", ")", "|", "(", "1", "<<", "PB5", ")", "|", "(", "1", "<<", "PB4", ")", "|", "(", "1", "<<", "PB3", ")", ")", ";", "PORTB", "|=", "0xBC", ";", "SPCR", "=", "(", "1", "<<", "SPE", ")", "|", "(", "1", "<<", "MSTR", ")", "|", "(", "1", "<<", "CPOL", ")", "|", "(", "1", "<<", "CPHA", ")", ";", "SPSR", "=", "(", "1", "<<", "SPI2X", ")", ";", "}" ]

[ "Initialize", "SPI", "Master", "-", "note", "that", "ADXL345", "needs", "Mode", "3", "and", "uSD", "usually", "needs", "Mode", "0", "but", "most", "SD", "disk", "seem", "to", "to", "work", "fine", "with", "Mode", "3", "so", "leave", "as", "Mode", "3", "." ]

[ "// Set MOSI, SCK and SS output, all others input", "// PB7-SCK, PB6-MISO, PB5-MOSI, PB4-SS, PB3-uSD CS", "// Set bits MOSI & SCK", "// Enable SPI, Master, set clock rate fck", "// Select SPI Mode 3 - CPOL=1, CPHA=1 clk/8", "//\tSPCR = (1<<SPE)|(1<<MSTR)|(1<<CPOL)|(1<<CPHA)|(1<<SPR0);", "// Select SPI Mode 3 - CPOL=1, CPHA=1 clk/2", "// Select SPI Mode 0 - CPOL=0, CPHA=0 clk/64", "//\tSPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(1<<SPR0);", "// Select SPI Mode 0 - CPOL=0, CPHA=0 clk/2", "//\tSPCR = (1<<SPE)|(1<<MSTR);", "// Chan's code", "//\tSPCR = 0x50;", "// SPSR = (1 << SPI2X);" ]

[]

[ "Apache-2.0" ]

[ "Computes", "the", "dot", "product", "of", "two", "vectors" ]

[ "double", "Vector_Dot_Product", "(", "double", "v1", "[", "3", "]", ",", "double", "v2", "[", "3", "]", ")", "{", "double", "result", "=", "0", ";", "for", "(", "int", "c", "=", "0", ";", "c", "<", "3", ";", "c", "++", ")", "{", "result", "+=", "v1", "[", "c", "]", "*", "v2", "[", "c", "]", ";", "}", "return", "result", ";", "}" ]

[ "Computes", "the", "dot", "product", "of", "two", "vectors" ]

[]

[ { "param": "v1", "type": "double" }, { "param": "v2", "type": "double" } ]

[ "Apache-2.0" ]

[ "Computes", "the", "cross", "product", "of", "two", "vectors", "out", "has", "to", "different", "from", "v1", "and", "v2", "(", "no", "in", "-", "place", ")", "!" ]

[ "void", "Vector_Cross_Product", "(", "double", "out", "[", "3", "]", ",", "double", "v1", "[", "3", "]", ",", "double", "v2", "[", "3", "]", ")", "{", "out", "[", "0", "]", "=", "(", "v1", "[", "1", "]", "*", "v2", "[", "2", "]", ")", "-", "(", "v1", "[", "2", "]", "*", "v2", "[", "1", "]", ")", ";", "out", "[", "1", "]", "=", "(", "v1", "[", "2", "]", "*", "v2", "[", "0", "]", ")", "-", "(", "v1", "[", "0", "]", "*", "v2", "[", "2", "]", ")", ";", "out", "[", "2", "]", "=", "(", "v1", "[", "0", "]", "*", "v2", "[", "1", "]", ")", "-", "(", "v1", "[", "1", "]", "*", "v2", "[", "0", "]", ")", ";", "}" ]

[ "Computes", "the", "cross", "product", "of", "two", "vectors", "out", "has", "to", "different", "from", "v1", "and", "v2", "(", "no", "in", "-", "place", ")", "!" ]

[]

[ { "param": "out", "type": "double" }, { "param": "v1", "type": "double" }, { "param": "v2", "type": "double" } ]

[ "Apache-2.0" ]

[ "Multiply", "the", "vector", "by", "a", "scalar" ]

[ "void", "Vector_Scale", "(", "double", "out", "[", "3", "]", ",", "double", "v", "[", "3", "]", ",", "double", "scale", ")", "{", "for", "(", "int", "c", "=", "0", ";", "c", "<", "3", ";", "c", "++", ")", "{", "out", "[", "c", "]", "=", "v", "[", "c", "]", "*", "scale", ";", "}", "}" ]

[ "Multiply", "the", "vector", "by", "a", "scalar" ]

[]

[ { "param": "out", "type": "double" }, { "param": "v", "type": "double" }, { "param": "scale", "type": "double" } ]

[ "Apache-2.0" ]

[ "Init", "rotation", "matrix", "using", "euler", "angles" ]

[ "void", "init_rotation_matrix", "(", "double", "m", "[", "3", "]", "[", "3", "]", ",", "double", "yaw", ",", "double", "pitch", ",", "double", "roll", ")", "{", "double", "c1", "=", "cos", "(", "roll", ")", ";", "double", "s1", "=", "sin", "(", "roll", ")", ";", "double", "c2", "=", "cos", "(", "pitch", ")", ";", "double", "s2", "=", "sin", "(", "pitch", ")", ";", "double", "c3", "=", "cos", "(", "yaw", ")", ";", "double", "s3", "=", "sin", "(", "yaw", ")", ";", "m", "[", "0", "]", "[", "0", "]", "=", "c2", "*", "c3", ";", "m", "[", "0", "]", "[", "1", "]", "=", "c3", "*", "s1", "*", "s2", "-", "c1", "*", "s3", ";", "m", "[", "0", "]", "[", "2", "]", "=", "s1", "*", "s3", "+", "c1", "*", "c3", "*", "s2", ";", "m", "[", "1", "]", "[", "0", "]", "=", "c2", "*", "s3", ";", "m", "[", "1", "]", "[", "1", "]", "=", "c1", "*", "c3", "+", "s1", "*", "s2", "*", "s3", ";", "m", "[", "1", "]", "[", "2", "]", "=", "c1", "*", "s2", "*", "s3", "-", "c3", "*", "s1", ";", "m", "[", "2", "]", "[", "0", "]", "=", "-", "s2", ";", "m", "[", "2", "]", "[", "1", "]", "=", "c2", "*", "s1", ";", "m", "[", "2", "]", "[", "2", "]", "=", "c1", "*", "c2", ";", "}" ]

[ "Init", "rotation", "matrix", "using", "euler", "angles" ]

[ "// Euler angles, right-handed, intrinsic, XYZ convention", "// (which means: rotate around body axes Z, Y', X'')" ]

[ { "param": "m", "type": "double" }, { "param": "yaw", "type": "double" }, { "param": "pitch", "type": "double" }, { "param": "roll", "type": "double" } ]

[ "MIT" ]

[ "wraps", "RSA", "key", "generation", "DER", "encoding", "and", "initial", "SHA", "-", "1", "hashing" ]

[ "RSA", "*", "easygen", "(", "uint16_t", "num", ",", "uint8_t", "len", ",", "uint8_t", "*", "der", ",", "uint8_t", "edl", ",", "SHA_CTX", "*", "ctx", ")", "{", "uint8_t", "der_len", ";", "RSA", "*", "rsa", ";", "for", "(", ";", ";", ")", "{", "rsa", "=", "RSA_generate_key", "(", "num", ",", "3", ",", "NULL", ",", "NULL", ")", ";", "if", "(", "!", "rsa", ")", "return", "rsa", ";", "uint8_t", "*", "tmp", "=", "der", ";", "der_len", "=", "i2d_RSAPublicKey", "(", "rsa", ",", "&", "tmp", ")", ";", "if", "(", "der_len", "==", "edl", "-", "len", "+", "1", ")", "break", ";", "RSA_free", "(", "rsa", ")", ";", "}", "der", "[", "RSA_ADD_DER_OFF", "]", "+=", "len", "-", "1", ";", "der", "[", "der_len", "-", "2", "]", "+=", "len", "-", "1", ";", "SHA1_Init", "(", "ctx", ")", ";", "SHA1_Update", "(", "ctx", ",", "der", ",", "der_len", "-", "1", ")", ";", "return", "rsa", ";", "}" ]

[ "wraps", "RSA", "key", "generation", "DER", "encoding", "and", "initial", "SHA", "-", "1", "hashing" ]

[ "// ugly, I know, but better than using goto IMHO", "// if key generation fails (no [P]RNG seed?)", "// encode RSA key in X.690 DER format", "// encoded key was the correct size, keep going", "// encoded key was the wrong size, try again", "// adjust for the actual size of e", "// and prepare our hash context" ]

[ { "param": "num", "type": "uint16_t" }, { "param": "len", "type": "uint8_t" }, { "param": "der", "type": "uint8_t" }, { "param": "edl", "type": "uint8_t" }, { "param": "ctx", "type": "SHA_CTX" } ]

[ "Apache-2.0" ]

[ "@brief", "Find", "object", "by", "id", "in", "the", "container", "@param", "id", "the", "id", "of", "the", "object", "@return", "the", "raw", "pointer", "to", "the", "object", "if", "found", ".", "@return", "nullptr", "if", "the", "object", "is", "not", "found", "." ]

[ "T", "*", "Find", "(", "const", "I", "id", ")", "{", "auto", "iter", "", "=", "object_dict_", ".", "find", "(", "id", ")", ";", "if", "(", "iter", "==", "object_dict_", ".", "end", "(", ")", ")", "{", "return", "nullptr", ";", "}", "else", "{", "return", "&", "iter", "->", "second", ";", "}", "}" ]

[ "@brief", "Find", "object", "by", "id", "in", "the", "container", "@param", "id", "the", "id", "of", "the", "object", "@return", "the", "raw", "pointer", "to", "the", "object", "if", "found", "." ]

[]

[ { "param": "id", "type": "I" } ]

[ "Apache-2.0" ]

[ "Pre", "-", "4", ".", "20", "kernels", "have", "a", "bug", "where", "CephFS", "uses", "the", "RADOS", "copy", "-", "from", "command", "in", "copy_file_range", "()", "when", "it", "shouldn", "'", "t", ".", "There", "is", "no", "workaround", "except", "to", "fall", "back", "to", "a", "regular", "copy", "." ]

[ "static", "int", "uv__is_buggy_cephfs", "(", "int", "fd", ")", "{", "struct", "statfs", "s", ";", "if", "(", "-1", "==", "fstatfs", "(", "fd", ",", "&", "s", ")", ")", "return", "0", ";", "if", "(", "s", ".", "f_type", "!=", "0xC36400", ")", "return", "0", ";", "return", "uv__kernel_version", "(", ")", "<", "0x041400", ";", "}" ]

[ "Pre", "-", "4", ".", "20", "kernels", "have", "a", "bug", "where", "CephFS", "uses", "the", "RADOS", "copy", "-", "from", "command", "in", "copy_file_range", "()", "when", "it", "shouldn", "'", "t", "." ]

[ "/* CephFS */", "/* 4.20.0 */" ]

[ { "param": "fd", "type": "int" } ]

[ "Apache-2.0" ]

[ "return", "uv", "errno", "from", "posix", "errno", "why", "so", "WET" ]

[ "cat_errno_t", "cat_translate_unix_error", "(", "int", "error", ")", "{", "#define", "CAT_ERROR_GEN", "(", "name", ",", "_", ")", "\\\n if(error == name){\\\n return CAT_##name;\\\n }", "\n\n", "ORIG_ERRNO_MAP", "(", "CAT_ERROR_GEN", ")", "", "#undef", " CAT_ERROR_GEN", "\n\n", "return", "CAT_UNCODED", ";", "}" ]

[ "return", "uv", "errno", "from", "posix", "errno", "why", "so", "WET" ]

[]

[ { "param": "error", "type": "int" } ]

[ "Apache-2.0" ]

[ "One", "-", "time", "initialization", "code", "for", "functionality", "defined", "in", "util", ".", "c", "." ]

[ "void", "uv__util_init", "(", "void", ")", "{", "LARGE_INTEGER", "perf_frequency", ";", "InitializeCriticalSection", "(", "&", "process_title_lock", ")", ";", "if", "(", "QueryPerformanceFrequency", "(", "&", "perf_frequency", ")", ")", "{", "hrtime_frequency_", "=", "perf_frequency", ".", "QuadPart", ";", "}", "else", "{", "uv_fatal_error", "(", "GetLastError", "(", ")", ",", "\"", "\"", ")", ";", "}", "}" ]

[ "One", "-", "time", "initialization", "code", "for", "functionality", "defined", "in", "util", ".", "c", "." ]

[ "/* Initialize process title access mutex. */", "/* Retrieve high-resolution timer frequency\n * and precompute its reciprocal.\n */" ]

[]

[ "Apache-2.0" ]

[ "Converts", "a", "UTF", "-", "8", "string", "into", "a", "UTF", "-", "16", "one", ".", "The", "resulting", "string", "is", "null", "-", "terminated", ".", "If", "utf8", "is", "null", "terminated", "utf8len", "can", "be", "set", "to", "-", "1", "otherwise", "it", "must", "be", "specified", "." ]

[ "int", "uv__convert_utf8_to_utf16", "(", "const", "char", "*", "utf8", ",", "int", "utf8len", ",", "WCHAR", "*", "*", "utf16", ")", "{", "int", "bufsize", ";", "if", "(", "utf8", "==", "NULL", ")", "return", "UV_EINVAL", ";", "bufsize", "=", "MultiByteToWideChar", "(", "CP_UTF8", ",", "0", ",", "utf8", ",", "utf8len", ",", "NULL", ",", "0", ")", ";", "if", "(", "bufsize", "==", "0", ")", "return", "uv_translate_sys_error", "(", "GetLastError", "(", ")", ")", ";", "*", "utf16", "=", "uv__malloc", "(", "sizeof", "(", "WCHAR", ")", "*", "(", "bufsize", "+", "1", ")", ")", ";", "if", "(", "*", "utf16", "==", "NULL", ")", "return", "UV_ENOMEM", ";", "bufsize", "=", "MultiByteToWideChar", "(", "CP_UTF8", ",", "0", ",", "utf8", ",", "utf8len", ",", "*", "utf16", ",", "bufsize", ")", ";", "if", "(", "bufsize", "==", "0", ")", "{", "uv__free", "(", "*", "utf16", ")", ";", "*", "utf16", "=", "NULL", ";", "return", "uv_translate_sys_error", "(", "GetLastError", "(", ")", ")", ";", "}", "(", "*", "utf16", ")", "[", "bufsize", "]", "=", "L'", "\\0", "'", ";", "return", "0", ";", "}" ]

[ "Converts", "a", "UTF", "-", "8", "string", "into", "a", "UTF", "-", "16", "one", "." ]

[ "/* Check how much space we need */", "/* Allocate the destination buffer adding an extra byte for the terminating\n * NULL. If utf8len is not -1 MultiByteToWideChar will not add it, so\n * we do it ourselves always, just in case. */", "/* Convert to UTF-16 */" ]

[ { "param": "utf8", "type": "char" }, { "param": "utf8len", "type": "int" }, { "param": "utf16", "type": "WCHAR" } ]

[ "Apache-2.0" ]

[ "Runs", "in", "CF", "thread", "pushed", "event", "into", "handle", "'", "s", "event", "list" ]

[ "static", "void", "uv__fsevents_push_event", "(", "uv_fs_event_t", "*", "handle", ",", "QUEUE", "*", "events", ",", "int", "err", ")", "{", "assert", "(", "events", "!=", "NULL", "||", "err", "!=", "0", ")", ";", "uv_mutex_lock", "(", "&", "handle", "->", "cf_mutex", ")", ";", "if", "(", "events", "!=", "NULL", ")", "QUEUE_ADD", "(", "&", "handle", "->", "cf_events", ",", "events", ")", ";", "if", "(", "err", "!=", "0", ")", "handle", "->", "cf_error", "=", "err", ";", "uv_mutex_unlock", "(", "&", "handle", "->", "cf_mutex", ")", ";", "uv_async_send", "(", "handle", "->", "cf_cb", ")", ";", "}" ]

[ "Runs", "in", "CF", "thread", "pushed", "event", "into", "handle", "'", "s", "event", "list" ]

[ "/* Concatenate two queues */", "/* Propagate error */" ]

[ { "param": "handle", "type": "uv_fs_event_t" }, { "param": "events", "type": "QUEUE" }, { "param": "err", "type": "int" } ]

[ "Apache-2.0" ]

[ "Runs", "in", "CF", "thread", "when", "there", "'", "re", "events", "in", "FSEventStream" ]

[ "static", "void", "uv__fsevents_event_cb", "(", "const", "FSEventStreamRef", "streamRef", ",", "void", "*", "info", ",", "size_t", "numEvents", ",", "void", "*", "eventPaths", ",", "const", "FSEventStreamEventFlags", "eventFlags", "[", "]", ",", "const", "FSEventStreamEventId", "eventIds", "[", "]", ")", "{", "size_t", "i", ";", "int", "len", ";", "char", "*", "*", "paths", ";", "char", "*", "path", ";", "char", "*", "pos", ";", "uv_fs_event_t", "*", "handle", ";", "QUEUE", "*", "q", ";", "uv_loop_t", "*", "loop", ";", "uv__cf_loop_state_t", "*", "state", ";", "uv__fsevents_event_t", "*", "event", ";", "FSEventStreamEventFlags", "flags", ";", "QUEUE", "head", ";", "loop", "=", "info", ";", "state", "=", "loop", "->", "cf_state", ";", "assert", "(", "state", "!=", "NULL", ")", ";", "paths", "=", "eventPaths", ";", "uv_mutex_lock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "QUEUE_FOREACH", "(", "q", ",", "&", "state", "->", "fsevent_handles", ")", "", "{", "handle", "=", "QUEUE_DATA", "(", "q", ",", "uv_fs_event_t", ",", "cf_member", ")", ";", "QUEUE_INIT", "(", "&", "head", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "numEvents", ";", "i", "++", ")", "{", "flags", "=", "eventFlags", "[", "i", "]", ";", "if", "(", "flags", "&", "kFSEventsSystem", ")", "continue", ";", "path", "=", "paths", "[", "i", "]", ";", "len", "=", "strlen", "(", "path", ")", ";", "if", "(", "handle", "->", "realpath_len", "==", "0", ")", "continue", ";", "if", "(", "len", "<", "handle", "->", "realpath_len", ")", "continue", ";", "if", "(", "handle", "->", "realpath_len", "!=", "len", "&&", "handle", "->", "realpath_len", ">", "1", "&&", "path", "[", "handle", "->", "realpath_len", "]", "!=", "'", "'", ")", "continue", ";", "if", "(", "memcmp", "(", "path", ",", "handle", "->", "realpath", ",", "handle", "->", "realpath_len", ")", "!=", "0", ")", "continue", ";", "if", "(", "!", "(", "handle", "->", "realpath_len", "==", "1", "&&", "handle", "->", "realpath", "[", "0", "]", "==", "'", "'", ")", ")", "{", "path", "+=", "handle", "->", "realpath_len", ";", "len", "-=", "handle", "->", "realpath_len", ";", "if", "(", "len", "<=", "1", "&&", "(", "flags", "&", "kFSEventStreamEventFlagItemIsDir", ")", ")", "continue", ";", "if", "(", "len", "==", "0", ")", "{", "while", "(", "len", "<", "handle", "->", "realpath_len", "&&", "path", "[", "-1", "]", "!=", "'", "'", ")", "{", "path", "--", ";", "len", "++", ";", "}", "flags", "&=", "~", "kFSEventsRenamed", ";", "}", "else", "{", "path", "++", ";", "len", "--", ";", "}", "}", "if", "(", "(", "handle", "->", "cf_flags", "&", "UV_FS_EVENT_RECURSIVE", ")", "==", "0", "&&", "*", "path", "!=", "'", "\\0", "'", ")", "{", "pos", "=", "strchr", "(", "path", "+", "1", ",", "'", "'", ")", ";", "if", "(", "pos", "!=", "NULL", ")", "continue", ";", "}", "event", "=", "uv__malloc", "(", "sizeof", "(", "*", "event", ")", "+", "len", ")", ";", "if", "(", "event", "==", "NULL", ")", "break", ";", "memset", "(", "event", ",", "0", ",", "sizeof", "(", "*", "event", ")", ")", ";", "memcpy", "(", "event", "->", "path", ",", "path", ",", "len", "+", "1", ")", ";", "event", "->", "events", "=", "UV_RENAME", ";", "if", "(", "0", "==", "(", "flags", "&", "kFSEventsRenamed", ")", ")", "{", "if", "(", "0", "!=", "(", "flags", "&", "kFSEventsModified", ")", "||", "0", "==", "(", "flags", "&", "kFSEventStreamEventFlagItemIsDir", ")", ")", "event", "->", "events", "=", "UV_CHANGE", ";", "}", "QUEUE_INSERT_TAIL", "(", "&", "head", ",", "&", "event", "->", "member", ")", ";", "}", "if", "(", "!", "QUEUE_EMPTY", "(", "&", "head", ")", ")", "uv__fsevents_push_event", "(", "handle", ",", "&", "head", ",", "0", ")", ";", "}", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "}" ]

[ "Runs", "in", "CF", "thread", "when", "there", "'", "re", "events", "in", "FSEventStream" ]

[ "/* For each handle */", "/* Process and filter out events */", "/* Ignore system events */", "/* This should be unreachable */", "/* Filter out paths that are outside handle's request */", "/* Make sure that realpath actually named a directory,\n * (unless watching root, which alone keeps a trailing slash on the realpath)\n * or that we matched the whole string */", "/* Remove common prefix, unless the watched folder is \"/\" */", "/* Ignore events with path equal to directory itself */", "/* Since we're using fsevents to watch the file itself,\n * realpath == path, and we now need to get the basename of the file back\n * (for commonality with other codepaths and platforms). */", "/* Created and Removed seem to be always set, but don't make sense */", "/* Skip forward slash */", "/* Do not emit events from subdirectories (without option set) */" ]

[ { "param": "streamRef", "type": "FSEventStreamRef" }, { "param": "info", "type": "void" }, { "param": "numEvents", "type": "size_t" }, { "param": "eventPaths", "type": "void" }, { "param": "eventFlags", "type": "FSEventStreamEventFlags" }, { "param": "eventIds", "type": "FSEventStreamEventId" } ]

[ "Apache-2.0" ]

[ "Runs", "in", "CF", "thread", "when", "there", "'", "re", "new", "fsevent", "handles", "to", "add", "to", "stream" ]

[ "static", "void", "uv__fsevents_reschedule", "(", "uv_fs_event_t", "*", "handle", ",", "uv__cf_loop_signal_type_t", "type", ")", "{", "uv__cf_loop_state_t", "*", "state", ";", "QUEUE", "*", "q", ";", "uv_fs_event_t", "*", "curr", ";", "CFArrayRef", "cf_paths", ";", "CFStringRef", "*", "paths", ";", "unsigned", "int", "i", ";", "int", "err", ";", "unsigned", "int", "path_count", ";", "state", "=", "handle", "->", "loop", "->", "cf_state", ";", "paths", "=", "NULL", ";", "cf_paths", "=", "NULL", ";", "err", "=", "0", ";", "i", "=", "0", ";", "uv_mutex_lock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "if", "(", "state", "->", "fsevent_need_reschedule", "==", "0", ")", "{", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "goto", "final", ";", "}", "state", "->", "fsevent_need_reschedule", "=", "0", ";", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "uv__fsevents_destroy_stream", "(", "handle", "->", "loop", ")", ";", "err", "=", "UV_ENOMEM", ";", "uv_mutex_lock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "path_count", "=", "state", "->", "fsevent_handle_count", ";", "if", "(", "path_count", "!=", "0", ")", "{", "paths", "=", "uv__malloc", "(", "sizeof", "(", "*", "paths", ")", "*", "path_count", ")", ";", "if", "(", "paths", "==", "NULL", ")", "{", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "goto", "final", ";", "}", "q", "=", "&", "state", "->", "fsevent_handles", ";", "for", "(", ";", "i", "<", "path_count", ";", "i", "++", ")", "{", "q", "=", "QUEUE_NEXT", "(", "q", ")", ";", "assert", "(", "q", "!=", "&", "state", "->", "fsevent_handles", ")", ";", "curr", "=", "QUEUE_DATA", "(", "q", ",", "uv_fs_event_t", ",", "cf_member", ")", ";", "assert", "(", "curr", "->", "realpath", "!=", "NULL", ")", ";", "paths", "[", "i", "]", "=", "pCFStringCreateWithFileSystemRepresentation", "(", "NULL", ",", "curr", "->", "realpath", ")", ";", "if", "(", "paths", "[", "i", "]", "==", "NULL", ")", "{", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "goto", "final", ";", "}", "}", "}", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "err", "=", "0", ";", "if", "(", "path_count", "!=", "0", ")", "{", "cf_paths", "=", "pCFArrayCreate", "(", "NULL", ",", "(", "const", "void", "*", "*", ")", "paths", ",", "path_count", ",", "NULL", ")", ";", "if", "(", "cf_paths", "==", "NULL", ")", "{", "err", "=", "UV_ENOMEM", ";", "goto", "final", ";", "}", "err", "=", "uv__fsevents_create_stream", "(", "handle", "->", "loop", ",", "cf_paths", ")", ";", "}", "final", ":", "if", "(", "err", "!=", "0", ")", "{", "if", "(", "cf_paths", "==", "NULL", ")", "{", "while", "(", "i", "!=", "0", ")", "pCFRelease", "(", "paths", "[", "--", "i", "]", ")", ";", "uv__free", "(", "paths", ")", ";", "}", "else", "{", "pCFRelease", "(", "cf_paths", ")", ";", "}", "uv_mutex_lock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "QUEUE_FOREACH", "(", "q", ",", "&", "state", "->", "fsevent_handles", ")", "", "{", "curr", "=", "QUEUE_DATA", "(", "q", ",", "uv_fs_event_t", ",", "cf_member", ")", ";", "uv__fsevents_push_event", "(", "curr", ",", "NULL", ",", "err", ")", ";", "}", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "}", "if", "(", "type", "==", "kUVCFLoopSignalClosing", ")", "uv_sem_post", "(", "&", "state", "->", "fsevent_sem", ")", ";", "}" ]

[ "Runs", "in", "CF", "thread", "when", "there", "'", "re", "new", "fsevent", "handles", "to", "add", "to", "stream" ]

[ "/* NOTE: `i` is used in deallocation loop below */", "/* Optimization to prevent O(n^2) time spent when starting to watch\n * many files simultaneously\n */", "/* Destroy previous FSEventStream */", "/* Any failure below will be a memory failure */", "/* Create list of all watched paths */", "/* Create new FSEventStream */", "/* Deallocate all paths in case of failure */", "/* CFArray takes ownership of both strings and original C-array */", "/* Broadcast error to all handles */", "/*\n * Main thread will block until the removal of handle from the list,\n * we must tell it when we're ready.\n *\n * NOTE: This is coupled with `uv_sem_wait()` in `uv__fsevents_close`\n */" ]

[ { "param": "handle", "type": "uv_fs_event_t" }, { "param": "type", "type": "uv__cf_loop_signal_type_t" } ]

[ "Apache-2.0" ]

[ "Runs", "in", "CF", "thread", ".", "This", "is", "the", "CF", "loop", "'", "s", "body" ]

[ "static", "void", "*", "uv__cf_loop_runner", "(", "void", "*", "arg", ")", "{", "uv_loop_t", "*", "loop", ";", "uv__cf_loop_state_t", "*", "state", ";", "loop", "=", "arg", ";", "state", "=", "loop", "->", "cf_state", ";", "state", "->", "loop", "=", "pCFRunLoopGetCurrent", "(", ")", ";", "pCFRunLoopAddSource", "(", "state", "->", "loop", ",", "state", "->", "signal_source", ",", "*", "pkCFRunLoopDefaultMode", ")", ";", "uv_sem_post", "(", "&", "loop", "->", "cf_sem", ")", ";", "pCFRunLoopRun", "(", ")", ";", "pCFRunLoopRemoveSource", "(", "state", "->", "loop", ",", "state", "->", "signal_source", ",", "*", "pkCFRunLoopDefaultMode", ")", ";", "state", "->", "loop", "=", "NULL", ";", "return", "NULL", ";", "}" ]

[ "Runs", "in", "CF", "thread", "." ]

[]

[ { "param": "arg", "type": "void" } ]

[ "Apache-2.0" ]

[ "Runs", "in", "UV", "loop", "to", "notify", "CF", "thread" ]

[ "int", "uv__cf_loop_signal", "(", "uv_loop_t", "*", "loop", ",", "uv_fs_event_t", "*", "handle", ",", "uv__cf_loop_signal_type_t", "type", ")", "{", "uv__cf_loop_signal_t", "*", "item", ";", "uv__cf_loop_state_t", "*", "state", ";", "item", "=", "uv__malloc", "(", "sizeof", "(", "*", "item", ")", ")", ";", "if", "(", "item", "==", "NULL", ")", "return", "UV_ENOMEM", ";", "item", "->", "handle", "=", "handle", ";", "item", "->", "type", "=", "type", ";", "uv_mutex_lock", "(", "&", "loop", "->", "cf_mutex", ")", ";", "QUEUE_INSERT_TAIL", "(", "&", "loop", "->", "cf_signals", ",", "&", "item", "->", "member", ")", ";", "state", "=", "loop", "->", "cf_state", ";", "assert", "(", "state", "!=", "NULL", ")", ";", "pCFRunLoopSourceSignal", "(", "state", "->", "signal_source", ")", ";", "pCFRunLoopWakeUp", "(", "state", "->", "loop", ")", ";", "uv_mutex_unlock", "(", "&", "loop", "->", "cf_mutex", ")", ";", "return", "0", ";", "}" ]

[ "Runs", "in", "UV", "loop", "to", "notify", "CF", "thread" ]

[]

[ { "param": "loop", "type": "uv_loop_t" }, { "param": "handle", "type": "uv_fs_event_t" }, { "param": "type", "type": "uv__cf_loop_signal_type_t" } ]

[ "Apache-2.0" ]

[ "Runs", "in", "UV", "loop", "to", "initialize", "handle" ]

[ "int", "uv__fsevents_init", "(", "uv_fs_event_t", "*", "handle", ")", "{", "int", "err", ";", "uv__cf_loop_state_t", "*", "state", ";", "err", "=", "uv__fsevents_loop_init", "(", "handle", "->", "loop", ")", ";", "if", "(", "err", ")", "return", "err", ";", "handle", "->", "realpath", "=", "realpath", "(", "handle", "->", "path", ",", "NULL", ")", ";", "if", "(", "handle", "->", "realpath", "==", "NULL", ")", "return", "UV__ERR", "(", "errno", ")", ";", "handle", "->", "realpath_len", "=", "strlen", "(", "handle", "->", "realpath", ")", ";", "QUEUE_INIT", "(", "&", "handle", "->", "cf_events", ")", ";", "handle", "->", "cf_error", "=", "0", ";", "handle", "->", "cf_cb", "=", "uv__malloc", "(", "sizeof", "(", "*", "handle", "->", "cf_cb", ")", ")", ";", "if", "(", "handle", "->", "cf_cb", "==", "NULL", ")", "{", "err", "=", "UV_ENOMEM", ";", "goto", "fail_cf_cb_malloc", ";", "}", "handle", "->", "cf_cb", "->", "data", "=", "handle", ";", "uv_async_init", "(", "handle", "->", "loop", ",", "handle", "->", "cf_cb", ",", "uv__fsevents_cb", ")", ";", "handle", "->", "cf_cb", "->", "flags", "|=", "UV_HANDLE_INTERNAL", ";", "uv_unref", "(", "(", "uv_handle_t", "*", ")", "handle", "->", "cf_cb", ")", ";", "err", "=", "uv_mutex_init", "(", "&", "handle", "->", "cf_mutex", ")", ";", "if", "(", "err", ")", "goto", "fail_cf_mutex_init", ";", "state", "=", "handle", "->", "loop", "->", "cf_state", ";", "uv_mutex_lock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "QUEUE_INSERT_TAIL", "(", "&", "state", "->", "fsevent_handles", ",", "&", "handle", "->", "cf_member", ")", ";", "state", "->", "fsevent_handle_count", "++", ";", "state", "->", "fsevent_need_reschedule", "=", "1", ";", "uv_mutex_unlock", "(", "&", "state", "->", "fsevent_mutex", ")", ";", "assert", "(", "handle", "!=", "NULL", ")", ";", "err", "=", "uv__cf_loop_signal", "(", "handle", "->", "loop", ",", "handle", ",", "kUVCFLoopSignalRegular", ")", ";", "if", "(", "err", ")", "goto", "fail_loop_signal", ";", "return", "0", ";", "fail_loop_signal", ":", "uv_mutex_destroy", "(", "&", "handle", "->", "cf_mutex", ")", ";", "fail_cf_mutex_init", ":", "uv__free", "(", "handle", "->", "cf_cb", ")", ";", "handle", "->", "cf_cb", "=", "NULL", ";", "fail_cf_cb_malloc", ":", "uv__free", "(", "handle", "->", "realpath", ")", ";", "handle", "->", "realpath", "=", "NULL", ";", "handle", "->", "realpath_len", "=", "0", ";", "return", "err", ";", "}" ]

[ "Runs", "in", "UV", "loop", "to", "initialize", "handle" ]

[ "/* Get absolute path to file */", "/* Initialize event queue */", "/*\n * Events will occur in other thread.\n * Initialize callback for getting them back into event loop's thread\n */", "/* Insert handle into the list */", "/* Reschedule FSEventStream */" ]

[ { "param": "handle", "type": "uv_fs_event_t" } ]

[ "BSD-3-Clause" ]

[ "Set", "properties", "of", "the", "attached", "view", "." ]

[ "void", "SetViewProperties", "(", "float", "min_x", ",", "float", "min_y", ",", "float", "min_z", ",", "float", "max_x", ",", "float", "max_y", ",", "float", "max_z", ",", "float", "in_min_x", ",", "float", "in_min_y", ",", "float", "in_min_z", ",", "float", "in_max_x", ",", "float", "in_max_y", ",", "float", "in_max_z", ")", "{", "SetViewProperties", "(", "(", "float", "[", "3", "]", ")", "{", "min_x", ",", "min_y", ",", "min_z", "}", ",", "(", "float", "[", "3", "]", ")", "{", "max_x", ",", "max_y", ",", "max_z", "}", ",", "(", "float", "[", "3", "]", ")", "{", "in_min_x", ",", "in_min_y", ",", "in_min_z", "}", ",", "(", "float", "[", "3", "]", ")", "{", "in_max_x", ",", "in_max_y", ",", "in_max_z", "}", ")", ";", "}" ]

[ "Set", "properties", "of", "the", "attached", "view", "." ]

[]

[ { "param": "min_x", "type": "float" }, { "param": "min_y", "type": "float" }, { "param": "min_z", "type": "float" }, { "param": "max_x", "type": "float" }, { "param": "max_y", "type": "float" }, { "param": "max_z", "type": "float" }, { "param": "in_min_x", "type": "float" }, { "param": "in_min_y", "type": "float" }, { "param": "in_min_z", "type": "float" }, { "param": "in_max_x", "type": "float" }, { "param": "in_max_y", "type": "float" }, { "param": "in_max_z", "type": "float" } ]

[ "MIT" ]

[ "Given", "a", "path", "that", "may", "start", "with", "a", "PCI", "device", "populate", "the", "supplied", "buffer", "with", "the", "PCI", "domain", "/", "bus", "number", "and", "the", "peripheral", "ID", "and", "return", "0", ".", "If", "it", "doesn", "'", "t", "start", "with", "a", "PCI", "device", "or", "there", "is", "some", "error", "return", "-", "1" ]

[ "static", "int", "find_pci_device_prefix", "(", "const", "char", "*", "path", ",", "char", "*", "buf", ",", "ssize_t", "buf_sz", ")", "{", "const", "char", "*", "start", ",", "*", "end", ";", "if", "(", "strncmp", "(", "path", ",", "\"", "\"", ",", "12", ")", ")", "return", "-1", ";", "start", "=", "path", "+", "9", ";", "end", "=", "strchr", "(", "start", ",", "'", "'", ")", ";", "if", "(", "!", "end", ")", "return", "-1", ";", "end", "=", "strchr", "(", "end", "+", "1", ",", "'", "'", ")", ";", "if", "(", "!", "end", ")", "return", "-1", ";", "if", "(", "end", "-", "start", "+", "1", ">", "buf_sz", ")", "return", "-1", ";", "strncpy", "(", "buf", ",", "start", ",", "end", "-", "start", ")", ";", "buf", "[", "end", "-", "start", "]", "=", "'", "\\0", "'", ";", "return", "0", ";", "}" ]

[ "Given", "a", "path", "that", "may", "start", "with", "a", "PCI", "device", "populate", "the", "supplied", "buffer", "with", "the", "PCI", "domain", "/", "bus", "number", "and", "the", "peripheral", "ID", "and", "return", "0", "." ]

[ "/* Beginning of the prefix is the initial \"pci\" after \"/devices/\" */", "/* End of the prefix is two path '/' later, capturing the domain/bus number\n * and the peripheral ID. Example: pci0000:00/0000:00:1f.2 */", "/* Make sure we have enough room for the string plus null terminator */" ]

[ { "param": "path", "type": "char" }, { "param": "buf", "type": "char" }, { "param": "buf_sz", "type": "ssize_t" } ]

[ "MIT" ]

[ "do", "chown", "or", "chmod", "recursively", "with", "pattern", "matching" ]

[ "static", "int", "__chown_chmod_recur", "(", "enum", "builtin_cmds", "action", ",", "const", "char", "*", "matching_path", ",", "unsigned", "int", "uid", ",", "unsigned", "int", "gid", ",", "mode_t", "mode", ",", "const", "char", "*", "cur_path", ",", "int", "depth", ")", "{", "DIR", "*", "dirp", ";", "struct", "dirent", "*", "de", ";", "char", "*", "child_path", "=", "NULL", ";", "int", "len", ";", "int", "ret", "=", "0", ";", "if", "(", "!", "matching_path", ")", "{", "return", "-1", ";", "}", "if", "(", "!", "cur_path", ")", "{", "return", "-1", ";", "}", "if", "(", "depth", ">", "MAX_RECUR_DEPTH", ")", "{", "return", "0", ";", "}", "dirp", "=", "opendir", "(", "cur_path", ")", ";", "if", "(", "dirp", ")", "{", "while", "(", "(", "de", "=", "readdir", "(", "dirp", ")", ")", ")", "{", "if", "(", "(", "de", "->", "d_type", "==", "DT_DIR", ")", "&&", "(", "de", "->", "d_name", "[", "0", "]", "==", "'", "'", ")", "&&", "(", "(", "de", "->", "d_name", "[", "1", "]", "==", "'", "\\0", "'", ")", "||", "(", "(", "de", "->", "d_name", "[", "1", "]", "==", "'", "'", ")", "&&", "(", "de", "->", "d_name", "[", "2", "]", "==", "'", "\\0", "'", ")", ")", ")", ")", "{", "continue", ";", "}", "len", "=", "asprintf", "(", "&", "child_path", ",", "\"", "\"", ",", "cur_path", ",", "de", "->", "d_name", ")", ";", "if", "(", "len", "!=", "-1", ")", "{", "if", "(", "de", "->", "d_type", "==", "DT_DIR", ")", "{", "ret", "+=", "__chown_chmod_recur", "(", "action", ",", "matching_path", ",", "uid", ",", "gid", ",", "mode", ",", "child_path", ",", "(", "depth", "+", "1", ")", ")", ";", "}", "else", "{", "if", "(", "fnmatch", "(", "matching_path", ",", "child_path", ",", "FNM_PATHNAME", ")", "==", "0", ")", "{", "ret", "+=", "__chown_chmod_one", "(", "action", ",", "child_path", ",", "uid", ",", "gid", ",", "mode", ")", ";", "}", "}", "free", "(", "child_path", ")", ";", "child_path", "=", "NULL", ";", "}", "else", "{", "ret", "+=", "-1", ";", "}", "}", "closedir", "(", "dirp", ")", ";", "}", "return", "ret", ";", "}" ]

[ "do", "chown", "or", "chmod", "recursively", "with", "pattern", "matching" ]

[ "/* prevent this from doing infinitely recurison */", "/* ignore directories \".\" and \"..\" */", "/* prepare path */", "/* recurse into lowering level directory */", "/* FNM_PATHNAME: need to have the same number of '/' */", "/* failed to allocate space for child_path, */", "/* count as one failure. */" ]

[ { "param": "action", "type": "enum builtin_cmds" }, { "param": "matching_path", "type": "char" }, { "param": "uid", "type": "unsigned int" }, { "param": "gid", "type": "unsigned int" }, { "param": "mode", "type": "mode_t" }, { "param": "cur_path", "type": "char" }, { "param": "depth", "type": "int" } ]

[ "MIT" ]

[ "This", "function", "might", "request", "a", "reboot", "in", "which", "case", "it", "will", "not", "return", "." ]

[ "int", "do_mount_all", "(", "int", "nargs", ",", "char", "*", "*", "args", ")", "{", "pid_t", "pid", ";", "int", "ret", "=", "-1", ";", "int", "child_ret", "=", "-1", ";", "int", "status", ";", "const", "char", "*", "prop", ";", "struct", "fstab", "*", "fstab", ";", "if", "(", "nargs", "!=", "2", ")", "{", "return", "-1", ";", "}", "pid", "=", "fork", "(", ")", ";", "if", "(", "pid", ">", "0", ")", "{", "int", "wp_ret", "=", "TEMP_FAILURE_RETRY", "(", "waitpid", "(", "pid", ",", "&", "status", ",", "0", ")", ")", ";", "if", "(", "wp_ret", "<", "0", ")", "{", "NOTICE", "(", "\"", "\\n", "\"", ",", "wp_ret", ",", "errno", ")", ";", "}", "if", "(", "WIFEXITED", "(", "status", ")", ")", "{", "ret", "=", "WEXITSTATUS", "(", "status", ")", ";", "}", "else", "{", "ret", "=", "-1", ";", "}", "}", "else", "if", "(", "pid", "==", "0", ")", "{", "char", "*", "prop_val", ";", "klog_set_level", "(", "6", ")", ";", "prop_val", "=", "expand_references", "(", "args", "[", "1", "]", ")", ";", "if", "(", "!", "prop_val", ")", "{", "ERROR", "(", "\"", "\\n", "\"", ",", "args", "[", "1", "]", ")", ";", "return", "-1", ";", "}", "fstab", "=", "fs_mgr_read_fstab", "(", "prop_val", ")", ";", "free", "(", "prop_val", ")", ";", "child_ret", "=", "fs_mgr_mount_all", "(", "fstab", ")", ";", "fs_mgr_free_fstab", "(", "fstab", ")", ";", "if", "(", "child_ret", "==", "-1", ")", "{", "ERROR", "(", "\"", "\\n", "\"", ")", ";", "}", "_exit", "(", "child_ret", ")", ";", "}", "else", "{", "return", "-1", ";", "}", "if", "(", "ret", "==", "FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION", ")", "{", "property_set", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "}", "else", "if", "(", "ret", "==", "FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED", ")", "{", "property_set", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "property_set", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "}", "else", "if", "(", "ret", "==", "FS_MGR_MNTALL_DEV_NOT_ENCRYPTED", ")", "{", "property_set", "(", "\"", "\"", ",", "\"", "\"", ")", ";", "action_for_each_trigger", "(", "\"", "\"", ",", "action_add_queue_tail", ")", ";", "}", "else", "if", "(", "ret", "==", "FS_MGR_MNTALL_DEV_NEEDS_RECOVERY", ")", "{", "ERROR", "(", "\"", "\\n", "\"", ")", ";", "ret", "=", "wipe_data_via_recovery", "(", ")", ";", "}", "else", "if", "(", "ret", ">", "0", ")", "{", "ERROR", "(", "\"", "\\n", "\"", ",", "ret", ")", ";", "}", "return", "ret", ";", "}" ]

[ "This", "function", "might", "request", "a", "reboot", "in", "which", "case", "it", "will", "not", "return", "." ]

[ "/*\n * Call fs_mgr_mount_all() to mount all filesystems. We fork(2) and\n * do the call in the child to provide protection to the main init\n * process if anything goes wrong (crash or memory leak), and wait for\n * the child to finish in the parent.\n */", "/* Parent. Wait for the child to return */", "/* Unexpected error code. We will continue anyway. */", "/* child, call fs_mgr_mount_all() */", "/* So we can see what fs_mgr_mount_all() does */", "/* fork failed, return an error */", "/* If fs_mgr determined this is an unencrypted device, then trigger\n * that action.\n */", "/* Setup a wipe via recovery, and reboot into recovery */", "/* If reboot worked, there is no return. */", "/* else ... < 0: error */" ]

[ { "param": "nargs", "type": "int" }, { "param": "args", "type": "char" } ]

[ "MIT" ]

[ "This", "function", "populates", "the", "llist", "by", "reading", "the", "grammer", "text", "file" ]

[ "void", "readGrammar", "(", "char", "*", "fileName", ",", "Node", "*", "llist", ")", "{", "FILE", "*", "fp", "=", "fopen", "(", "fileName", ",", "\"", "\"", ")", ";", "if", "(", "fp", "==", "NULL", ")", "{", "printf", "(", "\"", "\\n", "\"", ",", "fileName", ")", ";", "exit", "(", "0", ")", ";", "}", "int", "line", "=", "0", ";", "char", "eachLine", "[", "1000", "]", ";", "while", "(", "fscanf", "(", "fp", ",", "\"", "\\n", "\"", ",", "eachLine", ")", "!=", "EOF", ")", "{", "char", "*", "delim", "=", "\"", "\"", ";", "char", "*", "token", ";", "token", "=", "strtok", "(", "eachLine", ",", "delim", ")", ";", "llist", "[", "line", "]", ".", "element", "=", "(", "char", "*", ")", "malloc", "(", "sizeof", "(", "char", ")", "*", "(", "strlen", "(", "token", ")", "+", "1", ")", ")", ";", "strcpy", "(", "llist", "[", "line", "]", ".", "element", ",", "token", ")", ";", "llist", "[", "line", "]", ".", "nxt", "=", "NULL", ";", "Node", "*", "curr", "=", "&", "llist", "[", "line", "]", ";", "token", "=", "strtok", "(", "NULL", ",", "delim", ")", ";", "int", "ruleSize", "=", "0", ";", "while", "(", "token", "!=", "NULL", ")", "{", "if", "(", "strcmp", "(", "ARROW", ",", "token", ")", "!=", "0", ")", "{", "Node", "*", "next", "=", "(", "Node", "*", ")", "malloc", "(", "sizeof", "(", "Node", ")", ")", ";", "next", "->", "element", "=", "(", "char", "*", ")", "malloc", "(", "sizeof", "(", "char", ")", "*", "(", "strlen", "(", "token", ")", "+", "1", ")", ")", ";", "strcpy", "(", "next", "->", "element", ",", "token", ")", ";", "next", "->", "ruleSize", "=", "0", ";", "next", "->", "nxt", "=", "NULL", ";", "curr", "->", "nxt", "=", "next", ";", "curr", "=", "next", ";", "ruleSize", "++", ";", "}", "token", "=", "strtok", "(", "NULL", ",", "delim", ")", ";", "}", "curr", "=", "&", "llist", "[", "line", "]", ";", "curr", "->", "ruleSize", "=", "ruleSize", ";", "line", "++", ";", "}", "fclose", "(", "fp", ")", ";", "}" ]

[ "This", "function", "populates", "the", "llist", "by", "reading", "the", "grammer", "text", "file" ]

[ "// Exit if file could not be opened", "// Read the file line by line", "// Extract the leftmost non-terminal of the rule" ]

[ { "param": "fileName", "type": "char" }, { "param": "llist", "type": "Node" } ]

[ "MIT" ]

[ "check", "if", "the", "token", "is", "an", "integer" ]

[ "int", "isNum", "(", "char", "*", "token", ")", "{", "char", "*", "ptr", "=", "token", ";", "for", "(", ";", "*", "ptr", "!=", "'", "\\0", "'", ";", "ptr", "++", ")", "{", "char", "ch", "=", "*", "ptr", ";", "if", "(", "!", "(", "ch", ">=", "'", "'", "&&", "ch", "<=", "'", "'", ")", ")", "{", "return", "0", ";", "}", "}", "return", "1", ";", "}" ]

[ "check", "if", "the", "token", "is", "an", "integer" ]

[]

[ { "param": "token", "type": "char" } ]

[ "MIT" ]

[ "check", "if", "the", "token", "id", "an", "ID" ]

[ "int", "isID", "(", "char", "*", "token", ")", "{", "char", "*", "ptr", "=", "token", ";", "char", "ch", "=", "*", "ptr", ";", "if", "(", "!", "(", "ch", "==", "'", "'", "||", "(", "ch", ">=", "'", "'", "&&", "ch", "<=", "'", "'", ")", "||", "(", "ch", ">=", "'", "'", "&&", "ch", "<=", "'", "'", ")", ")", ")", "{", "return", "0", ";", "}", "ptr", "++", ";", "for", "(", ";", "*", "ptr", "!=", "'", "\\0", "'", ";", "ptr", "++", ")", "{", "ch", "=", "*", "ptr", ";", "if", "(", "!", "(", "ch", "==", "'", "'", "||", "(", "ch", ">=", "'", "'", "&&", "ch", "<=", "'", "'", ")", "||", "(", "ch", ">=", "'", "'", "&&", "ch", "<=", "'", "'", ")", "||", "(", "ch", ">=", "'", "'", "&&", "ch", "<=", "'", "'", ")", ")", ")", "{", "return", "0", ";", "}", "}", "return", "1", ";", "}" ]

[ "check", "if", "the", "token", "id", "an", "ID" ]

[]

[ { "param": "token", "type": "char" } ]

[ "MIT" ]

[ "Takes", "input", "as", "a", "token", "and", "returns", "the", "appropriate", "TokenName" ]

[ "TokenName", "findCorrectToken", "(", "char", "*", "token", ")", "{", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "PROGRAM", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "RBOP", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "RBCL", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "CBOP", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "CBCL", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "SBOP", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "SBCL", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "DECLARE", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "LIST", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "OF", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "VARIABLES", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "ARRAY", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "JAGGED", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "SIZE", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "VALUES", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "INTEGER", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "REAL", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "BOOLEAN", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "COLON", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "SEMICOLON", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "PLUS", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "MINUS", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "MULT", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "DIV", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "AND", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "OR", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "TWODOT", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "R", ";", "}", "else", "if", "(", "strcmp", "(", "token", ",", "\"", "\"", ")", "==", "0", ")", "{", "return", "EQUALS", ";", "}", "else", "if", "(", "isNum", "(", "token", ")", ")", "{", "return", "NUM", ";", "}", "else", "if", "(", "isID", "(", "token", ")", ")", "{", "return", "ID", ";", "}", "else", "{", "return", "ERR", ";", "}", "}" ]

[ "Takes", "input", "as", "a", "token", "and", "returns", "the", "appropriate", "TokenName" ]

[]

[ { "param": "token", "type": "char" } ]

[ "Apache-2.0" ]

[ "Check", "if", "the", "first", "iterator", "is", "at", "end", ".", "In", "debug", "mode", "additionally", "check", "that", "at", "least", "one", "iterator", "is", "present", "and", "that", "all", "iterators", "'", "IsAtEnd", "()", "methods", "return", "the", "same", "thing" ]

[ "bool", "IsAtEnd", "(", ")", "{", "#ifdef", "NDEBUG", "return", "m_Iterators", "[", "0", "]", ".", "IsAtEnd", "(", ")", ";", "#else", "assert", "(", "m_Iterators", ".", "size", "(", ")", ")", ";", "bool", "retval", "=", "m_Iterators", "[", "0", "]", ".", "IsAtEnd", "(", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "m_Iterators", ".", "size", "(", ")", ";", "++", "i", ")", "assert", "(", "m_Iterators", "[", "i", "]", ".", "IsAtEnd", "(", ")", "==", "retval", ")", ";", "return", "retval", ";", "#endif", "}" ]

[ "Check", "if", "the", "first", "iterator", "is", "at", "end", "." ]

[]

[]

[ "Apache-2.0" ]

[ "This", "is", "the", "callback", "passed", "to", "the", "FSEvents", "API", "which", "calls", "the", "Python", "callback", "function", "in", "turn", "by", "passing", "in", "event", "data", "as", "Python", "objects", ".", ":", "param", "stream_ref", ":", "A", "pointer", "to", "an", "`", "`", "FSEventStream", "`", "`", "instance", ".", ":", "param", "stream_callback_info_ref", ":", "Callback", "context", "information", "passed", "by", "the", "FSEvents", "API", ".", "This", "contains", "a", "reference", "to", "the", "Python", "callback", "that", "this", "function", "calls", "in", "turn", "with", "information", "about", "the", "events", ".", ":", "param", "num_events", ":", "An", "unsigned", "integer", "representing", "the", "number", "of", "events", "captured", "by", "the", "FSEvents", "API", ".", ":", "param", "event_paths", ":", "An", "array", "of", "NUL", "-", "terminated", "C", "strings", "representing", "event", "paths", ".", ":", "param", "event_flags", ":", "An", "array", "of", "`", "`", "FSEventStreamEventFlags", "`", "`", "unsigned", "integral", "mask", "values", ".", ":", "param", "event_ids", ":", "An", "array", "of", "64", "-", "bit", "unsigned", "integers", "representing", "event", "identifiers", "." ]

[ "static", "void", "watchdog_FSEventStreamCallback", "(", "ConstFSEventStreamRef", "stream_ref", ",", "StreamCallbackInfo", "*", "stream_callback_info_ref", ",", "size_t", "num_events", ",", "const", "char", "*", "event_paths", "[", "]", ",", "const", "FSEventStreamEventFlags", "event_flags", "[", "]", ",", "const", "FSEventStreamEventId", "event_ids", "[", "]", ")", "{", "size_t", "i", "=", "0", ";", "PyObject", "*", "callback_result", "=", "NULL", ";", "PyObject", "*", "path", "=", "NULL", ";", "PyObject", "*", "flags", "=", "NULL", ";", "PyObject", "*", "py_event_flags", "=", "NULL", ";", "PyObject", "*", "py_event_paths", "=", "NULL", ";", "PyThreadState", "*", "saved_thread_state", "=", "NULL", ";", "PyEval_AcquireLock", "(", ")", ";", "saved_thread_state", "=", "PyThreadState_Swap", "(", "stream_callback_info_ref", "->", "thread_state", ")", ";", "py_event_paths", "=", "PyList_New", "(", "num_events", ")", ";", "py_event_flags", "=", "PyList_New", "(", "num_events", ")", ";", "if", "(", "G_NOT", "(", "py_event_paths", "&&", "py_event_flags", ")", ")", "{", "Py_DECREF", "(", "py_event_paths", ")", ";", "Py_DECREF", "(", "py_event_flags", ")", ";", "return", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "num_events", ";", "++", "i", ")", "{", "path", "=", "PyString_FromString", "(", "event_paths", "[", "i", "]", ")", ";", "flags", "=", "PyInt_FromLong", "(", "event_flags", "[", "i", "]", ")", ";", "if", "(", "G_NOT", "(", "path", "&&", "flags", ")", ")", "{", "Py_DECREF", "(", "py_event_paths", ")", ";", "Py_DECREF", "(", "py_event_flags", ")", ";", "return", ";", "}", "PyList_SET_ITEM", "(", "py_event_paths", ",", "i", ",", "path", ")", ";", "PyList_SET_ITEM", "(", "py_event_flags", ",", "i", ",", "flags", ")", ";", "}", "callback_result", "=", "PyObject_CallFunction", "(", "stream_callback_info_ref", "->", "python_callback", ",", "\"", "\"", ",", "py_event_paths", ",", "py_event_flags", ")", ";", "if", "(", "G_IS_NULL", "(", "callback_result", ")", ")", "{", "if", "(", "G_NOT", "(", "PyErr_Occurred", "(", ")", ")", ")", "{", "PyErr_SetString", "(", "PyExc_ValueError", ",", "ERROR_CANNOT_CALL_CALLBACK", ")", ";", "}", "CFRunLoopStop", "(", "stream_callback_info_ref", "->", "run_loop_ref", ")", ";", "}", "PyThreadState_Swap", "(", "saved_thread_state", ")", ";", "PyEval_ReleaseLock", "(", ")", ";", "}" ]

[ "This", "is", "the", "callback", "passed", "to", "the", "FSEvents", "API", "which", "calls", "the", "Python", "callback", "function", "in", "turn", "by", "passing", "in", "event", "data", "as", "Python", "objects", "." ]

[ "/* Acquire interpreter lock and save original thread state. */", "/* Convert event flags and paths to Python ints and strings. */", "/*NULL*/", "/*NULL*/", "/* Call the Python callback function supplied by the stream information\n * struct. The Python callback function should accept two arguments,\n * both being Python lists:\n *\n * def python_callback(event_paths, event_flags): \n * pass\n */", "/* Release the lock and restore thread state. */" ]

[ { "param": "stream_ref", "type": "ConstFSEventStreamRef" }, { "param": "stream_callback_info_ref", "type": "StreamCallbackInfo" }, { "param": "num_events", "type": "size_t" }, { "param": "event_paths", "type": "char" }, { "param": "event_flags", "type": "FSEventStreamEventFlags" }, { "param": "event_ids", "type": "FSEventStreamEventId" } ]

[ "Apache-2.0" ]

[ "Creates", "an", "instance", "of", "`", "`", "FSEventStream", "`", "`", "and", "returns", "a", "pointer", "to", "the", "instance", ".", ":", "param", "stream_callback_info_ref", ":", "Pointer", "to", "the", "callback", "context", "information", "that", "will", "be", "passed", "by", "the", "FSEvents", "API", "to", "the", "callback", "handler", "specified", "by", "the", "`", "`", "callback", "`", "`", "argument", "to", "this", "function", ".", "This", "information", "contains", "a", "reference", "to", "the", "Python", "callback", "that", "it", "must", "call", "in", "turn", "passing", "on", "the", "event", "information", "as", "Python", "objects", "to", "the", "the", "Python", "callback", ".", ":", "param", "py_paths", ":", "A", "Python", "list", "of", "Python", "strings", "representing", "path", "names", "to", "monitor", ".", ":", "param", "callback", ":", "A", "function", "pointer", "of", "type", "`", "`", "FSEventStreamCallback", "`", "`", "." ]

[ "static", "FSEventStreamRef", "watchdog_FSEventStreamCreate", "(", "StreamCallbackInfo", "*", "stream_callback_info_ref", ",", "PyObject", "*", "py_paths", ",", "FSEventStreamCallback", "callback", ")", "{", "CFAbsoluteTime", "stream_latency", "=", "0.01", ";", "CFMutableArrayRef", "paths", "=", "NULL", ";", "FSEventStreamRef", "stream_ref", "=", "NULL", ";", "G_RETURN_NULL_IF_NULL", "(", "py_paths", ")", ";", "G_RETURN_NULL_IF_NULL", "(", "callback", ")", ";", "paths", "=", "watchdog_CFMutableArrayRef_from_PyStringList", "(", "py_paths", ")", ";", "G_RETURN_NULL_IF_NULL", "(", "paths", ")", ";", "FSEventStreamContext", "stream_context", "=", "{", "0", ",", "stream_callback_info_ref", ",", "NULL", ",", "NULL", ",", "NULL", "}", ";", "stream_ref", "=", "FSEventStreamCreate", "(", "kCFAllocatorDefault", ",", "callback", ",", "&", "stream_context", ",", "paths", ",", "kFSEventStreamEventIdSinceNow", ",", "stream_latency", ",", "kFSEventStreamCreateFlagNoDefer", ")", ";", "CFRelease", "(", "paths", ")", ";", "return", "stream_ref", ";", "}" ]

[ "Creates", "an", "instance", "of", "`", "`", "FSEventStream", "`", "`", "and", "returns", "a", "pointer", "to", "the", "instance", "." ]

[ "/* Check arguments. */", "/* Convert the Python paths list to a CFMutableArray. */", "/* Create the event stream. */" ]

[ { "param": "stream_callback_info_ref", "type": "StreamCallbackInfo" }, { "param": "py_paths", "type": "PyObject" }, { "param": "callback", "type": "FSEventStreamCallback" } ]

[ "Apache-2.0" ]

[ "Adds", "various", "attributes", "to", "the", "Python", "module", ".", ":", "param", "module", ":", "A", "pointer", "to", "the", "Python", "module", "object", "to", "inject", "the", "attributes", "into", "." ]

[ "static", "void", "watchdog_module_add_attributes", "(", "PyObject", "*", "module", ")", "{", "PyObject", "*", "version_tuple", "=", "Py_BuildValue", "(", "\"", "\"", ",", "WATCHDOG_VERSION_MAJOR", ",", "WATCHDOG_VERSION_MINOR", ",", "WATCHDOG_VERSION_BUILD", ")", ";", "PyModule_AddIntConstant", "(", "module", ",", "\"", "\"", ",", "kCFFileDescriptorReadCallBack", ")", ";", "PyModule_AddIntConstant", "(", "module", ",", "\"", "\"", ",", "kCFFileDescriptorWriteCallBack", ")", ";", "PyModule_AddObject", "(", "module", ",", "\"", "\"", ",", "version_tuple", ")", ";", "PyModule_AddObject", "(", "module", ",", "\"", "\"", ",", "Py_BuildValue", "(", "\"", "\"", ",", "WATCHDOG_VERSION_STRING", ")", ")", ";", "}" ]

[ "Adds", "various", "attributes", "to", "the", "Python", "module", "." ]

[ "/* Adds version information. */" ]

[ { "param": "module", "type": "PyObject" } ]

[ "Apache-2.0" ]

[ "Initialize", "the", "Python", "2", ".", "x", "module", "." ]

[ "void", "init_watchdog_fsevents", "(", "void", ")", "{", "PyObject", "*", "module", "=", "Py_InitModule3", "(", "MODULE_NAME", ",", "watchdog_fsevents_methods", ",", "watchdog_fsevents_module__doc__", ")", ";", "watchdog_module_add_attributes", "(", "module", ")", ";", "watchdog_module_init", "(", ")", ";", "}" ]

[ "Initialize", "the", "Python", "2", ".", "x", "module", "." ]

[]

[]

[ "Apache-2.0" ]

[ "Initialize", "the", "Python", "3", ".", "x", "module", "." ]

[ "PyMODINIT_FUNC", "PyInit__watchdog_fsevents", "(", "void", ")", "{", "PyObject", "*", "module", "=", "PyModule_Create", "(", "&", "watchdog_fsevents_module", ")", ";", "watchdog_module_add_attributes", "(", "module", ")", ";", "watchdog_module_init", "(", ")", ";", "return", "module", ";", "}" ]

[ "Initialize", "the", "Python", "3", ".", "x", "module", "." ]

[]

[]

[ "Apache-2.0" ]

[ "Reads", "a", "proto", "float", "value", "from", "the", "current", "cursor", "." ]

[ "Status", "ReadFloat", "(", "uint32_t", "field_number", ",", "float", "*", "out", ")", "{", "static_assert", "(", "sizeof", "(", "float", ")", "==", "sizeof", "(", "uint32_t", ")", ",", "\"", "\"", ")", ";", "return", "ReadFixed", "(", "field_number", ",", "out", ")", ";", "}" ]

[ "Reads", "a", "proto", "float", "value", "from", "the", "current", "cursor", "." ]

[]

[ { "param": "field_number", "type": "uint32_t" }, { "param": "out", "type": "float" } ]

[ "Apache-2.0" ]

[ "Reads", "a", "proto", "double", "value", "from", "the", "current", "cursor", "." ]

[ "Status", "ReadDouble", "(", "uint32_t", "field_number", ",", "double", "*", "out", ")", "{", "static_assert", "(", "sizeof", "(", "double", ")", "==", "sizeof", "(", "uint64_t", ")", ",", "\"", "\"", ")", ";", "return", "ReadFixed", "(", "field_number", ",", "out", ")", ";", "}" ]

[ "Reads", "a", "proto", "double", "value", "from", "the", "current", "cursor", "." ]

[]

[ { "param": "field_number", "type": "uint32_t" }, { "param": "out", "type": "double" } ]

[ "MIT" ]

[ "canonical_order_string", "Reorder", "the", "string", "into", "canonical", "order", "-", "D108", "/", "D109", ".", "Starters", "(", "chars", "with", "combining", "class", "==", "0", ")", "don", "'", "t", "move", "so", "look", "for", "continuous", "substrings", "of", "non", "-", "starters", "and", "only", "reorder", "those", "." ]

[ "static", "void", "canonical_order_string", "(", "const", "struct", "norm_table", "*", "info", ",", "WCHAR", "*", "str", ",", "unsigned", "int", "len", ")", "{", "unsigned", "int", "ch", ",", "i", ",", "r", ",", "next", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "+=", "r", ")", "{", "if", "(", "!", "(", "r", "=", "get_utf16", "(", "str", "+", "i", ",", "len", "-", "i", ",", "&", "ch", ")", ")", ")", "return", ";", "if", "(", "i", "&&", "is_starter", "(", "info", ",", "ch", ")", ")", "{", "if", "(", "i", ">", "next", "+", "1", ")", "canonical_order_substring", "(", "info", ",", "str", "+", "next", ",", "i", "-", "next", ")", ";", "next", "=", "i", "+", "r", ";", "}", "}", "if", "(", "i", ">", "next", "+", "1", ")", "canonical_order_substring", "(", "info", ",", "str", "+", "next", ",", "i", "-", "next", ")", ";", "}" ]

[ "canonical_order_string", "Reorder", "the", "string", "into", "canonical", "order", "-", "D108", "/", "D109", "." ]

[ "/* at least two successive non-starters */" ]

[ { "param": "info", "type": "struct norm_table" }, { "param": "str", "type": "WCHAR" }, { "param": "len", "type": "unsigned int" } ]

[ "MIT" ]

[ "helper", "for", "the", "various", "utf8", "mbstowcs", "functions" ]

[ "static", "unsigned", "int", "decode_utf8_char", "(", "unsigned", "char", "ch", ",", "const", "char", "*", "*", "str", ",", "const", "char", "*", "strend", ")", "{", "static", "const", "char", "utf8_length", "[", "128", "]", "=", "{", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "1", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "2", ",", "3", ",", "3", ",", "3", ",", "3", ",", "3", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", "}", ";", "static", "const", "unsigned", "char", "utf8_mask", "[", "4", "]", "=", "{", "0x7f", ",", "0x1f", ",", "0x0f", ",", "0x07", "}", ";", "unsigned", "int", "len", "=", "utf8_length", "[", "ch", "-", "0x80", "]", ";", "unsigned", "int", "res", "=", "ch", "&", "utf8_mask", "[", "len", "]", ";", "const", "char", "*", "end", "=", "*", "str", "+", "len", ";", "if", "(", "end", ">", "strend", ")", "{", "*", "str", "=", "end", ";", "return", "~", "0", ";", "}", "switch", "(", "len", ")", "{", "case", "3", ":", "if", "(", "(", "ch", "=", "end", "[", "-3", "]", "^", "0x80", ")", ">=", "0x40", ")", "break", ";", "res", "=", "(", "res", "<<", "6", ")", "|", "ch", ";", "(", "*", "str", ")", "++", ";", "if", "(", "res", "<", "0x10", ")", "break", ";", "case", "2", ":", "if", "(", "(", "ch", "=", "end", "[", "-2", "]", "^", "0x80", ")", ">=", "0x40", ")", "break", ";", "res", "=", "(", "res", "<<", "6", ")", "|", "ch", ";", "if", "(", "res", ">=", "0x110000", ">>", "6", ")", "break", ";", "(", "*", "str", ")", "++", ";", "if", "(", "res", "<", "0x20", ")", "break", ";", "if", "(", "res", ">=", "0xd800", ">>", "6", "&&", "res", "<=", "0xdfff", ">>", "6", ")", "break", ";", "case", "1", ":", "if", "(", "(", "ch", "=", "end", "[", "-1", "]", "^", "0x80", ")", ">=", "0x40", ")", "break", ";", "res", "=", "(", "res", "<<", "6", ")", "|", "ch", ";", "(", "*", "str", ")", "++", ";", "if", "(", "res", "<", "0x80", ")", "break", ";", "return", "res", ";", "}", "return", "~", "0", ";", "}" ]

[ "helper", "for", "the", "various", "utf8", "mbstowcs", "functions" ]

[ "/* number of following bytes in sequence based on first byte value (for bytes above 0x7f) */", "/* 0x80-0x8f */", "/* 0x90-0x9f */", "/* 0xa0-0xaf */", "/* 0xb0-0xbf */", "/* 0xc0-0xcf */", "/* 0xd0-0xdf */", "/* 0xe0-0xef */", "/* 0xf0-0xff */", "/* first byte mask depending on UTF-8 sequence length */" ]

[ { "param": "ch", "type": "unsigned char" }, { "param": "str", "type": "char" }, { "param": "strend", "type": "char" } ]

[ "MIT" ]

[ "for", "OTA", "update", "by", "ble", "dongle" ]

[ "void", "gatt_attribute_value_callback", "(", "uint8", "connection", ",", "uint16", "handle", ",", "enum", "attributes_attribute_change_reason", "cb_type", ",", "uint16", "offset", ",", "const", "uint8", "*", "data", ",", "uint8", "len", ")", "{", "curr_connection", "=", "connection", ";", "if", "(", "handle", "==", "ota_control", ")", "{", "if", "(", "len", ">", "1", "||", "offset", ">", "0", ")", "gatt_user_write_rsp", "(", "connection", ",", "0x80", ")", ";", "else", "{", "command", "=", "data", "[", "0", "]", ";", "if", "(", "command", ">", "4", ")", "{", "gatt_user_write_rsp", "(", "curr_connection", ",", "0x80", ")", ";", "}", "else", "{", "if", "(", "command", "==", "3", ")", "{", "hw_reset", "(", "1", ")", ";", "}", "else", "{", "ps_data_temp", "[", "0", "]", "=", "0x01", ";", "ps_save", "(", "ps_cleaning", ",", "ps_data_temp", ",", "1", ")", ";", "dfu_pointer", "=", "FIRST_USER_PAGE_ADDRESS", ";", "gatt_user_write_rsp", "(", "curr_connection", ",", "0x00", ")", ";", "}", "}", "}", "}", "if", "(", "(", "handle", "==", "BG_ATT_ota_data", ")", "&&", "(", "(", "dfu_pointer", "+", "len", ")", "<=", "(", "FIRST_USER_PAGE_ADDRESS", "+", "(", "uint32", ")", "128", "*", "(", "uint32", ")", "1024", ")", ")", ")", "{", "flash_write", "(", "(", "dfu_pointer", ">>", "2", ")", ",", "data", ",", "len", ")", ";", "dfu_pointer", "+=", "(", "len", ")", ";", "}", "}" ]

[ "for", "OTA", "update", "by", "ble", "dongle" ]

[ "//save connection handle, is always 0 if only slave\r", "// Check if OTA control point attribute is written by the remote device and execute the command\r", "// Command 0 : Erase flash block 0 (0x0-0x1FFFF)\r", "// Command 1 : Erase flash block 1 (0x10000-0x3FFFF)\r", "// Command 2 : Reset DFU data pointer\r", "// Command 3 : Boot to DFU mode\r", "// In case of errors application error code 0x80 is returned to the remote device\r", "// In case the flash comms fails error code 0x90 is returned to the remote device\r", "//attribute is user attribute, reason is always write_request_user\r", "// Not a valid command -> report application error code : 0x80\r", "// Unknown command -> report application error code : 0x80\r", "// Command 3 received -> Boot to DFU mode\r", "/* Other commands are not used, but still accepted in order\r\n to be compatible with the external flash OTA\r\n implementation */", "// Check if OTA data attribute is written which carries the firmware update\r" ]

[ { "param": "connection", "type": "uint8" }, { "param": "handle", "type": "uint16" }, { "param": "cb_type", "type": "enum attributes_attribute_change_reason" }, { "param": "offset", "type": "uint16" }, { "param": "data", "type": "uint8" }, { "param": "len", "type": "uint8" } ]

[ "MIT" ]

[ "disconnected", "event", "handler", "(", "copied", "from", "stubs", ".", "c", ")" ]

[ "void", "connection_disconnect_callback", "(", "uint8", "conn", ",", "uint8", "reason", ")", "{", "disconnect_count", "=", "0", ";", "connection_count", "=", "0", ";", "ble_state_changed_flag", "=", "1", ";", "if", "(", "conn", "==", "connection_handle_app", ")", "{", "connected", "&=", "~", "connection_app", ";", "AppConnectionStatus", "=", "AppRadioOff", ";", "connection_lost_app", "=", "1", ";", "connection_handle_app", "=", "255", ";", "if", "(", "(", "reason", "==", "0", ")", "||", "(", "reason", "==", "0x13", ")", "||", "(", "reason", "==", "0x16", ")", ")", "{", "AppState", "=", "App_off", ";", "}", "else", "{", "if", "(", "(", "AppState", "==", "App_on", ")", "&&", "(", "ble_radio_state", "==", "Radio_on", ")", ")", "{", "scanningApp_start", "(", ")", ";", "}", "else", "{", "AppState", "=", "App_off", ";", "}", "}", "}", "if", "(", "conn", "==", "connection_handle_du", ")", "{", "DuConnectionStatus", "=", "DuRadioOff", ";", "if", "(", "(", "SD_status", "==", "SD_on", ")", "&&", "(", "ble_radio_state", "==", "Radio_on", ")", ")", "{", "scanningDu_start", "(", ")", ";", "if", "(", "motorStatus", "==", "motor_on", ")", "{", "errorInfo", ".", "year", "=", "currentTime", ".", "year", ";", "errorInfo", ".", "month", "=", "currentTime", ".", "month", ";", "errorInfo", ".", "day", "=", "currentTime", ".", "day", ";", "errorInfo", ".", "hour", "=", "currentTime", ".", "hour", ";", "errorInfo", ".", "minute", "=", "currentTime", ".", "minute", ";", "errorInfo", ".", "second", "=", "currentTime", ".", "second", ";", "errorInfo", ".", "error_type", "=", "Packet_Error_BLEDisconnect", ";", "errorInfo", ".", "error_BLEDisconnect", "++", ";", "if", "(", "(", "connected", "&", "connection_app", ")", "&&", "(", "appInitDone", ")", ")", "{", "wb_data", "[", "0", "]", "=", "Packet_Type_Data", ";", "wb_data", "[", "1", "]", "=", "Packet_Data_ErrorInfo", ";", "packet_data", ".", "errorInfo", "=", "errorInfo", ";", "memcpy", "(", "&", "wb_data", "[", "2", "]", ",", "packet_data", ".", "bytes", ",", "sizeof", "(", "packet_data", ".", "errorInfo", ")", ")", ";", "gatt_write_attribute", "(", "connection_handle_app", ",", "att_handle_app_WB_data", ",", "wb_data", ",", "sizeof", "(", "packet_data", ".", "errorInfo", ")", "+", "2", ")", ";", "ps_reset_error", "(", ")", ";", "}", "else", "{", "ps_save_error", "(", ")", ";", "}", "}", "}", "connected", "&=", "~", "connection_du", ";", "connection_lost_du", "=", "1", ";", "motorStatus", "=", "motor_off", ";", "connection_handle_du", "=", "255", ";", "if", "(", "(", "ble_radio_state", "==", "Radio_pairing", ")", "&&", "(", "pairing_mx2plus", ")", ")", "{", "scanningDu_start", "(", ")", ";", "}", "set_led_event", "(", ")", ";", "}", "if", "(", "conn", "==", "connection_handle_dg", ")", "{", "connected", "&=", "~", "connection_dongle", ";", "connection_lost_dg", "=", "1", ";", "connection_handle_dg", "=", "255", ";", "}", "if", "(", "ble_radio_state", "==", "Radio_off", ")", "{", "ble_state", "=", "STATE_STANDBY", ";", "disconnect_device", "(", ")", ";", "}", "}" ]

[ "disconnected", "event", "handler", "(", "copied", "from", "stubs", ".", "c", ")" ]

[ "// user disconnected connection\r", "// bluetooth off state. turn off all connected device\r" ]

[ { "param": "conn", "type": "uint8" }, { "param": "reason", "type": "uint8" } ]

[ "MIT" ]

[ "Passed", "as", "a", "converter", "function", "to", "PyArg_ParseTuple" ]

[ "int", "extract_bfd_capsule", "(", "PyObject", "*", "obj", ",", "void", "*", "dst", ")", "{", "if", "(", "PyCapsule_IsValid", "(", "obj", ",", "\"", "\"", ")", ")", "{", "*", "(", "(", "bfd", "*", "*", ")", "dst", ")", "=", "PyCapsule_GetPointer", "(", "obj", ",", "\"", "\"", ")", ";", "return", "1", ";", "}", "else", "{", "PyErr_SetString", "(", "PyExc_TypeError", ",", "\"", "\"", ")", ";", "}", "return", "0", ";", "}" ]

[ "Passed", "as", "a", "converter", "function", "to", "PyArg_ParseTuple" ]

[ "// Is this obj a PyCapsule?", "// Extract the bfd * from the capsule", "// The conversion was successful", "// The conversion failed" ]

[ { "param": "obj", "type": "PyObject" }, { "param": "dst", "type": "void" } ]

[ "MIT" ]

[ "Helpers", "that", "packs", "A", "and", "B", "in", "their", "continguous", "accessing", "pattern", "." ]

[ "void", "internalPackB4", "(", "int", "L", ",", "float", "*", "packB", ",", "float", "*", "B", ",", "int", "ldb", ")", "{", "float", "*", "bp", "=", "B", ";", "float", "*", "packBptr", "=", "packB", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "L", ";", "++", "i", ")", "{", "vst1q_f32", "(", "packBptr", ",", "vld1q_f32", "(", "bp", ")", ")", ";", "packBptr", "+=", "4", ";", "bp", "+=", "ldb", ";", "}", "}" ]

[ "Helpers", "that", "packs", "A", "and", "B", "in", "their", "continguous", "accessing", "pattern", "." ]

[]

[ { "param": "L", "type": "int" }, { "param": "packB", "type": "float" }, { "param": "B", "type": "float" }, { "param": "ldb", "type": "int" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_usedp", "Return", "Value", ":", "byte", "Descriptions", ":", "use", "dp", "for", "measurement" ]

[ "byte", "libaroma_window_usedp", "(", "byte", "isdp", ")", "{", "if", "(", "isdp", "==", "1", ")", "{", "_libaroma_window_measurement_dp", "=", "1", ";", "}", "else", "if", "(", "!", "isdp", ")", "{", "_libaroma_window_measurement_dp", "=", "0", ";", "}", "return", "_libaroma_window_measurement_dp", ";", "}" ]

[ "Function", ":", "libaroma_window_usedp", "Return", "Value", ":", "byte", "Descriptions", ":", "use", "dp", "for", "measurement" ]

[]

[ { "param": "isdp", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_measure_calculate", "Return", "Value", ":", "int", "Descriptions", ":", "calculate", "measurement" ]

[ "int", "libaroma_window_measure_calculate", "(", "int", "cv", ",", "int", "pos", ",", "int", "max", ",", "int", "is_size", ",", "int", "x", ")", "{", "if", "(", "is_size", ")", "{", "if", "(", "pos", "<=", "0", ")", "{", "switch", "(", "pos", ")", "{", "case", "LIBAROMA_POS_HALF", ":", "return", "(", "max", "/", "2", ")", "-", "x", ";", "break", ";", "case", "LIBAROMA_POS_1P3", ":", "return", "(", "max", "/", "3", ")", "-", "x", ";", "break", ";", "case", "LIBAROMA_POS_2P3", ":", "return", "(", "max", "*", "2", "/", "3", ")", "-", "x", ";", "break", ";", "case", "LIBAROMA_POS_1P4", ":", "return", "(", "max", "/", "4", ")", "-", "x", ";", "break", ";", "case", "LIBAROMA_POS_3P4", ":", "return", "(", "max", "*", "3", "/", "4", ")", "-", "x", ";", "break", ";", "case", "LIBAROMA_SIZE_FULL", ":", "return", "max", ";", "break", ";", "case", "LIBAROMA_SIZE_HALF", ":", "return", "max", "/", "2", ";", "break", ";", "case", "LIBAROMA_SIZE_THIRD", ":", "return", "max", "/", "3", ";", "break", ";", "case", "LIBAROMA_SIZE_QUARTER", ":", "return", "max", "/", "4", ";", "break", ";", "default", ":", "return", "abs", "(", "pos", ")", ";", "}", "}", "}", "else", "{", "if", "(", "pos", "<", "0", ")", "{", "switch", "(", "pos", ")", "{", "case", "LIBAROMA_POS_HALF", ":", "return", "max", "/", "2", ";", "break", ";", "case", "LIBAROMA_POS_1P3", ":", "return", "max", "/", "3", ";", "break", ";", "case", "LIBAROMA_POS_2P3", ":", "return", "max", "*", "2", "/", "3", ";", "break", ";", "case", "LIBAROMA_POS_1P4", ":", "return", "max", "/", "4", ";", "break", ";", "case", "LIBAROMA_POS_3P4", ":", "return", "max", "*", "3", "/", "4", ";", "break", ";", "default", ":", "return", "abs", "(", "pos", ")", ";", "}", "}", "}", "return", "cv", ";", "}" ]

[ "Function", ":", "libaroma_window_measure_calculate", "Return", "Value", ":", "int", "Descriptions", ":", "calculate", "measurement" ]

[]

[ { "param": "cv", "type": "int" }, { "param": "pos", "type": "int" }, { "param": "max", "type": "int" }, { "param": "is_size", "type": "int" }, { "param": "x", "type": "int" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_measure_size", "Return", "Value", ":", "byte", "Descriptions", ":", "measure", "window", "size" ]

[ "byte", "libaroma_window_measure_size", "(", "LIBAROMA_WINDOWP", "win", ")", "{", "if", "(", "win", ")", "{", "if", "(", "win", "->", "parent", "!=", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "_libaroma_window_measurement_dp", ")", "{", "win", "->", "x", "=", "libaroma_dp", "(", "win", "->", "rx", ")", ";", "win", "->", "y", "=", "libaroma_dp", "(", "win", "->", "ry", ")", ";", "win", "->", "w", "=", "libaroma_dp", "(", "win", "->", "rw", ")", ";", "win", "->", "h", "=", "libaroma_dp", "(", "win", "->", "rh", ")", ";", "}", "else", "{", "win", "->", "x", "=", "win", "->", "rx", ";", "win", "->", "y", "=", "win", "->", "ry", ";", "win", "->", "w", "=", "win", "->", "rw", ";", "win", "->", "h", "=", "win", "->", "rh", ";", "}", "win", "->", "ax", "=", "win", "->", "x", ";", "win", "->", "ay", "=", "win", "->", "y", ";", "win", "->", "x", "=", "libaroma_window_measure_calculate", "(", "win", "->", "x", ",", "win", "->", "rx", ",", "libaroma_wm", "(", ")", "->", "w", ",", "0", ",", "0", ")", ";", "win", "->", "y", "=", "libaroma_window_measure_calculate", "(", "win", "->", "y", ",", "win", "->", "ry", ",", "libaroma_wm", "(", ")", "->", "h", ",", "0", ",", "0", ")", ";", "win", "->", "w", "=", "libaroma_window_measure_calculate", "(", "win", "->", "w", ",", "win", "->", "rw", ",", "libaroma_wm", "(", ")", "->", "w", ",", "1", ",", "win", "->", "x", ")", ";", "win", "->", "h", "=", "libaroma_window_measure_calculate", "(", "win", "->", "h", ",", "win", "->", "rh", ",", "libaroma_wm", "(", ")", "->", "h", ",", "1", ",", "win", "->", "y", ")", ";", "if", "(", "win", "->", "w", "+", "win", "->", "x", ">", "libaroma_wm", "(", ")", "->", "w", ")", "{", "win", "->", "w", "=", "libaroma_wm", "(", ")", "->", "w", "-", "win", "->", "x", ";", "}", "if", "(", "win", "->", "h", "+", "win", "->", "y", ">", "libaroma_wm", "(", ")", "->", "h", ")", "{", "win", "->", "h", "=", "libaroma_wm", "(", ")", "->", "h", "-", "win", "->", "y", ";", "}", "_libaroma_window_measure_save", "(", "win", ",", "NULL", ")", ";", "LIBAROMA_MSG", "_msg", ";", "libaroma_window_process_event", "(", "win", ",", "libaroma_wm_compose", "(", "&", "_msg", ",", "LIBAROMA_MSG_WIN_MEASURED", ",", "NULL", ",", "0", ",", "0", ")", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}" ]

[ "Function", ":", "libaroma_window_measure_size", "Return", "Value", ":", "byte", "Descriptions", ":", "measure", "window", "size" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window", "Return", "Value", ":", "LIBAROMA_WINDOWP", "Descriptions", ":", "creates", "a", "new", "window" ]

[ "LIBAROMA_WINDOWP", "libaroma_window", "(", "char", "*", "bg_theme_name", ",", "int", "x", ",", "int", "y", ",", "int", "w", ",", "int", "h", ")", "{", "__CHECK_WM", "(", "NULL", ")", ";", "LIBAROMA_WINDOWP", "win", "=", "(", "LIBAROMA_WINDOWP", ")", "calloc", "(", "sizeof", "(", "LIBAROMA_WINDOW", ")", ",", "1", ")", ";", "if", "(", "!", "win", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "NULL", ";", "}", "if", "(", "bg_theme_name", ")", "{", "snprintf", "(", "win", "->", "theme_bg", ",", "256", ",", "\"", "\"", ",", "bg_theme_name", ")", ";", "}", "else", "{", "win", "->", "theme_bg", "[", "0", "]", "=", "0", ";", "}", "win", "->", "rx", "=", "x", ";", "win", "->", "ry", "=", "y", ";", "win", "->", "rw", "=", "w", ";", "win", "->", "rh", "=", "h", ";", "win", "->", "onpool", "=", "1", ";", "win", "->", "prev_screen", "=", "libaroma_fb_snapshoot_canvas", "(", ")", ";", "win", "->", "ui_thread", "=", "_libaroma_window_ui_thread", ";", "libaroma_window_measure_size", "(", "win", ")", ";", "return", "win", ";", "}" ]

[ "Function", ":", "libaroma_window", "Return", "Value", ":", "LIBAROMA_WINDOWP", "Descriptions", ":", "creates", "a", "new", "window" ]

[]

[ { "param": "bg_theme_name", "type": "char" }, { "param": "x", "type": "int" }, { "param": "y", "type": "int" }, { "param": "w", "type": "int" }, { "param": "h", "type": "int" } ]

[ "Apache-2.0" ]

[ "Function", ":", "_libaroma_window_updatebg", "Return", "Value", ":", "byte", "Descriptions", ":", "update", "window", "background" ]

[ "byte", "_libaroma_window_updatebg", "(", "LIBAROMA_WINDOWP", "win", ")", "{", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "->", "handler", "!=", "NULL", ")", "{", "if", "(", "win", "->", "handler", "->", "updatebg", "!=", "NULL", ")", "{", "if", "(", "win", "->", "handler", "->", "updatebg", "(", "win", ")", ")", "{", "if", "(", "win", "->", "onupdatebg", ")", "{", "win", "->", "onupdatebg", "(", "win", ",", "win", "->", "bg", ")", ";", "}", "return", "1", ";", "}", "return", "0", ";", "}", "}", "if", "(", "win", "->", "parent", "!=", "NULL", ")", "{", "return", "0", ";", "}", "int", "w", "=", "win", "->", "w", ";", "int", "h", "=", "win", "->", "h", ";", "if", "(", "win", "->", "bg", "!=", "NULL", ")", "{", "if", "(", "(", "win", "->", "bg", "->", "w", "==", "w", ")", "&&", "(", "win", "->", "bg", "->", "h", "==", "h", ")", ")", "{", "return", "1", ";", "}", "libaroma_canvas_free", "(", "win", "->", "bg", ")", ";", "}", "win", "->", "bg", "=", "libaroma_canvas", "(", "w", ",", "h", ")", ";", "libaroma_canvas_setcolor", "(", "win", "->", "bg", ",", "libaroma_colorget", "(", "NULL", ",", "win", ")", "->", "window_bg", ",", "0xff", ")", ";", "if", "(", "win", "->", "theme_bg", "[", "0", "]", "!=", "0", ")", "{", "libaroma_wm_draw_theme", "(", "win", "->", "bg", ",", "win", "->", "theme_bg", ",", "0", ",", "0", ",", "win", "->", "bg", "->", "w", ",", "win", "->", "bg", "->", "h", ",", "NULL", ")", ";", "}", "if", "(", "win", "->", "onupdatebg", "!=", "NULL", ")", "{", "win", "->", "onupdatebg", "(", "win", ",", "win", "->", "bg", ")", ";", "}", "return", "1", ";", "}" ]

[ "Function", ":", "_libaroma_window_updatebg", "Return", "Value", ":", "byte", "Descriptions", ":", "update", "window", "background" ]

[ "/* draw background */", "/* not need recreate background */", "/* default canvas color */", "/* from theme canvas */", "/* from updatebg callback */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "_libaroma_window_recalculate", "Return", "Value", ":", "byte", "Descriptions", ":", "recalculate", "client", "size" ]

[ "byte", "_libaroma_window_recalculate", "(", "LIBAROMA_WINDOWP", "win", ")", "{", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "libaroma_window_isactive", "(", "win", ")", ")", "{", "_libaroma_window_updatebg", "(", "win", ")", ";", "libaroma_window_invalidate", "(", "win", ",", "1", ")", ";", "}", "return", "1", ";", "}" ]

[ "Function", ":", "_libaroma_window_recalculate", "Return", "Value", ":", "byte", "Descriptions", ":", "recalculate", "client", "size" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_resize", "Return", "Value", ":", "byte", "Descriptions", ":", "resize", "window" ]

[ "byte", "libaroma_window_resize", "(", "LIBAROMA_WINDOWP", "win", ",", "int", "x", ",", "int", "y", ",", "int", "w", ",", "int", "h", ")", "{", "if", "(", "!", "win", ")", "{", "return", "0", ";", "}", "if", "(", "win", "->", "parent", "!=", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "win", "->", "rx", "=", "x", ";", "win", "->", "ry", "=", "y", ";", "win", "->", "rw", "=", "w", ";", "win", "->", "rh", "=", "h", ";", "if", "(", "libaroma_window_measure_size", "(", "win", ")", ")", "{", "return", "_libaroma_window_ready", "(", "win", ")", ";", "}", "return", "0", ";", "}" ]

[ "Function", ":", "libaroma_window_resize", "Return", "Value", ":", "byte", "Descriptions", ":", "resize", "window" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "x", "type": "int" }, { "param": "y", "type": "int" }, { "param": "w", "type": "int" }, { "param": "h", "type": "int" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_isactive", "Return", "Value", ":", "byte", "Descriptions", ":", "check", "if", "window", "is", "active" ]

[ "byte", "libaroma_window_isactive", "(", "LIBAROMA_WINDOWP", "win", ")", "{", "if", "(", "win", "!=", "NULL", ")", "{", "LIBAROMA_WINDOWP", "w", "=", "win", ";", "while", "(", "w", "->", "parent", ")", "{", "w", "=", "w", "->", "parent", ";", "}", "return", "(", "(", "w", "==", "libaroma_wm_get_active_window", "(", ")", ")", "?", "1", ":", "0", ")", ";", "}", "return", "0", ";", "}" ]

[ "Function", ":", "libaroma_window_isactive", "Return", "Value", ":", "byte", "Descriptions", ":", "check", "if", "window", "is", "active" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_add", "Return", "Value", ":", "byte", "Descriptions", ":", "add", "control", "into", "window" ]

[ "byte", "libaroma_window_add", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_CONTROLP", "ctl", ")", "{", "__CHECK_WM", "(", "0", ")", ";", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "ctl", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "ctl", "->", "window", "!=", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "libaroma_window_measure", "(", "win", ",", "ctl", ")", ";", "if", "(", "win", "->", "childn", "==", "0", ")", "{", "win", "->", "childs", "=", "(", "LIBAROMA_CONTROLP", "*", ")", "malloc", "(", "sizeof", "(", "LIBAROMA_CONTROLP", ")", ")", ";", "if", "(", "!", "win", "->", "childs", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "win", "->", "childs", "=", "NULL", ";", "return", "0", ";", "}", "win", "->", "childs", "[", "0", "]", "=", "ctl", ";", "}", "else", "{", "LIBAROMA_CONTROLP", "*", "newchilds", "=", "(", "LIBAROMA_CONTROLP", "*", ")", "realloc", "(", "win", "->", "childs", ",", "sizeof", "(", "LIBAROMA_CONTROLP", ")", "*", "(", "win", "->", "childn", "+", "1", ")", ")", ";", "if", "(", "!", "newchilds", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "win", "->", "childs", "=", "newchilds", ";", "win", "->", "childs", "[", "win", "->", "childn", "]", "=", "ctl", ";", "}", "ctl", "->", "window", "=", "win", ";", "win", "->", "childn", "++", ";", "_libaroma_window_recalculate", "(", "win", ")", ";", "return", "1", ";", "}" ]

[ "Function", ":", "libaroma_window_add", "Return", "Value", ":", "byte", "Descriptions", ":", "add", "control", "into", "window" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "ctl", "type": "LIBAROMA_CONTROLP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_del", "Return", "Value", ":", "byte", "Descriptions", ":", "delete", "control", "from", "window" ]

[ "byte", "libaroma_window_del", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_CONTROLP", "ctl", ")", "{", "__CHECK_WM", "(", "0", ")", ";", "if", "(", "ctl", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "!=", "ctl", "->", "window", ")", "{", "return", "0", ";", "}", "if", "(", "win", "->", "childn", "<=", "0", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "else", "if", "(", "win", "->", "childn", "==", "1", ")", "{", "if", "(", "win", "->", "childs", "[", "0", "]", "==", "ctl", ")", "{", "ctl", "->", "window", "=", "NULL", ";", "win", "->", "childn", "=", "0", ";", "free", "(", "win", "->", "childs", ")", ";", "win", "->", "childs", "=", "NULL", ";", "_libaroma_window_recalculate", "(", "win", ")", ";", "return", "1", ";", "}", "else", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "}", "LIBAROMA_CONTROLP", "*", "newchilds", "=", "(", "LIBAROMA_CONTROLP", "*", ")", "malloc", "(", "sizeof", "(", "LIBAROMA_CONTROLP", ")", "*", "(", "win", "->", "childn", "-", "1", ")", ")", ";", "if", "(", "!", "newchilds", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "int", "j", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "if", "(", "win", "->", "childs", "[", "i", "]", "!=", "ctl", ")", "{", "newchilds", "[", "j", "++", "]", "=", "win", "->", "childs", "[", "i", "]", ";", "if", "(", "j", "==", "win", "->", "childn", "-", "2", ")", "{", "free", "(", "newchilds", ")", ";", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "}", "}", "free", "(", "win", "->", "childs", ")", ";", "win", "->", "childs", "=", "newchilds", ";", "win", "->", "childn", "--", ";", "_libaroma_window_recalculate", "(", "win", ")", ";", "return", "1", ";", "}" ]

[ "Function", ":", "libaroma_window_del", "Return", "Value", ":", "byte", "Descriptions", ":", "delete", "control", "from", "window" ]

[ "/* current ctl not found */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "ctl", "type": "LIBAROMA_CONTROLP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_measure", "Return", "Value", ":", "byte", "Descriptions", ":", "measure", "control", "size" ]

[ "byte", "libaroma_window_measure", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_CONTROLP", "ctl", ")", "{", "if", "(", "win", "&&", "ctl", ")", "{", "if", "(", "_libaroma_window_measurement_dp", ")", "{", "ctl", "->", "x", "=", "libaroma_dp", "(", "ctl", "->", "rx", ")", ";", "ctl", "->", "y", "=", "libaroma_dp", "(", "ctl", "->", "ry", ")", ";", "ctl", "->", "w", "=", "libaroma_dp", "(", "ctl", "->", "rw", ")", ";", "ctl", "->", "h", "=", "libaroma_dp", "(", "ctl", "->", "rh", ")", ";", "}", "else", "{", "ctl", "->", "x", "=", "ctl", "->", "rx", ";", "ctl", "->", "y", "=", "ctl", "->", "ry", ";", "ctl", "->", "w", "=", "ctl", "->", "rw", ";", "ctl", "->", "h", "=", "ctl", "->", "rh", ";", "}", "ctl", "->", "x", "=", "libaroma_window_measure_calculate", "(", "ctl", "->", "x", ",", "ctl", "->", "rx", ",", "win", "->", "w", ",", "0", ",", "0", ")", ";", "ctl", "->", "y", "=", "libaroma_window_measure_calculate", "(", "ctl", "->", "y", ",", "ctl", "->", "ry", ",", "win", "->", "h", ",", "0", ",", "0", ")", ";", "ctl", "->", "w", "=", "libaroma_window_measure_calculate", "(", "ctl", "->", "w", ",", "ctl", "->", "rw", ",", "win", "->", "w", ",", "1", ",", "ctl", "->", "x", ")", ";", "ctl", "->", "h", "=", "libaroma_window_measure_calculate", "(", "ctl", "->", "h", ",", "ctl", "->", "rh", ",", "win", "->", "h", ",", "1", ",", "ctl", "->", "y", ")", ";", "if", "(", "ctl", "->", "w", "+", "ctl", "->", "x", ">", "win", "->", "w", ")", "{", "ctl", "->", "w", "=", "win", "->", "w", "-", "ctl", "->", "x", ";", "}", "if", "(", "ctl", "->", "h", "+", "ctl", "->", "y", ">", "win", "->", "h", ")", "{", "ctl", "->", "h", "=", "win", "->", "h", "-", "ctl", "->", "y", ";", "}", "if", "(", "ctl", "->", "w", "<", "ctl", "->", "minw", ")", "{", "ctl", "->", "w", "=", "ctl", "->", "minw", ";", "}", "if", "(", "ctl", "->", "h", "<", "ctl", "->", "minh", ")", "{", "ctl", "->", "h", "=", "ctl", "->", "minh", ";", "}", "_libaroma_window_measure_save", "(", "NULL", ",", "ctl", ")", ";", "if", "(", "ctl", "->", "handler", "->", "message", ")", "{", "LIBAROMA_MSG", "_msg", ";", "ctl", "->", "handler", "->", "message", "(", "ctl", ",", "libaroma_wm_compose", "(", "&", "_msg", ",", "LIBAROMA_MSG_WIN_MEASURED", ",", "NULL", ",", "0", ",", "0", ")", ")", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}" ]

[ "Function", ":", "libaroma_window_measure", "Return", "Value", ":", "byte", "Descriptions", ":", "measure", "control", "size" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "ctl", "type": "LIBAROMA_CONTROLP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_attach", "Return", "Value", ":", "LIBAROMA_CONTROLP", "Descriptions", ":", "attach", "control", "into", "window" ]

[ "LIBAROMA_CONTROLP", "libaroma_window_attach", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_CONTROLP", "ctl", ")", "{", "if", "(", "win", ")", "{", "if", "(", "libaroma_window_add", "(", "win", ",", "ctl", ")", ")", "{", "return", "ctl", ";", "}", "ALOGW", "(", "\"", "\"", ")", ";", "libaroma_control_free", "(", "ctl", ")", ";", "return", "NULL", ";", "}", "return", "ctl", ";", "}" ]

[ "Function", ":", "libaroma_window_attach", "Return", "Value", ":", "LIBAROMA_CONTROLP", "Descriptions", ":", "attach", "control", "into", "window" ]

[ "/* attach into window */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "ctl", "type": "LIBAROMA_CONTROLP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_getid", "Return", "Value", ":", "LIBAROMA_CONTROLP", "Descriptions", ":", "get", "control", "by", "id" ]

[ "LIBAROMA_CONTROLP", "libaroma_window_getid", "(", "LIBAROMA_WINDOWP", "win", ",", "word", "id", ")", "{", "__CHECK_WM", "(", "NULL", ")", ";", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "NULL", ";", "}", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "if", "(", "win", "->", "childs", "[", "i", "]", "->", "id", "==", "id", ")", "{", "return", "win", "->", "childs", "[", "i", "]", ";", "}", "}", "return", "NULL", ";", "}" ]

[ "Function", ":", "libaroma_window_getid", "Return", "Value", ":", "LIBAROMA_CONTROLP", "Descriptions", ":", "get", "control", "by", "id" ]

[ "/* not found */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "id", "type": "word" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_setfocus", "Return", "Value", ":", "LIBAROMA_CONTROLP", "Descriptions", ":", "set", "control", "focus" ]

[ "LIBAROMA_CONTROLP", "libaroma_window_setfocus", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_CONTROLP", "ctl", ")", "{", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "NULL", ";", "}", "if", "(", "ctl", "!=", "NULL", ")", "{", "if", "(", "win", "!=", "ctl", "->", "window", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "NULL", ";", "}", "if", "(", "ctl", "->", "handler", "->", "focus", "!=", "NULL", ")", "{", "if", "(", "win", "->", "focused", "==", "ctl", ")", "{", "return", "ctl", ";", "}", "if", "(", "ctl", "->", "handler", "->", "focus", "(", "ctl", ",", "1", ")", ")", "{", "if", "(", "win", "->", "focused", ")", "{", "win", "->", "focused", "->", "handler", "->", "focus", "(", "win", "->", "focused", ",", "0", ")", ";", "}", "win", "->", "focused", "=", "ctl", ";", "return", "ctl", ";", "}", "}", "return", "NULL", ";", "}", "else", "{", "if", "(", "win", "->", "focused", ")", "{", "return", "win", "->", "focused", ";", "}", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "if", "(", "win", "->", "childs", "[", "i", "]", "->", "handler", "->", "focus", "!=", "NULL", ")", "{", "return", "libaroma_window_setfocus", "(", "win", ",", "win", "->", "childs", "[", "i", "]", ")", ";", "}", "}", "}", "return", "NULL", ";", "}" ]

[ "Function", ":", "libaroma_window_setfocus", "Return", "Value", ":", "LIBAROMA_CONTROLP", "Descriptions", ":", "set", "control", "focus" ]

[ "/* set */", "/* find focus */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "ctl", "type": "LIBAROMA_CONTROLP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_sync", "Return", "Value", ":", "byte", "Descriptions", ":", "sync", "window", "canvas" ]

[ "byte", "libaroma_window_sync", "(", "LIBAROMA_WINDOWP", "win", ",", "int", "x", ",", "int", "y", ",", "int", "w", ",", "int", "h", ")", "{", "__CHECK_WM", "(", "0", ")", ";", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "->", "handler", "!=", "NULL", ")", "{", "if", "(", "win", "->", "handler", "->", "sync", "!=", "NULL", ")", "{", "return", "win", "->", "handler", "->", "sync", "(", "win", ",", "x", ",", "y", ",", "w", ",", "h", ")", ";", "}", "}", "if", "(", "win", "->", "parent", "!=", "NULL", ")", "{", "return", "0", ";", "}", "if", "(", "!", "win", "->", "lock_sync", ")", "{", "if", "(", "!", "libaroma_window_isactive", "(", "win", ")", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "->", "dc", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "libaroma_wm_sync", "(", "win", "->", "x", "+", "x", ",", "win", "->", "y", "+", "y", ",", "w", ",", "h", ")", ";", "}", "return", "1", ";", "}" ]

[ "Function", ":", "libaroma_window_sync", "Return", "Value", ":", "byte", "Descriptions", ":", "sync", "window", "canvas" ]

[ "/* sync workspace */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "x", "type": "int" }, { "param": "y", "type": "int" }, { "param": "w", "type": "int" }, { "param": "h", "type": "int" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_invalidate", "Return", "Value", ":", "byte", "Descriptions", ":", "invalidate", "window", "drawing" ]

[ "byte", "libaroma_window_invalidate", "(", "LIBAROMA_WINDOWP", "win", ",", "byte", "sync", ")", "{", "__CHECK_WM", "(", "0", ")", ";", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "->", "handler", "!=", "NULL", ")", "{", "if", "(", "win", "->", "handler", "->", "invalidate", "!=", "NULL", ")", "{", "return", "win", "->", "handler", "->", "invalidate", "(", "win", ",", "sync", ")", ";", "}", "}", "if", "(", "win", "->", "parent", "!=", "NULL", ")", "{", "return", "0", ";", "}", "if", "(", "!", "libaroma_window_isactive", "(", "win", ")", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "->", "dc", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "(", "!", "win", "->", "lock_sync", ")", "||", "(", "sync", "==", "10", ")", ")", "{", "libaroma_draw", "(", "win", "->", "dc", ",", "win", "->", "bg", ",", "0", ",", "0", ",", "1", ")", ";", "int", "i", ";", "#ifdef", "LIBAROMA_CONFIG_OPENMP", "#pragma", " omp parallel for", "\n", "#endif", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "libaroma_control_draw", "(", "win", "->", "childs", "[", "i", "]", ",", "0", ")", ";", "}", "if", "(", "sync", ")", "{", "libaroma_window_sync", "(", "win", ",", "0", ",", "0", ",", "win", "->", "w", ",", "win", "->", "h", ")", ";", "}", "}", "return", "1", ";", "}" ]

[ "Function", ":", "libaroma_window_invalidate", "Return", "Value", ":", "byte", "Descriptions", ":", "invalidate", "window", "drawing" ]

[ "/* draw bg */", "/* draw childs */", "/* draw no sync */", "/* sync */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "sync", "type": "byte" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_calculate_pos", "Return", "Value", ":", "void", "Descriptions", ":", "calculate", "screen", "position", "to", "window", "/", "control", "position" ]

[ "void", "libaroma_window_calculate_pos", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_CONTROLP", "ctl", ",", "int", "*", "x", ",", "int", "*", "y", ")", "{", "if", "(", "win", "!=", "NULL", ")", "{", "*", "x", "-=", "win", "->", "x", ";", "*", "y", "-=", "win", "->", "y", ";", "}", "else", "if", "(", "(", "ctl", "!=", "NULL", ")", "&&", "(", "ctl", "->", "window", "!=", "NULL", ")", ")", "{", "*", "x", "-=", "ctl", "->", "window", "->", "x", ";", "*", "y", "-=", "ctl", "->", "window", "->", "y", ";", "}", "if", "(", "ctl", "!=", "NULL", ")", "{", "*", "x", "-=", "ctl", "->", "x", ";", "*", "y", "-=", "ctl", "->", "y", ";", "}", "}" ]

[ "Function", ":", "libaroma_window_calculate_pos", "Return", "Value", ":", "void", "Descriptions", ":", "calculate", "screen", "position", "to", "window", "/", "control", "position" ]

[ "/*\n\t*x-=libaroma_wm()->x;\n\t*y-=libaroma_wm()->y;\n\t*/" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "ctl", "type": "LIBAROMA_CONTROLP" }, { "param": "x", "type": "int" }, { "param": "y", "type": "int" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_calculate_pos_abs", "Return", "Value", ":", "void", "Descriptions", ":", "calculate", "absolute", "screen", "position", "to", "top", "window", "position" ]

[ "void", "libaroma_window_calculate_pos_abs", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_CONTROLP", "ctl", ",", "int", "*", "x", ",", "int", "*", "y", ")", "{", "if", "(", "ctl", "!=", "NULL", ")", "{", "*", "x", "-=", "ctl", "->", "x", ";", "*", "y", "-=", "ctl", "->", "y", ";", "win", "=", "ctl", "->", "window", ";", "}", "while", "(", "win", "!=", "NULL", ")", "{", "*", "x", "-=", "win", "->", "ax", ";", "*", "y", "-=", "win", "->", "ay", ";", "win", "=", "win", "->", "parent", ";", "}", "}" ]

[ "Function", ":", "libaroma_window_calculate_pos_abs", "Return", "Value", ":", "void", "Descriptions", ":", "calculate", "absolute", "screen", "position", "to", "top", "window", "position" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "ctl", "type": "LIBAROMA_CONTROLP" }, { "param": "x", "type": "int" }, { "param": "y", "type": "int" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_post_command", "Return", "Value", ":", "byte", "Descriptions", ":", "post", "direct", "command" ]

[ "byte", "libaroma_window_post_command", "(", "dword", "cmd", ")", "{", "return", "libaroma_msg_post", "(", "LIBAROMA_MSG_WIN_DIRECTMSG", ",", "0", ",", "0", ",", "(", "int", ")", "cmd", ",", "0", ",", "NULL", ")", ";", "}" ]

[ "Function", ":", "libaroma_window_post_command", "Return", "Value", ":", "byte", "Descriptions", ":", "post", "direct", "command" ]

[]

[ { "param": "cmd", "type": "dword" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_post_command_ex", "Return", "Value", ":", "byte", "Descriptions", ":", "post", "direct", "command", "extended" ]

[ "byte", "libaroma_window_post_command_ex", "(", "dword", "cmd", ",", "byte", "state", ",", "int", "key", ",", "int", "y", ",", "voidp", "d", ")", "{", "return", "libaroma_msg_post", "(", "LIBAROMA_MSG_WIN_DIRECTMSG", ",", "state", ",", "key", ",", "(", "int", ")", "cmd", ",", "y", ",", "d", ")", ";", "}" ]

[ "Function", ":", "libaroma_window_post_command_ex", "Return", "Value", ":", "byte", "Descriptions", ":", "post", "direct", "command", "extended" ]

[]

[ { "param": "cmd", "type": "dword" }, { "param": "state", "type": "byte" }, { "param": "key", "type": "int" }, { "param": "y", "type": "int" }, { "param": "d", "type": "voidp" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_process_event", "Return", "Value", ":", "dword", "Descriptions", ":", "process", "message" ]

[ "dword", "libaroma_window_process_event", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_MSGP", "msg", ")", "{", "__CHECK_WM", "(", "0", ")", ";", "if", "(", "win", "==", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "if", "(", "win", "->", "parent", "!=", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "dword", "ret", "=", "0", ";", "if", "(", "win", "->", "handler", ")", "{", "if", "(", "win", "->", "handler", "->", "message_hooker", ")", "{", "if", "(", "win", "->", "handler", "->", "message_hooker", "(", "win", ",", "msg", ",", "&", "ret", ")", ")", "{", "return", "ret", ";", "}", "}", "}", "switch", "(", "msg", "->", "msg", ")", "{", "case", "LIBAROMA_MSG_WIN_ACTIVE", ":", "{", "win", "->", "focused", "=", "NULL", ";", "win", "->", "touched", "=", "NULL", ";", "if", "(", "msg", "->", "x", "!=", "10", ")", "{", "_libaroma_window_ready", "(", "win", ")", ";", "}", "if", "(", "(", "!", "win", "->", "lock_sync", ")", "||", "(", "msg", "->", "x", "==", "10", ")", ")", "{", "if", "(", "(", "!", "win", "->", "active", ")", "||", "(", "msg", "->", "x", "==", "10", ")", ")", "{", "int", "i", ";", "win", "->", "active", "=", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "if", "(", "win", "->", "childs", "[", "i", "]", "->", "handler", "->", "message", ")", "{", "win", "->", "childs", "[", "i", "]", "->", "handler", "->", "message", "(", "win", "->", "childs", "[", "i", "]", ",", "msg", ")", ";", "}", "}", "}", "}", "}", "break", ";", "case", "LIBAROMA_MSG_WIN_RESIZE", ":", "{", "int", "i", ";", "_libaroma_window_ready", "(", "win", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "if", "(", "win", "->", "childs", "[", "i", "]", "->", "handler", "->", "message", ")", "{", "win", "->", "childs", "[", "i", "]", "->", "handler", "->", "message", "(", "win", "->", "childs", "[", "i", "]", ",", "msg", ")", ";", "}", "}", "}", "break", ";", "case", "LIBAROMA_MSG_WIN_INACTIVE", ":", "{", "if", "(", "win", "->", "active", ")", "{", "win", "->", "active", "=", "0", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "if", "(", "win", "->", "childs", "[", "i", "]", "->", "handler", "->", "message", ")", "{", "win", "->", "childs", "[", "i", "]", "->", "handler", "->", "message", "(", "win", "->", "childs", "[", "i", "]", ",", "msg", ")", ";", "}", "}", "win", "->", "focused", "=", "NULL", ";", "win", "->", "touched", "=", "NULL", ";", "}", "}", "break", ";", "case", "LIBAROMA_MSG_WIN_MEASURED", ":", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "libaroma_window_measure", "(", "win", ",", "win", "->", "childs", "[", "i", "]", ")", ";", "}", "}", "break", ";", "case", "LIBAROMA_MSG_WIN_DIRECTMSG", ":", "{", "return", "(", "dword", ")", "msg", "->", "x", ";", "}", "break", ";", "case", "LIBAROMA_MSG_WIN_INVALIDATE", ":", "{", "libaroma_window_invalidate", "(", "win", ",", "1", ")", ";", "}", "break", ";", "case", "LIBAROMA_MSG_TOUCH", ":", "{", "if", "(", "msg", "->", "state", "==", "LIBAROMA_HID_EV_STATE_DOWN", ")", "{", "win", "->", "touched", "=", "NULL", ";", "int", "x", "=", "msg", "->", "x", ";", "int", "y", "=", "msg", "->", "y", ";", "libaroma_window_calculate_pos", "(", "win", ",", "NULL", ",", "&", "x", ",", "&", "y", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "win", "->", "childn", ";", "i", "++", ")", "{", "if", "(", "_libaroma_window_is_inside", "(", "win", "->", "childs", "[", "i", "]", ",", "x", ",", "y", ")", ")", "{", "win", "->", "touched", "=", "win", "->", "childs", "[", "i", "]", ";", "break", ";", "}", "}", "if", "(", "win", "->", "touched", "!=", "NULL", ")", "{", "if", "(", "win", "->", "touched", "->", "handler", "->", "message", ")", "{", "ret", "=", "win", "->", "touched", "->", "handler", "->", "message", "(", "win", "->", "touched", ",", "msg", ")", ";", "}", "}", "}", "else", "if", "(", "win", "->", "touched", "!=", "NULL", ")", "{", "if", "(", "msg", "->", "state", "==", "LIBAROMA_HID_EV_STATE_MOVE", ")", "{", "if", "(", "win", "->", "touched", "->", "handler", "->", "message", ")", "{", "ret", "=", "win", "->", "touched", "->", "handler", "->", "message", "(", "win", "->", "touched", ",", "msg", ")", ";", "}", "}", "else", "if", "(", "msg", "->", "state", "==", "LIBAROMA_HID_EV_STATE_UP", ")", "{", "if", "(", "win", "->", "touched", "->", "handler", "->", "message", ")", "{", "ret", "=", "win", "->", "touched", "->", "handler", "->", "message", "(", "win", "->", "touched", ",", "msg", ")", ";", "}", "win", "->", "touched", "=", "NULL", ";", "}", "}", "}", "break", ";", "}", "return", "ret", ";", "}" ]

[ "Function", ":", "libaroma_window_process_event", "Return", "Value", ":", "dword", "Descriptions", ":", "process", "message" ]

[ "/* set current window size */", "/* signal child */", "/* stop thread manager */", "/* send inactive message to child */", "/* remeasured all childs */", "/* touch handler */" ]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "msg", "type": "LIBAROMA_MSGP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_window_pool", "Return", "Value", ":", "dword", "Descriptions", ":", "poll", "window", "messages" ]

[ "dword", "libaroma_window_pool", "(", "LIBAROMA_WINDOWP", "win", ",", "LIBAROMA_MSGP", "msg", ")", "{", "if", "(", "!", "win", ")", "{", "return", "0", ";", "}", "if", "(", "win", "->", "parent", "!=", "NULL", ")", "{", "ALOGW", "(", "\"", "\"", ")", ";", "return", "0", ";", "}", "LIBAROMA_MSG", "_msg", ";", "LIBAROMA_MSGP", "cmsg", "=", "(", "msg", "!=", "NULL", ")", "?", "msg", ":", "&", "_msg", ";", "byte", "ret", "=", "libaroma_wm_getmessage", "(", "cmsg", ")", ";", "if", "(", "ret", ")", "{", "return", "libaroma_window_process_event", "(", "win", ",", "cmsg", ")", ";", "}", "return", "0", ";", "}" ]

[ "Function", ":", "libaroma_window_pool", "Return", "Value", ":", "dword", "Descriptions", ":", "poll", "window", "messages" ]

[]

[ { "param": "win", "type": "LIBAROMA_WINDOWP" }, { "param": "msg", "type": "LIBAROMA_MSGP" } ]

[ "Apache-2.0" ]

[ "Function", ":", "libaroma_listitem_isoption", "Return", "Value", ":", "byte", "Descriptions", ":", "check", "if", "item", "is", "option", "checkbox" ]

[ "byte", "libaroma_listitem_isoption", "(", "LIBAROMA_CTL_LIST_ITEMP", "item", ")", "{", "if", "(", "item", "->", "handler", "!=", "&", "_libaroma_listitem_check_handler", ")", "{", "return", "0", ";", "}", "if", "(", "item", "->", "flags", "&", "LIBAROMA_LISTITEM_CHECK_OPTION", ")", "{", "return", "1", ";", "}", "return", "0", ";", "}" ]

[ "Function", ":", "libaroma_listitem_isoption", "Return", "Value", ":", "byte", "Descriptions", ":", "check", "if", "item", "is", "option", "checkbox" ]

[]

[ { "param": "item", "type": "LIBAROMA_CTL_LIST_ITEMP" } ]