reactos/tools/ms2ps/ms2ps.cpp

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2004 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id: ms2ps.cpp,v 1.4 2004/08/21 19:59:52 arty Exp $
  20  * COPYRIGHT:       See COPYING in the top level directory
  21  * PROJECT:         ReactOS seh conversion tool
  22  * FILE:            tools/ms2ps/ms2ps.cpp
  23  * PURPOSE:         Conversion tool from msvc to pseh style seh
  24  * PROGRAMMER:      Art Yerkes
  25  */
  26
  27 #include <iostream>
  28 #include <vector>
  29 #include <list>
  30 #include <set>
  31 #include <map>
  32 #include <deque>
  33 #include <ctype.h>
  34
  35 #define MAYBE(x)
  36
  37 using std::string;
  38 using std::cin;
  39 using std::cout;
  40 using std::cerr;
  41 using std::endl;
  42 using std::istream;
  43
  44 typedef std::list<std::string> sl_t;
  45 typedef sl_t::iterator sl_it;
  46
  47 string TRY_TOKEN = "__try";
  48 string EXCEPT_TOKEN = "__except";
  49 string FINALLY_TOKEN = "__finally";
  50 char *c_operators[] = {
  51     "{",
  52     "}",
  53     "(",
  54     ")",
  55     NULL
  56 };
  57
  58 int isident( int c ) {
  59     return (c != '{') && (c != '}') && (c != '(') && (c != ')') &&
  60         (c != '\'') && (c != '\"') && !isspace(c);
  61 }
  62
  63 bool areinclass( string str, int (*isclass)(int) ) {
  64     int i;
  65
  66     for( i = 0; i < (int)str.size(); i++ )
  67         if( !isclass( str[i] ) ) return false;
  68
  69     return true;
  70 }
  71
  72 bool areident( string s ) { return areinclass( s, isident ); }
  73
  74 bool isop( string tok ) {
  75     int i;
  76     for( i = 0; c_operators[i] && tok != c_operators[i]; i++ );
  77     if( c_operators[i] ) return true; else return false;
  78 }
  79
  80 enum fstate { EMPTY, INT, FRAC, EXP };
  81
  82 string generic_match( string tok, string la,
  83                            bool (*mf)( string ) ) {
  84     if( tok.size() < 1 ) return "";
  85     if( mf(tok) && !mf(la) ) return tok; else return "";
  86 }
  87
  88 string match_operator( string tok, string la ) {
  89     return generic_match( tok, la, isop );
  90 }
  91
  92 string match_ident( string tok, string la ) {
  93     return generic_match( tok, la, areident );
  94 }
  95
  96 string match_quoted_const( string tok, string la, char q ) {
  97     if( ((tok.size() && tok[0] == q) ||
  98          ((tok.size() > 2) && tok[0] == 'L' && tok[1] == q)) &&
  99         (tok.rfind(q) == (tok.size() - 1)) ) {
 100         if( (tok.rfind("\\") != (tok.size() - 2)) ||
 101             (tok.size() > 3 && tok.rfind("\\\\") == (tok.size() - 3)) )
 102             return tok;
 103         else return "";
 104     }
 105     else return "";
 106 }
 107
 108 sl_t snarf_tokens( string line ) {
 109     int i;
 110     sl_t out;
 111     string curtok, la, op, ident, qconst;
 112
 113     line += " ";
 114
 115     for( i = 0; i < (int)line.size() - 1; i++ ) {
 116         /*cout << "Char [" << line[i] << "] and [" << line[i+1] << "]"
 117           << endl; */
 118
 119         if( (!curtok.size() ||
 120              (curtok[0] != '\'' && curtok[0] != '\"')) &&
 121             (curtok.size() <= 2 ||
 122              curtok[0] != 'L' ||
 123              (curtok[1] != '\'' && curtok[1] != '\"')) &&
 124              isspace(line[i]) ) {
 125             if( curtok.size() ) out.push_back( curtok );
 126             curtok = "";
 127             continue;
 128         }
 129
 130         curtok.push_back( line[i] );
 131
 132         la = curtok + line[i+1];
 133
 134         op = match_operator( curtok, la );
 135
 136         if( op != "" ) {
 137             out.push_back( op MAYBE(+ "O") );
 138             curtok = "";
 139             continue;
 140         }
 141
 142         if( la != "L\"" && la != "L\'" ) {
 143             ident = match_ident( curtok, la );
 144
 145             if( ident != "" ) {
 146                 out.push_back( ident MAYBE(+ "I") );
 147                 curtok = "";
 148                 continue;
 149             }
 150         }
 151
 152         qconst = match_quoted_const( curtok, la, '\'' );
 153
 154         if( qconst != "" ) {
 155             out.push_back( qconst MAYBE(+ "q") );
 156             curtok = "";
 157             continue;
 158         }
 159
 160         qconst = match_quoted_const( curtok, la, '\"' );
 161
 162         if( qconst != "" ) {
 163             out.push_back( qconst MAYBE(+ "Q") );
 164             curtok = "";
 165             continue;
 166         }
 167     }
 168
 169     return out;
 170 }
 171
 172 istream &getline_no_comments( istream &is, string &line ) {
 173     string buf;
 174     int ch;
 175     int seen_slash = false;
 176
 177     while( (ch = is.get()) != -1 ) {
 178         if( seen_slash ) {
 179             if( ch == '/' ) {
 180                 do {
 181                     ch = is.get();
 182                 } while( ch != -1 && ch != '\n' && ch != '\r' );
 183                 break;
 184             } else if( ch == '*' ) {
 185                 ch = is.get(); /* Skip one char */
 186                 do {
 187                     while( ch != '*' )
 188                         ch = is.get();
 189                     ch = is.get();
 190                 } while( ch != '/' );
 191                 buf += ' ';
 192             } else {
 193                 buf += '/'; buf += (char)ch;
 194             }
 195             seen_slash = false;
 196         } else {
 197             if( ch == '/' ) seen_slash = true;
 198             else if( ch == '\r' || ch == '\n' ) break;
 199             else buf += (char)ch;
 200         }
 201     }
 202
 203     line = buf;
 204
 205     return is;
 206 }
 207
 208 bool expand_input( sl_t &tok ) {
 209     string line;
 210     sl_t new_tokens;
 211     bool out = false;
 212
 213     out = getline_no_comments( cin, line );
 214     while( line.size() && isspace( line[0] ) )
 215         line = line.substr( 1 );
 216     if( line[0] == '#' ) {
 217         tok.push_back( line );
 218         while( line[line.size()-1] == '\\' ) {
 219             getline_no_comments( cin, line );
 220             tok.push_back( line );
 221             tok.push_back( "\n" );
 222         }
 223         tok.push_back( "\n" );
 224     } else {
 225         new_tokens = snarf_tokens( line );
 226         tok.splice( tok.end(), new_tokens );
 227         tok.push_back( "\n" );
 228     }
 229
 230     return out;
 231 }
 232
 233 sl_it
 234 complete_block( sl_it i,
 235                 sl_it end,
 236                 string start_ch, string end_ch) {
 237     int bc = 1;
 238
 239     for( i++; i != end && bc; i++ ) {
 240         if( *i == start_ch ) bc++;
 241         if( *i == end_ch ) bc--;
 242     }
 243
 244     return i;
 245 }
 246
 247 string makename( string intro ) {
 248     static int i = 0;
 249     char buf[100];
 250
 251     sprintf( buf, "%s%d", intro.c_str(), i++ );
 252
 253     return buf;
 254 }
 255
 256 void append_block( sl_t &t, sl_it b, sl_it e ) {
 257     while( b != e ) {
 258         t.push_back( *b );
 259         b++;
 260     }
 261 }
 262
 263 void error( sl_t &container, sl_it it, string l ) {
 264     int line = 0;
 265     for( sl_it i = container.begin(); i != it; i++ )
 266         if( (*i)[0] == '#' ) {
 267             sscanf( i->substr(1).c_str(), "%d", &line );
 268             cerr << "*standard-input*:" << line << ": " << l;
 269         }
 270 }
 271
 272 /* Goal: match and transform one __try { a } __except [ (foo) ] { b }
 273  * [ __finally { c } ]
 274  *
 275  * into
 276  *
 277  * _SEH_FINALLY(name1) { c }
 278  * _SEH_FILTER(name2) { return (foo | EXCEPTION_EXECUTE_HANDLER); }
 279  * _SEH_TRY_FILTER_FINALLY(name1,name2) {
 280  *   a
 281  * } _SEH_HANDLE {
 282  *   b
 283  * } _SEH_END;
 284  */
 285
 286 void handle_try( sl_t &container, sl_it try_kw, sl_it end ) {
 287     string temp;
 288     sl_t pseh_clause, temp_tok;
 289     string finally_name, filter_name;
 290     sl_it try_block, try_block_end, except_kw, paren, end_paren,
 291         except_block, except_block_end, todelete,
 292         finally_kw, finally_block, finally_block_end, clause_end;
 293
 294     try_block = try_kw;
 295     try_block++;
 296     try_block_end = complete_block( try_block, end, "{", "}" );
 297
 298     if( try_block_end == end )
 299         error( container, try_block, "unclosed try block");
 300
 301     except_kw = try_block_end;
 302
 303     if( *except_kw == FINALLY_TOKEN ) {
 304         finally_kw = except_kw;
 305         except_kw = end;
 306         paren = end;
 307         end_paren = end;
 308         except_block = end;
 309         except_block_end = end;
 310     } else if( *except_kw == EXCEPT_TOKEN ) {
 311         paren = except_kw;
 312         paren++;
 313         if( *paren == "(" ) {
 314             end_paren = complete_block( paren, end, "(", ")" );
 315             except_block = end_paren;
 316         } else {
 317             except_block = paren;
 318             paren = end;
 319             end_paren = end;
 320         }
 321         except_block_end = complete_block( except_block, end, "{", "}" );
 322         finally_kw = except_block_end;
 323     } else {
 324         except_kw = paren = end_paren = except_block = except_block_end =
 325             finally_kw = finally_block = finally_block_end = end;
 326     }
 327
 328     if( finally_kw != end && *finally_kw != FINALLY_TOKEN ) {
 329         finally_kw = end;
 330         finally_block = end;
 331         finally_block_end = end;
 332     } else {
 333         finally_block = finally_kw;
 334         finally_block++;
 335         finally_block_end = complete_block( finally_block, end, "{", "}" );
 336     }
 337
 338     if( finally_block_end != end ) clause_end = finally_block_end;
 339     else if( except_block_end != end ) clause_end = except_block_end;
 340     else clause_end = try_block_end;
 341
 342     /* Skip one so that we can do != on clause_end */
 343
 344     /* Now for the output phase -- we've collected the whole seh clause
 345      * and it lies between try_kw and clause_end */
 346
 347     finally_name = makename("_Finally");
 348     filter_name = makename("_Filter");
 349
 350     pseh_clause.push_back( "_SEH_FINALLY" );
 351     pseh_clause.push_back( "(" );
 352     pseh_clause.push_back( finally_name );
 353     pseh_clause.push_back( ")" );
 354     if( finally_kw != end )
 355         append_block( pseh_clause, finally_block, finally_block_end );
 356     else {
 357         pseh_clause.push_back( "{" );
 358         pseh_clause.push_back( "}" );
 359     }
 360
 361     pseh_clause.push_back( "_SEH_FILTER" );
 362     pseh_clause.push_back( "(" );
 363     pseh_clause.push_back( filter_name );
 364     pseh_clause.push_back( ")" );
 365     pseh_clause.push_back( "{" );
 366     pseh_clause.push_back( "return" );
 367     if( paren != end )
 368         append_block( pseh_clause, paren, end_paren );
 369     else
 370         pseh_clause.push_back( "EXCEPTION_EXECUTE_HANDLER" );
 371     pseh_clause.push_back( ";" );
 372     pseh_clause.push_back( "}" );
 373
 374     pseh_clause.push_back( "_SEH_TRY_FILTER_FINALLY" );
 375     pseh_clause.push_back( "(" );
 376     pseh_clause.push_back( filter_name );
 377     pseh_clause.push_back( "," );
 378     pseh_clause.push_back( finally_name );
 379     pseh_clause.push_back( ")" );
 380     append_block( pseh_clause, try_block, try_block_end );
 381     pseh_clause.push_back( "_SEH_HANDLE" );
 382     pseh_clause.push_back( "{" );
 383     if( except_block != end )
 384         append_block( pseh_clause, except_block, except_block_end );
 385     pseh_clause.push_back( "}" );
 386     pseh_clause.push_back( "_SEH_END" );
 387     pseh_clause.push_back( ";" );
 388
 389     container.splice( try_kw, pseh_clause );
 390     while( try_kw != clause_end ) {
 391         todelete = try_kw;
 392         try_kw++;
 393         container.erase( todelete );
 394     }
 395 }
 396
 397 void print_tokens( sl_it begin, sl_it end ) {
 398     for( sl_it i = begin; i != end; i++ )
 399         if( *i == "\n" ) cout << *i;
 400         else cout << /*"[" <<*/ *i << /*"]" <<*/ " ";
 401 }
 402
 403 int main( int argc, char **argv ) {
 404     sl_t tok;
 405     sl_it try_found;
 406     int i;
 407
 408     for( i = 1; i < argc; i++ ) {
 409         if( string(argv[i]) == "-try" && i < argc - 1 ) {
 410             i++;
 411             TRY_TOKEN = argv[i];
 412         } else if( string(argv[i]) == "-except" && i < argc - 1 ) {
 413             i++;
 414             EXCEPT_TOKEN = argv[i];
 415         } else if( string(argv[i]) == "-finally" && i < argc - 1 ) {
 416             i++;
 417             FINALLY_TOKEN = argv[i];
 418         }
 419     }
 420
 421     /* XXX Uses much memory for large files */
 422     while( expand_input(tok) );
 423
 424     while( (try_found = find( tok.begin(), tok.end(), TRY_TOKEN )) !=
 425            tok.end() ) {
 426         handle_try( tok, try_found, tok.end() );
 427     }
 428
 429     print_tokens( tok.begin(), tok.end() );
 430 }