Geant4  10.03.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Macros | Typedefs | Functions | Variables
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:
768  case XML_TOK_PREFIXED_NAME:
769  state->handler = attlist1;
770  return XML_ROLE_ATTLIST_ELEMENT_NAME;
771  }
772  return common(state, tok);
773 }
attlist1
static PROLOG_HANDLER attlist1
Definition: xmlrole.cc:112
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#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:
789  case XML_TOK_PREFIXED_NAME:
790  state->handler = attlist2;
791  return XML_ROLE_ATTRIBUTE_NAME;
792  }
793  return common(state, tok);
794 }
setTopLevel
#define setTopLevel(state)
Definition: xmlrole.cc:102
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_DECL_CLOSE
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
attlist2
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;
822  return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
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 }
XML_TOK_OPEN_PAREN
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
KW_ENTITY
static const char KW_ENTITY[]
Definition: xmlrole.cc:52
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
KW_ID
static const char KW_ID[]
Definition: xmlrole.cc:56
attlist5
static PROLOG_HANDLER attlist5
Definition: xmlrole.cc:112
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
KW_IDREF
static const char KW_IDREF[]
Definition: xmlrole.cc:58
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
attlist3
static PROLOG_HANDLER attlist3
Definition: xmlrole.cc:112
KW_NMTOKENS
static const char KW_NMTOKENS[]
Definition: xmlrole.cc:76
int
typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData)
KW_CDATA
static const char KW_CDATA[]
Definition: xmlrole.cc:41
KW_ENTITIES
static const char KW_ENTITIES[]
Definition: xmlrole.cc:49
KW_NOTATION
static const char KW_NOTATION[]
Definition: xmlrole.cc:79
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
KW_IDREFS
static const char KW_IDREFS[]
Definition: xmlrole.cc:60
attlist8
static PROLOG_HANDLER attlist8
Definition: xmlrole.cc:112
KW_NMTOKEN
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:
849  case XML_TOK_PREFIXED_NAME:
850  state->handler = attlist4;
851  return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
852  }
853  return common(state, tok);
854 }
XML_TOK_NMTOKEN
#define XML_TOK_NMTOKEN
Definition: xmltok.h:52
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
attlist4
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 }
XML_TOK_CLOSE_PAREN
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
attlist3
static PROLOG_HANDLER attlist3
Definition: xmlrole.cc:112
XML_TOK_OR
#define XML_TOK_OR
Definition: xmltok.h:54
attlist8
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 }
XML_TOK_OPEN_PAREN
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
attlist6
static PROLOG_HANDLER attlist6
Definition: xmlrole.cc:112
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#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;
905  return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
906  }
907  return common(state, tok);
908 }
attlist7
static PROLOG_HANDLER attlist7
Definition: xmlrole.cc:112
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#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 }
XML_TOK_CLOSE_PAREN
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
attlist6
static PROLOG_HANDLER attlist6
Definition: xmlrole.cc:112
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_OR
#define XML_TOK_OR
Definition: xmltok.h:54
attlist8
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;
947  return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
948  }
949  if (XmlNameMatchesAscii(enc,
950  ptr + MIN_BYTES_PER_CHAR(enc),
951  end,
952  KW_REQUIRED)) {
953  state->handler = attlist1;
954  return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
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;
966  return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
967  }
968  return common(state, tok);
969 }
KW_FIXED
static const char KW_FIXED[]
Definition: xmlrole.cc:54
attlist1
static PROLOG_HANDLER attlist1
Definition: xmlrole.cc:112
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
attlist9
static PROLOG_HANDLER attlist9
Definition: xmlrole.cc:112
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
MIN_BYTES_PER_CHAR
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
XML_TOK_POUND_NAME
#define XML_TOK_POUND_NAME
Definition: xmltok.h:53
KW_IMPLIED
static const char KW_IMPLIED[]
Definition: xmlrole.cc:66
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
KW_REQUIRED
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;
983  return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
984  }
985  return common(state, tok);
986 }
attlist1
static PROLOG_HANDLER attlist1
Definition: xmlrole.cc:112
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_LITERAL
#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 }
XML_TOK_PARAM_ENTITY_REF
#define XML_TOK_PARAM_ENTITY_REF
Definition: xmltok.h:61
error
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 }
setTopLevel
#define setTopLevel(state)
Definition: xmlrole.cc:102
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_DECL_CLOSE
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
prolog_state::role_none
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:
231  case XML_TOK_PREFIXED_NAME:
232  state->handler = doctype1;
233  return XML_ROLE_DOCTYPE_NAME;
234  }
235  return common(state, tok);
236 }
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
doctype1
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;
248  case XML_TOK_OPEN_BRACKET:
249  state->handler = internalSubset;
250  return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
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 }
KW_PUBLIC
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
internalSubset
static PROLOG_HANDLER internalSubset
Definition: xmlrole.cc:112
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
KW_SYSTEM
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
XML_TOK_DECL_CLOSE
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
prolog2
static PROLOG_HANDLER prolog2
Definition: xmlrole.cc:112
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
doctype2
static PROLOG_HANDLER doctype2
Definition: xmlrole.cc:112
XML_TOK_OPEN_BRACKET
#define XML_TOK_OPEN_BRACKET
Definition: xmltok.h:58
doctype3
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;
280  return XML_ROLE_DOCTYPE_PUBLIC_ID;
281  }
282  return common(state, tok);
283 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
doctype3
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;
297  return XML_ROLE_DOCTYPE_SYSTEM_ID;
298  }
299  return common(state, tok);
300 }
doctype4
static PROLOG_HANDLER doctype4
Definition: xmlrole.cc:112
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_LITERAL
#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;
312  case XML_TOK_OPEN_BRACKET:
313  state->handler = internalSubset;
314  return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
315  case XML_TOK_DECL_CLOSE:
316  state->handler = prolog2;
317  return XML_ROLE_DOCTYPE_CLOSE;
318  }
319  return common(state, tok);
320 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
internalSubset
static PROLOG_HANDLER internalSubset
Definition: xmlrole.cc:112
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_DECL_CLOSE
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
prolog2
static PROLOG_HANDLER prolog2
Definition: xmlrole.cc:112
XML_TOK_OPEN_BRACKET
#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 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_DECL_CLOSE
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
prolog2
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:
999  case XML_TOK_PREFIXED_NAME:
1000  state->handler = element1;
1001  return XML_ROLE_ELEMENT_NAME;
1002  }
1003  return common(state, tok);
1004 }
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
element1
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;
1019  state->role_none = XML_ROLE_ELEMENT_NONE;
1020  return XML_ROLE_CONTENT_EMPTY;
1021  }
1022  if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
1023  state->handler = declClose;
1024  state->role_none = XML_ROLE_ELEMENT_NONE;
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 }
XML_TOK_OPEN_PAREN
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
prolog_state::level
unsigned level
Definition: xmlrole.h:93
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
KW_ANY
static const char KW_ANY[]
Definition: xmlrole.cc:37
declClose
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112
KW_EMPTY
static const char KW_EMPTY[]
Definition: xmlrole.cc:47
element2
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;
1065  return XML_ROLE_CONTENT_ELEMENT_OPT;
1066  case XML_TOK_NAME_ASTERISK:
1067  state->handler = element7;
1068  return XML_ROLE_CONTENT_ELEMENT_REP;
1069  case XML_TOK_NAME_PLUS:
1070  state->handler = element7;
1071  return XML_ROLE_CONTENT_ELEMENT_PLUS;
1072  }
1073  return common(state, tok);
1074 }
XML_TOK_NAME_ASTERISK
#define XML_TOK_NAME_ASTERISK
Definition: xmltok.h:66
XML_TOK_OPEN_PAREN
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
prolog_state::level
unsigned level
Definition: xmlrole.h:93
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
MIN_BYTES_PER_CHAR
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
XML_TOK_POUND_NAME
#define XML_TOK_POUND_NAME
Definition: xmltok.h:53
KW_PCDATA
static const char KW_PCDATA[]
Definition: xmlrole.cc:82
XML_TOK_NAME_QUESTION
#define XML_TOK_NAME_QUESTION
Definition: xmltok.h:65
element6
static PROLOG_HANDLER element6
Definition: xmlrole.cc:112
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
XML_TOK_NAME_PLUS
#define XML_TOK_NAME_PLUS
Definition: xmltok.h:67
element7
static PROLOG_HANDLER element7
Definition: xmlrole.cc:112
element3
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;
1088  state->role_none = XML_ROLE_ELEMENT_NONE;
1089  return XML_ROLE_GROUP_CLOSE;
1090  case XML_TOK_CLOSE_PAREN_ASTERISK:
1091  state->handler = declClose;
1092  state->role_none = XML_ROLE_ELEMENT_NONE;
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 }
XML_TOK_CLOSE_PAREN
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_CLOSE_PAREN_ASTERISK
#define XML_TOK_CLOSE_PAREN_ASTERISK
Definition: xmltok.h:71
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XML_TOK_OR
#define XML_TOK_OR
Definition: xmltok.h:54
element4
static PROLOG_HANDLER element4
Definition: xmlrole.cc:112
declClose
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 }
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
element5
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;
1129  case XML_TOK_CLOSE_PAREN_ASTERISK:
1130  state->handler = declClose;
1131  state->role_none = XML_ROLE_ELEMENT_NONE;
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 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_CLOSE_PAREN_ASTERISK
#define XML_TOK_CLOSE_PAREN_ASTERISK
Definition: xmltok.h:71
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XML_TOK_OR
#define XML_TOK_OR
Definition: xmltok.h:54
element4
static PROLOG_HANDLER element4
Definition: xmlrole.cc:112
declClose
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;
1159  return XML_ROLE_CONTENT_ELEMENT_OPT;
1160  case XML_TOK_NAME_ASTERISK:
1161  state->handler = element7;
1162  return XML_ROLE_CONTENT_ELEMENT_REP;
1163  case XML_TOK_NAME_PLUS:
1164  state->handler = element7;
1165  return XML_ROLE_CONTENT_ELEMENT_PLUS;
1166  }
1167  return common(state, tok);
1168 }
XML_TOK_NAME_ASTERISK
#define XML_TOK_NAME_ASTERISK
Definition: xmltok.h:66
XML_TOK_OPEN_PAREN
#define XML_TOK_OPEN_PAREN
Definition: xmltok.h:56
prolog_state::level
unsigned level
Definition: xmlrole.h:93
XML_TOK_PREFIXED_NAME
#define XML_TOK_PREFIXED_NAME
Definition: xmltok.h:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_NAME_QUESTION
#define XML_TOK_NAME_QUESTION
Definition: xmltok.h:65
XML_TOK_NAME_PLUS
#define XML_TOK_NAME_PLUS
Definition: xmltok.h:67
element7
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;
1184  state->role_none = XML_ROLE_ELEMENT_NONE;
1185  }
1186  return XML_ROLE_GROUP_CLOSE;
1187  case XML_TOK_CLOSE_PAREN_ASTERISK:
1188  state->level -= 1;
1189  if (state->level == 0) {
1190  state->handler = declClose;
1191  state->role_none = XML_ROLE_ELEMENT_NONE;
1192  }
1193  return XML_ROLE_GROUP_CLOSE_REP;
1194  case XML_TOK_CLOSE_PAREN_QUESTION:
1195  state->level -= 1;
1196  if (state->level == 0) {
1197  state->handler = declClose;
1198  state->role_none = XML_ROLE_ELEMENT_NONE;
1199  }
1200  return XML_ROLE_GROUP_CLOSE_OPT;
1201  case XML_TOK_CLOSE_PAREN_PLUS:
1202  state->level -= 1;
1203  if (state->level == 0) {
1204  state->handler = declClose;
1205  state->role_none = XML_ROLE_ELEMENT_NONE;
1206  }
1207  return XML_ROLE_GROUP_CLOSE_PLUS;
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 }
XML_TOK_CLOSE_PAREN
#define XML_TOK_CLOSE_PAREN
Definition: xmltok.h:57
prolog_state::level
unsigned level
Definition: xmlrole.h:93
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_CLOSE_PAREN_ASTERISK
#define XML_TOK_CLOSE_PAREN_ASTERISK
Definition: xmltok.h:71
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XML_TOK_OR
#define XML_TOK_OR
Definition: xmltok.h:54
XML_TOK_CLOSE_PAREN_PLUS
#define XML_TOK_CLOSE_PAREN_PLUS
Definition: xmltok.h:72
element6
static PROLOG_HANDLER element6
Definition: xmlrole.cc:112
XML_TOK_CLOSE_PAREN_QUESTION
#define XML_TOK_CLOSE_PAREN_QUESTION
Definition: xmltok.h:70
XML_TOK_COMMA
#define XML_TOK_COMMA
Definition: xmltok.h:73
declClose
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;
456  return XML_ROLE_GENERAL_ENTITY_NAME;
457  }
458  return common(state, tok);
459 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PERCENT
#define XML_TOK_PERCENT
Definition: xmltok.h:55
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
entity2
static PROLOG_HANDLER entity2
Definition: xmlrole.cc:112
entity1
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;
473  return XML_ROLE_PARAM_ENTITY_NAME;
474  }
475  return common(state, tok);
476 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
entity7
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);
655  return XML_ROLE_ENTITY_COMPLETE;
656  }
657  return common(state, tok);
658 }
setTopLevel
#define setTopLevel(state)
Definition: xmlrole.cc:102
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_DECL_CLOSE
#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;
500  state->role_none = XML_ROLE_ENTITY_NONE;
501  return XML_ROLE_ENTITY_VALUE;
502  }
503  return common(state, tok);
504 }
KW_PUBLIC
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
KW_SYSTEM
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
entity3
static PROLOG_HANDLER entity3
Definition: xmlrole.cc:112
entity4
static PROLOG_HANDLER entity4
Definition: xmlrole.cc:112
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
declClose
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;
518  return XML_ROLE_ENTITY_PUBLIC_ID;
519  }
520  return common(state, tok);
521 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
entity4
static PROLOG_HANDLER entity4
Definition: xmlrole.cc:112
XML_TOK_LITERAL
#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;
535  return XML_ROLE_ENTITY_SYSTEM_ID;
536  }
537  return common(state, tok);
538 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
entity5
static PROLOG_HANDLER entity5
Definition: xmlrole.cc:112
XML_TOK_LITERAL
#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);
552  return XML_ROLE_ENTITY_COMPLETE;
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 }
setTopLevel
#define setTopLevel(state)
Definition: xmlrole.cc:102
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
entity6
static PROLOG_HANDLER entity6
Definition: xmlrole.cc:112
XML_TOK_DECL_CLOSE
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
KW_NDATA
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;
575  state->role_none = XML_ROLE_ENTITY_NONE;
576  return XML_ROLE_ENTITY_NOTATION_NAME;
577  }
578  return common(state, tok);
579 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
declClose
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;
603  state->role_none = XML_ROLE_ENTITY_NONE;
604  return XML_ROLE_ENTITY_VALUE;
605  }
606  return common(state, tok);
607 }
KW_PUBLIC
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
KW_SYSTEM
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
entity8
static PROLOG_HANDLER entity8
Definition: xmlrole.cc:112
declClose
static PROLOG_HANDLER declClose
Definition: xmlrole.cc:112
entity9
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;
621  return XML_ROLE_ENTITY_PUBLIC_ID;
622  }
623  return common(state, tok);
624 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
entity9
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;
638  return XML_ROLE_ENTITY_SYSTEM_ID;
639  }
640  return common(state, tok);
641 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
entity10
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;
383  case XML_TOK_PARAM_ENTITY_REF:
384  return XML_ROLE_PARAM_ENTITY_REF;
385  case XML_TOK_CLOSE_BRACKET:
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 }
KW_ELEMENT
static const char KW_ELEMENT[]
Definition: xmlrole.cc:45
KW_ENTITY
static const char KW_ENTITY[]
Definition: xmlrole.cc:52
attlist0
static PROLOG_HANDLER attlist0
Definition: xmlrole.cc:112
doctype5
static PROLOG_HANDLER doctype5
Definition: xmlrole.cc:112
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_COMMENT
#define XML_TOK_COMMENT
Definition: xmltok.h:44
MIN_BYTES_PER_CHAR
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
KW_ATTLIST
static const char KW_ATTLIST[]
Definition: xmlrole.cc:39
XML_TOK_PARAM_ENTITY_REF
#define XML_TOK_PARAM_ENTITY_REF
Definition: xmltok.h:61
KW_NOTATION
static const char KW_NOTATION[]
Definition: xmlrole.cc:79
XML_TOK_PI
#define XML_TOK_PI
Definition: xmltok.h:42
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
entity0
static PROLOG_HANDLER entity0
Definition: xmlrole.cc:112
XML_TOK_CLOSE_BRACKET
#define XML_TOK_CLOSE_BRACKET
Definition: xmltok.h:59
notation0
static PROLOG_HANDLER notation0
Definition: xmlrole.cc:112
XML_TOK_NONE
#define XML_TOK_NONE
Definition: xmltok.h:18
XML_TOK_DECL_OPEN
#define XML_TOK_DECL_OPEN
Definition: xmltok.h:49
element0
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 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
notation1
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 }
KW_PUBLIC
static const char KW_PUBLIC[]
Definition: xmlrole.cc:84
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_NAME
#define XML_TOK_NAME
Definition: xmltok.h:51
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
KW_SYSTEM
static const char KW_SYSTEM[]
Definition: xmlrole.cc:89
notation2
static PROLOG_HANDLER notation2
Definition: xmlrole.cc:112
notation3
static PROLOG_HANDLER notation3
Definition: xmlrole.cc:112
XmlNameMatchesAscii
#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;
713  return XML_ROLE_NOTATION_PUBLIC_ID;
714  }
715  return common(state, tok);
716 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
notation4
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;
730  state->role_none = XML_ROLE_NOTATION_NONE;
731  return XML_ROLE_NOTATION_SYSTEM_ID;
732  }
733  return common(state, tok);
734 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
declClose
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;
748  state->role_none = XML_ROLE_NOTATION_NONE;
749  return XML_ROLE_NOTATION_SYSTEM_ID;
750  case XML_TOK_DECL_CLOSE:
751  setTopLevel(state);
752  return XML_ROLE_NOTATION_NO_SYSTEM_ID;
753  }
754  return common(state, tok);
755 }
setTopLevel
#define setTopLevel(state)
Definition: xmlrole.cc:102
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_DECL_CLOSE
#define XML_TOK_DECL_CLOSE
Definition: xmltok.h:50
prolog_state::role_none
int role_none
Definition: xmlrole.h:94
XML_TOK_LITERAL
#define XML_TOK_LITERAL
Definition: xmltok.h:60
declClose
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;
161  case XML_TOK_INSTANCE_START:
162  state->handler = error;
163  return XML_ROLE_INSTANCE_START;
164  }
165  return common(state, tok);
166 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
KW_DOCTYPE
static const char KW_DOCTYPE[]
Definition: xmlrole.cc:43
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_COMMENT
#define XML_TOK_COMMENT
Definition: xmltok.h:44
MIN_BYTES_PER_CHAR
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
doctype0
static PROLOG_HANDLER doctype0
Definition: xmlrole.cc:112
XML_TOK_BOM
#define XML_TOK_BOM
Definition: xmltok.h:45
XML_TOK_PI
#define XML_TOK_PI
Definition: xmltok.h:42
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
prolog1
static PROLOG_HANDLER prolog1
Definition: xmlrole.cc:112
error
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
XML_TOK_INSTANCE_START
#define XML_TOK_INSTANCE_START
Definition: xmltok.h:62
XML_TOK_XML_DECL
#define XML_TOK_XML_DECL
Definition: xmltok.h:43
XML_TOK_DECL_OPEN
#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;
192  case XML_TOK_INSTANCE_START:
193  state->handler = error;
194  return XML_ROLE_INSTANCE_START;
195  }
196  return common(state, tok);
197 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
KW_DOCTYPE
static const char KW_DOCTYPE[]
Definition: xmlrole.cc:43
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_COMMENT
#define XML_TOK_COMMENT
Definition: xmltok.h:44
MIN_BYTES_PER_CHAR
#define MIN_BYTES_PER_CHAR(enc)
Definition: xmlrole.cc:93
doctype0
static PROLOG_HANDLER doctype0
Definition: xmlrole.cc:112
XML_TOK_BOM
#define XML_TOK_BOM
Definition: xmltok.h:45
XML_TOK_PI
#define XML_TOK_PI
Definition: xmltok.h:42
XmlNameMatchesAscii
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)
Definition: xmltok.h:231
error
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
XML_TOK_INSTANCE_START
#define XML_TOK_INSTANCE_START
Definition: xmltok.h:62
XML_TOK_DECL_OPEN
#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;
213  case XML_TOK_INSTANCE_START:
214  state->handler = error;
215  return XML_ROLE_INSTANCE_START;
216  }
217  return common(state, tok);
218 }
common
static int FASTCALL common(PROLOG_STATE *state, int tok)
Definition: xmlrole.cc:1309
XML_TOK_PROLOG_S
#define XML_TOK_PROLOG_S
Definition: xmltok.h:48
XML_TOK_COMMENT
#define XML_TOK_COMMENT
Definition: xmltok.h:44
XML_TOK_PI
#define XML_TOK_PI
Definition: xmltok.h:42
error
static PROLOG_HANDLER error
Definition: xmlrole.cc:112
XML_TOK_INSTANCE_START
#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 }
prolog0
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:
= {
ASCII_A, ASCII_N, ASCII_Y, '\0' }
ASCII_Y
#define ASCII_Y
Definition: ascii.h:29
ASCII_A
#define ASCII_A
Definition: ascii.h:5
ASCII_N
#define ASCII_N
Definition: ascii.h:18

Definition at line 37 of file xmlrole.cc.

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

Definition at line 39 of file xmlrole.cc.

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

Definition at line 41 of file xmlrole.cc.

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

Definition at line 43 of file xmlrole.cc.

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

Definition at line 45 of file xmlrole.cc.

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

Definition at line 47 of file xmlrole.cc.

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

Definition at line 49 of file xmlrole.cc.

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

Definition at line 52 of file xmlrole.cc.

const char KW_FIXED[]
static
Initial value:
= {
ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' }
ASCII_X
#define ASCII_X
Definition: ascii.h:28
ASCII_I
#define ASCII_I
Definition: ascii.h:13
ASCII_D
#define ASCII_D
Definition: ascii.h:8
ASCII_F
#define ASCII_F
Definition: ascii.h:10
ASCII_E
#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' }
ASCII_I
#define ASCII_I
Definition: ascii.h:13
ASCII_D
#define ASCII_D
Definition: ascii.h:8

Definition at line 56 of file xmlrole.cc.

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

Definition at line 58 of file xmlrole.cc.

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

Definition at line 60 of file xmlrole.cc.

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

Definition at line 66 of file xmlrole.cc.

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

Definition at line 72 of file xmlrole.cc.

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

Definition at line 74 of file xmlrole.cc.

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

Definition at line 76 of file xmlrole.cc.

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

Definition at line 79 of file xmlrole.cc.

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

Definition at line 82 of file xmlrole.cc.

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

Definition at line 84 of file xmlrole.cc.

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

Definition at line 86 of file xmlrole.cc.

const char KW_SYSTEM[]
static
Initial value:
= {
ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' }
ASCII_Y
#define ASCII_Y
Definition: ascii.h:29
ASCII_S
#define ASCII_S
Definition: ascii.h:23
ASCII_M
#define ASCII_M
Definition: ascii.h:17
ASCII_E
#define ASCII_E
Definition: ascii.h:9
ASCII_T
#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.