int native_dirmonitor_new(Ref *r, const char *path)
{
FileMonitor *fm = FileMonitor_new();
{
wchar_t *wpath = filename_to_utf16(path, NULL);
fm->hDir = CreateFileW(wpath, FILE_LIST_DIRECTORY,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL);
free(wpath);
}
if (fm->hDir == INVALID_HANDLE_VALUE) {
fs->throw_error_select(THROW_CANNOT_OPEN_FILE__STR, Str_new(path, -1));
free(fm);
return FALSE;
}
fm->ref = r;
fm->overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
fm->valid = TRUE;
if (!refresh_dirmonitor(fm, FALSE)) {
CloseHandle(fm->overlapped.hEvent);
CloseHandle(fm->hDir);
fs->throw_error_select(THROW_CANNOT_OPEN_FILE__STR, Str_new(path, -1));
return FALSE;
}
r->v[INDEX_FILEMONITOR_STRUCT] = ptr_Value(fm);
return TRUE;
}
void get_local_timezone_name(char *buf, int max)
{
char cbuf[MAX_NAME_LEN];
TIME_ZONE_INFORMATION tzi;
memset(&tzi, 0, sizeof(tzi));
GetTimeZoneInformation(&tzi);
convert_english_tzname(cbuf, tzi.StandardName);
windows_tz_to_tzid(buf, max, Str_new(cbuf, -1));
}
/*-----------------------------------------------------------------------------
* Init functions
*----------------------------------------------------------------------------*/
DEFINE_init_module()
{
input_buf = Str_new(STR_SIZE);
p = Str_data(input_buf);
input_stack = OBJ_NEW(List);
input_stack->free_data = m_free_compat;
init_sym();
utarray_new(scan_state, &ut_scan_state_icd);
}
RE
RE_vnewf (
const char * pszFmt,
va_list args ) {
RE self;
Str str;
str = Str_new("");
Str_vappendf(str, pszFmt, args);
self = RE_new(Str_get(str));
Str_delete(str);
return (self);
}
void SrcFile_init( SrcFile *self )
{
self->filename = NULL;
self->line_filename = NULL;
self->line = Str_new(STR_SIZE);
self->line_stack = OBJ_NEW( List );
OBJ_AUTODELETE( self->line_stack ) = false;
self->line_stack->free_data = m_free_compat;
self->file_stack = OBJ_NEW( List );
OBJ_AUTODELETE( self->file_stack ) = false;
self->file_stack->free_data = free_file_stack_elem;
}
/**
* *.bmp;*.jpg -> "*.bmp;*.jpg", "*.bmp;*.jpg"
* Image file:*.bmp;*.jpg -> "Image file", "*.bmp;*.jpg"
*/
static void split_filter_name(Str *name, Str *filter, RefStr *src)
{
int i;
for (i = src->size - 1; i >= 0; i--) {
if (src->c[i] == ':') {
name->p = src->c;
name->size = i;
filter->p = src->c + i + 1;
filter->size = src->size - i - 1;
return;
}
}
*name = Str_new(src->c, src->size);
*filter = *name;
}
static int strio_tostr(Value *vret, Value *v, RefNode *node)
{
RefBytesIO *mb = Value_bytesio(*v);
if (fg->stk_top > v + 1) {
Str s = Str_new(mb->buf.p, mb->buf.size);
RefStr *fmt = Value_vp(v[1]);
if (!string_format_sub(vret, s, fmt->c, fmt->size, FALSE)) {
return FALSE;
}
} else {
*vret = cstr_Value(fs->cls_str, mb->buf.p, mb->buf.size);
}
return TRUE;
}
static RE
RE_assign (
RE self,
const char * pszRE ) {
if (self->pszPrevTarget) {
Free((void *) self->pszPrevTarget);
self->pszPrevTarget = (void *) 0;
}
if (self->pszTmp) {
Free((void *) self->pszTmp);
self->pszTmp = (void *) 0;
}
regcomp(& self->regex, pszRE, REG_EXTENDED);
{
int i;
for (i = 0; i < RE_MaxNumSubStr; i ++) {
self->astr[i] = Str_new("");
}
}
return (self);
}
bool validateConfig(AppConfig_t *_config) {
Str *errorMsg = Str_new();
// check if valid port is given
if (_config->mipiPort < 0 || _config->mipiPort > 2) {
errorMsg->set(errorMsg, "Only ports 0 (OV_2), 1 (Aptina) or 2 (OV_2) are supported.");
fprintf(stdout, "%s\n", errorMsg->str);
fflush(stdout);
return false;
}
// check is if Aptina and the resolution must be max at 720p
if (_config->mipiPort == 1 &&
(_config->width * _config->height) > (1280*720)) {
errorMsg->set(errorMsg, "Aptina CANNOT have resolution more than 720p.");
fprintf(stdout, "%s\n", errorMsg->str);
fflush(stdout);
return false;
}
return true;
}
/*
* 全称セレクタ あらゆる要素にマッチする。
E タイプセレクタ Eという名称の要素にマッチする。
E F 子孫セレクタ E要素の子孫であるF要素にマッチする。
E > F 子供セレクタ E要素の子供であるF要素にマッチする。
E + F 隣接兄弟セレクタ 兄であるE要素の直後にある弟のF要素にマッチする。
E[foo] 属性セレクタ foo属性が設定されたE要素にマッチする（値が何であれ）。
E[foo="warning"] 属性セレクタ foo属性値が warning であるE要素にマッチする。
E[foo~="warning"] 属性セレクタ foo属性値が空白類文字で区切られた語のリストであり，そのうちひとつが warning という語であるE要素にマッチする。
E[lang|="en"] 属性セレクタ lang属性値がハイフンで区切られた語のリストであり，そのリストが en という語で始っているE要素にマッチする。
DIV.warning クラスセレクタ DIV[class~="warning"]
E#myid IDセレクタ E[id="myid"]
*/
static int parse_css_selector_sub(XMLPattern **pp, int *pnum, SelectorTok *tk, Mem *mem)
{
XMLPattern *pat = NULL;
XMLPattern **ppat = NULL;
XMLAttrPattern *attr = NULL;
XMLAttrPattern **pattr = NULL;
int subnode = TRUE;
// 空白を除外
if (tk->type == STK_SPACE) {
SelectorTok_next(tk);
}
ppat = pp;
for (;;) {
if (tk->type != STK_GT) {
pat = fs->Mem_get(mem, sizeof(*pat));
memset(pat, 0, sizeof(*pat));
*ppat = pat;
ppat = &pat->next;
pattr = &pat->attr;
pat->index = *pnum;
(*pnum)++;
if (*pp == NULL) {
*pp = pat;
}
pat->subnode = subnode;
subnode = TRUE;
}
switch (tk->type) {
case STK_STAR:
SelectorTok_next(tk);
break;
case STK_IDENT:
attr = fs->Mem_get(mem, sizeof(*attr));
memset(attr, 0, sizeof(*attr));
*pattr = attr;
pattr = &attr->next;
attr->type = XT_NAME;
attr->val = tk->val;
SelectorTok_next(tk);
break;
default:
break;
}
for (;;) {
int type = tk->type;
switch (type) {
case STK_DOT:
case STK_HASH:
case STK_COLON:
SelectorTok_next(tk);
if (tk->type != STK_IDENT) {
goto ERROR_END;
}
attr = fs->Mem_get(mem, sizeof(*attr));
memset(attr, 0, sizeof(*attr));
*pattr = attr;
pattr = &attr->next;
switch (type) {
case STK_DOT:
attr->type = XT_ATTR_MATCH;
attr->key = Str_new("class", 5);
attr->val = tk->val;
break;
case STK_HASH:
attr->type = XT_ATTR_EQ;
attr->key = Str_new("id", 2);
attr->val = tk->val;
break;
case STK_COLON:
if (str_eq(tk->val.p, tk->val.size, "checked", -1)) {
attr->type = XT_ATTR_EXIST;
attr->key = Str_new("checked", -1);
} else if (str_eq(tk->val.p, tk->val.size, "selected", -1)) {
attr->type = XT_ATTR_EXIST;
attr->key = Str_new("selected", -1);
} else {
goto ERROR_END;
}
break;
}
SelectorTok_next(tk);
break;
case STK_LB:
SelectorTok_next(tk);
if (tk->type != STK_IDENT) {
goto ERROR_END;
}
attr = fs->Mem_get(mem, sizeof(*attr));
memset(attr, 0, sizeof(*attr));
*pattr = attr;
pattr = &attr->next;
attr->type = XT_ATTR_EXIST;
attr->key = tk->val;
SelectorTok_next(tk);
if (tk->type == STK_EQ) {
attr->type = XT_ATTR_EQ;
} else if (tk->type == STK_TILDE_EQ) {
attr->type = XT_ATTR_MATCH;
} else if (tk->type == STK_BAR_EQ) {
attr->type = XT_ATTR_FIRST;
}
if (attr->type != XT_ATTR_EXIST) {
SelectorTok_next(tk);
if (tk->type != STK_IDENT && tk->type != STK_STR) {
goto ERROR_END;
}
attr->val = tk->val;
SelectorTok_next(tk);
}
if (tk->type != STK_RB) {
goto ERROR_END;
}
SelectorTok_next(tk);
break;
case STK_GT:
subnode = FALSE;
SelectorTok_next(tk);
break;
default:
goto BREAK;
}
}
BREAK:
*pattr = NULL;
switch (tk->type) {
case STK_EOS:
case STK_COMMA:
*ppat = NULL;
return TRUE;
case STK_SPACE:
break;
default:
goto ERROR_END;
}
SelectorTok_next(tk);
}
ERROR_END:
if (tk->type == STK_ERROR) {
fs->throw_errorf(fs->mod_lang, "ValueError", "Unknown token");
} else {
fs->throw_errorf(fs->mod_lang, "ValueError", "Unexpected token");
}
return FALSE;
}
int main_fox(int argc, const char **argv)
{
ArgumentInfo ai;
RefNode *mod;
RefStr *name_startup;
int ret = FALSE;
memset(&ai, 0, sizeof(ai));
init_stdio();
// デフォルト値
fs->max_alloc = 64 * 1024 * 1024; // 64MB
fs->max_stack = 32768;
fv->err_dst = "alert";
if (!parse_args(&ai, argc, argv)) {
goto ERROR_END;
}
fox_init_compile(FALSE);
if (ai.srcfile != NULL) {
mod = get_module_by_file(ai.srcfile);
if (mod != NULL) {
mod->u.m.src_path = ai.srcfile;
}
} else {
throw_errorf(fs->mod_lang, "ArgumentError", "Missing filename");
goto ERROR_END;
}
// ソースを読み込んだ後で実行
if (fs->running_mode == RUNNING_MODE_CGI) {
throw_errorf(fs->mod_lang, "CompileError", "CGI mode is not supported");
goto ERROR_END;
}
init_fox_stack();
if (mod == NULL) {
throw_error_select(THROW_CANNOT_OPEN_FILE__STR, Str_new(ai.srcfile, -1));
goto ERROR_END;
}
if (fg->error != VALUE_NULL) {
goto ERROR_END;
}
// 参照できない名前で登録
name_startup = intern("[startup]", 9);
mod->name = name_startup;
Hash_add_p(&fg->mod_root, &fg->st_mem, name_startup, mod);
if (!fox_link()) {
goto ERROR_END;
}
if (!fox_run(mod)) {
goto ERROR_END;
}
ret = TRUE;
ERROR_END:
print_last_error();
fox_close();
return ret;
}
static int textio_gets_sub(Value *vret, Ref *ref, int trim)
{
Value stream = ref->v[INDEX_TEXTIO_STREAM];
StrBuf buf;
Str result;
int ret = TRUE;
RefNode *s_type = Value_type(stream);
if (s_type == fs->cls_bytesio) {
buf.p = NULL;
if (!bytesio_gets_sub(&result, stream)) {
result.size = 0;
}
} else {
StrBuf_init(&buf, 0);
if (!stream_gets_sub(&buf, stream, '\n')) {
StrBuf_close(&buf);
return FALSE;
}
result = Str_new(buf.p, buf.size);
}
if (result.size > 0) {
RefTextIO *tio = Value_vp(ref->v[INDEX_TEXTIO_TEXTIO]);
if (trim) {
// 末尾の改行を取り除く
if (result.size > 0 && result.p[result.size - 1] == '\n') {
result.size--;
if (result.size > 0 && result.p[result.size - 1] == '\r') {
result.size--;
}
}
}
if (tio->cs == fs->cs_utf8) {
if (invalid_utf8_pos(result.p, result.size) >= 0) {
if (tio->trans) {
// 不正な文字をU+FFFDに置き換える
*vret = cstr_Value_conv(result.p, result.size, NULL);
} else {
throw_error_select(THROW_INVALID_UTF8);
ret = FALSE;
goto FINALLY;
}
} else {
*vret = cstr_Value(fs->cls_str, result.p, result.size);
}
} else {
StrBuf buf2;
if (tio->in.ic == (void*)-1) {
if (!IconvIO_open(&tio->in, tio->cs, fs->cs_utf8, tio->trans ? UTF8_ALTER_CHAR : NULL)) {
ret = FALSE;
goto FINALLY;
}
}
StrBuf_init(&buf2, result.size);
if (!IconvIO_conv(&tio->in, &buf2, result.p, result.size, FALSE, TRUE)) {
StrBuf_close(&buf2);
ret = FALSE;
goto FINALLY;
}
*vret = cstr_Value(fs->cls_str, buf2.p, buf2.size);
StrBuf_close(&buf2);
}
}
FINALLY:
if (buf.p != NULL) {
StrBuf_close(&buf);
}
return ret;
}
