Exemple #1
0
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;
}
Exemple #2
0
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));
}
Exemple #3
0
/*-----------------------------------------------------------------------------
*   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);
}
Exemple #4
0
Fichier : re.c Projet : knaka/src
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);
}
Exemple #5
0
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;
}
Exemple #6
0
/**
 * *.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;
}
Exemple #7
0
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;
}
Exemple #8
0
Fichier : re.c Projet : knaka/src
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;
}
Exemple #10
0
/*

*   全称セレクタ  あらゆる要素にマッチする。
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;
}
Exemple #11
0
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;
}
Exemple #12
0
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;
}