int scan(FILE *target)
{
hash_t *var_map = malloc(sizeof(hash_t));
hash_init(var_map, 1024);
write_header(target);
int ret = 0;
while(next() == true){
if(is_alpha() == false){
printf("An instruction can only start with a function call or assignment\n");
return 1;
}
char *current_token = get_token();
char *temp;
strcpy(temp, current_token);
if(next() == false){
printf("Incomplete instruction\n");
return 1;
}
if(is_left()){
ret = parse_call(target, temp, var_map); /* It is a call */
} else if(is_assignment()){
ret = parse_assignment(target, temp, var_map); /* It is an assignment */
} else {
printf("Not a valid instruction\n");
return 1;
}
if(ret == 1 ){
printf("Syntax error\n");
return 1;
}
}
write_end(target);
free(var_map);
return ret;
}
node_p tree_copy(const node_cp& source, CallFactory factory)
{
// Simply parse the sexpr. This isn't the most efficient but is
// extremely simple.
size_t i = 0;
string sexpr = source->to_s();
if (sexpr.empty()) {
return node_p();
}
if (sexpr[0] == '(') {
return parse_call(sexpr, i, factory);
}
return parse_literal(sexpr, i);
}
IronBee::Predicate::node_p parse(const std::string& s) const
{
size_t i = 0;
IronBee::Predicate::node_p node = parse_call(s, i, m_factory);
if (! node) {
BOOST_THROW_EXCEPTION(
IronBee::einval() << IronBee::errinfo_what(
"Parse failed."
)
);
}
if (i != s.length() - 1) {
BOOST_THROW_EXCEPTION(
IronBee::einval() << IronBee::errinfo_what(
"Parse did not consume all input."
)
);
}
return node;
}
/*
* Parse one statement. 'foo = bar', or 'if (...) {...}', or '{...}',
* and so on.
*/
static int parse_statement(policy_lex_file_t *lexer, policy_item_t **tail)
{
int rcode;
policy_reserved_word_t reserved;
policy_lex_t token, assign;
char lhs[256], rhs[256];
policy_assignment_t *this;
/*
* See what kind of token we have.
*/
token = policy_lex_file(lexer, 0, lhs, sizeof(lhs));
switch (token) {
case POLICY_LEX_LC_BRACKET:
rcode = parse_block(lexer, tail);
if (!rcode) {
return 0;
}
break;
case POLICY_LEX_BARE_WORD:
reserved = fr_str2int(policy_reserved_words,
lhs,
POLICY_RESERVED_UNKNOWN);
switch (reserved) {
case POLICY_RESERVED_IF:
if (parse_if(lexer, tail)) {
return 1;
}
return 0;
break;
case POLICY_RESERVED_CONTROL:
case POLICY_RESERVED_REQUEST:
case POLICY_RESERVED_REPLY:
case POLICY_RESERVED_PROXY_REQUEST:
case POLICY_RESERVED_PROXY_REPLY:
if (parse_attribute_block(lexer, tail,
reserved))
return 1;
return 0;
break;
case POLICY_RESERVED_PRINT:
if (parse_print(lexer, tail)) {
return 1;
}
return 0;
break;
case POLICY_RESERVED_RETURN:
if (parse_return(lexer, tail)) {
return 1;
}
return 0;
break;
case POLICY_RESERVED_MODULE:
if (parse_module(lexer, tail)) {
return 1;
}
return 0;
break;
case POLICY_RESERVED_UNKNOWN: /* wasn't a reserved word */
/*
* Is a named policy, parse the reference to it.
*/
if (rlm_policy_find(lexer->policies, lhs) != NULL) {
if (!parse_call(lexer, tail, lhs)) {
return 0;
}
return 1;
}
{
const DICT_ATTR *dattr;
/*
* Bare words MUST be dictionary attributes
*/
dattr = dict_attrbyname(lhs);
if (!dattr) {
fprintf(stderr, "%s[%d]: Expected attribute name, got \"%s\"\n",
lexer->filename, lexer->lineno, lhs);
return 0;
}
debug_tokens("%s[%d]: Got attribute %s\n",
lexer->filename, lexer->lineno,
lhs);
}
break;
default:
fprintf(stderr, "%s[%d]: Unexpected reserved word \"%s\"\n",
lexer->filename, lexer->lineno, lhs);
return 0;
} /* switch over reserved words */
break;
/*
* Return from nested blocks.
*/
case POLICY_LEX_RC_BRACKET:
policy_lex_push_token(lexer, token);
return 2; /* magic */
case POLICY_LEX_EOF: /* nothing more to do */
return 3;
default:
fprintf(stderr, "%s[%d]: Unexpected %s\n",
lexer->filename, lexer->lineno,
fr_int2str(policy_explanations,
token, "string"));
break;
}
/*
* Parse a bare statement.
*/
assign = policy_lex_file(lexer, 0, rhs, sizeof(rhs));
switch (assign) {
case POLICY_LEX_ASSIGN:
case POLICY_LEX_SET_EQUALS:
case POLICY_LEX_AND_EQUALS:
case POLICY_LEX_OR_EQUALS:
case POLICY_LEX_PLUS_EQUALS:
break;
default:
fprintf(stderr, "%s[%d]: Unexpected assign %s\n",
lexer->filename, lexer->lineno,
fr_int2str(policy_explanations,
assign, "string"));
return 0;
}
this = rad_malloc(sizeof(*this));
memset(this, 0, sizeof(*this));
this->item.type = POLICY_TYPE_ASSIGNMENT;
this->item.lineno = lexer->lineno;
token = policy_lex_file(lexer, 0, rhs, sizeof(rhs));
if ((token != POLICY_LEX_BARE_WORD) &&
(token != POLICY_LEX_DOUBLE_QUOTED_STRING)) {
fprintf(stderr, "%s[%d]: Unexpected rhs %s\n",
lexer->filename, lexer->lineno,
fr_int2str(policy_explanations,
token, "string"));
rlm_policy_free_item((policy_item_t *) this);
return 0;
}
this->rhs_type = token;
this->rhs = strdup(rhs);
token = policy_lex_file(lexer, POLICY_LEX_FLAG_RETURN_EOL,
rhs, sizeof(rhs));
if (token != POLICY_LEX_EOL) {
fprintf(stderr, "%s[%d]: Expected EOL\n",
lexer->filename, lexer->lineno);
rlm_policy_free_item((policy_item_t *) this);
return 0;
}
debug_tokens("[ASSIGN %s %s %s]\n",
lhs, fr_int2str(rlm_policy_tokens, assign, "?"), rhs);
/*
* Fill in the assignment struct
*/
this->lhs = strdup(lhs);
this->assign = assign;
*tail = (policy_item_t *) this;
return 1;
}
struct node *parse_factor(struct compiler *compiler)
{
switch (lexer_current(compiler))
{
case T_BEGIN:
return parse_begin(compiler);
case T_IF:
return parse_if(compiler);
case T_UNLESS:
return parse_unless(compiler);
case T_CASE:
return parse_case(compiler);
case T_CLASS:
return parse_class(compiler);
case T_MODULE:
return parse_module(compiler);
case T_DEF:
return parse_method(compiler);
case T_YIELD:
return parse_yield(compiler);
case T_RETURN:
return parse_return(compiler);
case T_BREAK:
return parse_break(compiler);
case T_NEXT:
return parse_next(compiler);
case T_REDO:
return parse_redo(compiler);
case T_SQUARE_OPEN:
{
struct node *result = alloc_node(compiler, N_ARRAY);
lexer_next(compiler);
if(lexer_current(compiler) == T_SQUARE_CLOSE)
result->left = 0;
else
result->left = parse_array_element(compiler);
lexer_match(compiler, T_SQUARE_CLOSE);
return result;
}
case T_STRING:
{
struct node *result = alloc_node(compiler, N_STRING);
result->left = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
return result;
}
case T_STRING_START:
{
struct node *result = alloc_node(compiler, N_STRING_CONTINUE);
result->left = 0;
result->middle = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
result->right = parse_statements(compiler);
while(lexer_current(compiler) == T_STRING_CONTINUE)
{
struct node *node = alloc_node(compiler, N_STRING_CONTINUE);
node->left = result;
node->middle = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
node->right = parse_statements(compiler);
result = node;
}
if(lexer_require(compiler, T_STRING_END))
{
struct node *node = alloc_node(compiler, N_STRING_START);
node->left = result;
node->right = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
return node;
}
return result;
}
case T_SELF:
{
lexer_next(compiler);
return &self_node;
}
case T_TRUE:
{
lexer_next(compiler);
return alloc_node(compiler, N_TRUE);
}
case T_FALSE:
{
lexer_next(compiler);
return alloc_node(compiler, N_FALSE);
}
case T_NIL:
{
lexer_next(compiler);
return &nil_node;
}
case T_NUMBER:
{
struct node *result = alloc_node(compiler, N_NUMBER);
char *text = get_token_str(lexer_token(compiler));
result->left = (void* )atoi(text);
lexer_next(compiler);
return result;
}
case T_IVAR:
{
rt_value symbol = rt_symbol_from_lexer(compiler);
lexer_next(compiler);
switch (lexer_current(compiler))
{
case T_ASSIGN_ADD:
case T_ASSIGN_SUB:
case T_ASSIGN_MUL:
case T_ASSIGN_DIV:
{
struct node *result;
enum token_type op_type = lexer_current(compiler) - OP_TO_ASSIGN;
lexer_next(compiler);
result = alloc_node(compiler, N_IVAR_ASSIGN);
result->right = alloc_node(compiler, N_BINARY_OP);
result->right->op = op_type;
result->right->left = alloc_node(compiler, N_IVAR);
result->right->left->left = (void *)symbol;
result->right->right = parse_expression(compiler);
result->left = (void *)symbol;
return result;
}
case T_ASSIGN:
{
struct node *result;
lexer_next(compiler);
result = alloc_node(compiler, N_IVAR_ASSIGN);
result->left = (void *)symbol;
result->right = parse_expression(compiler);
return result;
}
default:
{
struct node *result = alloc_node(compiler, N_IVAR);
result->left = (void *)symbol;
return result;
}
}
}
case T_IDENT:
return parse_identifier(compiler);
case T_EXT_IDENT:
return parse_call(compiler, 0, &self_node, false);
case T_PARAM_OPEN:
{
lexer_next(compiler);
struct node *result = parse_statements(compiler);
lexer_match(compiler, T_PARAM_CLOSE);
return result;
}
default:
{
COMPILER_ERROR(compiler, "Expected expression but found %s", token_type_names[lexer_current(compiler)]);
lexer_next(compiler);
return 0;
}
}
}
struct node *parse_identifier(struct compiler *compiler)
{
rt_value symbol = rt_symbol_from_lexer(compiler);
lexer_next(compiler);
switch (lexer_current(compiler))
{
case T_ASSIGN_ADD:
case T_ASSIGN_SUB:
case T_ASSIGN_MUL:
case T_ASSIGN_DIV:
{
struct node *result;
enum token_type op_type = lexer_current(compiler) - OP_TO_ASSIGN;
lexer_next(compiler);
if (rt_symbol_is_const(symbol))
result = alloc_node(compiler, N_ASSIGN_CONST);
else
result = alloc_node(compiler, N_ASSIGN);
result->right = alloc_node(compiler, N_BINARY_OP);
result->right->op = op_type;
if (rt_symbol_is_const(symbol))
{
result->left = &self_node;
result->middle = (void *)symbol;
result->right->left = alloc_node(compiler, N_CONST);
result->right->left->left = &self_node;
result->right->left->right = (void *)symbol;
}
else
{
result->left = (void *)scope_get(compiler->current_block, symbol);
result->right->left = alloc_node(compiler, N_VAR);
result->right->left->left = (void *)scope_get(compiler->current_block, symbol);
}
result->right->right = parse_expression(compiler);
return result;
}
case T_ASSIGN:
{
struct node *result;
lexer_next(compiler);
if (rt_symbol_is_const(symbol))
{
result = alloc_node(compiler, N_ASSIGN_CONST);
result->left = &self_node;
result->middle = (void *)symbol;
}
else
{
result = alloc_node(compiler, N_ASSIGN);
result->left = (void *)scope_get(compiler->current_block, symbol);
}
result->right = parse_expression(compiler);
return result;
}
// Function call or local variable
default:
return parse_call(compiler, symbol, &self_node, true);
}
}
