/**
* Parses a Content-Length header value.
*/
int parse_header_content_length(struct parser *p) {
char c, *buffer;
int i, m, r;
if (ready(p) < 3)
return PARSING_WAIT;
c = buffer_get(&(p->buffer), p->mark);
for (m = 1; isdigit(c) || c == ' ' || c == '\t'; m++) {
if (ready(p) < 3 + m)
return PARSING_WAIT;
c = buffer_get(&(p->buffer), p->mark + m);
}
buffer = buffer_copy(&(p->buffer), p->mark, m - 1);
if (buffer == NULL) {
p->error = E_MEMORY;
return PARSING_ERROR;
}
advance_mark(p, m - 1);
r = parse_constant(p, CRLF, 2);
if (r != PARSING_DONE) {
free(buffer);
return r;
}
errno = 0;
p->request.content_length = strtol(buffer, NULL, 10);
free(buffer);
return (errno == 0) ? PARSING_DONE : PARSING_ERROR;
}
static IteratorT parse_meta(const char * prefix, IteratorT begin, IteratorT end) {
IteratorT next = parse_constant(prefix, begin, end);
if (next != begin) {
return parse_string(parse_meta_character, next, end);
} else {
return begin;
}
}
void commandStore::execute(const std::vector<std::string>& cmd) {
if (svmMemory->get_start()) {
index_t rDest = parse_register(cmd[1]);
index_t rSrc = parse_register(cmd[2]);
address_t C = parse_constant(cmd[3]);
execute(rDest, rSrc, C);
}
svmMemory->inc_program_counter();
}
/**
* Parses the request method.
*/
int parse_request_method(struct parser *p) {
char first;
int r;
if (ready(p) == 0)
return PARSING_WAIT;
first = buffer_get(&(p->buffer), p->mark);
if (first == m_get[0]) {
r = parse_constant(p, m_get, sizeof(m_get) - 1);
if (r != PARSING_DONE)
return r;
p->request.method = METHOD_GET;
} else if (first == m_head[0]) {
r = parse_constant(p, m_head, sizeof(m_head) - 1);
if (r != PARSING_DONE)
return r;
p->request.method = METHOD_HEAD;
} else if (is_token_char(first)) {
// other methods
if (ready(p) < 2)
return PARSING_WAIT;
advance_mark(p, 1);
while (is_token_char(buffer_get(&(p->buffer), p->mark))) {
if (ready(p) < 2)
return PARSING_WAIT;
advance_mark(p, 1);
}
if (buffer_get(&(p->buffer), p->mark) != ' ')
return PARSING_ERROR;
advance_mark(p, 1);
p->request.method = METHOD_OTHER;
} else
return PARSING_ERROR;
return PARSING_DONE;
}
/**
* Parses the HTTP version. Must be "HTTP/1.x".
*/
int parse_http_version(struct parser *p) {
char c;
int r;
if (ready(p) < sizeof(http_version) + 1)
return PARSING_WAIT;
r = parse_constant(p, http_version, sizeof(http_version) - 2);
if (r != PARSING_DONE)
return r;
c = buffer_get(&(p->buffer), p->mark);
if (!isdigit(c))
return PARSING_ERROR;
p->request.version = c;
advance_mark(p, 1);
return parse_constant(p, CRLF, 2);
}
static IteratorT parse_path(IteratorT begin, IteratorT end) {
// This is optional, and signifies an absolute path.
IteratorT absolute_begin = parse_constant("/", begin, end);
IteratorT current = parse_string(parse_path_character, absolute_begin, end);
if (current == begin)
return begin;
while (current != end) {
IteratorT next = parse_constant("/", current, end);
if (next == current)
return current;
current = parse_string(parse_path_character, next, end);
}
return current;
}
// authority = [ userinfo "@" ] host [ ":" port ]
// port = *DIGIT
static IteratorT parse_authority(IteratorT begin, IteratorT end, Authority & authority) {
IteratorT user_info_begin = begin;
IteratorT user_info_end = parse_string(parse_user_info_character, begin, end);
IteratorT host_begin = parse_constant("@", user_info_end, end);
// Can we parse the "@" symbol?
if (host_begin != user_info_end) {
// Valid user info was found:
authority.user_info_begin = user_info_begin;
authority.user_info_end = user_info_end;
} else {
host_begin = begin;
}
IteratorT host_end = parse_host(host_begin, end);
if (host_end == host_begin) {
// We can't continue as host is required.
return host_end;
}
authority.host_begin = host_begin;
authority.host_end = host_end;
IteratorT port_begin = parse_constant(":", host_end, end);
if (port_begin != host_end) {
IteratorT port_end = parse_predicate(is_numeric, port_begin, end);
authority.port_begin = port_begin;
authority.port_end = port_end;
return port_end;
} else {
return host_end;
}
}
static IteratorT parse_scheme(IteratorT begin, IteratorT end) {
IteratorT next = parse_predicate(is_alpha, begin, end);
if (next == begin) {
return begin;
}
next = parse_predicate(is_scheme_character, next, end);
IteratorT scheme_end = parse_constant(":", next, end);
if (scheme_end == next) {
return begin;
} else {
return scheme_end;
}
}
/**
* Parses a header value. Deprecated header line folding is not supported.
*/
int parse_header_value(struct parser *p) {
char c;
if (ready(p) < 3)
return PARSING_WAIT;
c = buffer_get(&(p->buffer), p->mark);
while (isgraph(c) || c == ' ' || c == '\t') {
advance_mark(p, 1);
if (ready(p) < 3)
return PARSING_WAIT;
c = buffer_get(&(p->buffer), p->mark);
}
return parse_constant(p, CRLF, 2);
}
static void handle_num (const char *var, int *v_ptr, const char *val)
{
char *end;
if (*val == 'p' || *val == 'P')
val++;
else if (isalpha (*val))
{
*v_ptr = parse_constant (var, &val);
return;
}
*v_ptr = strtol (val, &end, 0);
if (*end)
fprintf (stderr, "config: Variable '%s': ignoring trailing junk '%s' after value (%d)!\n", var, end, *v_ptr);
}
static IteratorT parse_hierarchy(IteratorT begin, IteratorT end, Hierarchy & hierarchy) {
// (//([^/?#]*))?
IteratorT authority_begin = parse_constant("//", begin, end);
IteratorT authority_end = authority_begin;
if (authority_begin != begin) {
authority_end = parse_authority(authority_begin, end, hierarchy.authority);
hierarchy.authority_begin = authority_begin;
hierarchy.authority_end = authority_end;
}
// ([^?#]*)
hierarchy.path_begin = authority_end;
hierarchy.path_end = parse_path(hierarchy.path_begin, end);
return hierarchy.path_end;
}
exparser::return_type exparser::loop(const std::string& s) {
if (s.empty()) return return_false;
if (debug) std::cout << "PARSING : " << s << std::endl;
if (debug) std::cerr << "Try parenthesis" << std::endl;
return_type parenthesis = parse_parenthesis(s);
if (parenthesis) return parenthesis;
if (debug) std::cerr << "Try constant" << std::endl;
return_type constant = parse_constant(s);
if (constant) return constant;
if (debug) std::cerr << "Try variable" << std::endl;
return_type variable = parse_variable(s);
if (variable) return variable;
if (debug) std::cerr << "Try plus" << std::endl;
return_type plus = parse_plus(s);
if (plus) return plus;
if (debug) std::cerr << "Try minus" << std::endl;
return_type minus = parse_minus(s);
if (minus) return minus;
if (debug) std::cerr << "Try multiply" << std::endl;
return_type multiply = parse_multiply(s);
if (multiply) return multiply;
if (debug) std::cerr << "Try divide" << std::endl;
return_type divide = parse_divide(s);
if (divide) return divide;
if (debug) std::cerr << "Try poewr" << std::endl;
return_type power = parse_power(s);
if (power) return power;
if (debug) std::cerr << "Try function" << std::endl;
return_type function = parse_function(s);
if (function) return function;
return return_false;
}
// URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
// ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
// 12 3 4 5 6 7 8 9
static IteratorT parse(IteratorT begin, IteratorT end, Components & components) {
// (([^:/?#]+):)?
IteratorT scheme_begin = begin;
IteratorT scheme_end = parse_scheme(scheme_begin, end);
if (scheme_end != scheme_begin) {
components.scheme_begin = scheme_begin;
components.scheme_end = scheme_end - 1;
}
IteratorT hierarchy_begin = parse_constant(":", scheme_end, end);
IteratorT hierarchy_end = parse_hierarchy(hierarchy_begin, end, components.hierarchy);
if (hierarchy_end == hierarchy_begin) {
return hierarchy_begin;
}
components.hierarchy_begin = hierarchy_begin;
components.hierarchy_end = hierarchy_end;
IteratorT query_begin = hierarchy_end;
IteratorT query_end = parse_meta("?", query_begin, end);
if (query_end != query_begin) {
components.query_begin = query_begin;
components.query_end = query_end;
}
IteratorT fragment_begin = query_end;
IteratorT fragment_end = parse_meta("#", fragment_begin, end);
if (fragment_end != fragment_begin) {
components.fragment_begin = fragment_begin;
components.fragment_end = fragment_end;
}
components.complete = true;
return fragment_end;
}
instruction_ptr Parser::parse_value()
{
int start_line = current_lexeme().line();
if (match_current_lexeme(kSubtraction))
{
next_lexeme();
instruction_ptr value = parse_value();
if (!value)
{
report_current_syntax_error();
return instruction_ptr();
}
return instruction_ptr(new ArithmeticOperationInstruction(start_line, kSub, instruction_ptr(new Constant(start_line, 0)), value));
}
if (match_current_lexeme(kLeftBracket))
{
next_lexeme();
instruction_ptr expression = parse_expression();
if (!match_current_lexeme(kRightBracket))
{
report_current_syntax_error();
return instruction_ptr();
}
next_lexeme();
return expression;
}
instruction_ptr value = parse_constant();
if (!value)
value = parse_function_call();
return value;
}
/**
* Parses HTTP headers. Only a few headers are actually processed, while most
* values are discarded.
*/
int parse_headers(struct parser *p) {
int r;
while (TRUE) {
switch (p->state) {
case PARSING_HEADERS:
r = parse_constant(p, CRLF, 2);
if (r != PARSING_ERROR)
return r;
p->state = PARSING_HEADER_NAME;
debug("parsing header");
case PARSING_HEADER_NAME:
case PARSING_HEADER_NAME_ANY:
r = parse_header_name(p);
if (r != PARSING_DONE)
return r;
debug("parsed header name");
}
switch (p->state) {
case PARSING_HEADER_VALUE:
r = parse_header_value(p);
break;
case PARSING_HEADER_CONTENT_LENGTH:
r = parse_header_content_length(p);
break;
default:
return PARSING_ERROR;
}
if (r != PARSING_DONE)
return r;
p->state = PARSING_HEADERS;
debug("parsed header value");
}
return PARSING_DONE;
}
int add_constant(struct radeon_compiler *c, const char *const_str)
{
float data[4];
unsigned index;
struct rc_constant_list *constants;
struct rc_constant constant;
if (!parse_constant(&index, data, const_str)) {
return 0;
}
constants = &c->Program.Constants;
if (constants->_Reserved < index) {
struct rc_constant * newlist;
constants->_Reserved = index + 100;
newlist = malloc(sizeof(struct rc_constant) * constants->_Reserved);
if (constants->Constants) {
memcpy(newlist, constants->Constants,
sizeof(struct rc_constant) *
constants->_Reserved);
free(constants->Constants);
}
constants->Constants = newlist;
}
memset(&constant, 0, sizeof(constant));
constant.Type = RC_CONSTANT_IMMEDIATE;
constant.Size = 4;
memcpy(constant.u.Immediate, data, sizeof(float) * 4);
constants->Constants[index] = constant;
constants->Count = MAX2(constants->Count, index + 1);
return 1;
}
cgc_ssize_t
cgc_tokenize(char *str, struct token *tokens)
{
int ret;
char c;
struct token *token = tokens;
while ((c = *str++)) {
if (c == '_' || cgc_islower(c)) {
if ((ret = parse_variable(str - 1, token)) < 0)
return ret;
str += ret - 1;
token++;
continue;
}
if (cgc_isdigit(c)) {
if ((ret = parse_constant(str - 1, token)) < 0)
return ret;
str += ret - 1;
token++;
continue;
}
switch (c) {
case '=':
token->type = TOK_ASSIGNMENT;
break;
case '+':
token->type = TOK_ADD;
break;
case '-':
token->type = TOK_SUBTRACT;
break;
case '*':
token->type = TOK_MULTIPLY;
break;
case '/':
token->type = TOK_DIVIDE;
break;
case '~':
token->type = TOK_NEGATE;
break;
case '&':
token->type = TOK_ADDRESS_OF;
break;
case '$':
token->type = TOK_DEREFERENCE;
break;
case '(':
token->type = TOK_LEFT_PARENTHESIS;
break;
case ')':
token->type = TOK_RIGHT_PARENTHESIS;
break;
case ' ':
continue;
default:
return EXIT_FAILURE;
}
token++;
}
return token - tokens;
}
void get_token(Token *t)
{
/* check if we need to free the previous string */
if (t->token_string != NULL)
{
free(t->token_string);
t->token_string = NULL;
}
enum Token_type a = peek_token_type();
if (a != Tsymbol)
{
t->type = a;
t->token_string = copy_token_string(token_index, token_index);
token_index += 1;
if (debug) fprintf(stderr, "next token: %s\n", t->token_string);
return;
}
if (isalpha(input_buffer[token_index]))
{
int j;
for (j = token_index; j < input_line_length; j++)
{
if (isalpha(input_buffer[j])) continue;
if (isdigit(input_buffer[j])) continue;
if (input_buffer[j] == '_') continue;
if (input_buffer[j] == '.') continue;
/* not alpha, digit or underbar or period */
break;
}
/* symbol is from token_index to j-1 */
t->token_string = copy_token_string(token_index, j-1);
token_index = j;
if (debug) fprintf(stderr, "next token: %s\n", t->token_string);
/* search to see if this token is an opcode */
opcode *op = search_opcode(t->token_string);
if (op != NULL)
{
t->type = Topcode;
t->op = op;
return;
}
/* search to see if this token is a known symbol */
symbol *sy = search_symbol(t->token_string);
if (sy != NULL)
{
t->type = Tsymbol;
t->sy = sy;
t->value = sy->value;
return;
}
/* we have a symbol that is not currently defined */
t->type = Tsymbol;
t->sy = NULL;
t->value = 0;
return;
}
/* A numeric constant */
else if (isdigit(input_buffer[token_index]) || (input_buffer[token_index] == '-'))
{
int value;
if (parse_constant(t, &value))
{
t->type = Tconstant;
t->value = value;
if (debug) fprintf(stderr, "next token: constant %d\n", t->value);
return;
}
}
/* A character constant: '.' */
else if ((input_buffer[token_index] == '\'') && (input_buffer[token_index+2] == '\''))
{
t->type = Tconstant;
t->value = input_buffer[token_index+1];
t->token_string = malloc(4);
t->token_string[0] = t->token_string[2] = '\'';
t->token_string[1] = t->value;
t->token_string[3] = '\0';
token_index += 3;
if (debug) fprintf(stderr, "next token: char constant %d (%c)\n", t->value, t->value);
return;
}
/* and anything else is just illegal */
/* should we advance the token_index here? */
t->type = Tillegal;
if (debug) fprintf(stderr, "next token: illegal\n");
return;
}
// Parses a set of constant arguments
struct list *parse_constant_args(struct lexer_state *lexer,
enum token_type close)
{
struct value *arg = NULL;
struct list *args = list_new();
// First check for empty list
lex(lexer);
if(lexer->error == UNRECOGNIZED_TOKEN)
{
print_error(lexer, LEX_ERROR);
clear_value_list(args);
return NULL;
}
if(lexer->error == END_OF_INPUT)
{
print_error(lexer, UNEXPECTED_END);
clear_value_list(args);
return NULL;
}
// If we already have close token, just return empty list
if(lexer->type == close)
return args;
else
lexer_rewind(lexer);
while(lexer->error == OK)
{
// First parse a value and add it to the list
arg = parse_constant(lexer);
if(!arg)
{
clear_function_list(args);
return NULL;
}
list_push_back(args, arg);
// Now checking for a separator or end of the list
lex(lexer);
if(lexer->error == UNRECOGNIZED_TOKEN)
{
print_error(lexer, LEX_ERROR);
clear_value_list(args);
return NULL;
}
if(lexer->error == END_OF_INPUT)
{
print_error(lexer, UNEXPECTED_END);
clear_value_list(args);
return NULL;
}
if(lexer->type == close)
break;
// If the list is still open, we expect a separator
if(lexer->type != SEPARATOR)
{
print_error(lexer, INVALID_ELEMENT);
clear_value_list(args);
return NULL;
}
}
return args;
}
string
r_language_rep::get_color (tree t, int start, int end) {
static bool setup_done= false;
if (!setup_done) {
r_color_setup_constants (colored);
r_color_setup_keywords (colored);
r_color_setup_otherlexeme (colored);
setup_done= true;
}
static string none= "";
if (start >= end) return none;
string s= t->label;
string r1=s(0,start) ;
int pos=0;int opos;
bool backquote= false;
bool after_backquote;
bool postfix= false;
bool possible_function= true;
bool possible_type= false;
bool possible_class= false;
bool possible_future_type= false;
bool possible_future_function= true;
bool possible_future_class= false;
string type;
bool is_markup;
#if 0
// There isn't much point to the following, because its only effet is pos and type, and both are reset below.
do {
do {
opos=pos;
parse_string (s, pos);
if (opos<pos) break;
parse_comment_single_line (s, pos);
if (opos < pos) {
type= "comment";
break;
}
pos++;
} while(false);
} while( pos<N(s) );
#endif
pos=0;
do {
type= none;
do {
after_backquote= backquote;
possible_function= possible_future_function;
possible_type= possible_future_type;
possible_class= possible_future_class;
opos= pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_string (s, pos);
if (opos<pos) {
type= "string";
backquote= false;
postfix= false;
possible_future_function= false;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_number (s, pos);
if (opos<pos) {
type= "number";
backquote= false;
postfix= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_comment_single_line (s, pos);
if (opos<pos) {
type= "comment";
backquote= false;
postfix= false;
possible_future_type= false;
possible_type= false;
break;
}
parse_modifier (colored, s, pos);
if (opos<pos) {
type="keyword";
backquote= false;
postfix= false;
possible_future_type= false;
possible_type= false;
possible_function= false;
break;
}
parse_postfix (colored, s, pos);
if (opos<pos) {
type="keyword";
backquote= false;
postfix= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
possible_function= false;
possible_future_class= false;
break;
}
parse_class (colored, s, pos);
if (opos<pos) {
type= "keyword";
backquote=false;
postfix=false;
possible_future_type= false;
possible_type= false;
possible_future_class=true;
possible_future_function= false;
break;
}
parse_keyword (colored, s, pos);
if (opos<pos) {
type= "keyword";
backquote= false;
postfix= false;
possible_future_type= false;
possible_type= false;
possible_function= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_other_op_assign (colored, s, pos); //not left parenthesis
if (opos<pos) {
type= "other_lexeme";// was
type = "op assign" ;
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_other_op_index (colored, s, pos); //not left parenthesis
if (opos<pos) {
type= "other_lexeme";// was
type = "op index" ;
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_other_lexeme (colored, s, pos); //not left parenthesis
if (opos<pos) {
type= "other_lexeme";// was
type = "operator" ;
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_type= false;
possible_future_class= false;
possible_type= false;
break;
}
parse_constant (colored, s, pos);
if (opos<pos) {
type= "constant";
backquote= false;
postfix= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_backquote (s, pos);
if (opos<pos) {
backquote= true;
postfix= false;
possible_future_function= false;
possible_future_class= false;
break;
}
parse_identifier_or_markup (colored, s, pos, postfix, is_markup);
if (opos<pos) {
if (is_markup) {type= "identifier_markup";} else type= "identifier";
backquote= false;
postfix= false;
possible_future_function=false;
possible_future_class= false;
break;
}
parse_parenthesized (s, pos);
// stops after well parenthesized ) or before // or /{ or " or /"
if (opos<pos && pos<=start) {
type="left_parenthesis";
backquote= false;
postfix= false;
possible_function= false;
possible_future_function= true;
possible_future_class= false;
break;
}
if (opos<pos && possible_type==true)
return "dark green";
if (opos<pos && after_backquote)
return none;
backquote= false;
postfix= false;
pos= opos;
pos++;
} while (false); // This while() is so that we can easily escape with break.
} while (pos<=start);
if (possible_type) return "dark green";
if (type=="string") return "#a06040";
if (type=="operator") return "red";
if (type=="op assign") return "dark green";
if (type=="op index") return "dark blue";
if (type=="comment") return "brown";
if (type=="keyword" && !after_backquote) return "#8020c0";
if (type=="other_lexeme") return none;
if (type=="constant") return "#2060c0";
if (type=="number") return "#2060c0";
if (type=="left_parenthesis") return none;
if (type=="identifier" && !possible_function && !possible_class ) return none;
if (type=="identifier_markup" && !possible_function && !possible_class ) return COLOR_MARKUP;
if ( (type=="identifier" || type=="identifier_markup") && possible_function) {
possible_function= false;
do {
do {
opos=pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_identifier (colored, s, pos,false);
if (opos<pos) { possible_function= true; break; }
parse_number (s, pos);
if (opos<pos) { possible_function= true; break; }
parse_constant (colored, s, pos);
if (opos<pos) { possible_function= true; break; }
parse_comment_single_line (s, pos);
if (opos<pos) break;
parse_parenthesized (s, pos);
if (opos<pos) { possible_function= true; break; }
} while (false);
} while (opos != pos);
if (!possible_function) {
if (type=="identifier") {return none;}
else return COLOR_MARKUP; // type=="identifier_markup"
} else do {
do {
opos=pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_identifier (colored, s, pos,false);
if (opos<pos) break;
parse_number(s,pos);
if (opos<pos) break;
parse_constant (colored, s, pos);
if (opos<pos) break;
parse_comment_single_line(s,pos);
if (opos<pos) break;
parse_parenthesized (s, pos);
if (opos<pos) break;
if (type=="identifier") {return none;}
else return COLOR_MARKUP;
} while (false);
}
while (pos<N(s));
} // type==identifier || type==identifier_markup && possible function
if ( (type=="identifier" || type=="identifier_markup") && possible_class) {
do {
do {
opos=pos;
parse_blanks (s, pos);
if (opos<pos) break;
parse_identifier (colored, s, pos,false);
if (opos<pos) break;
parse_number(s,pos);
if (opos<pos) break;
parse_constant (colored, s, pos);
if (opos<pos) break;
parse_comment_single_line(s,pos);
if (opos<pos) break;
parse_parenthesized (s, pos);
if (opos<pos) break;
if (type=="identifier") {return none;}
else return COLOR_MARKUP;
} while (false);
}
while (pos<N(s));
}
if (type=="identifier_markup") {return COLOR_MARKUP;}
else return none;
}
int parse_expression(char *expr) {
if (strlen(strtrim(expr)) == 0)
return BREAK;
char *token;
static const char *operators = "+/*-%^";
static const char *mfuncs = "|ln|sqrt|sin|cos|tan|asin|acos|atan|";
static const char *constants = "|e|pi|";
double operand;
char *ptr;
while ((token = strsep(&expr, " \n"))) {
if (strlen(token) == 0) continue;
if (*token == ':') /* precision specified */
parse_precision(++token);
else if (strchr(operators, *token) && strlen(token) == 1) { /* operator */
if (stackptr - opstack < 2) {
fprintf(stderr, "!! Malformed expression -- too few operands.\n");
return CONTINUE;
}
if (parse_operator(*token) > 0) {
return CONTINUE;
}
} else if ((ptr = strstr(mfuncs, strlower(token))) != NULL &&
*(ptr - 1) == '|' && *(ptr + strlen(token)) == '|') {
/* validated trig function */
if (stackptr - opstack < 1) {
fprintf(stderr, "!! Malformed expression -- too few operands.\n");
return CONTINUE;
}
parse_mfunc(token);
} else if ((ptr = strstr(constants, strlower(token))) != NULL &&
*(ptr - 1) == '|' && *(ptr + strlen(token)) == '|') {
/* validated constant */
parse_constant(token);
} else { /* it's an operand, or it's bad input */
if (parse_operand(token, &operand) > 0) /* parsing failed on bad input */
return CONTINUE;
if (stackptr == &opstack[STACK_SIZE]) { /* stack overflow */
fprintf(stderr, "!! Stack overflow. Expression too large.\n");
return CONTINUE;
}
*stackptr++ = operand;
}
}
if (stackptr - opstack > 1)
fprintf(stderr, "!! Malformed expression -- too many operands.\n");
else if (stackptr - opstack == 1) {
if (verbose >= 1)
printf(" = %.*f\n", precision, *--stackptr);
else
printf("%.*f\n", precision, *--stackptr);
}
return CONTINUE;
}