コード例 #1
0
ファイル: parser.cpp プロジェクト: dreamtraveler/tools
void Parser::parse_seg(ptr<Token> token) {
    SegmentToken *seg = static_cast<SegmentToken*>(token.get());
    Language *lang = Language::get(seg->name()->text());

    if (!lang) {
        log_error(token->loc(), "unknown language name '%p'.", seg->name()->text());
    }

    bool first = true;
    while (1) {
        token = cur(); 
        eat();
        if (token->is_eol()) {
            break;
        }

        ptr<Token> name = token;

        if (first) {
            if (!token->is_iden()) {
                log_expect(token->loc(), "identifier or eol");
            }
            first = false;
        }
        else {
            if (*token != ',') {
                log_expect(token->loc(), "',' or eol");
            }
            token = cur();
            eat();
            if (!token->is_iden()) {
                log_expect(token->loc(), "identifier or eol");
            }
        }
        token = cur();
        eat();
        if (*token != '=') {
            log_expect(token->loc(), "'='");
        }
        ptr<Token> value = cur();
        eat();
        if (!token_is_constant(value)) {
            log_expect(token->loc(), "constant");
        }
        lang->option(name->text(), value);
    }
    parse_raw(_input.is_root() ? &lang->head() : nullptr);
}
コード例 #2
0
ファイル: pkttype.c プロジェクト: battistuz/antelope_contrib
int whatis_pkttype( uchar_t *packet )

{
     Raw *raw;
     PktPar *pkt;
     ushort_t *val;
     ushort_t code;
     char *parse;
     int  i, nelem;
     char key[64];

     val = ( ushort_t *)  packet;
     code = *val;
 
     Par.raw.pkttype =  code;
     if( RawPkts == NULL) init_RawPkts();
     sprintf( key, "%d\0", code );
     if( code == 0 )  {
        complain( 0, " whatis_pkttype(): Can't recognize a packet type %0x%0x\n", packet[0], packet[1] );
        return -1;
     }

     raw = ( Raw *) getarr( RawPkts, (char *) &key[0] );
     if( raw == NULL ) { 
        complain( 0, " whatis_pkttype(): Can't get RawPkts info for %0x%0x\n", packet[0], packet[1] );
        return -1;
     }
     memcpy( (char *) &Par.raw, (char *) raw, sizeof( Raw ) );
     switch(  parse_raw( packet, raw->parse, raw->pkttype ) ) {

	case -1:
          complain( 0, " whatis_pkttype(): Can't parse raw packet - %0x%0x\n", packet[0], packet[1] );
          return -1;
	case 0:
          return 0;
	case 1:
          return (int) raw->pkttype;
     }
	

}
コード例 #3
0
struct book
*fen_book_open(const char *path)
{
	FILE *f = NULL;
	struct book *book = NULL;
	size_t file_size;

	if ((f = fopen(path, "r")) == NULL)
		return NULL;

	if (bin_file_size(f, &file_size) != 0)
		goto error;

	book = xmalloc(sizeof *book + file_size + 1);
	book->type = bt_fen;
	book->file = NULL;

	if (fread(book->raw, 1, file_size, f) != 1)
		goto error;

	book->raw[file_size] = '\0';

	if (parse_raw(book->raw, &book->fen_book) != 0)
		goto error;

	if (ferror(f))
		goto error;

	(void) fclose(f);
	return book;

error:
	if (book != NULL)
		free(book);
	if (f != NULL)
		fclose(f);
	return NULL;
}
コード例 #4
0
ファイル: template.c プロジェクト: diroussel/lua-web-tools
/*
 * Prepares a template file.
 */
static apr_status_t parse_template (parser_rec *p) {
	apr_status_t status;
	apr_finfo_t finfo;
	apr_file_t *file;
	apr_size_t size;

	/* read file */
	if ((status = apr_stat(&finfo, p->filename, APR_FINFO_SIZE, p->pool))
			!= APR_SUCCESS) {
		p->err = apr_psprintf(p->pool, "file '%s' does not exist",
				p->filename);
		return status;
	}
	if ((status = apr_file_open(&file, p->filename, APR_READ, 0, p->pool))
			!= APR_SUCCESS) {
		p->err = apr_psprintf(p->pool, "file '%s' cannot be opened",
				p->filename);
		return status;
	}
	apr_pool_cleanup_register(p->pool, file, file_close,
			apr_pool_cleanup_null);
	p->buf = apr_palloc(p->pool, finfo.size + 1);
	size = finfo.size;
	if ((status = apr_file_read(file, p->buf, &size)) != APR_SUCCESS) {
		p->err = apr_psprintf(p->pool, "file '%s' cannot be read",
				p->filename);
		return status;
	}
	if ((status = apr_file_close(file)) != APR_SUCCESS) {
		p->err = apr_psprintf(p->pool, "file '%s' cannot be closed",
				p->filename);
		return status;
	}
	apr_pool_cleanup_kill(p->pool, file, file_close);
	p->buf[size] = '\0';

	/* no parse? */
	if ((p->flags & TEMPLATE_FPARSE) == 0) {
		p->pos = p->buf + size;
		p->begin = p->buf;
		parse_raw(p);
		return APR_SUCCESS;
	}

	/* process elements and substitution, treat all else as raw */
	p->pos = p->buf;
	p->begin = p->pos;
	while (*p->pos != '\0') {
		switch (*p->pos) {
		case '<':
			if ((p->pos[1] == 'l' && p->pos[2] == ':')
					|| (p->pos[1] == '/'
					&& p->pos[2] == 'l'
					&& p->pos[3] == ':')) {
				parse_raw(p);
				if ((status = parse_element(p))
						!= APR_SUCCESS) {
					return status;
				}
				p->begin = p->pos;
			} else {
				p->pos++;
			}
			break;

		case '$':
			switch (p->pos[1]) {
			case '{':
			case '[':
				parse_raw(p);
				if ((status = parse_sub(p)) != APR_SUCCESS) {
					return status;
				}
				p->begin = p->pos;
				break;

			case '$':
				p->pos++;
				parse_raw(p);
				p->pos++;
				p->begin = p->pos;
				break;

			default:
				p->pos++;
			}
			break;

		default:
			p->pos++;
		}
	} 
	parse_raw(p);

	return APR_SUCCESS;
}