Changeset 1445


Ignore:
Timestamp:
Sep 14, 2011, 7:19:46 PM (8 years ago)
Author:
ksherdy
Message:

Modularize pablo_template.cpp.

Location:
proto
Files:
17 added
12 edited

Legend:

Unmodified
Added
Removed
  • proto/Xerces/src/Makefile

    r1436 r1445  
    1 SRCFILE=xmlwf.cpp
     1SRCFILE=xmlwf.cpp xml_error.c ErrorUtil.cpp ErrorTracker.cpp XMLTestSuiteError.cpp
    22OUTFILE=xmlwf
    33TEST= run_all.py
  • proto/Xerces/src/TagMatcher.h

    r1436 r1445  
    22#include <algorithm>
    33#include <iostream>
     4#include <string.h>
    45using namespace std;
    56
  • proto/Xerces/src/xml_error.c

    r1436 r1445  
    77
    88#include "xml_error.h"
     9#include <stdio.h>
     10#include <stdlib.h>
     11
     12const char * XML_Constraint_Strings[] = {
     13                "wfc-PEinInternalSubset",
     14                "ExtSubset",
     15                "PE-between-Decls",
     16                "GIMatch",
     17                "uniqattspec",
     18                "NoExternalRefs",
     19                "CleanAttrVals",
     20                "wf-Legalchar",
     21                "wf-entdeclared",
     22                "textent",
     23                "norecursion",
     24                "indtd",
     25                "vc-roottype",
     26                "vc-PEinMarkupDecl",
     27                "vc-check-rmd",
     28                "elementvalid",
     29                "ValueType",
     30                "EDUnique",
     31                "vc-PEinGroup",
     32                "vc-MixedChildrenUnique",
     33                "id",
     34                "one-id-per-el",
     35                "id-default",
     36                "idref",
     37                "entname",
     38                "nmtok",
     39                "notatn",
     40                "OneNotationPer",
     41                "NoNotationEmpty",
     42                "NoDuplicateTokens",
     43                "enum",
     44                "RequiredAttr",
     45                "defattrvalid",
     46                "FixedAttr",
     47                "condsec-nesting",
     48                "vc-entdeclared",
     49                "not-declared",
     50                "UniqueNotationName"};
     51
     52const char * XML_NonTerminal_Names[] = {
     53                "document  [1]",
     54                "Char  [2]",
     55                "S  [3]",
     56                "NameChar  [4]",
     57                "Name  [5]",
     58                "Names  [6]",
     59                "Nmtoken  [7]",
     60                "Nmtokens  [8]",
     61                "EntityValue  [9]",
     62                "AttValue  [10]",
     63                "SystemLiteral  [11]",
     64                "PubidLiteral  [12]",
     65                "PubidChar  [13]",
     66                "CharData  [14]",
     67                "Comment  [15]",
     68                "PI  [16]",
     69                "PITarget  [17]",
     70                "CDSect  [18]",
     71                "CDStart  [19]",
     72                "CData  [20]",
     73                "CDEnd  [21]",
     74                "prolog  [22]",
     75                "XMLDecl  [23]",
     76                "VersionInfo  [24]",
     77                "Eq  [25]",
     78                "VersionNum  [26]",
     79                "Misc  [27]",
     80                "doctypedecl  [28]",
     81                "DeclSep  [28a]",
     82                "intSubset  [28b]",
     83                "markupdecl  [29]",
     84                "extSubset  [30]",
     85                "extSubsetDecl  [31]",
     86                "SDDecl  [32]",
     87                "element  [39]",
     88                "STag  [40]",
     89                "Attribute  [41]",
     90                "ETag  [42]",
     91                "content  [43]",
     92                "EmptyElemTag  [44]",
     93                "elementdecl  [45]",
     94                "contentspec  [46]",
     95                "children  [47]",
     96                "cp  [48]",
     97                "choice  [49]",
     98                "seq  [50]",
     99                "Mixed  [51]",
     100                "AttlistDecl  [52]",
     101                "AttDef  [53]",
     102                "AttType  [54]",
     103                "StringType  [55]",
     104                "TokenizedType  [56]",
     105                "EnumeratedType  [57]",
     106                "NotationType  [58]",
     107                "Enumeration  [59]",
     108                "DefaultDecl  [60]",
     109                "conditionalSect  [61]",
     110                "includeSect  [62]",
     111                "ignoreSect  [63]",
     112                "ignoreSectContents  [64]",
     113                "Ignore  [65]",
     114                "CharRef  [66]",
     115                "Reference  [67]",
     116                "EntityRef  [68]",
     117                "PEReference  [69]",
     118                "EntityDecl  [70]",
     119                "GEDecl  [71]",
     120                "PEDecl  [72]",
     121                "EntityDef  [73]",
     122                "PEDef  [74]",
     123                "ExternalID  [75]",
     124                "NDataDecl  [76]",
     125                "TextDecl  [77]",
     126                "extParsedEnt  [78]",
     127                "EncodingDecl  [80]",
     128                "EncName  [81]",
     129                "NotationDecl  [82]",
     130                "PublicID  [83]",
     131                "Letter  [84]",
     132                "BaseChar  [85]",
     133                "Ideographic  [86]",
     134                "CombiningChar  [87]",
     135                "Digit  [88]",
     136                "Extender  [89]"};
     137
    9138
    10139void ShowConstraintError(enum XML_Constraint errCode) {
  • proto/Xerces/src/xml_error.h

    r1436 r1445  
    5353                vErr_UniqueNotationName};
    5454
    55 const char * XML_Constraint_Strings[] = {
    56                 "wfc-PEinInternalSubset",
    57                 "ExtSubset",
    58                 "PE-between-Decls",
    59                 "GIMatch",
    60                 "uniqattspec",
    61                 "NoExternalRefs",
    62                 "CleanAttrVals",
    63                 "wf-Legalchar",
    64                 "wf-entdeclared",
    65                 "textent",
    66                 "norecursion",
    67                 "indtd",
    68                 "vc-roottype",
    69                 "vc-PEinMarkupDecl",
    70                 "vc-check-rmd",
    71                 "elementvalid",
    72                 "ValueType",
    73                 "EDUnique",
    74                 "vc-PEinGroup",
    75                 "vc-MixedChildrenUnique",
    76                 "id",
    77                 "one-id-per-el",
    78                 "id-default",
    79                 "idref",
    80                 "entname",
    81                 "nmtok",
    82                 "notatn",
    83                 "OneNotationPer",
    84                 "NoNotationEmpty",
    85                 "NoDuplicateTokens",
    86                 "enum",
    87                 "RequiredAttr",
    88                 "defattrvalid",
    89                 "FixedAttr",
    90                 "condsec-nesting",
    91                 "vc-entdeclared",
    92                 "not-declared",
    93                 "UniqueNotationName"};
     55extern const char * XML_Constraint_Strings[];
    9456
    9557/* The following enum provides codes for XML nonterminals using
     
    184146                NT_Extender};
    185147
    186 const char * XML_NonTerminal_Names[] = {
    187                 "document  [1]",
    188                 "Char  [2]",
    189                 "S  [3]",
    190                 "NameChar  [4]",
    191                 "Name  [5]",
    192                 "Names  [6]",
    193                 "Nmtoken  [7]",
    194                 "Nmtokens  [8]",
    195                 "EntityValue  [9]",
    196                 "AttValue  [10]",
    197                 "SystemLiteral  [11]",
    198                 "PubidLiteral  [12]",
    199                 "PubidChar  [13]",
    200                 "CharData  [14]",
    201                 "Comment  [15]",
    202                 "PI  [16]",
    203                 "PITarget  [17]",
    204                 "CDSect  [18]",
    205                 "CDStart  [19]",
    206                 "CData  [20]",
    207                 "CDEnd  [21]",
    208                 "prolog  [22]",
    209                 "XMLDecl  [23]",
    210                 "VersionInfo  [24]",
    211                 "Eq  [25]",
    212                 "VersionNum  [26]",
    213                 "Misc  [27]",
    214                 "doctypedecl  [28]",
    215                 "DeclSep  [28a]",
    216                 "intSubset  [28b]",
    217                 "markupdecl  [29]",
    218                 "extSubset  [30]",
    219                 "extSubsetDecl  [31]",
    220                 "SDDecl  [32]",
    221                 "element  [39]",
    222                 "STag  [40]",
    223                 "Attribute  [41]",
    224                 "ETag  [42]",
    225                 "content  [43]",
    226                 "EmptyElemTag  [44]",
    227                 "elementdecl  [45]",
    228                 "contentspec  [46]",
    229                 "children  [47]",
    230                 "cp  [48]",
    231                 "choice  [49]",
    232                 "seq  [50]",
    233                 "Mixed  [51]",
    234                 "AttlistDecl  [52]",
    235                 "AttDef  [53]",
    236                 "AttType  [54]",
    237                 "StringType  [55]",
    238                 "TokenizedType  [56]",
    239                 "EnumeratedType  [57]",
    240                 "NotationType  [58]",
    241                 "Enumeration  [59]",
    242                 "DefaultDecl  [60]",
    243                 "conditionalSect  [61]",
    244                 "includeSect  [62]",
    245                 "ignoreSect  [63]",
    246                 "ignoreSectContents  [64]",
    247                 "Ignore  [65]",
    248                 "CharRef  [66]",
    249                 "Reference  [67]",
    250                 "EntityRef  [68]",
    251                 "PEReference  [69]",
    252                 "EntityDecl  [70]",
    253                 "GEDecl  [71]",
    254                 "PEDecl  [72]",
    255                 "EntityDef  [73]",
    256                 "PEDef  [74]",
    257                 "ExternalID  [75]",
    258                 "NDataDecl  [76]",
    259                 "TextDecl  [77]",
    260                 "extParsedEnt  [78]",
    261                 "EncodingDecl  [80]",
    262                 "EncName  [81]",
    263                 "NotationDecl  [82]",
    264                 "PublicID  [83]",
    265                 "Letter  [84]",
    266                 "BaseChar  [85]",
    267                 "Ideographic  [86]",
    268                 "CombiningChar  [87]",
    269                 "Digit  [88]",
    270                 "Extender  [89]"};
     148extern const char * XML_NonTerminal_Names[];
    271149
    272150void ShowConstraintError(enum XML_Constraint errCode);
  • proto/Xerces/src/xmldecl.h

    r1436 r1445  
    116116
    117117};
     118
     119#include "xmldecl.c"
     120
    118121#endif
  • proto/parabix2/pablo_template.cpp

    r1232 r1445  
    66#include "../lib/lib_simd.h"
    77
     8typedef long ScanBlock;
     9typedef SIMD_type BytePack;
     10typedef SIMD_type BitBlock;
     11
    812#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
    913#define SEGMENT_BLOCKS 12
     
    1115#define OVERLAP_BUFSIZE (sizeof(SIMD_type))
    1216
    13 typedef long ScanBlock;
    14 typedef SIMD_type BytePack;
    15 typedef SIMD_type BitBlock;
    16 
    1717#include "../lib/carryQ.h"
    1818#include "xmldecl.h"
    19 #include "xml_error.c"
    20 #include "xmldecl.c"
    2119#include "namechars.h"
     20
     21//#include "xml_error.c"
     22//#include "xmldecl.c"
    2223
    2324#include "../lib/perflib/perfsec.h"
     
    2627#include "TagMatcher.h"
    2728#include "LineColTracker.h"
     29#include "ErrorUtil.h"
     30#include "ErrorTracker.h"
     31#include "XMLTestSuiteError.h"
    2832
    2933
     
    4751char * source;
    4852
    49 
    5053LineColTracker tracker;
    51 
    52 static inline void ReportError(const char * error_msg, int error_pos_in_block) {
    53   int error_line, error_column;
    54   tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
    55   fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
    56 }
    57 
    58 class ErrorTracker {
    59 public:
    60         ErrorTracker() { noted_pos_in_block = -1;}
    61 
    62         inline void NoteError(const char * error_msg, BitBlock err_strm) {
    63           int pos_in_block = count_forward_zeroes(err_strm);
    64           if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
    65             noted_pos_in_block = pos_in_block;
    66             noted_error = error_msg;
    67           }
    68         }
    69 
    70         inline void If_Error_Report_First() {
    71           if (noted_pos_in_block > -1) {
    72                   int error_line, error_column;
    73                   ReportError(noted_error, noted_pos_in_block);
    74                   exit(-1);
    75           }
    76         }
    77  
    78 private:
    79   const char * noted_error;
    80   int noted_pos_in_block;       
    81 };
    82 
    83 
    8454TagMatcher matcher;
     55ErrorTracker error_tracker;
    8556BitBlock EOF_mask = simd_const_1(1);
    8657
    87 ErrorTracker error_tracker;
    88 
    89 static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
     58//      static inline int StreamScanToFirst(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block)
     59
     60static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int), int * error_pos_in_block) {
     61
    9062        int blk;
    9163        int block_pos = 0;
     64        int pos;
    9265
    9366        for (blk = 0; blk < blk_count; blk++) {
    9467                ScanBlock s = stream[blk];
    9568                while(s) {
    96                         int code = (ProcessPos(cfzl(s) + block_pos));
    97                         if (code) return code;
     69                        pos = (cfzl(s) + block_pos);
     70                        int code = (ProcessPos(pos));
     71                        if (code) {
     72                                *error_pos_in_block = pos;
     73                                return code; // error code
     74                        }
    9875                        s = s & (s-1);  // clear rightmost bit.
    9976                }
     
    10380}
    10481
    105 
    106 
    10782static inline int NameStrt_check(int pos) {
    10883        int block_pos = block_base + pos;
    10984        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
    110               ReportError("name start error", pos);
    111               exit(-1);
     85              return XMLTestSuiteError::NAME_START;
    11286        }
    11387        return 0;
     
    11791        int block_pos = block_base + pos;
    11892        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
    119               ReportError("name error", pos);
    120               exit(-1);
     93                  return XMLTestSuiteError::NAME;
    12194        }
    12295        return 0;
     
    128101        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
    129102              // "<?xml" legal at start of file.
    130               if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
    131               ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
    132               exit(-1);
     103              if (!((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0]))) {
     104                  return XMLTestSuiteError::XMLPINAME;
     105              }
    133106        }
    134107        return 0;
     
    138111        int block_pos = block_base + pos;
    139112        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
    140               ReportError("CDATA error", pos);
    141               exit(-1);
     113                  return XMLTestSuiteError::CDATA;
    142114        }
    143115        return 0;
     
    148120        unsigned char* s = (unsigned char*)&source[block_pos];
    149121        if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
    150               ReportError("Undefined reference", pos);
    151               exit(-1);
     122              return XMLTestSuiteError::UNDEFREF;
    152123        }
    153124        return 0;
     
    161132          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
    162133          if (ch_val> 0x10FFFF ){
    163             ReportError("Illegal character reference", pos);
    164             exit(-1);
     134                return XMLTestSuiteError::CHARREF;
    165135          }
    166136          s++;
    167137        }
    168138        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    169           ReportError("Illegal character reference", pos);
    170           exit(-1);
     139          return XMLTestSuiteError::CHARREF;
    171140        }
    172141        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    173           ReportError("Illegal XML 1.0 character reference", pos);
    174           exit(-1);
     142          return XMLTestSuiteError::XML10CHARREF;
    175143        }
    176144        return 0;
     
    184152          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
    185153          if (ch_val> 0x10FFFF ){
    186             ReportError("Illegal character reference", pos);
    187             exit(-1);
     154                        return XMLTestSuiteError::CHARREF;
    188155          }
    189156          s++;
    190157        }
    191158        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
    192           ReportError("Illegal character reference", pos);
    193           exit(-1);
     159                  return XMLTestSuiteError::CHARREF;
    194160        }
    195161        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
    196           ReportError("Illegal XML 1.0 character reference", pos);
    197           exit(-1);
     162                  return XMLTestSuiteError::XML10CHARREF;
    198163        }
    199164        return 0;
     
    220185          }
    221186          if (ch_val==60){
    222             ReportError("Attribute values contain '<' characters after reference expansion", pos);
    223             exit(-1);
     187            return XMLTestSuiteError::ATTREF;
    224188          }
    225189        }
    226190        else if(at_Ref_lt<ASCII>(s)){
    227           ReportError("Attribute values contain '<' characters after reference expansion", pos);
    228           exit(-1);
     191          return XMLTestSuiteError::ATTREF;
    229192        }
    230193        return 0;
     
    254217static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, int chars_avail){
    255218            tracker.StoreNewlines(lex.LF);
     219            int rv, error_pos_in_block, error_line, error_column;
    256220
    257221                if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
    258                   StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
    259                   StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
     222                  rv = StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check, &error_pos_in_block);
     223                  if (rv) {
     224                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     225                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     226                          exit(-1);
     227                  }
     228
     229                  rv = StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check, &error_pos_in_block);
     230                  if (rv) {
     231                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     232                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     233                          exit(-1);
     234                  }
    260235                }
    261236
    262237                if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
    263                   StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
     238                  rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check, &error_pos_in_block);
     239                  if (rv) {
     240                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     241                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     242                          exit(-1);
     243                  }
    264244                }
    265245
    266246                if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
    267                   StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
     247                  rv = StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check, &error_pos_in_block);
     248                  if (rv) {
     249                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     250                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     251                          exit(-1);
     252                  }
    268253                }
    269254
    270255                if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
    271                   StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
     256                  rv = StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check, &error_pos_in_block);
     257                  if (rv) {
     258                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     259                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     260                          exit(-1);
     261                  }
    272262                }
    273263
    274264                if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
    275                   StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
     265                  rv = StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check, &error_pos_in_block);
     266                  if (rv) {
     267                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     268                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     269                          exit(-1);
     270                  }
    276271                }
    277272
    278273                if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
    279                   StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
     274                  rv = StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check, &error_pos_in_block);
     275                  if (rv) {
     276                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     277                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     278                          exit(-1);
     279                  }
    280280                }
    281281
    282282                if (bitblock_has_bit(check_streams.att_refs)){
    283                   StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
    284                 }
    285 
    286                 error_tracker.If_Error_Report_First();
     283                  rv = StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check, &error_pos_in_block);
     284                  if (rv) {
     285                          tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
     286                          ReportError(XMLTestSuiteError::get_msg(rv), error_line, error_column);
     287                          exit(-1);
     288                  }
     289                }
     290
     291                if(error_tracker.Has_Noted_Error()){
     292                        tracker.get_Line_and_Column(error_tracker.Noted_Pos_In_Block(), error_line, error_column);
     293                        ReportError(error_tracker.Noted_Error_Msg(), error_line, error_column);
     294                        exit(-1);
     295                }
    287296
    288297                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
  • proto/parabix2/src/Makefile

    r1285 r1445  
    1 SRCFILE=xmlwf.cpp
     1SRCFILE=xmlwf.cpp xml_error.c ErrorUtil.cpp ErrorTracker.cpp XMLTestSuiteError.cpp
    22OUTFILE=xmlwf
    33TEST= run_all.py
     
    2929avx:    $(SRCFILE)
    3030        $(CC) -o $(OUTFILE) $(SRCFILE) -march=nocona -m64 -mavx
    31 
    3231
    3332threads:        $(SRCFILE)
  • proto/parabix2/src/TagMatcher.h

    r911 r1445  
    22#include <algorithm>
    33#include <iostream>
     4#include <string.h>
    45using namespace std;
    56
  • proto/parabix2/src/tag_matcher.h

    r912 r1445  
    22#include <algorithm>
    33#include <iostream>
     4#include <string.h>
    45using namespace std;
    56
  • proto/parabix2/src/xml_error.c

    r458 r1445  
    77
    88#include "xml_error.h"
     9#include <stdio.h>
     10#include <stdlib.h>
     11
     12const char * XML_Constraint_Strings[] = {
     13                "wfc-PEinInternalSubset",
     14                "ExtSubset",
     15                "PE-between-Decls",
     16                "GIMatch",
     17                "uniqattspec",
     18                "NoExternalRefs",
     19                "CleanAttrVals",
     20                "wf-Legalchar",
     21                "wf-entdeclared",
     22                "textent",
     23                "norecursion",
     24                "indtd",
     25                "vc-roottype",
     26                "vc-PEinMarkupDecl",
     27                "vc-check-rmd",
     28                "elementvalid",
     29                "ValueType",
     30                "EDUnique",
     31                "vc-PEinGroup",
     32                "vc-MixedChildrenUnique",
     33                "id",
     34                "one-id-per-el",
     35                "id-default",
     36                "idref",
     37                "entname",
     38                "nmtok",
     39                "notatn",
     40                "OneNotationPer",
     41                "NoNotationEmpty",
     42                "NoDuplicateTokens",
     43                "enum",
     44                "RequiredAttr",
     45                "defattrvalid",
     46                "FixedAttr",
     47                "condsec-nesting",
     48                "vc-entdeclared",
     49                "not-declared",
     50                "UniqueNotationName"};
     51
     52const char * XML_NonTerminal_Names[] = {
     53                "document  [1]",
     54                "Char  [2]",
     55                "S  [3]",
     56                "NameChar  [4]",
     57                "Name  [5]",
     58                "Names  [6]",
     59                "Nmtoken  [7]",
     60                "Nmtokens  [8]",
     61                "EntityValue  [9]",
     62                "AttValue  [10]",
     63                "SystemLiteral  [11]",
     64                "PubidLiteral  [12]",
     65                "PubidChar  [13]",
     66                "CharData  [14]",
     67                "Comment  [15]",
     68                "PI  [16]",
     69                "PITarget  [17]",
     70                "CDSect  [18]",
     71                "CDStart  [19]",
     72                "CData  [20]",
     73                "CDEnd  [21]",
     74                "prolog  [22]",
     75                "XMLDecl  [23]",
     76                "VersionInfo  [24]",
     77                "Eq  [25]",
     78                "VersionNum  [26]",
     79                "Misc  [27]",
     80                "doctypedecl  [28]",
     81                "DeclSep  [28a]",
     82                "intSubset  [28b]",
     83                "markupdecl  [29]",
     84                "extSubset  [30]",
     85                "extSubsetDecl  [31]",
     86                "SDDecl  [32]",
     87                "element  [39]",
     88                "STag  [40]",
     89                "Attribute  [41]",
     90                "ETag  [42]",
     91                "content  [43]",
     92                "EmptyElemTag  [44]",
     93                "elementdecl  [45]",
     94                "contentspec  [46]",
     95                "children  [47]",
     96                "cp  [48]",
     97                "choice  [49]",
     98                "seq  [50]",
     99                "Mixed  [51]",
     100                "AttlistDecl  [52]",
     101                "AttDef  [53]",
     102                "AttType  [54]",
     103                "StringType  [55]",
     104                "TokenizedType  [56]",
     105                "EnumeratedType  [57]",
     106                "NotationType  [58]",
     107                "Enumeration  [59]",
     108                "DefaultDecl  [60]",
     109                "conditionalSect  [61]",
     110                "includeSect  [62]",
     111                "ignoreSect  [63]",
     112                "ignoreSectContents  [64]",
     113                "Ignore  [65]",
     114                "CharRef  [66]",
     115                "Reference  [67]",
     116                "EntityRef  [68]",
     117                "PEReference  [69]",
     118                "EntityDecl  [70]",
     119                "GEDecl  [71]",
     120                "PEDecl  [72]",
     121                "EntityDef  [73]",
     122                "PEDef  [74]",
     123                "ExternalID  [75]",
     124                "NDataDecl  [76]",
     125                "TextDecl  [77]",
     126                "extParsedEnt  [78]",
     127                "EncodingDecl  [80]",
     128                "EncName  [81]",
     129                "NotationDecl  [82]",
     130                "PublicID  [83]",
     131                "Letter  [84]",
     132                "BaseChar  [85]",
     133                "Ideographic  [86]",
     134                "CombiningChar  [87]",
     135                "Digit  [88]",
     136                "Extender  [89]"};
     137
    9138
    10139void ShowConstraintError(enum XML_Constraint errCode) {
  • proto/parabix2/src/xml_error.h

    r458 r1445  
    5353                vErr_UniqueNotationName};
    5454
    55 const char * XML_Constraint_Strings[] = {
    56                 "wfc-PEinInternalSubset",
    57                 "ExtSubset",
    58                 "PE-between-Decls",
    59                 "GIMatch",
    60                 "uniqattspec",
    61                 "NoExternalRefs",
    62                 "CleanAttrVals",
    63                 "wf-Legalchar",
    64                 "wf-entdeclared",
    65                 "textent",
    66                 "norecursion",
    67                 "indtd",
    68                 "vc-roottype",
    69                 "vc-PEinMarkupDecl",
    70                 "vc-check-rmd",
    71                 "elementvalid",
    72                 "ValueType",
    73                 "EDUnique",
    74                 "vc-PEinGroup",
    75                 "vc-MixedChildrenUnique",
    76                 "id",
    77                 "one-id-per-el",
    78                 "id-default",
    79                 "idref",
    80                 "entname",
    81                 "nmtok",
    82                 "notatn",
    83                 "OneNotationPer",
    84                 "NoNotationEmpty",
    85                 "NoDuplicateTokens",
    86                 "enum",
    87                 "RequiredAttr",
    88                 "defattrvalid",
    89                 "FixedAttr",
    90                 "condsec-nesting",
    91                 "vc-entdeclared",
    92                 "not-declared",
    93                 "UniqueNotationName"};
     55extern const char * XML_Constraint_Strings[];
    9456
    9557/* The following enum provides codes for XML nonterminals using
     
    184146                NT_Extender};
    185147
    186 const char * XML_NonTerminal_Names[] = {
    187                 "document  [1]",
    188                 "Char  [2]",
    189                 "S  [3]",
    190                 "NameChar  [4]",
    191                 "Name  [5]",
    192                 "Names  [6]",
    193                 "Nmtoken  [7]",
    194                 "Nmtokens  [8]",
    195                 "EntityValue  [9]",
    196                 "AttValue  [10]",
    197                 "SystemLiteral  [11]",
    198                 "PubidLiteral  [12]",
    199                 "PubidChar  [13]",
    200                 "CharData  [14]",
    201                 "Comment  [15]",
    202                 "PI  [16]",
    203                 "PITarget  [17]",
    204                 "CDSect  [18]",
    205                 "CDStart  [19]",
    206                 "CData  [20]",
    207                 "CDEnd  [21]",
    208                 "prolog  [22]",
    209                 "XMLDecl  [23]",
    210                 "VersionInfo  [24]",
    211                 "Eq  [25]",
    212                 "VersionNum  [26]",
    213                 "Misc  [27]",
    214                 "doctypedecl  [28]",
    215                 "DeclSep  [28a]",
    216                 "intSubset  [28b]",
    217                 "markupdecl  [29]",
    218                 "extSubset  [30]",
    219                 "extSubsetDecl  [31]",
    220                 "SDDecl  [32]",
    221                 "element  [39]",
    222                 "STag  [40]",
    223                 "Attribute  [41]",
    224                 "ETag  [42]",
    225                 "content  [43]",
    226                 "EmptyElemTag  [44]",
    227                 "elementdecl  [45]",
    228                 "contentspec  [46]",
    229                 "children  [47]",
    230                 "cp  [48]",
    231                 "choice  [49]",
    232                 "seq  [50]",
    233                 "Mixed  [51]",
    234                 "AttlistDecl  [52]",
    235                 "AttDef  [53]",
    236                 "AttType  [54]",
    237                 "StringType  [55]",
    238                 "TokenizedType  [56]",
    239                 "EnumeratedType  [57]",
    240                 "NotationType  [58]",
    241                 "Enumeration  [59]",
    242                 "DefaultDecl  [60]",
    243                 "conditionalSect  [61]",
    244                 "includeSect  [62]",
    245                 "ignoreSect  [63]",
    246                 "ignoreSectContents  [64]",
    247                 "Ignore  [65]",
    248                 "CharRef  [66]",
    249                 "Reference  [67]",
    250                 "EntityRef  [68]",
    251                 "PEReference  [69]",
    252                 "EntityDecl  [70]",
    253                 "GEDecl  [71]",
    254                 "PEDecl  [72]",
    255                 "EntityDef  [73]",
    256                 "PEDef  [74]",
    257                 "ExternalID  [75]",
    258                 "NDataDecl  [76]",
    259                 "TextDecl  [77]",
    260                 "extParsedEnt  [78]",
    261                 "EncodingDecl  [80]",
    262                 "EncName  [81]",
    263                 "NotationDecl  [82]",
    264                 "PublicID  [83]",
    265                 "Letter  [84]",
    266                 "BaseChar  [85]",
    267                 "Ideographic  [86]",
    268                 "CombiningChar  [87]",
    269                 "Digit  [88]",
    270                 "Extender  [89]"};
     148extern const char * XML_NonTerminal_Names[];
    271149
    272150void ShowConstraintError(enum XML_Constraint errCode);
Note: See TracChangeset for help on using the changeset viewer.