Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
xmlrole.cc File Reference
#include <stddef.h>
#include "expat_external.h"
#include "internal.h"
#include "xmlrole.h"
#include "ascii.h"
Include dependency graph for xmlrole.cc:

Go to the source code of this file.

Macros

#define MIN_BYTES_PER_CHAR(enc)   ((enc)->minBytesPerChar)
 
#define setTopLevel(state)   ((state)->handler = internalSubset)
 

Typedefs

typedef int PTRCALL PROLOG_HANDLER (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 

Functions

static int FASTCALL common (PROLOG_STATE *state, int tok)
 
static int PTRCALL prolog0 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL prolog1 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL prolog2 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL doctype0 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL doctype1 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL doctype2 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL doctype3 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL doctype4 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL doctype5 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL internalSubset (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity0 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity1 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity2 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity3 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity4 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity5 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity6 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity7 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity8 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity9 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL entity10 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL notation0 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL notation1 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL notation2 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL notation3 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL notation4 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist0 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist1 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist2 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist3 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist4 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist5 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist6 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist7 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist8 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL attlist9 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element0 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element1 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element2 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element3 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element4 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element5 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element6 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL element7 (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL declClose (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
static int PTRCALL error (PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)
 
void XmlPrologStateInit (PROLOG_STATE *state)
 

Variables

static const char KW_ANY []
 
static const char KW_ATTLIST []
 
static const char KW_CDATA []
 
static const char KW_DOCTYPE []
 
static const char KW_ELEMENT []
 
static const char KW_EMPTY []
 
static const char KW_ENTITIES []
 
static const char KW_ENTITY []
 
static const char KW_FIXED []
 
static const char KW_ID []
 
static const char KW_IDREF []
 
static const char KW_IDREFS []
 
static const char KW_IMPLIED []
 
static const char KW_NDATA []
 
static const char KW_NMTOKEN []
 
static const char KW_NMTOKENS []
 
static const char KW_NOTATION []
 
static const char KW_PCDATA []
 
static const char KW_PUBLIC []
 
static const char KW_REQUIRED []
 
static const char KW_SYSTEM []
 
static PROLOG_HANDLER prolog0
 
static PROLOG_HANDLER prolog1
 
static PROLOG_HANDLER prolog2
 
static PROLOG_HANDLER doctype0
 
static PROLOG_HANDLER doctype1
 
static PROLOG_HANDLER doctype2
 
static PROLOG_HANDLER doctype3
 
static PROLOG_HANDLER doctype4
 
static PROLOG_HANDLER doctype5
 
static PROLOG_HANDLER internalSubset
 
static PROLOG_HANDLER entity0
 
static PROLOG_HANDLER entity1
 
static PROLOG_HANDLER entity2
 
static PROLOG_HANDLER entity3
 
static PROLOG_HANDLER entity4
 
static PROLOG_HANDLER entity5
 
static PROLOG_HANDLER entity6
 
static PROLOG_HANDLER entity7
 
static PROLOG_HANDLER entity8
 
static PROLOG_HANDLER entity9
 
static PROLOG_HANDLER entity10
 
static PROLOG_HANDLER notation0
 
static PROLOG_HANDLER notation1
 
static PROLOG_HANDLER notation2
 
static PROLOG_HANDLER notation3
 
static PROLOG_HANDLER notation4
 
static PROLOG_HANDLER attlist0
 
static PROLOG_HANDLER attlist1
 
static PROLOG_HANDLER attlist2
 
static PROLOG_HANDLER attlist3
 
static PROLOG_HANDLER attlist4
 
static PROLOG_HANDLER attlist5
 
static PROLOG_HANDLER attlist6
 
static PROLOG_HANDLER attlist7
 
static PROLOG_HANDLER attlist8
 
static PROLOG_HANDLER attlist9
 
static PROLOG_HANDLER element0
 
static PROLOG_HANDLER element1
 
static PROLOG_HANDLER element2
 
static PROLOG_HANDLER element3
 
static PROLOG_HANDLER element4
 
static PROLOG_HANDLER element5
 
static PROLOG_HANDLER element6
 
static PROLOG_HANDLER element7
 
static PROLOG_HANDLER declClose
 
static PROLOG_HANDLER error
 

Macro Definition Documentation

#define MIN_BYTES_PER_CHAR (   enc)    ((enc)->minBytesPerChar)

Definition at line 93 of file xmlrole.cc.

#define setTopLevel (   state)    ((state)->handler = internalSubset)

Definition at line 102 of file xmlrole.cc.

Typedef Documentation

typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state, int tok, const char *ptr, const char *end, const ENCODING *enc)

Definition at line 105 of file xmlrole.cc.

Function Documentation

static int PTRCALL attlist0 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 758 of file xmlrole.cc.

763 {
764  switch (tok) {
765  case XML_TOK_PROLOG_S:
766  return XML_ROLE_ATTLIST_NONE;
767  case XML_TOK_NAME:
769  state->handler = attlist1;
771  }
772  return common(state, tok);
773 }
static PROLOG_HANDLER attlist1
Definition: xmlrole.cc:112
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48

Here is the call graph for this function:

static int PTRCALL attlist1 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 776 of file xmlrole.cc.

781 {
782  switch (tok) {
783  case XML_TOK_PROLOG_S:
784  return XML_ROLE_ATTLIST_NONE;
785  case XML_TOK_DECL_CLOSE:
786  setTopLevel(state);
787  return XML_ROLE_ATTLIST_NONE;
788  case XML_TOK_NAME:
790  state->handler = attlist2;
792  }
793  return common(state, tok);
794 }
#define setTopLevel(state)
Definition: xmlrole.cc:102
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
static PROLOG_HANDLER attlist2
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL attlist2 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 797 of file xmlrole.cc.

802 {
803  switch (tok) {
804  case XML_TOK_PROLOG_S:
805  return XML_ROLE_ATTLIST_NONE;
806  case XML_TOK_NAME:
807  {
808  static const char * const types[] = {
809  KW_CDATA,
810  KW_ID,
811  KW_IDREF,
812  KW_IDREFS,
813  KW_ENTITY,
814  KW_ENTITIES,
815  KW_NMTOKEN,
816  KW_NMTOKENS,
817  };
818  int i;
819  for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
820  if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
821  state->handler = attlist8;
823  }
824  }
825  if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
826  state->handler = attlist5;
827  return XML_ROLE_ATTLIST_NONE;
828  }
829  break;
830  case XML_TOK_OPEN_PAREN:
831  state->handler = attlist3;
832  return XML_ROLE_ATTLIST_NONE;
833  }
834  return common(state, tok);
835 }
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
static const char KW_ENTITY[]
Definition: xmlrole.cc:52
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
static const char KW_ID[]
Definition: xmlrole.cc:56
static PROLOG_HANDLER attlist5
Definition: xmlrole.cc:112
#define XML_TOK_NAME
Definition: xmltok.h:51
static const char KW_IDREF[]
Definition: xmlrole.cc:58
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER attlist3
Definition: xmlrole.cc:112
static const char KW_NMTOKENS[]
Definition: xmlrole.cc:76
typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData)
static const char KW_CDATA[]
Definition: xmlrole.cc:41
static const char KW_ENTITIES[]
Definition: xmlrole.cc:49
static const char KW_NOTATION[]
Definition: xmlrole.cc:79
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static const char KW_IDREFS[]
Definition: xmlrole.cc:60
static PROLOG_HANDLER attlist8
Definition: xmlrole.cc:112
static const char KW_NMTOKEN[]
Definition: xmlrole.cc:74

Here is the call graph for this function:

static int PTRCALL attlist3 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 838 of file xmlrole.cc.

843 {
844  switch (tok) {
845  case XML_TOK_PROLOG_S:
846  return XML_ROLE_ATTLIST_NONE;
847  case XML_TOK_NMTOKEN:
848  case XML_TOK_NAME:
850  state->handler = attlist4;
852  }
853  return common(state, tok);
854 }
#define XML_TOK_NMTOKEN
Definition: xmltok.h:52
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER attlist4
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL attlist4 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 857 of file xmlrole.cc.

862 {
863  switch (tok) {
864  case XML_TOK_PROLOG_S:
865  return XML_ROLE_ATTLIST_NONE;
866  case XML_TOK_CLOSE_PAREN:
867  state->handler = attlist8;
868  return XML_ROLE_ATTLIST_NONE;
869  case XML_TOK_OR:
870  state->handler = attlist3;
871  return XML_ROLE_ATTLIST_NONE;
872  }
873  return common(state, tok);
874 }
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER attlist3
Definition: xmlrole.cc:112
#define XML_TOK_OR
Definition: xmltok.h:54
static PROLOG_HANDLER attlist8
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL attlist5 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 877 of file xmlrole.cc.

882 {
883  switch (tok) {
884  case XML_TOK_PROLOG_S:
885  return XML_ROLE_ATTLIST_NONE;
886  case XML_TOK_OPEN_PAREN:
887  state->handler = attlist6;
888  return XML_ROLE_ATTLIST_NONE;
889  }
890  return common(state, tok);
891 }
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
static PROLOG_HANDLER attlist6
Definition: xmlrole.cc:112
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48

Here is the call graph for this function:

static int PTRCALL attlist6 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 894 of file xmlrole.cc.

899 {
900  switch (tok) {
901  case XML_TOK_PROLOG_S:
902  return XML_ROLE_ATTLIST_NONE;
903  case XML_TOK_NAME:
904  state->handler = attlist7;
906  }
907  return common(state, tok);
908 }
static PROLOG_HANDLER attlist7
Definition: xmlrole.cc:112
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48

Here is the call graph for this function:

static int PTRCALL attlist7 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 911 of file xmlrole.cc.

916 {
917  switch (tok) {
918  case XML_TOK_PROLOG_S:
919  return XML_ROLE_ATTLIST_NONE;
920  case XML_TOK_CLOSE_PAREN:
921  state->handler = attlist8;
922  return XML_ROLE_ATTLIST_NONE;
923  case XML_TOK_OR:
924  state->handler = attlist6;
925  return XML_ROLE_ATTLIST_NONE;
926  }
927  return common(state, tok);
928 }
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
static PROLOG_HANDLER attlist6
Definition: xmlrole.cc:112
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_OR
Definition: xmltok.h:54
static PROLOG_HANDLER attlist8
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL attlist8 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 932 of file xmlrole.cc.

937 {
938  switch (tok) {
939  case XML_TOK_PROLOG_S:
940  return XML_ROLE_ATTLIST_NONE;
941  case XML_TOK_POUND_NAME:
942  if (XmlNameMatchesAscii(enc,
943  ptr + MIN_BYTES_PER_CHAR(enc),
944  end,
945  KW_IMPLIED)) {
946  state->handler = attlist1;
948  }
949  if (XmlNameMatchesAscii(enc,
950  ptr + MIN_BYTES_PER_CHAR(enc),
951  end,
952  KW_REQUIRED)) {
953  state->handler = attlist1;
955  }
956  if (XmlNameMatchesAscii(enc,
957  ptr + MIN_BYTES_PER_CHAR(enc),
958  end,
959  KW_FIXED)) {
960  state->handler = attlist9;
961  return XML_ROLE_ATTLIST_NONE;
962  }
963  break;
964  case XML_TOK_LITERAL:
965  state->handler = attlist1;
967  }
968  return common(state, tok);
969 }
static const char KW_FIXED[]
Definition: xmlrole.cc:54
static PROLOG_HANDLER attlist1
Definition: xmlrole.cc:112
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
static PROLOG_HANDLER attlist9
Definition: xmlrole.cc:112
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
#define XML_TOK_POUND_NAME
Definition: xmltok.h:53
static const char KW_IMPLIED[]
Definition: xmlrole.cc:66
#define XML_TOK_LITERAL
Definition: xmltok.h:60
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static const char KW_REQUIRED[]
Definition: xmlrole.cc:86

Here is the call graph for this function:

static int PTRCALL attlist9 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 972 of file xmlrole.cc.

977 {
978  switch (tok) {
979  case XML_TOK_PROLOG_S:
980  return XML_ROLE_ATTLIST_NONE;
981  case XML_TOK_LITERAL:
982  state->handler = attlist1;
984  }
985  return common(state, tok);
986 }
static PROLOG_HANDLER attlist1
Definition: xmlrole.cc:112
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_LITERAL
Definition: xmltok.h:60

Here is the call graph for this function:

static int FASTCALL common ( PROLOG_STATE state,
int  tok 
)
static

Definition at line 1309 of file xmlrole.cc.

1310 {
1311 #ifdef XML_DTD
1312  if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
1313  return XML_ROLE_INNER_PARAM_ENTITY_REF;
1314 #endif
1315  state->handler = error;
1316  return XML_ROLE_ERROR;
1317 }
#define XML_TOK_PARAM_ENTITY_REF
Definition: xmltok.h:61
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
static int PTRCALL declClose ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1282 of file xmlrole.cc.

1287 {
1288  switch (tok) {
1289  case XML_TOK_PROLOG_S:
1290  return state->role_none;
1291  case XML_TOK_DECL_CLOSE:
1292  setTopLevel(state);
1293  return state->role_none;
1294  }
1295  return common(state, tok);
1296 }
#define setTopLevel(state)
Definition: xmlrole.cc:102
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
int role_none
Definition: xmlrole.h:94

Here is the call graph for this function:

static int PTRCALL doctype0 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 221 of file xmlrole.cc.

226 {
227  switch (tok) {
228  case XML_TOK_PROLOG_S:
229  return XML_ROLE_DOCTYPE_NONE;
230  case XML_TOK_NAME:
232  state->handler = doctype1;
233  return XML_ROLE_DOCTYPE_NAME;
234  }
235  return common(state, tok);
236 }
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER doctype1
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL doctype1 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 239 of file xmlrole.cc.

244 {
245  switch (tok) {
246  case XML_TOK_PROLOG_S:
247  return XML_ROLE_DOCTYPE_NONE;
249  state->handler = internalSubset;
251  case XML_TOK_DECL_CLOSE:
252  state->handler = prolog2;
253  return XML_ROLE_DOCTYPE_CLOSE;
254  case XML_TOK_NAME:
255  if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
256  state->handler = doctype3;
257  return XML_ROLE_DOCTYPE_NONE;
258  }
259  if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
260  state->handler = doctype2;
261  return XML_ROLE_DOCTYPE_NONE;
262  }
263  break;
264  }
265  return common(state, tok);
266 }
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
static PROLOG_HANDLER internalSubset
Definition: xmlrole.cc:112
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
static PROLOG_HANDLER prolog2
Definition: xmlrole.cc:112
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static PROLOG_HANDLER doctype2
Definition: xmlrole.cc:112
#define XML_TOK_OPEN_BRACKET
Definition: xmltok.h:58
static PROLOG_HANDLER doctype3
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL doctype2 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 269 of file xmlrole.cc.

274 {
275  switch (tok) {
276  case XML_TOK_PROLOG_S:
277  return XML_ROLE_DOCTYPE_NONE;
278  case XML_TOK_LITERAL:
279  state->handler = doctype3;
281  }
282  return common(state, tok);
283 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_LITERAL
Definition: xmltok.h:60
static PROLOG_HANDLER doctype3
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL doctype3 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 286 of file xmlrole.cc.

291 {
292  switch (tok) {
293  case XML_TOK_PROLOG_S:
294  return XML_ROLE_DOCTYPE_NONE;
295  case XML_TOK_LITERAL:
296  state->handler = doctype4;
298  }
299  return common(state, tok);
300 }
static PROLOG_HANDLER doctype4
Definition: xmlrole.cc:112
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_LITERAL
Definition: xmltok.h:60

Here is the call graph for this function:

static int PTRCALL doctype4 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 303 of file xmlrole.cc.

308 {
309  switch (tok) {
310  case XML_TOK_PROLOG_S:
311  return XML_ROLE_DOCTYPE_NONE;
313  state->handler = internalSubset;
315  case XML_TOK_DECL_CLOSE:
316  state->handler = prolog2;
317  return XML_ROLE_DOCTYPE_CLOSE;
318  }
319  return common(state, tok);
320 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
static PROLOG_HANDLER internalSubset
Definition: xmlrole.cc:112
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
static PROLOG_HANDLER prolog2
Definition: xmlrole.cc:112
#define XML_TOK_OPEN_BRACKET
Definition: xmltok.h:58

Here is the call graph for this function:

static int PTRCALL doctype5 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 323 of file xmlrole.cc.

328 {
329  switch (tok) {
330  case XML_TOK_PROLOG_S:
331  return XML_ROLE_DOCTYPE_NONE;
332  case XML_TOK_DECL_CLOSE:
333  state->handler = prolog2;
334  return XML_ROLE_DOCTYPE_CLOSE;
335  }
336  return common(state, tok);
337 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
static PROLOG_HANDLER prolog2
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element0 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 989 of file xmlrole.cc.

994 {
995  switch (tok) {
996  case XML_TOK_PROLOG_S:
997  return XML_ROLE_ELEMENT_NONE;
998  case XML_TOK_NAME:
1000  state->handler = element1;
1001  return XML_ROLE_ELEMENT_NAME;
1002  }
1003  return common(state, tok);
1004 }
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER element1
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element1 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1007 of file xmlrole.cc.

1012 {
1013  switch (tok) {
1014  case XML_TOK_PROLOG_S:
1015  return XML_ROLE_ELEMENT_NONE;
1016  case XML_TOK_NAME:
1017  if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
1018  state->handler = declClose;
1020  return XML_ROLE_CONTENT_EMPTY;
1021  }
1022  if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
1023  state->handler = declClose;
1025  return XML_ROLE_CONTENT_ANY;
1026  }
1027  break;
1028  case XML_TOK_OPEN_PAREN:
1029  state->handler = element2;
1030  state->level = 1;
1031  return XML_ROLE_GROUP_OPEN;
1032  }
1033  return common(state, tok);
1034 }
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
unsigned level
Definition: xmlrole.h:93
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
int role_none
Definition: xmlrole.h:94
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static const char KW_ANY[]
Definition: xmlrole.cc:37
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112
static const char KW_EMPTY[]
Definition: xmlrole.cc:47
static PROLOG_HANDLER element2
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element2 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1037 of file xmlrole.cc.

1042 {
1043  switch (tok) {
1044  case XML_TOK_PROLOG_S:
1045  return XML_ROLE_ELEMENT_NONE;
1046  case XML_TOK_POUND_NAME:
1047  if (XmlNameMatchesAscii(enc,
1048  ptr + MIN_BYTES_PER_CHAR(enc),
1049  end,
1050  KW_PCDATA)) {
1051  state->handler = element3;
1052  return XML_ROLE_CONTENT_PCDATA;
1053  }
1054  break;
1055  case XML_TOK_OPEN_PAREN:
1056  state->level = 2;
1057  state->handler = element6;
1058  return XML_ROLE_GROUP_OPEN;
1059  case XML_TOK_NAME:
1060  case XML_TOK_PREFIXED_NAME:
1061  state->handler = element7;
1062  return XML_ROLE_CONTENT_ELEMENT;
1063  case XML_TOK_NAME_QUESTION:
1064  state->handler = element7;
1066  case XML_TOK_NAME_ASTERISK:
1067  state->handler = element7;
1069  case XML_TOK_NAME_PLUS:
1070  state->handler = element7;
1072  }
1073  return common(state, tok);
1074 }
#define XML_TOK_NAME_ASTERISK
Definition: xmltok.h:66
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
unsigned level
Definition: xmlrole.h:93
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
#define XML_TOK_POUND_NAME
Definition: xmltok.h:53
static const char KW_PCDATA[]
Definition: xmlrole.cc:82
#define XML_TOK_NAME_QUESTION
Definition: xmltok.h:65
static PROLOG_HANDLER element6
Definition: xmlrole.cc:112
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
#define XML_TOK_NAME_PLUS
Definition: xmltok.h:67
static PROLOG_HANDLER element7
Definition: xmlrole.cc:112
static PROLOG_HANDLER element3
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element3 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1077 of file xmlrole.cc.

1082 {
1083  switch (tok) {
1084  case XML_TOK_PROLOG_S:
1085  return XML_ROLE_ELEMENT_NONE;
1086  case XML_TOK_CLOSE_PAREN:
1087  state->handler = declClose;
1089  return XML_ROLE_GROUP_CLOSE;
1091  state->handler = declClose;
1093  return XML_ROLE_GROUP_CLOSE_REP;
1094  case XML_TOK_OR:
1095  state->handler = element4;
1096  return XML_ROLE_ELEMENT_NONE;
1097  }
1098  return common(state, tok);
1099 }
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_CLOSE_PAREN_ASTERISK
Definition: xmltok.h:71
int role_none
Definition: xmlrole.h:94
#define XML_TOK_OR
Definition: xmltok.h:54
static PROLOG_HANDLER element4
Definition: xmlrole.cc:112
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element4 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1102 of file xmlrole.cc.

1107 {
1108  switch (tok) {
1109  case XML_TOK_PROLOG_S:
1110  return XML_ROLE_ELEMENT_NONE;
1111  case XML_TOK_NAME:
1112  case XML_TOK_PREFIXED_NAME:
1113  state->handler = element5;
1114  return XML_ROLE_CONTENT_ELEMENT;
1115  }
1116  return common(state, tok);
1117 }
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER element5
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element5 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1120 of file xmlrole.cc.

1125 {
1126  switch (tok) {
1127  case XML_TOK_PROLOG_S:
1128  return XML_ROLE_ELEMENT_NONE;
1130  state->handler = declClose;
1132  return XML_ROLE_GROUP_CLOSE_REP;
1133  case XML_TOK_OR:
1134  state->handler = element4;
1135  return XML_ROLE_ELEMENT_NONE;
1136  }
1137  return common(state, tok);
1138 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_CLOSE_PAREN_ASTERISK
Definition: xmltok.h:71
int role_none
Definition: xmlrole.h:94
#define XML_TOK_OR
Definition: xmltok.h:54
static PROLOG_HANDLER element4
Definition: xmlrole.cc:112
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element6 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1141 of file xmlrole.cc.

1146 {
1147  switch (tok) {
1148  case XML_TOK_PROLOG_S:
1149  return XML_ROLE_ELEMENT_NONE;
1150  case XML_TOK_OPEN_PAREN:
1151  state->level += 1;
1152  return XML_ROLE_GROUP_OPEN;
1153  case XML_TOK_NAME:
1154  case XML_TOK_PREFIXED_NAME:
1155  state->handler = element7;
1156  return XML_ROLE_CONTENT_ELEMENT;
1157  case XML_TOK_NAME_QUESTION:
1158  state->handler = element7;
1160  case XML_TOK_NAME_ASTERISK:
1161  state->handler = element7;
1163  case XML_TOK_NAME_PLUS:
1164  state->handler = element7;
1166  }
1167  return common(state, tok);
1168 }
#define XML_TOK_NAME_ASTERISK
Definition: xmltok.h:66
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
unsigned level
Definition: xmlrole.h:93
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_NAME_QUESTION
Definition: xmltok.h:65
#define XML_TOK_NAME_PLUS
Definition: xmltok.h:67
static PROLOG_HANDLER element7
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL element7 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1171 of file xmlrole.cc.

1176 {
1177  switch (tok) {
1178  case XML_TOK_PROLOG_S:
1179  return XML_ROLE_ELEMENT_NONE;
1180  case XML_TOK_CLOSE_PAREN:
1181  state->level -= 1;
1182  if (state->level == 0) {
1183  state->handler = declClose;
1185  }
1186  return XML_ROLE_GROUP_CLOSE;
1188  state->level -= 1;
1189  if (state->level == 0) {
1190  state->handler = declClose;
1192  }
1193  return XML_ROLE_GROUP_CLOSE_REP;
1195  state->level -= 1;
1196  if (state->level == 0) {
1197  state->handler = declClose;
1199  }
1200  return XML_ROLE_GROUP_CLOSE_OPT;
1202  state->level -= 1;
1203  if (state->level == 0) {
1204  state->handler = declClose;
1206  }
1208  case XML_TOK_COMMA:
1209  state->handler = element6;
1210  return XML_ROLE_GROUP_SEQUENCE;
1211  case XML_TOK_OR:
1212  state->handler = element6;
1213  return XML_ROLE_GROUP_CHOICE;
1214  }
1215  return common(state, tok);
1216 }
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
unsigned level
Definition: xmlrole.h:93
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_CLOSE_PAREN_ASTERISK
Definition: xmltok.h:71
int role_none
Definition: xmlrole.h:94
#define XML_TOK_OR
Definition: xmltok.h:54
#define XML_TOK_CLOSE_PAREN_PLUS
Definition: xmltok.h:72
static PROLOG_HANDLER element6
Definition: xmlrole.cc:112
#define XML_TOK_CLOSE_PAREN_QUESTION
Definition: xmltok.h:70
#define XML_TOK_COMMA
Definition: xmltok.h:73
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL entity0 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 442 of file xmlrole.cc.

447 {
448  switch (tok) {
449  case XML_TOK_PROLOG_S:
450  return XML_ROLE_ENTITY_NONE;
451  case XML_TOK_PERCENT:
452  state->handler = entity1;
453  return XML_ROLE_ENTITY_NONE;
454  case XML_TOK_NAME:
455  state->handler = entity2;
457  }
458  return common(state, tok);
459 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PERCENT
Definition: xmltok.h:55
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER entity2
Definition: xmlrole.cc:112
static PROLOG_HANDLER entity1
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL entity1 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 462 of file xmlrole.cc.

467 {
468  switch (tok) {
469  case XML_TOK_PROLOG_S:
470  return XML_ROLE_ENTITY_NONE;
471  case XML_TOK_NAME:
472  state->handler = entity7;
474  }
475  return common(state, tok);
476 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER entity7
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL entity10 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 644 of file xmlrole.cc.

649 {
650  switch (tok) {
651  case XML_TOK_PROLOG_S:
652  return XML_ROLE_ENTITY_NONE;
653  case XML_TOK_DECL_CLOSE:
654  setTopLevel(state);
656  }
657  return common(state, tok);
658 }
#define setTopLevel(state)
Definition: xmlrole.cc:102
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50

Here is the call graph for this function:

static int PTRCALL entity2 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 479 of file xmlrole.cc.

484 {
485  switch (tok) {
486  case XML_TOK_PROLOG_S:
487  return XML_ROLE_ENTITY_NONE;
488  case XML_TOK_NAME:
489  if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
490  state->handler = entity4;
491  return XML_ROLE_ENTITY_NONE;
492  }
493  if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
494  state->handler = entity3;
495  return XML_ROLE_ENTITY_NONE;
496  }
497  break;
498  case XML_TOK_LITERAL:
499  state->handler = declClose;
501  return XML_ROLE_ENTITY_VALUE;
502  }
503  return common(state, tok);
504 }
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
static PROLOG_HANDLER entity3
Definition: xmlrole.cc:112
static PROLOG_HANDLER entity4
Definition: xmlrole.cc:112
int role_none
Definition: xmlrole.h:94
#define XML_TOK_LITERAL
Definition: xmltok.h:60
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL entity3 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 507 of file xmlrole.cc.

512 {
513  switch (tok) {
514  case XML_TOK_PROLOG_S:
515  return XML_ROLE_ENTITY_NONE;
516  case XML_TOK_LITERAL:
517  state->handler = entity4;
519  }
520  return common(state, tok);
521 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER entity4
Definition: xmlrole.cc:112
#define XML_TOK_LITERAL
Definition: xmltok.h:60

Here is the call graph for this function:

static int PTRCALL entity4 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 524 of file xmlrole.cc.

529 {
530  switch (tok) {
531  case XML_TOK_PROLOG_S:
532  return XML_ROLE_ENTITY_NONE;
533  case XML_TOK_LITERAL:
534  state->handler = entity5;
536  }
537  return common(state, tok);
538 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER entity5
Definition: xmlrole.cc:112
#define XML_TOK_LITERAL
Definition: xmltok.h:60

Here is the call graph for this function:

static int PTRCALL entity5 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 541 of file xmlrole.cc.

546 {
547  switch (tok) {
548  case XML_TOK_PROLOG_S:
549  return XML_ROLE_ENTITY_NONE;
550  case XML_TOK_DECL_CLOSE:
551  setTopLevel(state);
553  case XML_TOK_NAME:
554  if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
555  state->handler = entity6;
556  return XML_ROLE_ENTITY_NONE;
557  }
558  break;
559  }
560  return common(state, tok);
561 }
#define setTopLevel(state)
Definition: xmlrole.cc:102
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER entity6
Definition: xmlrole.cc:112
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static const char KW_NDATA[]
Definition: xmlrole.cc:72

Here is the call graph for this function:

static int PTRCALL entity6 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 564 of file xmlrole.cc.

569 {
570  switch (tok) {
571  case XML_TOK_PROLOG_S:
572  return XML_ROLE_ENTITY_NONE;
573  case XML_TOK_NAME:
574  state->handler = declClose;
577  }
578  return common(state, tok);
579 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
int role_none
Definition: xmlrole.h:94
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL entity7 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 582 of file xmlrole.cc.

587 {
588  switch (tok) {
589  case XML_TOK_PROLOG_S:
590  return XML_ROLE_ENTITY_NONE;
591  case XML_TOK_NAME:
592  if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
593  state->handler = entity9;
594  return XML_ROLE_ENTITY_NONE;
595  }
596  if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
597  state->handler = entity8;
598  return XML_ROLE_ENTITY_NONE;
599  }
600  break;
601  case XML_TOK_LITERAL:
602  state->handler = declClose;
604  return XML_ROLE_ENTITY_VALUE;
605  }
606  return common(state, tok);
607 }
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
int role_none
Definition: xmlrole.h:94
#define XML_TOK_LITERAL
Definition: xmltok.h:60
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static PROLOG_HANDLER entity8
Definition: xmlrole.cc:112
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112
static PROLOG_HANDLER entity9
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL entity8 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 610 of file xmlrole.cc.

615 {
616  switch (tok) {
617  case XML_TOK_PROLOG_S:
618  return XML_ROLE_ENTITY_NONE;
619  case XML_TOK_LITERAL:
620  state->handler = entity9;
622  }
623  return common(state, tok);
624 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_LITERAL
Definition: xmltok.h:60
static PROLOG_HANDLER entity9
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL entity9 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 627 of file xmlrole.cc.

632 {
633  switch (tok) {
634  case XML_TOK_PROLOG_S:
635  return XML_ROLE_ENTITY_NONE;
636  case XML_TOK_LITERAL:
637  state->handler = entity10;
639  }
640  return common(state, tok);
641 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_LITERAL
Definition: xmltok.h:60
static PROLOG_HANDLER entity10
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL error ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 1299 of file xmlrole.cc.

1304 {
1305  return XML_ROLE_NONE;
1306 }
static int PTRCALL internalSubset ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 340 of file xmlrole.cc.

345 {
346  switch (tok) {
347  case XML_TOK_PROLOG_S:
348  return XML_ROLE_NONE;
349  case XML_TOK_DECL_OPEN:
350  if (XmlNameMatchesAscii(enc,
351  ptr + 2 * MIN_BYTES_PER_CHAR(enc),
352  end,
353  KW_ENTITY)) {
354  state->handler = entity0;
355  return XML_ROLE_ENTITY_NONE;
356  }
357  if (XmlNameMatchesAscii(enc,
358  ptr + 2 * MIN_BYTES_PER_CHAR(enc),
359  end,
360  KW_ATTLIST)) {
361  state->handler = attlist0;
362  return XML_ROLE_ATTLIST_NONE;
363  }
364  if (XmlNameMatchesAscii(enc,
365  ptr + 2 * MIN_BYTES_PER_CHAR(enc),
366  end,
367  KW_ELEMENT)) {
368  state->handler = element0;
369  return XML_ROLE_ELEMENT_NONE;
370  }
371  if (XmlNameMatchesAscii(enc,
372  ptr + 2 * MIN_BYTES_PER_CHAR(enc),
373  end,
374  KW_NOTATION)) {
375  state->handler = notation0;
376  return XML_ROLE_NOTATION_NONE;
377  }
378  break;
379  case XML_TOK_PI:
380  return XML_ROLE_PI;
381  case XML_TOK_COMMENT:
382  return XML_ROLE_COMMENT;
386  state->handler = doctype5;
387  return XML_ROLE_DOCTYPE_NONE;
388  case XML_TOK_NONE:
389  return XML_ROLE_NONE;
390  }
391  return common(state, tok);
392 }
static const char KW_ELEMENT[]
Definition: xmlrole.cc:45
static const char KW_ENTITY[]
Definition: xmlrole.cc:52
static PROLOG_HANDLER attlist0
Definition: xmlrole.cc:112
static PROLOG_HANDLER doctype5
Definition: xmlrole.cc:112
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_COMMENT
Definition: xmltok.h:44
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
static const char KW_ATTLIST[]
Definition: xmlrole.cc:39
#define XML_TOK_PARAM_ENTITY_REF
Definition: xmltok.h:61
static const char KW_NOTATION[]
Definition: xmlrole.cc:79
#define XML_TOK_PI
Definition: xmltok.h:42
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static PROLOG_HANDLER entity0
Definition: xmlrole.cc:112
#define XML_TOK_CLOSE_BRACKET
Definition: xmltok.h:59
static PROLOG_HANDLER notation0
Definition: xmlrole.cc:112
#define XML_TOK_NONE
Definition: xmltok.h:18
#define XML_TOK_DECL_OPEN
Definition: xmltok.h:49
static PROLOG_HANDLER element0
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL notation0 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 661 of file xmlrole.cc.

666 {
667  switch (tok) {
668  case XML_TOK_PROLOG_S:
669  return XML_ROLE_NOTATION_NONE;
670  case XML_TOK_NAME:
671  state->handler = notation1;
672  return XML_ROLE_NOTATION_NAME;
673  }
674  return common(state, tok);
675 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static PROLOG_HANDLER notation1
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL notation1 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 678 of file xmlrole.cc.

683 {
684  switch (tok) {
685  case XML_TOK_PROLOG_S:
686  return XML_ROLE_NOTATION_NONE;
687  case XML_TOK_NAME:
688  if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
689  state->handler = notation3;
690  return XML_ROLE_NOTATION_NONE;
691  }
692  if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
693  state->handler = notation2;
694  return XML_ROLE_NOTATION_NONE;
695  }
696  break;
697  }
698  return common(state, tok);
699 }
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_NAME
Definition: xmltok.h:51
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
static PROLOG_HANDLER notation2
Definition: xmlrole.cc:112
static PROLOG_HANDLER notation3
Definition: xmlrole.cc:112
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231

Here is the call graph for this function:

static int PTRCALL notation2 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 702 of file xmlrole.cc.

707 {
708  switch (tok) {
709  case XML_TOK_PROLOG_S:
710  return XML_ROLE_NOTATION_NONE;
711  case XML_TOK_LITERAL:
712  state->handler = notation4;
714  }
715  return common(state, tok);
716 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_LITERAL
Definition: xmltok.h:60
static PROLOG_HANDLER notation4
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL notation3 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 719 of file xmlrole.cc.

724 {
725  switch (tok) {
726  case XML_TOK_PROLOG_S:
727  return XML_ROLE_NOTATION_NONE;
728  case XML_TOK_LITERAL:
729  state->handler = declClose;
732  }
733  return common(state, tok);
734 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
int role_none
Definition: xmlrole.h:94
#define XML_TOK_LITERAL
Definition: xmltok.h:60
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL notation4 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 737 of file xmlrole.cc.

742 {
743  switch (tok) {
744  case XML_TOK_PROLOG_S:
745  return XML_ROLE_NOTATION_NONE;
746  case XML_TOK_LITERAL:
747  state->handler = declClose;
750  case XML_TOK_DECL_CLOSE:
751  setTopLevel(state);
753  }
754  return common(state, tok);
755 }
#define setTopLevel(state)
Definition: xmlrole.cc:102
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
int role_none
Definition: xmlrole.h:94
#define XML_TOK_LITERAL
Definition: xmltok.h:60
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112

Here is the call graph for this function:

static int PTRCALL prolog0 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 132 of file xmlrole.cc.

137 {
138  switch (tok) {
139  case XML_TOK_PROLOG_S:
140  state->handler = prolog1;
141  return XML_ROLE_NONE;
142  case XML_TOK_XML_DECL:
143  state->handler = prolog1;
144  return XML_ROLE_XML_DECL;
145  case XML_TOK_PI:
146  state->handler = prolog1;
147  return XML_ROLE_PI;
148  case XML_TOK_COMMENT:
149  state->handler = prolog1;
150  return XML_ROLE_COMMENT;
151  case XML_TOK_BOM:
152  return XML_ROLE_NONE;
153  case XML_TOK_DECL_OPEN:
154  if (!XmlNameMatchesAscii(enc,
155  ptr + 2 * MIN_BYTES_PER_CHAR(enc),
156  end,
157  KW_DOCTYPE))
158  break;
159  state->handler = doctype0;
160  return XML_ROLE_DOCTYPE_NONE;
162  state->handler = error;
164  }
165  return common(state, tok);
166 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
static const char KW_DOCTYPE[]
Definition: xmlrole.cc:43
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_COMMENT
Definition: xmltok.h:44
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
static PROLOG_HANDLER doctype0
Definition: xmlrole.cc:112
#define XML_TOK_BOM
Definition: xmltok.h:45
#define XML_TOK_PI
Definition: xmltok.h:42
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static PROLOG_HANDLER prolog1
Definition: xmlrole.cc:112
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
#define XML_TOK_INSTANCE_START
Definition: xmltok.h:62
#define XML_TOK_XML_DECL
Definition: xmltok.h:43
#define XML_TOK_DECL_OPEN
Definition: xmltok.h:49

Here is the call graph for this function:

static int PTRCALL prolog1 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 169 of file xmlrole.cc.

174 {
175  switch (tok) {
176  case XML_TOK_PROLOG_S:
177  return XML_ROLE_NONE;
178  case XML_TOK_PI:
179  return XML_ROLE_PI;
180  case XML_TOK_COMMENT:
181  return XML_ROLE_COMMENT;
182  case XML_TOK_BOM:
183  return XML_ROLE_NONE;
184  case XML_TOK_DECL_OPEN:
185  if (!XmlNameMatchesAscii(enc,
186  ptr + 2 * MIN_BYTES_PER_CHAR(enc),
187  end,
188  KW_DOCTYPE))
189  break;
190  state->handler = doctype0;
191  return XML_ROLE_DOCTYPE_NONE;
193  state->handler = error;
195  }
196  return common(state, tok);
197 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
static const char KW_DOCTYPE[]
Definition: xmlrole.cc:43
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_COMMENT
Definition: xmltok.h:44
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
static PROLOG_HANDLER doctype0
Definition: xmlrole.cc:112
#define XML_TOK_BOM
Definition: xmltok.h:45
#define XML_TOK_PI
Definition: xmltok.h:42
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
#define XML_TOK_INSTANCE_START
Definition: xmltok.h:62
#define XML_TOK_DECL_OPEN
Definition: xmltok.h:49

Here is the call graph for this function:

static int PTRCALL prolog2 ( PROLOG_STATE state,
int  tok,
const char *  ptr,
const char *  end,
const ENCODING enc 
)
static

Definition at line 200 of file xmlrole.cc.

205 {
206  switch (tok) {
207  case XML_TOK_PROLOG_S:
208  return XML_ROLE_NONE;
209  case XML_TOK_PI:
210  return XML_ROLE_PI;
211  case XML_TOK_COMMENT:
212  return XML_ROLE_COMMENT;
214  state->handler = error;
216  }
217  return common(state, tok);
218 }
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
#define XML_TOK_COMMENT
Definition: xmltok.h:44
#define XML_TOK_PI
Definition: xmltok.h:42
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
#define XML_TOK_INSTANCE_START
Definition: xmltok.h:62

Here is the call graph for this function:

void XmlPrologStateInit ( PROLOG_STATE state)

Definition at line 1320 of file xmlrole.cc.

1321 {
1322  state->handler = prolog0;
1323 #ifdef XML_DTD
1324  state->documentEntity = 1;
1325  state->includeLevel = 0;
1326  state->inEntityValue = 0;
1327 #endif /* XML_DTD */
1328 }
static PROLOG_HANDLER prolog0
Definition: xmlrole.cc:112

Here is the caller graph for this function:

Variable Documentation

PROLOG_HANDLER attlist0
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist1
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist2
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist3
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist4
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist5
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist6
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist7
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist8
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER attlist9
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER declClose
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER doctype0
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER doctype1
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER doctype2
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER doctype3
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER doctype4
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER doctype5
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element0
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element1
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element2
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element3
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element4
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element5
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element6
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER element7
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity0
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity1
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity10
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity2
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity3
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity4
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity5
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity6
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity7
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity8
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER entity9
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER error
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER internalSubset
static

Definition at line 112 of file xmlrole.cc.

const char KW_ANY[]
static
Initial value:
= {
#define ASCII_Y
Definition: ascii.h:29
#define ASCII_A
Definition: ascii.h:5
#define ASCII_N
Definition: ascii.h:18

Definition at line 37 of file xmlrole.cc.

const char KW_ATTLIST[]
static
Initial value:
= {
#define ASCII_S
Definition: ascii.h:23
#define ASCII_L
Definition: ascii.h:16
#define ASCII_A
Definition: ascii.h:5
#define ASCII_I
Definition: ascii.h:13
#define ASCII_T
Definition: ascii.h:24

Definition at line 39 of file xmlrole.cc.

const char KW_CDATA[]
static
Initial value:
= {
#define ASCII_C
Definition: ascii.h:7
#define ASCII_A
Definition: ascii.h:5
#define ASCII_D
Definition: ascii.h:8
#define ASCII_T
Definition: ascii.h:24

Definition at line 41 of file xmlrole.cc.

const char KW_DOCTYPE[]
static
Initial value:
= {
#define ASCII_Y
Definition: ascii.h:29
#define ASCII_O
Definition: ascii.h:19
#define ASCII_C
Definition: ascii.h:7
#define ASCII_D
Definition: ascii.h:8
#define ASCII_P
Definition: ascii.h:20
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 43 of file xmlrole.cc.

const char KW_ELEMENT[]
static
Initial value:
= {
#define ASCII_M
Definition: ascii.h:17
#define ASCII_L
Definition: ascii.h:16
#define ASCII_N
Definition: ascii.h:18
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 45 of file xmlrole.cc.

const char KW_EMPTY[]
static
Initial value:
= {
#define ASCII_Y
Definition: ascii.h:29
#define ASCII_M
Definition: ascii.h:17
#define ASCII_P
Definition: ascii.h:20
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 47 of file xmlrole.cc.

const char KW_ENTITIES[]
static
Initial value:
= {
'\0' }
#define ASCII_S
Definition: ascii.h:23
#define ASCII_I
Definition: ascii.h:13
#define ASCII_N
Definition: ascii.h:18
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 49 of file xmlrole.cc.

const char KW_ENTITY[]
static
Initial value:
= {
#define ASCII_Y
Definition: ascii.h:29
#define ASCII_I
Definition: ascii.h:13
#define ASCII_N
Definition: ascii.h:18
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 52 of file xmlrole.cc.

const char KW_FIXED[]
static
Initial value:
= {
#define ASCII_X
Definition: ascii.h:28
#define ASCII_I
Definition: ascii.h:13
#define ASCII_D
Definition: ascii.h:8
#define ASCII_F
Definition: ascii.h:10
#define ASCII_E
Definition: ascii.h:9

Definition at line 54 of file xmlrole.cc.

const char KW_ID[]
static
Initial value:
= {
ASCII_I, ASCII_D, '\0' }
#define ASCII_I
Definition: ascii.h:13
#define ASCII_D
Definition: ascii.h:8

Definition at line 56 of file xmlrole.cc.

const char KW_IDREF[]
static
Initial value:
= {
#define ASCII_R
Definition: ascii.h:22
#define ASCII_I
Definition: ascii.h:13
#define ASCII_D
Definition: ascii.h:8
#define ASCII_F
Definition: ascii.h:10
#define ASCII_E
Definition: ascii.h:9

Definition at line 58 of file xmlrole.cc.

const char KW_IDREFS[]
static
Initial value:
= {
#define ASCII_S
Definition: ascii.h:23
#define ASCII_R
Definition: ascii.h:22
#define ASCII_I
Definition: ascii.h:13
#define ASCII_D
Definition: ascii.h:8
#define ASCII_F
Definition: ascii.h:10
#define ASCII_E
Definition: ascii.h:9

Definition at line 60 of file xmlrole.cc.

const char KW_IMPLIED[]
static
Initial value:
= {
#define ASCII_M
Definition: ascii.h:17
#define ASCII_L
Definition: ascii.h:16
#define ASCII_I
Definition: ascii.h:13
#define ASCII_D
Definition: ascii.h:8
#define ASCII_P
Definition: ascii.h:20
#define ASCII_E
Definition: ascii.h:9

Definition at line 66 of file xmlrole.cc.

const char KW_NDATA[]
static
Initial value:
= {
#define ASCII_A
Definition: ascii.h:5
#define ASCII_N
Definition: ascii.h:18
#define ASCII_D
Definition: ascii.h:8
#define ASCII_T
Definition: ascii.h:24

Definition at line 72 of file xmlrole.cc.

const char KW_NMTOKEN[]
static
Initial value:
= {
#define ASCII_M
Definition: ascii.h:17
#define ASCII_O
Definition: ascii.h:19
#define ASCII_N
Definition: ascii.h:18
#define ASCII_K
Definition: ascii.h:15
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 74 of file xmlrole.cc.

const char KW_NMTOKENS[]
static
Initial value:
= {
'\0' }
#define ASCII_S
Definition: ascii.h:23
#define ASCII_M
Definition: ascii.h:17
#define ASCII_O
Definition: ascii.h:19
#define ASCII_N
Definition: ascii.h:18
#define ASCII_K
Definition: ascii.h:15
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 76 of file xmlrole.cc.

const char KW_NOTATION[]
static
Initial value:
=
'\0' }
#define ASCII_O
Definition: ascii.h:19
#define ASCII_A
Definition: ascii.h:5
#define ASCII_I
Definition: ascii.h:13
#define ASCII_N
Definition: ascii.h:18
#define ASCII_T
Definition: ascii.h:24

Definition at line 79 of file xmlrole.cc.

const char KW_PCDATA[]
static
Initial value:
= {
#define ASCII_C
Definition: ascii.h:7
#define ASCII_A
Definition: ascii.h:5
#define ASCII_D
Definition: ascii.h:8
#define ASCII_P
Definition: ascii.h:20
#define ASCII_T
Definition: ascii.h:24

Definition at line 82 of file xmlrole.cc.

const char KW_PUBLIC[]
static
Initial value:
= {
#define ASCII_U
Definition: ascii.h:25
#define ASCII_B
Definition: ascii.h:6
#define ASCII_C
Definition: ascii.h:7
#define ASCII_L
Definition: ascii.h:16
#define ASCII_I
Definition: ascii.h:13
#define ASCII_P
Definition: ascii.h:20

Definition at line 84 of file xmlrole.cc.

const char KW_REQUIRED[]
static
Initial value:
= {
'\0' }
#define ASCII_U
Definition: ascii.h:25
#define ASCII_R
Definition: ascii.h:22
#define ASCII_I
Definition: ascii.h:13
#define ASCII_D
Definition: ascii.h:8
#define ASCII_Q
Definition: ascii.h:21
#define ASCII_E
Definition: ascii.h:9

Definition at line 86 of file xmlrole.cc.

const char KW_SYSTEM[]
static
Initial value:
= {
#define ASCII_Y
Definition: ascii.h:29
#define ASCII_S
Definition: ascii.h:23
#define ASCII_M
Definition: ascii.h:17
#define ASCII_E
Definition: ascii.h:9
#define ASCII_T
Definition: ascii.h:24

Definition at line 89 of file xmlrole.cc.

PROLOG_HANDLER notation0
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER notation1
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER notation2
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER notation3
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER notation4
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER prolog0
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER prolog1
static

Definition at line 112 of file xmlrole.cc.

PROLOG_HANDLER prolog2
static

Definition at line 112 of file xmlrole.cc.