/* handler for parser QUOTES state */
static const WCHAR *quotes_state( struct parser *parser, const WCHAR *pos )
{
const WCHAR *p, *token_end = parser->start;
for (p = pos; !is_eol( parser, p ); p++)
{
if (*p == '"')
{
if (p+1 < parser->end && p[1] == '"') /* double quotes */
{
push_token( parser, p + 1 );
parser->start = token_end = p + 2;
p++;
}
else /* end of quotes */
{
push_token( parser, p );
parser->start = p + 1;
pop_state( parser );
return p + 1;
}
}
}
push_token( parser, p );
pop_state( parser );
return p;
}
static double eval_expr(const char *buf, int *pos) /* expr = term+expr | term-expr | term */
{
double rv = 0.0, lhs, rhs;
Token tok;
DB(printf("-- eval_expr(\"%s\", &pos=%p pos=%d)\n", buf+*pos, pos, *pos));
lhs = eval_term(buf, pos);
if(G_eval_error)
return rv;
DB(printf("-- expr lhs=%f\n", lhs));
tok = pull_token(buf, pos);
if(G_eval_error)
return rv;
DB(printf("-- expr token type '%c' = ", tok.type));
switch(tok.type)
{
case '\0':
DB(printf("END OF BUFFER\n"));
rv = lhs;
break;
case '+': /* addition */
rhs = eval_expr(buf, pos);
DB(printf("%f+%f", lhs, rhs));
rv = lhs+rhs;
DB(printf("=%f\n", rv));
break;
case '-': /* subtraction */
rhs = eval_expr(buf, pos);
DB(printf("%f-%f", lhs, rhs));
rv = lhs-rhs;
DB(printf("=%f\n", rv));
break;
case ')': /* end of group */
DB(printf("end group"));
push_token(tok);
rv = lhs;
DB(printf(" (rv=%f)\n", rv));
break;
case ',': /* argument delimiter */
DB(printf("delimiter"));
push_token(tok);
rv = lhs;
DB(printf(" (rv=%f)\n", rv));
break;
default:
DB(printf("invalid expr token\n"));
G_eval_error = EVAL_SYNTAX_ERROR;
rv = lhs;
}
DB(printf("-- expr rv=%f\n", rv));
return rv;
}
/*
* Parse a file path and return a structure containing its
* components.
*
* This function takes a file path (e.g. /var/tmp/myexample.txt)
* and produces a structure containing points to the path elements.
*
* typedef struct _PATHINFO_STRUCT {
* char* fullpath;
* char* filename;
* char* dirpath;
* char* extension;
* int isdir;
* } PATHINFO_STRUCT;
*
* The PATHINFO_STRUCT structure is allocated from the heap, as are
* the strings pointed two by its members. This memory must be
* returned to the heap by calling pathinfo_release, passing a pointer
* to the PATHINFO_STRUCT returned by pathinfo_parse.
*/
PATHINFO_STRUCT* pathinfo_parse_filepath(const char* pathname) {
DQHEADER deque;
PATHINFO_STRUCT* pathinfop;
char* pathdelim = "/";
char* pathbuff;
char* tokenp = NULL;
char* token_aheadp = NULL;
int isdir = 0;
// Get a pathinfo structure
pathinfop = calloc(1, sizeof(PATHINFO_STRUCT));
pathinfop->fullpath = strdup(pathname);
// Initialize a plenty big deque to hold path components.
dq_init(strlen(pathname) + 1, sizeof(char), &deque);
// Break the file path into tokens. Copy to a working buffer
// so we don't alter path with calls to strtok
pathbuff = strdup(pathname);
// Check for leading /
if (pathbuff[0] == '/') {
push_token(&deque, "/");
}
isdir = pathinfo_is_dir(pathname);
pathinfop->isdir = isdir;
// Get first token and look ahead token
tokenp = strtok(pathbuff, pathdelim);
token_aheadp = strtok(NULL, pathdelim);
while (tokenp != NULL) {
if (token_aheadp != NULL) {
// More tokens in path string
push_token(&deque, tokenp);
push_token(&deque, "/");
tokenp = token_aheadp;
token_aheadp = strtok(NULL, pathdelim);
} else {
// tokenp is the last token in the sequence
if (!isdir) {
parse_filename(pathinfop, tokenp);
} else {
push_token(&deque, tokenp);
}
tokenp = NULL;
}
}
set_dirpath(pathinfop, &deque);
free(pathbuff);
return pathinfop;
}
static void tokenize( struct pike_string *s )
{
int in_string = 0;
unsigned int ts=0, i, len=s->len;
const char *data = s->str;
struct svalue *osp = Pike_sp;
push_array( allocate_array_no_init( 0, 100 ) );
for( i=0; i<len; i++ )
{
if( in_string )
{
if( (data[i]=='@') )
{
if( data[i+1]!='@' )
{
push_token( data, ts, i-1 );
in_string=0;
ts=i+1;
}
else
i++;
}
}
else
{
switch( data[i] )
{
case '@':
ts=i+1;
in_string=1;
break;
case ':':
case ' ':
case '\t':
case '\n':
case '\r':
if( ts < i ) push_token( data, ts, i-1 );
ts=i+1;
break;
case ';':
if( ts < i ) push_token( data, ts, i-1 );
ts=i+1;
push_array( allocate_array_no_init( 0, 10 ) );
break;
}
}
}
if( ts < len ) push_token( data, ts, len-1 );
f_aggregate( Pike_sp-osp );
}
static int handle_token_colon( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( parser->empty_line
&& !push_indent( parser->indent, out ))
return 0;
if( parser->in_branch
&& !parser->parens_closed
&& parser->empty_line )
{
int i;
for( i = 4; i > 0; --i )
putc( ' ', out );
}
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
static int handle_token_assign_op( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( parser->empty_line ) {
if( !push_indent( parser->indent, out ) )
return 0;
int i;
for( i = 4; i > 0; --i )
putc( ' ', out );
}
else {
putc( ' ', out );
}
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
static int run_scan_toks(lua_State * L)
{
saved_tex_scanner texstate;
int macro_def = false, xpand = false;
halfword t, saved_defref;
int i = 1;
int top = lua_gettop(L);
if (top>0)
macro_def = lua_toboolean(L,1); /* \\def ? */
if (top>1)
xpand = lua_toboolean(L,2); /* expand ? */
save_tex_scanner(texstate);
saved_defref = def_ref;
(void) scan_toks(macro_def, xpand);
t = def_ref;
unsave_tex_scanner(texstate);
def_ref = saved_defref;
/* This function returns a pointer to the tail of a new token
list, and it also makes |def_ref| point to the reference count at the
head of that list. */
lua_newtable(L);
while (token_link(t)) {
t = token_link(t);
push_token(L,t);
lua_rawseti(L,-2,i++);
}
return 1;
}
static int handle_token_rparen( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( parser->in_branch
&& !parser->parens_closed )
{
--parser->paren_depth;
if( parser->paren_depth == 0 ) {
parser->parens_closed = 1;
}
if( parser->empty_line ) {
int i;
for( i = 4; i > 0; --i )
putc( ' ', out );
}
}
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
/*#define TOK_TO_CATCH PREPROC */
static void check_parser( Parser * parser )
{
if( parser->paren_depth < 0
|| parser->indent < 0
#if defined(LINE_TO_STOP) && defined(TOK_TO_CATCH)
|| (parser->cur_line == LINE_TO_STOP
&& parser->prev_tk.type == TOK_TO_CATCH)
#endif
)
{
fprintf( stderr, "\n**************************\n" );
if( parser->paren_depth < 0 ) {
fprintf( stderr, "ERROR: paren_depth < 0\n" );
}
if( parser->indent < 0 ) {
fprintf( stderr, "ERROR: indent < 0\n" );
}
if( parser->last_brace_indent < 0 ) {
fprintf( stderr, "ERROR: last_brace_indent < 0\n" );
}
fprintf( stderr, "paren_depth = %d\n",
parser->paren_depth );
fprintf( stderr, "indent = %d\n",
parser->indent );
fprintf( stderr, "last_brace_indent = %d\n",
parser->last_brace_indent );
fprintf( stderr, "Current line: %d\n",
parser->cur_line );
fprintf( stderr, "Current token:\n" );
push_token( &(parser->prev_tk), stderr );
fprintf( stderr, "\n");
abort();
}
}
static int handle_token_eol( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( !push_token( tk, out ) ) {
return 0;
}
parser->empty_line = 1;
parser->un_op = 0;
return 1;
}
main()
{
int type;
double op2;
char c;
char s[MAXOP];
while ((type = getop(s)) != EOF) {
switch (type) {
case NUMBER:
push_token(NUMBER, atof(s));
break;
case '+': case '-': case '/': case '*': case '%':
while (((c = top_char()) != EOF) && islesseq(type, c))
push_token(pop_char(), -1);
push_char(type);
break;
case '(':
push_char(type);
break;
case ')':
while (((c = pop_char()) != EOF) && c != '(')
push_token(c, -1);
break;
case '\n':
while ((c = pop_char()) != EOF)
push_token(c, -1);
calc();
break;
case 'q':
return;
default:
printf("error: unknown command %s\n", s);
break;
}
}
}
static int handle_token_rbrace( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
int lbi = parser->brace_indent[parser->last_brace_indent];
if( !parser->empty_line ) {
putc( '\n', out );
parser->empty_line = 1;
}
parser->indent = lbi;
if( !push_indent( parser->indent, out ) )
{
return 0;
}
if( !push_token( tk, out ) )
{
return 0;
}
--parser->last_brace_indent;
if( parser->last_brace_indent > 0
&& parser->last_brace_indent < parser->stack_size - 10
&& !shrink_stack( &(parser->brace_indent),
&(parser->stack_size) ) )
{
return 0;
}
lbi = parser->brace_indent[parser->last_brace_indent];
if( !parser->last_brace_indent )
{
parser->indent = lbi;
}
else
{
parser->indent = lbi + 1;
}
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
static int handle_token_comment( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( !parser->empty_line ) {
putc( '\t', out );
}
if( parser->empty_line
&& !push_indent( parser->indent, out ))
return 0;
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
/* handler for parser KEY_NAME state */
static
const CHAR*
key_name_state(
struct parser *parser,
const CHAR *pos)
{
const CHAR *p, *token_end = parser->start;
for (p = pos; !is_eol(parser, p); p++)
{
if (*p == ',') break;
switch(*p)
{
case '=':
push_token(parser, token_end);
if (!add_field_from_token(parser, 1)) return NULL;
parser->start = p + 1;
push_state(parser, VALUE_NAME);
set_state(parser, LEADING_SPACES);
return p + 1;
case ';':
push_token(parser, token_end);
if (!add_field_from_token(parser, 0)) return NULL;
push_state(parser, LINE_START);
set_state(parser, COMMENT);
return p + 1;
case '"':
push_token(parser, token_end);
parser->start = p + 1;
push_state(parser, KEY_NAME);
set_state(parser, QUOTES);
return p + 1;
case '\\':
push_token(parser, token_end);
parser->start = p;
push_state(parser, KEY_NAME);
set_state(parser, EOL_BACKSLASH);
return p;
default:
if (!isspace((unsigned char)*p)) token_end = p + 1;
else
{
push_token(parser, p);
push_state(parser, KEY_NAME);
set_state(parser, TRAILING_SPACES);
return p;
}
break;
}
}
push_token(parser, token_end);
set_state(parser, VALUE_NAME);
return p;
}
/*
* peek_token
* utility function to find the type of the next token that
* would be returned by the scanner
*
* returns type of token to be read next
*/
TokenType peek_token(struct ScanData *data) {
struct Token myToken;
/* if the token is on the stack, this is easy */
if (data->tokBuf != NULL) {
return data->tokBuf->token.type;
}
/* else get a copy of the next token */
(void)get_token(&myToken,data);
if (push_token(&myToken, data) != 0) {
/* cannot push back to stack, very bad */
fprintf(stderr,"Cannot push token back into buffer\n");
exit(1);
}
/* return its type */
return myToken.type;
}
/* handler for parser SECTION_NAME state */
static const WCHAR *section_name_state( struct parser *parser, const WCHAR *pos )
{
const WCHAR *p;
for (p = pos; !is_eol( parser, p ); p++)
{
if (*p == ']')
{
push_token( parser, p );
if (add_section_from_token( parser ) == NULL)
return NULL;
push_state( parser, LINE_START );
set_state( parser, COMMENT ); /* ignore everything else on the line */
return p + 1;
}
}
parser->error = INF_STATUS_BAD_SECTION_NAME_LINE; /* unfinished section name */
return NULL;
}
/* handler for parser EOL_BACKSLASH state */
static
const CHAR*
eol_backslash_state(
struct parser *parser,
const CHAR *pos )
{
const CHAR *p;
for (p = pos; !is_eof(parser, p); p++)
{
switch(*p)
{
case '\r':
continue;
case '\n':
parser->line_pos++;
parser->start = p + 1;
set_state(parser, LEADING_SPACES);
return p + 1;
case '\\':
continue;
case ';':
push_state(parser, EOL_BACKSLASH);
set_state(parser, COMMENT);
return p + 1;
default:
if (isspace((unsigned char)*p))
continue;
push_token(parser, p);
pop_state(parser);
return p;
}
}
parser->start = p;
pop_state(parser);
return p;
}
static int handle_token_lbrace( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
++parser->last_brace_indent;
if( parser->last_brace_indent >= parser->stack_size
&& !enlarge_stack( &(parser->brace_indent),
&(parser->stack_size) ) )
{
return 0;
}
parser->brace_indent[parser->last_brace_indent]
= parser->indent;
if( !parser->empty_line
&& parser->prev_tk.type != ASSIGN_OP )
{
putc( '\n', out );
parser->empty_line = 1;
}
// insert a space after '=' in array initialization
if( parser->prev_tk.type == ASSIGN_OP )
{
putc( ' ', out );
}
if( !push_indent( parser->indent, out ) )
return 0;
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->in_branch = 0;
++parser->indent;
parser->un_op = 0;
return 1;
}
static int handle_token_semicolon( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( parser->empty_line
&& !push_indent( parser->indent, out ) )
return 0;
if( parser->in_branch )
{
if( parser->parens_closed ) {
parser->in_branch = 0;
}
else if( parser->empty_line ) {
int i;
for( i = 4; i > 0; --i )
putc( ' ', out );
}
}
if( !push_token( tk, out ) )
return 0;
if( !parser->in_branch )
{
if( parser->last_brace_indent )
parser->indent = parser->brace_indent[parser
->last_brace_indent] + 1;
else
parser->indent = 0;
}
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
static int handle_token_case_kw( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( !parser->empty_line ) {
putc( '\n', out );
parser->empty_line = 1;
}
parser->indent = parser->brace_indent[parser->last_brace_indent];
if( parser->empty_line
&& !push_indent( parser->indent, out ))
return 0;
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
++parser->indent;
parser->un_op = 0;
return 1;
}
static double eval_fact(const char *buf, int *pos) /* fact = item^fact | item */
{
double rv = 0.0, lhs, rhs;
Token tok;
DB(printf("-- eval_fact(\"%s\", &pos=%p pos=%d)\n", buf+*pos, pos, *pos));
lhs = eval_item(buf, pos);
if(G_eval_error)
return rv;
DB(printf("-- fact lhs=%f\n", lhs));
tok = pull_token(buf, pos);
if(G_eval_error)
return rv;
DB(printf("-- fact token type '%c' = ", tok.type));
switch(tok.type)
{
case '\0':
DB(printf("END OF BUFFER\n"));
rv = lhs;
break;
case '^': /* exponentiation */
rhs = eval_fact(buf, pos);
DB(printf("%f^%f", lhs, rhs));
if(G_eval_error)
return rv;
rv = pow(lhs, rhs);
DB(printf("=%f\n", rv));
break;
default:
DB(printf("PUSHBACK\n"));
push_token(tok);
rv = lhs;
}
DB(printf("-- fact rv=%f\n", rv));
return rv;
}
static int handle_token_cond( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( tk->type == IF_KW && parser->prev_tk.type == ELSE_KW ) {
putc( ' ', out );
}
else if( !parser->empty_line ) {
putc( '\n', out );
parser->empty_line = 1;
}
if( parser->in_branch
&& parser->prev_tk.type != ELSE_KW )
{
++parser->indent;
}
else {
parser->in_branch = 1;
}
if( tk->type != ELSE_KW )
parser->parens_closed = 0;
else {
parser->parens_closed = 1;
}
if( parser->prev_tk.type != ELSE_KW
&& parser->empty_line
&& !push_indent( parser->indent, out ) )
return 0;
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
static double eval_item(const char *buf, int *pos) /* item = -item | +item | int | var | (expr) */
{
double rv = 0.0;
void *data;
int tlen, nargs, xargs;
DB(int i);
FunctionPtr fn;
DB(char *fname);
Token tok;
DB(printf("-- eval_item(\"%s\", &pos=%p pos=%d)\n", buf+*pos, pos, *pos));
tok = pull_token(buf, pos);
if(G_eval_error)
return rv;
DB(printf("-- item token type '%c' = ", tok.type));
switch(tok.type)
{
case '+': /* positive */
DB(printf("positive\n"));
rv = eval_fact(buf, pos);
break;
case '-': /* negative */
DB(printf("negative\n"));
rv = -eval_fact(buf, pos);
break;
case 'v': /* variable */
DB(printf("variable name '%s'=%f\n", tok.str, tok.value));
rv = tok.value;
break;
case 'f': /* function */
DB(printf("function name '%s'=%p(%d)\n", tok.str, tok.fn, tok.args));
tlen = tok.args;
nargs = tok.args;
xargs = nargs;
data = tok.data;
fn = tok.fn;
DB(fname = tok.str);
tok = pull_token(buf, pos);
if(G_eval_error == 0)
{
if(tok.type != '(')
G_eval_error = EVAL_SYNTAX_ERROR;
else
{
double *targ = NULL;
if(tlen > 0)
{
targ = (double*)lalloc(sizeof(double)*tlen);
if(targ == NULL)
{
G_eval_error = EVAL_MEM_ERROR;
break;
}
}else
tlen = 0;
if(eval_args(buf, pos, &nargs, &targ, &tlen, 0))
break;
DB(printf("-- item %d arguments\n", nargs));
if(xargs < 0)
{
if(nargs < 1)
{
DB(printf("-- item too few arguments\n"));
G_eval_error = EVAL_ARGS_ERROR;
break;
}
}else if(nargs != xargs)
{
DB(printf("-- item bad argument count (%d) need %d\n",
nargs, xargs));
G_eval_error = EVAL_ARGS_ERROR;
break;
}
tok = pull_token(buf, pos);
if(tok.type != ')')
G_eval_error = EVAL_SYNTAX_ERROR;
else if(G_eval_error == 0)
{
DB(printf("-- call function [%p] with %d args [%p]\n",
fn, nargs, targ));
DB(printf("-- %s(%f", fname, targ[0]));
DB(for(i=1;i<nargs;i++)printf(",%f",targ[i]));
DB(printf(")\n"));
if(fn(nargs, targ, &rv, data) != 0)
G_eval_error = EVAL_FUNCTION_ERROR;
DB(printf("-- rv = %f\n", rv));
}
}
}
break;
case 'n': /* number */
DB(printf("number value '%s'=%f\n", tok.str, tok.value));
rv = tok.value;
break;
case '(':
DB(printf("start grouping\n"));
rv = eval_expr(buf, pos);
tok = pull_token(buf, pos);
if(tok.type != ')')
G_eval_error = EVAL_SYNTAX_ERROR;
break;
default:
DB(printf("PUSHBACK\n"));
push_token(tok);
}
static double eval_term(const char *buf, int *pos) /* term = fact*term | fact/term | fact */
{
double rv = 0.0, lhs, rhs;
Token tok;
DB(printf("-- eval_term(\"%s\", &pos=%p pos=%d)\n", buf+*pos, pos, *pos));
lhs = eval_fact(buf, pos);
if(G_eval_error)
return rv;
DB(printf("-- term lhs=%f\n", lhs));
tok = pull_token(buf, pos);
if(G_eval_error)
return rv;
DB(printf("-- term token type '%c' = ", tok.type));
switch(tok.type)
{
case '\0':
DB(printf("END OF BUFFER\n"));
rv = lhs;
break;
case '*': /* multiplication */
rhs = eval_term(buf, pos);
DB(printf("%f*%f", lhs, rhs));
rv = lhs*rhs;
DB(printf("=%f\n", rv));
break;
case '/': /* division */
rhs = eval_term(buf, pos);
DB(printf("%f/%f", lhs, rhs));
if(rhs == 0.0)
{
DB(printf(" DIVISION BY ZERO\n"));
G_eval_error = EVAL_DIVIDE_BY_ZERO;
}else
{
rv = lhs/rhs;
DB(printf("=%f\n", rv));
}
break;
case '\\': /* modulo division */
rhs = eval_term(buf, pos);
DB(printf("%f%%%f", lhs, rhs));
if(rhs == 0.0)
{
DB(printf(" DIVISION BY ZERO\n"));
G_eval_error = EVAL_DIVIDE_BY_ZERO;
}else
{
rv = fmod(lhs, rhs);
DB(printf("=%f\n", rv));
}
break;
default:
DB(printf("PUSHBACK\n"));
push_token(tok);
rv = lhs;
}
DB(printf("-- term rv=%f\n", rv));
return rv;
}
static int handle_token_ident( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( !parser->in_branch ) {
if( !parser->empty_line ) {
if( parser->prev_tk.type == LBRACE
|| parser->prev_tk.type == SEMICOLON )
{
putc( '\n', out );
parser->empty_line = 1;
}
else if( parser->prev_tk.type != LPAREN
&& parser->prev_tk.type != LBRACKET
&& parser->prev_tk.type != STRUCT_SEP
&& !parser->un_op )
{
putc( ' ', out );
}
}
}
else if( parser->parens_closed ) {
if( parser->prev_tk.type == RPAREN
&& !parser->empty_line )
{
putc( '\n', out );
parser->empty_line = 1;
}
parser->in_branch = 0;
++parser->indent;
}
if( parser->empty_line
&& !push_indent( parser->indent, out ) )
{
return 0;
}
if( parser->in_branch
&& !parser->parens_closed
&& parser->empty_line )
{
int i;
for( i = 4; i > 0; --i )
putc( ' ', out );
}
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
static int handle_token_lparen( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( parser->in_branch ) {
if( parser->parens_closed ) {
if( !parser->empty_line ) {
putc( '\n', out );
parser->empty_line = 1;
}
++parser->indent;
if( !push_indent( parser->indent, out ) )
return 0;
parser->in_branch = 0;
}
else {
++parser->paren_depth;
if( parser->empty_line ) {
if( !push_indent( parser->indent, out ) )
return 0;
int i;
for( i = 4; i > 0; --i )
putc( ' ', out );
}
}
}
else
{
if( !parser->empty_line ) {
if( parser->prev_tk.type == LBRACE
|| parser->prev_tk.type == RBRACE
|| parser->prev_tk.type == SEMICOLON )
{
putc('\n', out );
parser->empty_line = 1;
}
}
if( parser->empty_line
&& !push_indent( parser->indent, out ) )
return 0;
}
/* putting space before token if needed */
if( !parser->empty_line
&& parser->prev_tk.type != LPAREN
&& parser->prev_tk.type != LBRACKET
&& parser->prev_tk.type != SEMICOLON
&& !parser->un_op )
{
putc( ' ', out );
}
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
parser->un_op = 0;
return 1;
}
static int handle_token_op( Token * tk, Parser * parser, FILE * out )
{
if( !tk || !parser || !out )
return 0;
if( !parser->empty_line
&& (!parser->in_branch || !parser->parens_closed) )
{
if( is_incr_or_decr( tk ) ) {
if( !parser->un_op
&& parser->prev_tk.type != LPAREN
&& parser->prev_tk.type != RPAREN
&& parser->prev_tk.type != LBRACKET
&& parser->prev_tk.type != RBRACKET
&& parser->prev_tk.type != IDENT
&& parser->prev_tk.type != NUM_CONST
&& parser->prev_tk.type != CHR_LIT
&& parser->prev_tk.type != STR_LIT )
{
putc( ' ', out );
}
}
else if( is_unary_op( tk ) ) {
if( is_incr_or_decr( &(parser->prev_tk ) ) ) {
putc( ' ', out );
}
else if( !parser->un_op
&& parser->prev_tk.type != LPAREN
&& parser->prev_tk.type != LBRACKET
&& !(parser->prev_tk.start[0] == '*'
&& tk->start[0] == '*') )
{
putc( ' ', out );
}
}
else if( parser->un_op
|| parser->prev_tk.type == RPAREN
|| parser->prev_tk.type == RBRACKET
|| parser->prev_tk.type == IDENT
|| parser->prev_tk.type == NUM_CONST
|| parser->prev_tk.type == CHR_LIT
|| parser->prev_tk.type == STR_LIT)
{
putc( ' ', out );
}
}
/* find out if this is an unary op */
if( is_incr_or_decr( tk ) ) {
parser->un_op = 1;
}
else if( is_unary_op( tk )
&& !is_incr_or_decr( &(parser->prev_tk) )
&& parser->prev_tk.type != IDENT
&& parser->prev_tk.type != NUM_CONST
&& parser->prev_tk.type != CHR_LIT
&& parser->prev_tk.type != STR_LIT
&& parser->prev_tk.type != RBRACKET )
{
if( parser->prev_tk.type != RPAREN ) {
parser->un_op = 1;
}
else if( parser->in_branch ) {
parser->un_op = 1;
}
}
else {
parser->un_op = 0;
}
if( parser->in_branch ) {
if( parser->parens_closed )
{
if( !parser->empty_line )
{
putc( '\n', out );
parser->empty_line = 1;
}
parser->in_branch = 0;
++parser->indent;
}
}
else if( parser->prev_tk.type == SEMICOLON ) {
putc( '\n', out );
parser->empty_line = 1;
}
if( parser->empty_line
&& !push_indent( parser->indent, out ))
return 0;
if( parser->in_branch
&& !parser->parens_closed
&& parser->empty_line )
{
int i;
for( i = 4; i > 0; --i )
putc( ' ', out );
}
if( !push_token( tk, out ) )
return 0;
parser->empty_line = 0;
return 1;
}
static int handle_token( Token * tk, Parser * parser, FILE * out)
{
if( tk->type == PREPROC ) {
if( !push_token( tk, out ) ) {
return 0;
}
parser->empty_line = 0;
return 1;
}
else if( tk->type == COMMENT
|| tk->type == MUL_COMMENT )
{
return handle_token_comment( tk, parser, out );
}
else if( tk->type == IF_KW
|| tk->type == ELSE_KW
|| tk->type == FOR_KW
|| tk->type == WHILE_KW
|| tk->type == DO_KW
|| tk->type == SWITCH_KW )
{
return handle_token_cond( tk, parser, out );
}
else if( tk->type == CASE_KW
|| tk->type == DEFAULT_KW )
{
return handle_token_case_kw( tk, parser, out );
}
else if( tk->type == IDENT
|| tk->type == NUM_CONST
|| tk->type == CHR_LIT
|| tk->type == STR_LIT )
{
return handle_token_ident( tk, parser, out );
}
else if( tk->type == LPAREN ) {
return handle_token_lparen( tk, parser, out );
}
else if( tk->type == RPAREN ) {
return handle_token_rparen( tk, parser, out );
}
else if( tk->type == LBRACE ) {
return handle_token_lbrace( tk, parser, out );
}
else if( tk->type == RBRACE ) {
return handle_token_rbrace( tk, parser, out );
}
else if( tk->type == LBRACKET
|| tk->type == RBRACKET )
{
return handle_token_bracket( tk, parser, out );
}
else if( tk->type == ASSIGN_OP ) {
return handle_token_assign_op( tk, parser, out );
}
else if( tk->type == OP ) {
return handle_token_op( tk, parser, out );
}
else if( tk->type == ELLIPSIS ) {
return handle_token_ellipsis( tk, parser, out );
}
else if( tk->type == STRUCT_SEP
|| tk->type == COMMA )
{
return handle_token_sep( tk, parser, out );
}
else if( tk->type == SEMICOLON ) {
return handle_token_semicolon( tk, parser, out );
}
else if( tk->type == COLON
|| tk->type == QUESTION )
{
return handle_token_colon( tk, parser, out );
}
else if( tk->type == EOL_TOK ) {
return handle_token_eol( tk, parser, out );
}
else
return 0;
return 1;
}
static int
do_parse (void)
{
int tok;
int unit1;
int continue_ulist;
char *start;
unit_count = 0;
start = p;
/* Parse the string. First, let's look for a default. */
tok = next_token ();
switch (tok)
{
case NATIVE:
endian = GFC_CONVERT_NATIVE;
break;
case SWAP:
endian = GFC_CONVERT_SWAP;
break;
case BIG:
endian = GFC_CONVERT_BIG;
break;
case LITTLE:
endian = GFC_CONVERT_LITTLE;
break;
case INTEGER:
/* A leading digit means that we are looking at an exception.
Reset the position to the beginning, and continue processing
at the exception list. */
p = start;
goto exceptions;
break;
case END:
goto end;
break;
default:
goto error;
break;
}
tok = next_token ();
switch (tok)
{
case ';':
def = endian;
break;
case ':':
/* This isn't a default after all. Reset the position to the
beginning, and continue processing at the exception list. */
p = start;
goto exceptions;
break;
case END:
def = endian;
goto end;
break;
default:
goto error;
break;
}
exceptions:
/* Loop over all exceptions. */
while(1)
{
tok = next_token ();
switch (tok)
{
case NATIVE:
if (next_token () != ':')
goto error;
endian = GFC_CONVERT_NATIVE;
break;
case SWAP:
if (next_token () != ':')
goto error;
endian = GFC_CONVERT_SWAP;
break;
case LITTLE:
if (next_token () != ':')
goto error;
endian = GFC_CONVERT_LITTLE;
break;
case BIG:
if (next_token () != ':')
goto error;
endian = GFC_CONVERT_BIG;
break;
case INTEGER:
push_token ();
break;
case END:
goto end;
break;
default:
goto error;
break;
}
/* We arrive here when we want to parse a list of
numbers. */
continue_ulist = 1;
do
{
tok = next_token ();
if (tok != INTEGER)
goto error;
unit1 = unit_num;
tok = next_token ();
/* The number can be followed by a - and another number,
which means that this is a unit range, a comma
or a semicolon. */
if (tok == '-')
{
if (next_token () != INTEGER)
goto error;
mark_range (unit1, unit_num);
tok = next_token ();
if (tok == END)
goto end;
else if (tok == ';')
continue_ulist = 0;
else if (tok != ',')
goto error;
}
else
{
mark_single (unit1);
switch (tok)
{
case ';':
continue_ulist = 0;
break;
case ',':
break;
case END:
goto end;
break;
default:
goto error;
}
}
} while (continue_ulist);
}
end:
return 0;
error:
def = GFC_CONVERT_NONE;
return -1;
}
/*
* If the file contains a control character, we can get multiple
* comments per line.
*/
static inline void push_comment(fb_parser_t *P, const char *first, const char *last)
{
if (P->doc_mode) {
push_token(P, tok_kw_doc_comment, first, last);
}
}