ms2ps.cpp File Reference

#include <iostream>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <deque>
#include <ctype.h>

Include dependency graph for ms2ps.cpp:

Go to the source code of this file.

Macros
#define	MAYBE(x)

Typedefs
typedef std::list< std::string >	sl_t
typedef sl_t::iterator	sl_it

Enumerations
enum	fstate { EMPTY , INT , FRAC , EXP }

Functions
int	isident (int c)
bool	areinclass (string str, int(*isclass)(int))
bool	areident (string s)
bool	isop (string tok)
string	generic_match (string tok, string la, bool(*mf)(string))
string	match_operator (string tok, string la)
string	match_ident (string tok, string la)
string	match_quoted_const (string tok, string la, char q)
sl_t	snarf_tokens (string line)
istream &	getline_no_comments (istream &is, string &line)
bool	expand_input (sl_t &tok)
sl_it	complete_block (sl_it i, sl_it end, string start_ch, string end_ch)
string	makename (string intro)
void	append_block (sl_t &t, sl_it b, sl_it e)
void	error (sl_t &container, sl_it it, string l)
void	handle_try (sl_t &container, sl_it try_kw, sl_it end)
void	print_tokens (sl_it begin, sl_it end)
int	main (int argc, char **argv)

Variables
string	TRY_TOKEN = "__try"
string	EXCEPT_TOKEN = "__except"
string	FINALLY_TOKEN = "__finally"
char *	c_operators []

Macro Definition Documentation

MAYBE

#define MAYBE

(

x

)

Definition at line 35 of file ms2ps.cpp.

Typedef Documentation

sl_it

typedef sl_t::iterator sl_it

Definition at line 45 of file ms2ps.cpp.

sl_t

typedef std::list<std::string> sl_t

Definition at line 44 of file ms2ps.cpp.

Enumeration Type Documentation

fstate

enum fstate

Enumerator
EMPTY
INT
FRAC
EXP

Definition at line 80 of file ms2ps.cpp.

{ EMPTY, INT, FRAC, EXP };

Function Documentation

append_block()

void append_block	(	sl_t &	t,
		sl_it	b,
		sl_it	e
	)

Definition at line 257 of file ms2ps.cpp.

                                               {
    while( b != e ) {
        t.push_back( *b );
        b++;
    }
}

Referenced by handle_try().

areident()

bool areident

(

string

s

)

Definition at line 72 of file ms2ps.cpp.

{ return areinclass( s, isident ); }

Referenced by match_ident().

areinclass()

bool areinclass	(	string	str,
		int(*)(int)	isclass
	)

Definition at line 63 of file ms2ps.cpp.

                                                   {
    int i;
 
    for( i = 0; i < (int)str.size(); i++ )
        if( !isclass( str[i] ) ) return false;
 
    return true;
}

Referenced by areident().

complete_block()

sl_it complete_block	(	sl_it	i,
		sl_it	end,
		string	start_ch,
		string	end_ch
	)

Definition at line 234 of file ms2ps.cpp.

                               {
    int bc = 1;
 
    for( i++; i != end && bc; i++ ) {
        if( *i == start_ch ) bc++;
        if( *i == end_ch ) bc--;
    }
 
    return i;
}

Referenced by handle_try().

error()

void error	(	sl_t &	container,
		sl_it	it,
		string	l
	)

Definition at line 264 of file ms2ps.cpp.

                                                  {
    int line = 0;
    for( sl_it i = container.begin(); i != it; i++ )
    if( (*i)[0] == '#' ) {
        sscanf( i->substr(1).c_str(), "%d", &line );
        cerr << "*standard-input*:" << line << ": " << l;
    }
}

expand_input()

bool expand_input

(

sl_t &

tok

)

Definition at line 208 of file ms2ps.cpp.

                               {
    string line;
    sl_t new_tokens;
    bool out = false;
 
    out = getline_no_comments( cin, line );
    while( line.size() && isspace( line[0] ) )
    line = line.substr( 1 );
    if( line[0] == '#' ) {
    tok.push_back( line );
    while( line[line.size()-1] == '\\' ) {
        getline_no_comments( cin, line );
        tok.push_back( line );
        tok.push_back( "\n" );
    }
    tok.push_back( "\n" );
    } else {
    new_tokens = snarf_tokens( line );
    tok.splice( tok.end(), new_tokens );
    tok.push_back( "\n" );
    }
 
    return out;
}

Referenced by main().

generic_match()

string generic_match	(	string	tok,
		string	la,
		bool(*)(string)	mf
	)

Definition at line 82 of file ms2ps.cpp.

                                             {
    if( tok.size() < 1 ) return "";
    if( mf(tok) && !mf(la) ) return tok; else return "";
}

Referenced by match_ident(), and match_operator().

getline_no_comments()

istream & getline_no_comments	(	istream &	is,
		string &	line
	)

Definition at line 172 of file ms2ps.cpp.

                                                          {
    string buf;
    int ch;
    int seen_slash = false;
 
    while( (ch = is.get()) != -1 ) {
    if( seen_slash ) {
        if( ch == '/' ) {
        do {
            ch = is.get();
        } while( ch != -1 && ch != '\n' && ch != '\r' );
        break;
        } else if( ch == '*' ) {
        ch = is.get(); /* Skip one char */
        do {
            while( ch != '*' )
            ch = is.get();
            ch = is.get();
        } while( ch != '/' );
        buf += ' ';
        } else {
        buf += '/'; buf += (char)ch;
        }
        seen_slash = false;
    } else {
        if( ch == '/' ) seen_slash = true;
        else if( ch == '\r' || ch == '\n' ) break;
        else buf += (char)ch;
    }
    }
 
    line = buf;
 
    return is;
}

Referenced by expand_input().

handle_try()

void handle_try	(	sl_t &	container,
		sl_it	try_kw,
		sl_it	end
	)

Definition at line 287 of file ms2ps.cpp.

                                                            {
    string temp;
    sl_t pseh_clause, temp_tok;
    string finally_name, filter_name;
    sl_it try_block, try_block_end, except_kw, paren, end_paren,
    except_block, except_block_end, todelete,
    finally_kw, finally_block, finally_block_end, clause_end;
 
    try_block = try_kw;
    try_block++;
    try_block_end = complete_block( try_block, end, "{", "}" );
 
    if( try_block_end == end )
    error( container, try_block, "unclosed try block");
 
    except_kw = try_block_end;
 
    if( *except_kw == FINALLY_TOKEN ) {
    finally_kw = except_kw;
    except_kw = end;
    paren = end;
    end_paren = end;
    except_block = end;
    except_block_end = end;
    } else if( *except_kw == EXCEPT_TOKEN ) {
    paren = except_kw;
    paren++;
    if( *paren == "(" ) {
        end_paren = complete_block( paren, end, "(", ")" );
        except_block = end_paren;
    } else {
        except_block = paren;
        paren = end;
        end_paren = end;
    }
    except_block_end = complete_block( except_block, end, "{", "}" );
    finally_kw = except_block_end;
    } else {
    except_kw = paren = end_paren = except_block = except_block_end =
    finally_kw = finally_block = finally_block_end = end;
    }
 
    if( finally_kw != end && *finally_kw != FINALLY_TOKEN ) {
    finally_kw = end;
    finally_block = end;
    finally_block_end = end;
    } else {
    finally_block = finally_kw;
    finally_block++;
    finally_block_end = complete_block( finally_block, end, "{", "}" );
    }
 
    if( finally_block_end != end ) clause_end = finally_block_end;
    else if( except_block_end != end ) clause_end = except_block_end;
    else clause_end = try_block_end;
 
    /* Skip one so that we can do != on clause_end */
 
    /* Now for the output phase -- we've collected the whole seh clause
     * and it lies between try_kw and clause_end */
 
    finally_name = makename("_Finally");
    filter_name = makename("_Filter");
 
    pseh_clause.push_back( "_SEH_FINALLY" );
    pseh_clause.push_back( "(" );
    pseh_clause.push_back( finally_name );
    pseh_clause.push_back( ")" );
    if( finally_kw != end )
    append_block( pseh_clause, finally_block, finally_block_end );
    else {
    pseh_clause.push_back( "{" );
    pseh_clause.push_back( "}" );
    }
 
    pseh_clause.push_back( "_SEH_FILTER" );
    pseh_clause.push_back( "(" );
    pseh_clause.push_back( filter_name );
    pseh_clause.push_back( ")" );
    pseh_clause.push_back( "{" );
    pseh_clause.push_back( "return" );
    if( paren != end )
    append_block( pseh_clause, paren, end_paren );
    else
    pseh_clause.push_back( "EXCEPTION_EXECUTE_HANDLER" );
    pseh_clause.push_back( ";" );
    pseh_clause.push_back( "}" );
 
    pseh_clause.push_back( "_SEH_TRY_FILTER_FINALLY" );
    pseh_clause.push_back( "(" );
    pseh_clause.push_back( filter_name );
    pseh_clause.push_back( "," );
    pseh_clause.push_back( finally_name );
    pseh_clause.push_back( ")" );
    append_block( pseh_clause, try_block, try_block_end );
    pseh_clause.push_back( "_SEH_HANDLE" );
    pseh_clause.push_back( "{" );
    if( except_block != end )
    append_block( pseh_clause, except_block, except_block_end );
    pseh_clause.push_back( "}" );
    pseh_clause.push_back( "_SEH_END" );
    pseh_clause.push_back( ";" );
 
    container.splice( try_kw, pseh_clause );
    while( try_kw != clause_end ) {
    todelete = try_kw;
    try_kw++;
    container.erase( todelete );
    }
}

Referenced by main().

isident()

int isident

(

int

c

)

Definition at line 58 of file ms2ps.cpp.

                     {
    return (c != '{') && (c != '}') && (c != '(') && (c != ')') &&
           (c != '\'') && (c != '\"') && !isspace(c);
}

Referenced by areident().

isop()

bool isop

(

string

tok

)

Definition at line 74 of file ms2ps.cpp.

                        {
    int i;
    for( i = 0; c_operators[i] && tok != c_operators[i]; i++ );
        if( c_operators[i] ) return true; else return false;
}

Referenced by match_operator().

main()

int main	(	int argc	,
		char **	argv
	)

Definition at line 404 of file ms2ps.cpp.

                                  {
    sl_t tok;
    sl_it try_found;
    int i;
 
    for( i = 1; i < argc; i++ ) {
    if( string(argv[i]) == "-try" && i < argc - 1 ) {
        i++;
        TRY_TOKEN = argv[i];
    } else if( string(argv[i]) == "-except" && i < argc - 1 ) {
        i++;
        EXCEPT_TOKEN = argv[i];
    } else if( string(argv[i]) == "-finally" && i < argc - 1 ) {
        i++;
        FINALLY_TOKEN = argv[i];
    }
    }
 
    /* XXX Uses much memory for large files */
    while( expand_input(tok) );
 
    while( (try_found = find( tok.begin(), tok.end(), TRY_TOKEN )) !=
            tok.end() ) {
        handle_try( tok, try_found, tok.end() );
    }
 
    tok.push_front("#include <pseh/framebased.h>\n");
    print_tokens( tok.begin(), tok.end() );
}

makename()

string makename

(

string

intro

)

Definition at line 248 of file ms2ps.cpp.

                                {
    static int i = 0;
    char buf[100];
 
    sprintf( buf, "%s%d", intro.c_str(), i++ );
 
    return buf;
}

Referenced by handle_try().

match_ident()

string match_ident	(	string	tok,
		string	la
	)

Definition at line 92 of file ms2ps.cpp.

                                            {
    return generic_match( tok, la, areident );
}

Referenced by snarf_tokens().

match_operator()

string match_operator	(	string	tok,
		string	la
	)

Definition at line 88 of file ms2ps.cpp.

                                               {
    return generic_match( tok, la, isop );
}

Referenced by snarf_tokens().

match_quoted_const()

string match_quoted_const	(	string	tok,
		string	la,
		char	q
	)

Definition at line 96 of file ms2ps.cpp.

                                                           {
    if( ((tok.size() && tok[0] == q) ||
        ((tok.size() > 2) && tok[0] == 'L' && tok[1] == q)) &&
         (tok.rfind(q) == (tok.size() - 1)) ) {
    if( (tok.rfind("\\") != (tok.size() - 2)) ||
        (tok.size() > 3 && tok.rfind("\\\\") == (tok.size() - 3)) )
        return tok;
    else return "";
    }
    else return "";
}

Referenced by snarf_tokens().

print_tokens()

void print_tokens	(	sl_it	begin,
		sl_it	end
	)

Definition at line 398 of file ms2ps.cpp.

                                            {
    for( sl_it i = begin; i != end; i++ )
    if( *i == "\n" ) cout << *i;
    else cout << /*"[" <<*/ *i << /*"]" <<*/ " ";
}

Referenced by main().

snarf_tokens()

sl_t snarf_tokens

(

string

line

)

Definition at line 108 of file ms2ps.cpp.

                                 {
    int i;
    sl_t out;
    string curtok, la, op, ident, qconst;
 
    line += " ";
 
    for( i = 0; i < (int)line.size() - 1; i++ ) {
    /*cout << "Char [" << line[i] << "] and [" << line[i+1] << "]"
           << endl; */
 
    if( (!curtok.size() ||
         (curtok[0] != '\'' && curtok[0] != '\"')) &&
         (curtok.size() <= 2 ||
          curtok[0] != 'L' ||
         (curtok[1] != '\'' && curtok[1] != '\"')) &&
          isspace(line[i]) ) {
        if( curtok.size() ) out.push_back( curtok );
        curtok = "";
        continue;
    }
 
    curtok.push_back( line[i] );
 
    la = curtok + line[i+1];
 
    op = match_operator( curtok, la );
 
    if( op != "" ) {
        out.push_back( op MAYBE(+ "O") );
        curtok = "";
        continue;
    }
 
    if( la != "L\"" && la != "L\'" ) {
        ident = match_ident( curtok, la );
 
        if( ident != "" ) {
        out.push_back( ident MAYBE(+ "I") );
        curtok = "";
        continue;
        }
    }
 
    qconst = match_quoted_const( curtok, la, '\'' );
 
    if( qconst != "" ) {
        out.push_back( qconst MAYBE(+ "q") );
        curtok = "";
        continue;
    }
 
    qconst = match_quoted_const( curtok, la, '\"' );
 
    if( qconst != "" ) {
        out.push_back( qconst MAYBE(+ "Q") );
        curtok = "";
        continue;
    }
    }
 
    return out;
}

Referenced by expand_input().

Variable Documentation

c_operators

char* c_operators[]

Initial value:

= {
    "{",
    "}",
    "(",
    ")",
    NULL
}

Definition at line 50 of file ms2ps.cpp.

Referenced by isop().

EXCEPT_TOKEN

string EXCEPT_TOKEN = "__except"

Definition at line 48 of file ms2ps.cpp.

Referenced by handle_try(), and main().

FINALLY_TOKEN

string FINALLY_TOKEN = "__finally"

Definition at line 49 of file ms2ps.cpp.

Referenced by handle_try(), and main().

TRY_TOKEN

string TRY_TOKEN = "__try"

Definition at line 47 of file ms2ps.cpp.

Referenced by main().