redfsm/xmlparse.kh

   1 /*
   2  *  Copyright 2001-2007 Adrian Thurston <thurston@cs.queensu.ca>
   3  */
   4
   5 /*  This file is part of Ragel.
   6  *
   7  *  Ragel is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  Ragel is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with Ragel; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21 #ifndef _XMLPARSE_H
  22 #define _XMLPARSE_H
  23
  24 #include "vector.h"
  25 #include "gendata.h"
  26 #include <iostream>
  27
  28 using std::ostream;
  29
  30 struct AttrMarker
  31 {
  32         char *id;
  33         int idLen;
  34         char *value;
  35         int valueLen;
  36 };
  37
  38 struct Attribute
  39 {
  40         char *id;
  41         char *value;
  42 };
  43
  44 typedef Vector<AttrMarker> AttrMkList;
  45 typedef Vector<Attribute> AttrList;
  46 struct XMLTagHashPair;
  47
  48 struct XMLTag
  49 {
  50         enum TagType { Open, Close };
  51
  52         XMLTag( XMLTagHashPair *tagId, TagType type ) :
  53                 tagId(tagId), type(type),
  54                 content(0), attrList(0) {}
  55
  56         Attribute *findAttr( const char *id )
  57         {
  58                 if ( attrList != 0 ) {
  59                         for ( AttrList::Iter attr = *attrList; attr.lte(); attr++ ) {
  60                                 if ( strcmp( id, attr->id ) == 0 )
  61                                         return attr;
  62                         }
  63                 }
  64                 return 0;
  65         }
  66
  67         XMLTagHashPair *tagId;
  68         TagType type;
  69
  70         /* Content is associtated with closing tags. */
  71         char *content;
  72
  73         /* Attribute lists are associated with opening tags. */
  74         AttrList *attrList;
  75 };
  76
  77
  78 struct XMLTagHashPair
  79 {
  80     const char *name;
  81     int id;
  82 };
  83
  84 struct Token
  85 {
  86         XMLTag *tag;
  87         InputLoc loc;
  88 };
  89
  90 struct InlineItem;
  91 struct InlineList;
  92
  93 struct LmSwitchVect;
  94 struct LmSwitchAction;
  95
  96 struct Parser
  97 {
  98         %%{
  99                 parser Parser;
 100
 101                 token TAG_unknown, TAG_ragel, TAG_ragel_def, TAG_host, TAG_state_list,
 102                         TAG_state, TAG_trans_list, TAG_t, TAG_machine, TAG_start_state,
 103                         TAG_error_state, TAG_action_list, TAG_action_table_list,
 104                         TAG_action, TAG_action_table, TAG_alphtype, TAG_element,
 105                         TAG_getkey, TAG_state_actions, TAG_entry_points, TAG_sub_action,
 106                         TAG_cond_space_list, TAG_cond_space, TAG_cond_list, TAG_c,
 107                         TAG_exports, TAG_ex;
 108
 109                 # Inline block tokens.
 110                 token TAG_text, TAG_goto, TAG_call, TAG_next, TAG_goto_expr,
 111                         TAG_call_expr, TAG_next_expr, TAG_ret, TAG_pchar, TAG_char,
 112                         TAG_hold, TAG_exec, TAG_curs, TAG_targs, TAG_entry, TAG_data,
 113                         TAG_lm_switch, TAG_init_act, TAG_set_act, TAG_set_tokend,
 114                         TAG_get_tokend, TAG_init_tokstart, TAG_set_tokstart;
 115
 116                 token TAG_write, TAG_access, TAG_break, TAG_arg, TAG_cs_expr;
 117
 118                 token TAG_p_expr, TAG_pe_expr, TAG_eof_expr, TAG_cs_expr, TAG_top_expr,
 119                         TAG_stack_expr, TAG_act_expr, TAG_tokstart_expr, TAG_tokend_expr,
 120                         TAG_data_expr, TAG_prepush, TAG_postpop, TAG_eof_t;
 121         }%%
 122
 123         %% write instance_data;
 124
 125         void init();
 126         int parseLangEl( int type, const Token *token );
 127
 128         Parser( char *fileName, bool outputActive, bool wantComplete ) :
 129                 fileName(fileName), sourceFileName(0), outStream(0),
 130                 outputActive(outputActive), wantComplete(wantComplete),
 131                 cgd(0) { }
 132
 133         int token( int tokenId, Token &token );
 134         int token( int tokenId, int col, int line );
 135         int token( XMLTag *tag, int col, int line );
 136
 137         /* Report an error encountered by the parser. */
 138         ostream &warning( const InputLoc &loc );
 139         ostream &error();
 140         ostream &error( const InputLoc &loc );
 141         ostream &parser_error( int tokId, Token &token );
 142         ostream &source_error( const InputLoc &loc );
 143
 144         /* The name of the root section, this does not change during an include. */
 145         char *fileName;
 146         char *sourceFileName;
 147         ostream *outStream;
 148         bool outputActive;
 149         bool wantComplete;
 150
 151         /* Collected during parsing. */
 152         char *attrKey;
 153         char *attrValue;
 154         int curAction;
 155         int curActionTable;
 156         int curTrans;
 157         int curState;
 158         int curCondSpace;
 159         int curStateCond;
 160
 161         CodeGenData *cgd;
 162         CodeGenMap codeGenMap;
 163
 164         Vector <char*> writeOptions;
 165 };
 166
 167 %% write token_defs;
 168
 169 int xml_parse( std::istream &input, char *fileName,
 170                 bool outputActive, bool wantComplete );
 171
 172 #endif /* _XMLPARSE_H */