projects / oweals / cde.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: aef2830)
dtinfo subdirectory dtinfogen
authorUlrich Wilkens <mail@uwilkens.de>
Wed, 28 Aug 2013 18:07:21 +0000 (20:07 +0200)
committerJon Trulson <jon@radscan.com>
Fri, 30 Aug 2013 01:44:12 +0000 (19:44 -0600)
43 files changed:
cde/programs/dtinfo/dtinfogen/Imakefile patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/Imakefile patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeData.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeRec.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/AusText.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/AusTextStorage.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/BookTasks.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/ContentType.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.h patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/DataRepository.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/DataTask.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/Dispatch.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/FlexBuffer.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/GenericId.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/GraphicsTask.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/MixedGen.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/NCFGen.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/NodeData.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/NodeTask.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/OL-Data.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/OL_DataExpr.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/RemoteId.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/ReplaceIdIdref.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLDefn.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLName.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/SearchPath.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/SearchStorage.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/StringList.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTask.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTaskDB.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/TOCTask.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen_worker.c patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/gr_type.C patch | blob | history
cde/programs/dtinfo/dtinfogen/infolib/etc/lex.C patch | blob | history
cde/programs/dtinfo/dtinfogen/install/valBase.C patch | blob | history
cde/programs/dtinfo/dtinfogen/mmdb/Imakefile patch | blob | history
cde/programs/dtinfo/dtinfogen/mmdb/StyleSheet/validator.C patch | blob | history
cde/programs/dtinfo/dtinfogen/mmdb/src/Imakefile patch | blob | history
cde/programs/dtinfo/dtinfogen/mmdb/src/main.C patch | blob | history
cde/programs/dtinfo/dtinfogen/mmdb/src/main_c_api.c patch | blob | history
cde/programs/dtinfo/dtinfogen/mmdb/src/restore.C patch | blob | history

diff --git a/cde/programs/dtinfo/dtinfogen/Imakefile b/cde/programs/dtinfo/dtinfogen/Imakefile
index ae75ef78d3ec9c4628f05b309a5c07ac2b8b223c..9234f3e93739c170be0428297ea41227c3657c6f 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/Imakefile
+++ b/cde/programs/dtinfo/dtinfogen/Imakefile
@@ -8,9 +8,9 @@ SUBDIRS=mmdb infolib install
 XCOMM redefine TopLevelProject to build DtInfo with standard CDE config dir
 #undef  TopLevelProject
 #define TopLevelProject                DtInfo
-IMAKE_DEFINES = -DTopLevelProject=TopLevelProject \
-               -DProjectTmplFile='<DtInfo.tmpl>' \
-               -DProjectRulesFile='<DtInfo.rules>'
+IMAKE_DEF_DTINFO =  -DTopLevelProject=TopLevelProject \
+                   -DProjectTmplFile='<DtInfo.tmpl>' \
+                   -DProjectRulesFile='<DtInfo.rules>'
 
 XCOMM Variables to switch on debug mode temporarily
 XCOMM CDEBUGFLAGS = -g -DDEBUG
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/Imakefile b/cde/programs/dtinfo/dtinfogen/infolib/Imakefile
index b3fa65b24db2047328e113b1608819d6e483947e..7451e0af8ee63f1468507273b1a77c86d740d435 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/Imakefile
+++ b/cde/programs/dtinfo/dtinfogen/infolib/Imakefile
@@ -10,9 +10,9 @@ LinkFile(C,C.ISO-8859-1)
 XCOMM redefine TopLevelProject to build DtInfo with standard CDE config dir
 #undef  TopLevelProject
 #define TopLevelProject                DtInfo
-IMAKE_DEFINES = -DTopLevelProject=TopLevelProject \
-               -DProjectTmplFile='<DtInfo.tmpl>' \
-               -DProjectRulesFile='<DtInfo.rules>'
+IMAKE_DEF_DTINFO =  -DTopLevelProject=TopLevelProject \
+                   -DProjectTmplFile='<DtInfo.tmpl>' \
+                   -DProjectRulesFile='<DtInfo.rules>'
 
 XCOMM Variables to switch on debug mode temporarily
 XCOMM CDEBUGFLAGS = -g -DDEBUG
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeData.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeData.C
index a5aea4731a1ae7397a1e0b2be143786b2bacab2f..7330d5186feef76fa9b186fb703902b6f054f37b 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeData.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeData.C
@@ -36,7 +36,7 @@ AttributeData::AttributeData( const Token &t,
 {
 
   const char *str;
-  if ( str = attribute_value( t, attr_name ) ) {
+  if ( (str = attribute_value( t, attr_name )) ) {
     data_complete = 1;
     ValueBuffer.writeStr( str );
   }
@@ -74,5 +74,8 @@ AttributeData::attribute_value( const Token &t, int attributeName )
            att_type == SGMLName::TOKEN ){
     return ( tmp->getAttrValueString() );
   }
+  else {
+    return 0;
+  }
 }
 
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeRec.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeRec.C
index b7851552c8dcca42a5b27fcf8a03a3c9c8190df7..444430eeff517dfa0e97aa980520ad1d51d51602 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeRec.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/AttributeRec.C
@@ -46,6 +46,7 @@ AttributeRec::AttributeRec( const char *name,
                              "type = %d", name, value, type));
 #endif
   
+  int len;
   next=NULL;
   attName = SGMLName::intern( name );
 
@@ -63,8 +64,9 @@ AttributeRec::AttributeRec( const char *name,
 
   case SGMLName::CDATA:
     attValue = -1;
-    attValueString = copy = new char[ strlen(value) + 1 ];
-    strcpy( copy, value );
+    len = strlen(value);
+    attValueString = copy = new char[len + 1];
+    *((char *) memcpy(copy, value, len) + len) = '\0';
     break;
 
   default:
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/AusText.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/AusText.C
index 875a7dfd44112aaadb1e8a402047083d2d9a7fde..853fd250e87312070a71b2d8dcae88bbf983a29e 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/AusText.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/AusText.C
@@ -90,7 +90,7 @@ AusText::write_start_tag ( const Token &t)
   
   int level = t.level();
   
-  if ( a = t.LookupAttr( OLAF::OL_scope ) ) {
+  if ( (a = t.LookupAttr( OLAF::OL_scope )) ) {
 
     switch ( a->getAttValue() ) {
 
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/AusTextStorage.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/AusTextStorage.C
index bedb406fef5e7b412e1d1f2649f5dc837c6d3db1..4611b8ef4bf1bf19d018773321c1c1f8b89e40b9 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/AusTextStorage.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/AusTextStorage.C
@@ -239,14 +239,15 @@ AusTextStore::AusTextStore( const char *path, const char *name )
     makedir(path);
   }
 
-  austext_path = new char [ strlen(path) + 1 + strlen("dtsearch") + 1 ];
+  int textlen = strlen(path) + 1 + strlen("dtsearch") + 1;
+  austext_path = new char [ textlen ];
   /*
    * throw(ResourceExhausted)
    *
    */
   assert ( austext_path != NULL );
   
-  sprintf( austext_path, "%s/dtsearch", path );
+  snprintf( austext_path, textlen, "%s/dtsearch", path );
   
   if ( !isdir(austext_path) ) {
     makedir(austext_path);
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/BookTasks.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/BookTasks.C
index d6a18d4e7a2fadefed54f2acea520bbc451c00f4..8cc4393b83223b0a7327ae642ab06f4613fbd5d2 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/BookTasks.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/BookTasks.C
@@ -75,8 +75,9 @@ const int A_DEFAULT_SECTION = OLAF::DefaultSection;
   
 BookCaseTask::BookCaseTask(const char *infolib)
 {
-  library = new char[strlen(infolib)+1];
-  strcpy(library, infolib);
+  int len = strlen(infolib);
+  library = new char[len + 1];
+  *((char *) memcpy(library, infolib, len) + len) = '\0';
 
   f_base = -1;
 
@@ -533,16 +534,17 @@ void BookTask::write_record(void)
     tabFiles->append(tabLocator->filename());
   }
       
-  for(int i = 0; i < tabNames->qty(); i++){
+  for(unsigned int i = 0; i < tabNames->qty(); i++){
     const char *name = tabNames->item(i);
     const char *loc = tabLocators->item(i);
     const char *line = tabLines->item(i);
     const char *file = tabFiles->item(i);
 
-    char *p = new char [strlen(name) + 1 + strlen(loc) + 1 
-                        + strlen(line) + 1 + strlen(file) + 1];
+    int plen = strlen(name) + 1 + strlen(loc) + 1
+                           + strlen(line) + 1 + strlen(file) + 1;
+    char *p = new char [plen];
 
-    sprintf(p, "%s\t%s\t%s\t%s", name, loc, line, file);
+    snprintf(p, plen, "%s\t%s\t%s\t%s", name, loc, line, file);
     tablines.append(p);
 
     delete p;
@@ -569,7 +571,7 @@ void BookTask::write_record(void)
                STRING_CODE, bk_title,
                INTEGER_CODE, f_seq_no,
                SHORT_LIST_CODE, tablines.qty(), STRING_CODE, tablines.array(),
-               -STRING_CODE, e_string , e_len,
+               -STRING_CODE, e_string , (size_t)e_len,
                NULL);
 
 #ifdef FISH_DEBUG
@@ -617,8 +619,9 @@ const char *BookTask::locator()
      * is the TOC node locator!
      */
     const char *l = f_node->locator();
-    tocLocator = new char[strlen(l) + 1];
-    strcpy(tocLocator, l);
+    int len = strlen(l);
+    tocLocator = new char[len + 1];
+    *((char *) memcpy(tocLocator, l, len) + len) = '\0';
   }
   
   return tocLocator;
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/ContentType.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/ContentType.C
index b0b81eabd99c16acaf956354efc6c4ea920fba51..fb5d9170f7ba127967b2242ede058d0b91aab6dd 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/ContentType.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/ContentType.C
@@ -251,7 +251,7 @@ static int dbgLevel = -1;
 
 static short int ol_data_nxt[][256] =
     {
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+     {  0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
@@ -278,9 +278,9 @@ static short int ol_data_nxt[][256] =
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0 },
 
-        3,    4,    4,    4,    4,    4,    4,    4,    4,    5,
+     {  3,    4,    4,    4,    4,    4,    4,    4,    4,    5,
         6,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    5,    4,    7,    8,    4,    4,    4,    9,
@@ -307,9 +307,9 @@ static short int ol_data_nxt[][256] =
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    4,    4,    4,    4,
+        4,    4,    4,    4,    4,    4 },
 
-        3,    4,    4,    4,    4,    4,    4,    4,    4,    5,
+     {  3,    4,    4,    4,    4,    4,    4,    4,    4,    5,
         6,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    5,    4,    7,    8,    4,    4,    4,    9,
@@ -336,9 +336,9 @@ static short int ol_data_nxt[][256] =
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    4,    4,    4,    4,
+        4,    4,    4,    4,    4,    4 },
 
-       -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
+     { -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
@@ -365,9 +365,9 @@ static short int ol_data_nxt[][256] =
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
-       -3,   -3,   -3,   -3,   -3,   -3,
+       -3,   -3,   -3,   -3,   -3,   -3 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,   -4,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,   -4,
        -4,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   -4,   15,   15,   15,   15,   15,   15,   15,
@@ -394,9 +394,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   16,
+     {  3,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   16,
        16,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   16,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
@@ -423,9 +423,9 @@ static short int ol_data_nxt[][256] =
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
-       -5,   -5,   -5,   -5,   -5,   -5,
+       -5,   -5,   -5,   -5,   -5,   -5 },
 
-        3,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   16,
+     {  3,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   16,
        16,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   16,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
@@ -452,9 +452,9 @@ static short int ol_data_nxt[][256] =
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
-       -6,   -6,   -6,   -6,   -6,   -6,
+       -6,   -6,   -6,   -6,   -6,   -6 },
 
-        3,   17,   17,   17,   17,   17,   17,   17,   17,   18,
+     {  3,   17,   17,   17,   17,   17,   17,   17,   17,   18,
        18,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   18,   17,   19,   17,   17,   17,   17,   17,
@@ -481,9 +481,9 @@ static short int ol_data_nxt[][256] =
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
-       17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,   -8,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,   -8,
        -8,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   -8,   15,   15,   15,   15,   15,   15,   15,
@@ -510,9 +510,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   21,   21,   21,   21,   21,   21,   21,   21,   22,
+     {  3,   21,   21,   21,   21,   21,   21,   21,   21,   22,
        22,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   22,   21,   21,   21,   21,   21,   21,   23,
@@ -539,9 +539,9 @@ static short int ol_data_nxt[][256] =
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
-       21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21 },
 
-        3,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
+     {  3,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
@@ -568,9 +568,9 @@ static short int ol_data_nxt[][256] =
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
-      -10,  -10,  -10,  -10,  -10,  -10,
+      -10,  -10,  -10,  -10,  -10,  -10 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -11,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -11,
       -11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -11,   15,   15,   15,   15,   15,   15,   15,
@@ -597,9 +597,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -12,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -12,
       -12,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -12,   15,   15,   15,   15,   15,   15,   15,
@@ -626,9 +626,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -13,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -13,
       -13,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -13,   15,   15,   15,   15,   15,   15,   15,
@@ -655,9 +655,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -14,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -14,
       -14,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -14,   15,   15,   15,   15,   15,   15,   15,
@@ -684,9 +684,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -15,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -15,
       -15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -15,   15,   15,   15,   15,   15,   15,   15,
@@ -713,9 +713,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,   16,
+     {  3,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,   16,
        16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,   16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
@@ -742,9 +742,9 @@ static short int ol_data_nxt[][256] =
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
-      -16,  -16,  -16,  -16,  -16,  -16,
+      -16,  -16,  -16,  -16,  -16,  -16 },
 
-        3,   17,   17,   17,   17,   17,   17,   17,   17,   18,
+     {  3,   17,   17,   17,   17,   17,   17,   17,   17,   18,
        18,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   18,   17,   19,   17,   17,   17,   17,   17,
@@ -771,9 +771,9 @@ static short int ol_data_nxt[][256] =
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
-       17,   17,   17,   17,   17,   17,
+       17,   17,   17,   17,   17,   17 },
 
-        3,   18,   18,   18,   18,   18,   18,   18,   18,   18,
+     {  3,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   28,   18,   18,   18,   18,   18,
@@ -800,9 +800,9 @@ static short int ol_data_nxt[][256] =
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
-       18,   18,   18,   18,   18,   18,
+       18,   18,   18,   18,   18,   18 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -19,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -19,
       -19,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -19,   15,   15,   15,   15,   15,   15,   15,
@@ -829,9 +829,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -20,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -20,
       -20,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -20,   15,   15,   15,   15,   15,   15,   15,
@@ -858,9 +858,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   21,   21,   21,   21,   21,   21,   21,   21,   22,
+     {  3,   21,   21,   21,   21,   21,   21,   21,   21,   22,
        22,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   22,   21,   21,   21,   21,   21,   21,   23,
@@ -887,9 +887,9 @@ static short int ol_data_nxt[][256] =
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
-       21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21 },
 
-        3,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+     {  3,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   30,
@@ -916,9 +916,9 @@ static short int ol_data_nxt[][256] =
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
-       22,   22,   22,   22,   22,   22,
+       22,   22,   22,   22,   22,   22 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -23,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -23,
       -23,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -23,   15,   15,   15,   15,   15,   15,   15,
@@ -945,9 +945,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -24,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -24,
       -24,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -24,   15,   15,   15,   15,   15,   15,   15,
@@ -974,9 +974,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -25,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -25,
       -25,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -25,   15,   15,   15,   15,   15,   15,   15,
@@ -1003,9 +1003,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -26,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -26,
       -26,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -26,   15,   15,   15,   15,   15,   15,   15,
@@ -1032,9 +1032,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -27,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -27,
       -27,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -27,   15,   15,   15,   15,   15,   15,   15,
@@ -1061,9 +1061,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
+     {  3,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
@@ -1090,9 +1090,9 @@ static short int ol_data_nxt[][256] =
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
-      -28,  -28,  -28,  -28,  -28,  -28,
+      -28,  -28,  -28,  -28,  -28,  -28 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -29,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -29,
       -29,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -29,   15,   15,   15,   15,   15,   15,   15,
@@ -1119,9 +1119,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
+     {  3,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
@@ -1148,9 +1148,9 @@ static short int ol_data_nxt[][256] =
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
-      -30,  -30,  -30,  -30,  -30,  -30,
+      -30,  -30,  -30,  -30,  -30,  -30 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -31,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -31,
       -31,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -31,   15,   15,   15,   15,   15,   15,   15,
@@ -1177,9 +1177,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -32,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -32,
       -32,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -32,   15,   15,   15,   15,   15,   15,   15,
@@ -1206,9 +1206,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -33,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -33,
       -33,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -33,   15,   15,   15,   15,   15,   15,   15,
@@ -1235,9 +1235,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -34,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -34,
       -34,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -34,   15,   15,   15,   15,   15,   15,   15,
@@ -1264,9 +1264,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -35,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -35,
       -35,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -35,   15,   15,   15,   15,   15,   15,   15,
@@ -1293,9 +1293,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -36,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -36,
       -36,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -36,   15,   15,   15,   15,   15,   15,   15,
@@ -1322,9 +1322,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -37,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -37,
       -37,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -37,   15,   15,   15,   15,   15,   15,   15,
@@ -1351,9 +1351,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -38,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -38,
       -38,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -38,   15,   15,   15,   15,   15,   15,   15,
@@ -1380,9 +1380,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -39,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -39,
       -39,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -39,   15,   15,   15,   15,   15,   15,   15,
@@ -1409,9 +1409,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -40,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -40,
       -40,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -40,   15,   15,   15,   15,   15,   15,   15,
@@ -1438,9 +1438,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -41,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -41,
       -41,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -41,   15,   15,   15,   15,   15,   15,   15,
@@ -1467,9 +1467,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -42,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -42,
       -42,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -42,   15,   15,   15,   15,   15,   15,   15,
@@ -1496,9 +1496,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -43,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -43,
       -43,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -43,   15,   15,   15,   15,   15,   15,   15,
@@ -1525,9 +1525,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -44,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -44,
       -44,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -44,   15,   15,   15,   15,   15,   15,   15,
@@ -1554,9 +1554,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -45,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -45,
       -45,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -45,   15,   15,   15,   15,   15,   15,   15,
@@ -1583,9 +1583,9 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-        3,   15,   15,   15,   15,   15,   15,   15,   15,  -46,
+     {  3,   15,   15,   15,   15,   15,   15,   15,   15,  -46,
       -46,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,  -46,   15,   15,   15,   15,   15,   15,   15,
@@ -1612,7 +1612,7 @@ static short int ol_data_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15
+       15,   15,   15,   15,   15,   15 }
 
     } ;
 
@@ -1746,7 +1746,9 @@ static int ol_data_did_buffer_switch_on_eof;
 static ol_data_state_type ol_data_get_previous_state ol_data_PROTO(( void ));
 static ol_data_state_type ol_data_try_NUL_trans ol_data_PROTO(( ol_data_state_type current_state ));
 static int ol_data_get_next_buffer ol_data_PROTO(( void ));
+#if 0
 static void ol_dataunput ol_data_PROTO(( ol_data_CHAR c, ol_data_CHAR *buf_ptr ));
+#endif
 void ol_datarestart ol_data_PROTO(( FILE *input_file ));
 void ol_data_switch_to_buffer ol_data_PROTO(( ol_data_BUFFER_STATE new_buffer ));
 void ol_data_load_buffer_state ol_data_PROTO(( void ));
@@ -1851,11 +1853,9 @@ case 2:
                                      // get rid of the 2 quotes 
                                      int len = strlen(( const char *)ol_datatext)-2;
                                      char *lit_str = new char [ len + 1 ];
-                                     strncpy ( lit_str, 
-                                               (const char *)ol_datatext + 1, 
-                                               len );
-
-                                     *(lit_str + len) = '\0';
+                                     *((char *) memcpy(lit_str,
+                                                (const char *)ol_datatext + 1,
+                                                 len) + len) = '\0';
                                      ol_datalval.string = lit_str;
                                   }
                                   else {
@@ -1874,11 +1874,9 @@ case 3:
                                      // get rid of the 2 quotes 
                                      int len = strlen(( const char *)ol_datatext)-2;
                                      char *lit_str = new char [ len + 1 ];
-                                     strncpy ( lit_str, 
-                                               (const char *)ol_datatext + 1, 
-                                               len );
-
-                                     *(lit_str + len) = '\0';
+                                     *((char *) memcpy(lit_str,
+                                                (const char *)ol_datatext + 1,
+                                                 len) + len) = '\0';
                                      ol_datalval.string = lit_str;
                                      
                                   }
@@ -2203,6 +2201,7 @@ register ol_data_state_type ol_data_current_state;
     }
 
 
+#if 0
 #ifdef ol_data_USE_PROTOS
 static void ol_dataunput( ol_data_CHAR c, register ol_data_CHAR *ol_data_bp )
 #else
@@ -2246,6 +2245,7 @@ register ol_data_CHAR *ol_data_bp;
      */
     ol_data_DO_BEFORE_ACTION; /* set up ol_datatext again */
     }
+#endif
 
 
 #ifdef __cplusplus
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.C
index 00f01c8ed5a3564cd82f02acc8adbc3343342248..192098cc1422d1764578ca5921fb21fcc63beaf6 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.C
@@ -53,8 +53,9 @@
 
 DB::DB(const char *name)
 {
-  f_name = new char[strlen(name)+1];
-  strcpy(f_name, name);
+  int len = strlen(name);
+  f_name = new char[len + 1];
+  *((char *) memcpy(f_name, name, len) + len) = '\0';
 }
 
 
@@ -116,8 +117,9 @@ DBTable::DBTable(DB *database, int schema_code, int cols, const char *name)
   f_schema_code = schema_code;
   f_cols = cols;
 
-  f_name = new char[strlen(name)+1];
-  strcpy(f_name, name);
+  int len = strlen(name);
+  f_name = new char[len + 1];
+  *((char *) memcpy(f_name, name, len) + len) = '\0';
 
   f_file = NULL;
   f_start = 0;
@@ -142,8 +144,9 @@ DBTable::file(DB::Access access)
     }else{
 
       const char *p = f_database->path();
-      char *path = new char[strlen(p) + 1 + strlen(f_name) + 1];
-      sprintf(path, "%s/%s", p, f_name);
+      int pathlen = strlen(p) + 1 + strlen(f_name) + 1;
+      char *path = new char[pathlen];
+      snprintf(path, pathlen, "%s/%s", p, f_name);
       
       f_file = fopen(path, access == DB::CREATE ? "w" : "r");
       
@@ -500,6 +503,7 @@ void DBCursor::short_list(FILE *fp, int *qout, int ltype, void *out)
        
        ungetc(c, fp);
        ret = fscanf(fp, "%d\n", &ftype);
+       if(ret == 0) throw(PosixError(errno, "Unable to fscanf\n"));
        FRIENDLY_ASSERT(ftype == STRING_CODE);
        
        string_field(fp, &item, NULL);
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.h b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.h
index bc9497c1059dfe6148fa4b13089d7b05af0fc35f..1a34d70e9df2bd8478c1894d50bc5d5c984f4673 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.h
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataBase.h
@@ -39,7 +39,8 @@ public:
   enum { MAXMSG = 200 };
   
   PosixError(int error_no, const char *msg)
-  { f_errno = error_no; strncpy(f_msg, msg, MAXMSG+1); };
+  { f_errno = error_no;
+    *((char *) memcpy(f_msg, msg, MAXMSG+1) + MAXMSG+1) = '\0'; };
 
   const char *msg(void) const { return f_msg; };
   int error_no(void) const { return f_errno; };
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataRepository.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataRepository.C
index de929d86e4d779c64d21562f16485e5df7dfa4af..efb73ef36aa6f6208eeaf6d2e158b3d80181160f 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataRepository.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataRepository.C
@@ -91,7 +91,7 @@ DataRepository::deActivateZone( int level )
     return;
   }
   
-  Rec ZoneRec = zone_stack->pop();
+  zone_stack->pop();
 
   // update the current_buf 
   if ( !zone_stack->empty() ) {
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataTask.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataTask.C
index 599e9c2a1665ac837d80f924191c4a93b3213461..b03d7ee48383f0036cd70ec86762729e2d2ef2fd 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/DataTask.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/DataTask.C
@@ -47,6 +47,10 @@ void DataTask::markup(const Token &t)
     
   case END:
     if(level > 0) level--;
+    break;
+
+  default:
+    break;
   }
 }
 
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/Dispatch.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/Dispatch.C
index 4abdf873bbe342b75db9eacb2d9c45e46d80f0c8..eaf9cf0a2e23d3eb23d5a08653dce322470b7436 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/Dispatch.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/Dispatch.C
@@ -103,6 +103,8 @@ Dispatch::token(TOKEN_TYPE tokType, unsigned char *Name )
                      "Unable to find entity definition for %.50s", Name);
     }
     break;
+  default:
+    break;
   }
   
 
@@ -168,9 +170,10 @@ Dispatch::entity_decl( SGMLDefn *defn )
 void
 Dispatch::file(const char *f)
 {
+  int len = strlen(f);
   delete f_file;
-  f_file = new char[strlen(f)+1];
-  strcpy(f_file, f);
+  f_file = new char[len + 1];
+  *((char *) memcpy(f_file, f, len) + len) = '\0';
 
   
   /*
@@ -184,7 +187,8 @@ Dispatch::file(const char *f)
       *p = '\0';
     }
     else {
-      strcpy( dirname,"." );
+      len = MIN(strlen(dirname), 1);
+      *((char *) memcpy(dirname, ".", len) + len) = '\0';
     }
     
     search_path_table->replace_file_scope( dirname );
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/FlexBuffer.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/FlexBuffer.C
index 22c063400417783cf69e543200d4e57874aeaf55..1d2b7425d5bc668be273842b639d88fc6fd2a189 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/FlexBuffer.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/FlexBuffer.C
@@ -45,7 +45,7 @@ FlexBuffer::FlexBuffer()
 void
 FlexBuffer::grow(size_t needed)
 {
-  if(needed + 1 > maxSize){
+  if(needed + 1 > (size_t) maxSize){
     char *born = new char[maxSize = needed * 3 / 2 + 10];
     
     if(pos){
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/GenericId.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/GenericId.C
index fc300fe5f3ef60bba282d90955f95383d0fad8ff..d42757aa4015424dbf7e4dc18f85825319e36e4c 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/GenericId.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/GenericId.C
@@ -83,7 +83,7 @@ GenericId::markup( const Token &t )
 
     if ( f_base == t.level() && !done ) {
 
-      if ( data_complete = f_data->DataIsComplete() ) {
+      if ( (data_complete = f_data->DataIsComplete()) ) {
        ValueBuffer.writeStr( f_data->content() );
       }
 
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/GraphicsTask.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/GraphicsTask.C
index 689a790bd8832ceac9cb301685bc0ccc8330c9e1..1cf78def813a0f68b162f15beccbee627cb272b4 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/GraphicsTask.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/GraphicsTask.C
@@ -206,8 +206,8 @@ GraphicsTask::write_record( const Token &t )
    */
 
   FlexBuffer graphics_buffer;
-  const char *size_info;
-  int graphics_available=0;
+  const char *size_info = NULL;
+  int graphics_available = 0;
   
     
   FILE *gp;
@@ -257,6 +257,9 @@ GraphicsTask::write_record( const Token &t )
        }
        break;
 
+      default:
+       break;
+
       }
 
       size_info = form("%d.%d.%s",
@@ -288,7 +291,7 @@ GraphicsTask::write_record( const Token &t )
                STRING_CODE, "v0",
                STRING_CODE, graphics_available?size_info : "0.0.0.0.0.0",
                -STRING_CODE, graphics_buffer.GetBuffer(),
-                             graphics_buffer.GetSize(),
+                             (size_t)graphics_buffer.GetSize(),
                STRING_CODE, f_title?f_title->content():"",
                NULL);
 
@@ -299,7 +302,8 @@ GraphicsTask::write_record( const Token &t )
                 STRING_CODE, "v0",
                 STRING_CODE, "@@ type info",
                 COMPRESSED_STRING_CODE, "@@ CompressedAgent",
-                -STRING_CODE, graphics_buffer.GetBuffer(), graphics_buffer.GetBSize(),
+                -STRING_CODE, graphics_buffer.GetBuffer(),
+                              (size_t)graphics_buffer.GetBSize(),
                 STRING_CODE, "@@ graphics title" );
       }
 
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/MixedGen.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/MixedGen.C
index e51766a6b0aca9e79869d7bb15f6e1da8600b5be..2836206d47aff46988568c68ec7b553309c5b4dc 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/MixedGen.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/MixedGen.C
@@ -274,8 +274,9 @@ locator_table( BookCaseDB& db,
                    INTEGER_CODE, &line_num,
                    NULL)){
 
-  char *buf = new char[strlen(nodeloc) + strlen(reflabel) + 2];
-  sprintf(buf, "%s\t%s", nodeloc, reflabel);
+  int buflen = strlen(nodeloc) + strlen(reflabel) + 2;
+  char *buf = new char[buflen];
+  snprintf(buf, buflen, "%s\t%s", nodeloc, reflabel);
     
     CC_String *loc_collect = new CC_String( locator );
     BTCollectable *node_collect = new BTCollectable( filename, 
@@ -403,8 +404,9 @@ writeCCF(BookCaseDB& db,
       // It will just loop through all the tabs, and report all the bad ones
       if ( !exception_flag ) {
        const char *tabOID = to_oid(mmdb, bcname, loc);
-       char *result = new char[nameLen + 1 + strlen(tabOID) + 1];
-       sprintf(result, "%s\t%s", name, tabOID );
+       int resultlen = nameLen + 1 + strlen(tabOID) + 1;
+       char *result = new char[resultlen];
+       snprintf(result, resultlen, "%s\t%s", name, tabOID );
        heap.add(result);
       }
     }
@@ -687,7 +689,6 @@ writeSGML(BookCaseDB &db,
   size_t dataLen;
   const char *data;
   char *bufptr;                // Walk through SGML data stream and update LAST fields
-  char *nevermind;     // We don't care about the return value from the parse
 
   while(sgml_cursor.next(STRING_CODE, &aBook,
                    STRING_CODE, &nodeLoc,
@@ -707,14 +708,14 @@ writeSGML(BookCaseDB &db,
     FlexBuffer new_node_buffer;
     
     bufptr = (char *) data;
-    nevermind = parse4last( bufptr );
+    parse4last( bufptr );
 
     insert_remotelink( &hd, (char *)data, dataLen, &new_node_buffer);
     
     out->insert_untagged(STRING_CODE, nodeLoc,
                         -STRING_CODE,
                         new_node_buffer.GetBuffer(),
-                        new_node_buffer.GetSize(),
+                        (size_t)new_node_buffer.GetSize(),
                         NULL);
   }
 
@@ -767,7 +768,7 @@ writeGraphics(BookCaseDB &db, const char *thisBook, DBCursor &gr_cursor,
                  STRING_CODE, name,
                  STRING_CODE, version,
                  STRING_CODE, typeInfo,
-                 -COMPRESSED_STRING_CODE, comp_agent, data, len,
+                 -COMPRESSED_STRING_CODE, comp_agent, data, (size_t)len,
                  STRING_CODE, title,
                  NULL);
     }
@@ -776,7 +777,7 @@ writeGraphics(BookCaseDB &db, const char *thisBook, DBCursor &gr_cursor,
                  STRING_CODE, name,
                  STRING_CODE, version,
                  STRING_CODE, typeInfo,
-                 -STRING_CODE, data, len,
+                 -STRING_CODE, data, (size_t)len,
                  STRING_CODE, title,
                  NULL);
     }
@@ -809,7 +810,7 @@ writeBooks(BookCaseDB& db,
   DBTable *sgml = db.table(BookCaseDB::NodeSGML, DB::READ);
   DBCursor SgmlCursor(*sgml);
 
-  DBCursor *GraphicsCursorPtr;
+  DBCursor *GraphicsCursorPtr = NULL;
   
   int process_graphics = 1;
   mtry {
@@ -925,7 +926,7 @@ usage(const char *progname)
 }
 
 
-main(int argc, char **argv)
+int main(int argc, char **argv)
 {
   INIT_EXCEPTIONS();
   
@@ -988,6 +989,7 @@ main(int argc, char **argv)
            form("%s.%s", bcname, "ps.dict"));
 
        x->its_oid().asciiOut(str_buf);
+       memcpy(comp_agent, str_buf.str().c_str(), COMPRESSED_AGENT_SIZE);
       }
 
       hashTable<CC_String, BTCollectable> hd(hash_func);
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/NCFGen.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/NCFGen.C
index 2ebd4e4c6f5398096182590b04eb8fc72ce8342f..2293bb9a1cc58711480fcf2e6fb3ed4991a5ab18 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/NCFGen.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/NCFGen.C
@@ -85,12 +85,12 @@ writeStyleSheets(BookCaseDB& db)
                    -STRING_CODE, &online, &len_o,
                    -STRING_CODE, &print, &len_p,
                    NULL)){
-    if( statusO=validate_stylesheet( online, len_o, ONLINE )){
+    if( (statusO=validate_stylesheet( online, len_o, ONLINE ))){
       Token::signalError(Token::User, Token::Continuable, 0, 0,
                         "Online style sheet for `%s' is invalid.", name);
     }
     
-    if( statusP=validate_stylesheet( print, len_p, PRINT )){
+    if( (statusP=validate_stylesheet( print, len_p, PRINT ))){
       Token::signalError(Token::User, Token::Continuable, 0, 0,
                         "Print style sheet for `%s' is invalid.", name);
     }
@@ -100,8 +100,8 @@ writeStyleSheets(BookCaseDB& db)
     }
     
     out->insert(STRING_CODE, name,
-               -STRING_CODE, online, len_o,
-               -STRING_CODE, print, len_p,
+               -STRING_CODE, online, (size_t)len_o,
+               -STRING_CODE, print, (size_t)len_p,
                NULL);
   }
 
@@ -155,6 +155,7 @@ buildNCF(BookCaseDB& db, const char *base_name, int compressed)
     handler *x = (base_ptr->get_obj_dict()).get_handler(
       form("%s.%s", base_name, "sgml.dict"));
     x->its_oid().asciiOut(str_buf);
+    memcpy(comp_agent, str_buf.str().c_str(), COMPRESSED_AGENT_SIZE);
     
 
     while(cursor.next(STRING_CODE, &bookLocator,
@@ -251,8 +252,11 @@ buildNCF(BookCaseDB& db, const char *base_name, int compressed)
       
       
       stylesheet_smart_ptr sheet(base_ptr, style);
-      ostringstream strout;
+      char oid_buf[BUFSIZE];
+      ostringstream strout(oid_buf);
       sheet.its_oid().asciiOut(strout);
+      strout << ends;
+      memcpy(oid_buf, strout.str().c_str(), BUFSIZE);
       
       ncf->insert(STRING_CODE, nodeLocator,
                  STRING_CODE, title,
@@ -260,7 +264,7 @@ buildNCF(BookCaseDB& db, const char *base_name, int compressed)
                  STRING_CODE, "",
                  STRING_CODE, bookLocator,
                  OID_CODE, "0.0", /* pointer to Book/CCF/DOC object */
-                 OID_CODE, (char *)strout.str().c_str(),
+                 OID_CODE, oid_buf,
                  NULL);
     }
     
@@ -285,7 +289,7 @@ usage(const char *progname)
 }
 
 //-------------------------------------------------------------------------
-main(int argc, char **argv)
+int main(int argc, char **argv)
 {
   INIT_EXCEPTIONS();
 
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeData.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeData.C
index e7249732e9db19ba5d2b353e97ff81d7c8e0459d..d8120a9c15faa876bce47eb700fe1a879c25a3fa 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeData.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeData.C
@@ -425,7 +425,7 @@ NodeData::write_record()
   DBTable *tbl = f_node->book()->bookcase()->table(BookCaseDB::NodeSGML);
   tbl->insert(STRING_CODE,  TocLocator,
              STRING_CODE,  NodeLocator,
-             -STRING_CODE, DbBuffer->GetBuffer(), DbBuffer->GetSize(),
+             -STRING_CODE, DbBuffer->GetBuffer(), (size_t)DbBuffer->GetSize(),
              NULL);
 
   /*
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeTask.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeTask.C
index 08323e4800ee7837a8c9c3c3938dde219f278549..c5fdfd6c620a7961c968a76914288921d5a73aef 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeTask.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/NodeTask.C
@@ -56,7 +56,7 @@ using namespace std;
 static int findDigits( int num ) 
 {
   char str[NUM_FIELDS+1];
-  sprintf( str, "%d", num );
+  snprintf( str, NUM_FIELDS+1, "%d", num );
   return( strlen(str) );
 }
 
@@ -301,16 +301,18 @@ int NodeTask::formatOrd(char * buf, int max)
   int ord_len = findDigits( ord );
 
   if ( ord_len > NUM_FIELDS ) {
-    throw(Unexpected(form("No. of sections = %d have exceeded the maximum number of sections allowed at one level\n", ord )));
+    throw(Unexpected(form("No. of sections = %d have exceeded"
+                         " the maximum number of sections allowed"
+                         " at one level\n", ord )));
   }
   
   if(f_parent == NULL){
     int buflen = strlen(buf);
     assert( buflen + NUM_FIELDS < max );
 
-    sprintf(buf, "%05d", ord); /* we assume max is
-                               * big enough to format one int
-                               */
+    snprintf(buf, NUM_FIELDS + 1, "%05d", ord);  /* we assume max is big
+                                                 * enough to format one int
+                                                 */
     ret = buflen + NUM_FIELDS;
 
   }else{
@@ -319,7 +321,7 @@ int NodeTask::formatOrd(char * buf, int max)
     int buflen = ret;
     assert ( buflen + NUM_FIELDS + 1< max );
 
-    sprintf(buf + buflen, ".%05d", ord);
+    snprintf(buf + buflen, NUM_FIELDS + 2, ".%05d", ord);
     ret = buflen + NUM_FIELDS + 1;
 
   }
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/OL-Data.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/OL-Data.C
index e61633446c9bcde3ccfe6c540a06a22d20dddd9a..f32f91695dee21d9783a547f55291cf6def2332c 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/OL-Data.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/OL-Data.C
@@ -153,7 +153,7 @@ OL_Data::OL_Data( const Token &t,
       {
        BaseData *sub_data = new AttributeData(t, eptr->name(), mode );
        if ( sub_data ) {
-         if (  data_avail= sub_data->DataWillBeAvailable() ) {
+         if ( (data_avail= sub_data->DataWillBeAvailable()) ) {
            ValueBuffer.write( sub_data->content(),
                               sub_data->content_size() );
            data_complete = 1;
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/OL_DataExpr.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/OL_DataExpr.C
index c38c86f6c9b29305bdd76d4ed758f0d928a43c8d..3b7a684ce400666e41adea2412906b2b81e04cf3 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/OL_DataExpr.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/OL_DataExpr.C
@@ -22,7 +22,7 @@
  */
 /* $TOG: OL_DataExpr.C /main/4 1997/12/23 11:38:27 bill $ */
 #ifndef lint
-static char ol_datasccsid[] = "@(#)yaccpar     1.8 (Berkeley) 01/20/90";
+static const char ol_datasccsid[] = "@(#)yaccpar       1.8 (Berkeley) 01/20/90";
 #endif
 #define ol_dataBYACC 1
 #line 2 "OL_DataExpr.y"
@@ -171,7 +171,7 @@ ol_dataparse()
 #if ol_dataDEBUG
     register char *ol_datas;
 
-    if (ol_datas = getenv("ol_dataDEBUG"))
+    if ((ol_datas = getenv("ol_dataDEBUG")))
     {
         ol_datan = *ol_datas;
         if (ol_datan >= '0' && ol_datan <= '9')
@@ -188,7 +188,7 @@ ol_dataparse()
     *ol_datassp = ol_datastate = 0;
 
 ol_dataloop:
-    if (ol_datan = ol_datadefred[ol_datastate]) goto ol_datareduce;
+    if ((ol_datan = ol_datadefred[ol_datastate])) goto ol_datareduce;
     if (ol_datachar < 0)
     {
         if ((ol_datachar = ol_datalex()) < 0) ol_datachar = 0;
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/RemoteId.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/RemoteId.C
index f5f892c731ff98af08141fae68762fb187aa9672..e8701f00f5d49c55f69cdc36cbcd31909d1f68e0 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/RemoteId.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/RemoteId.C
@@ -229,7 +229,7 @@ static char *current_file_name;
 #define OLIDREF_FILE 3
 static short int remote_nxt[][256] =
     {
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+     {  0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
@@ -256,9 +256,9 @@ static short int remote_nxt[][256] =
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0 },
 
-        9,   10,   10,   10,   10,   10,   10,   10,   10,   10,
+     {  9,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        11,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
@@ -285,9 +285,9 @@ static short int remote_nxt[][256] =
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
-       10,   10,   10,   10,   10,   10,
+       10,   10,   10,   10,   10,   10 },
 
-        9,   10,   10,   10,   10,   10,   10,   10,   10,   10,
+     {  9,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        11,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
@@ -314,9 +314,9 @@ static short int remote_nxt[][256] =
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
-       10,   10,   10,   10,   10,   10,
+       10,   10,   10,   10,   10,   10 },
 
-        9,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+     {  9,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   14,   13,
@@ -343,9 +343,9 @@ static short int remote_nxt[][256] =
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
-       13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13 },
 
-        9,   13,   13,   13,   13,   13,   13,   13,   13,   13,
+     {  9,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   14,   13,
@@ -372,9 +372,9 @@ static short int remote_nxt[][256] =
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
-       13,   13,   13,   13,   13,   13,
+       13,   13,   13,   13,   13,   13 },
 
-        9,   16,   16,   16,   16,   16,   16,   16,   16,   16,
+     {  9,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
@@ -401,9 +401,9 @@ static short int remote_nxt[][256] =
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
-       16,   16,   16,   16,   16,   16,
+       16,   16,   16,   16,   16,   16 },
 
-        9,   16,   16,   16,   16,   16,   16,   16,   16,   16,
+     {  9,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
@@ -430,9 +430,9 @@ static short int remote_nxt[][256] =
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
        16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
-       16,   16,   16,   16,   16,   16,
+       16,   16,   16,   16,   16,   16 },
 
-        9,   18,   18,   18,   18,   18,   18,   18,   18,   18,
+     {  9,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
@@ -459,9 +459,9 @@ static short int remote_nxt[][256] =
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
-       18,   18,   18,   18,   18,   18,
+       18,   18,   18,   18,   18,   18 },
 
-        9,   18,   18,   18,   18,   18,   18,   18,   18,   18,
+     {  9,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
@@ -488,9 +488,9 @@ static short int remote_nxt[][256] =
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
        18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
-       18,   18,   18,   18,   18,   18,
+       18,   18,   18,   18,   18,   18 },
 
-       -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
+     { -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
@@ -517,9 +517,9 @@ static short int remote_nxt[][256] =
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
-       -9,   -9,   -9,   -9,   -9,   -9,
+       -9,   -9,   -9,   -9,   -9,   -9 },
 
-        9,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
+     {  9,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
@@ -546,9 +546,9 @@ static short int remote_nxt[][256] =
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
-      -10,  -10,  -10,  -10,  -10,  -10,
+      -10,  -10,  -10,  -10,  -10,  -10 },
 
-        9,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
+     {  9,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
@@ -575,9 +575,9 @@ static short int remote_nxt[][256] =
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
-      -11,  -11,  -11,  -11,  -11,  -11,
+      -11,  -11,  -11,  -11,  -11,  -11 },
 
-        9,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
+     {  9,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,   20,  -12,  -12,  -12,  -12,
@@ -604,9 +604,9 @@ static short int remote_nxt[][256] =
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
-      -12,  -12,  -12,  -12,  -12,  -12,
+      -12,  -12,  -12,  -12,  -12,  -12 },
 
-        9,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+     {  9,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,  -13,   21,
@@ -633,9 +633,9 @@ static short int remote_nxt[][256] =
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
-       21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21 },
 
-        9,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
+     {  9,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
@@ -662,9 +662,9 @@ static short int remote_nxt[][256] =
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
-      -14,  -14,  -14,  -14,  -14,  -14,
+      -14,  -14,  -14,  -14,  -14,  -14 },
 
-        9,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
+     {  9,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,   24,  -15,  -15,  -15,  -15,
@@ -691,9 +691,9 @@ static short int remote_nxt[][256] =
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
-      -15,  -15,  -15,  -15,  -15,  -15,
+      -15,  -15,  -15,  -15,  -15,  -15 },
 
-        9,   26,   26,   26,   26,   26,   26,   26,   26,   26,
+     {  9,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
@@ -720,9 +720,9 @@ static short int remote_nxt[][256] =
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
-       26,   26,   26,   26,   26,   26,
+       26,   26,   26,   26,   26,   26 },
 
-        9,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
+     {  9,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
@@ -749,9 +749,9 @@ static short int remote_nxt[][256] =
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
-      -17,  -17,  -17,  -17,  -17,  -17,
+      -17,  -17,  -17,  -17,  -17,  -17 },
 
-        9,   28,   28,   28,   28,   28,   28,   28,   28,   28,
+     {  9,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
@@ -778,9 +778,9 @@ static short int remote_nxt[][256] =
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
-       28,   28,   28,   28,   28,   28,
+       28,   28,   28,   28,   28,   28 },
 
-        9,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
+     {  9,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
@@ -807,9 +807,9 @@ static short int remote_nxt[][256] =
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
-      -19,  -19,  -19,  -19,  -19,  -19,
+      -19,  -19,  -19,  -19,  -19,  -19 },
 
-        9,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
+     {  9,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
@@ -836,9 +836,9 @@ static short int remote_nxt[][256] =
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
-      -20,  -20,  -20,  -20,  -20,  -20,
+      -20,  -20,  -20,  -20,  -20,  -20 },
 
-        9,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+     {  9,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,  -21,   21,
@@ -865,9 +865,9 @@ static short int remote_nxt[][256] =
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
        21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
-       21,   21,   21,   21,   21,   21,
+       21,   21,   21,   21,   21,   21 },
 
-        9,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
+     {  9,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
@@ -894,9 +894,9 @@ static short int remote_nxt[][256] =
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
-      -22,  -22,  -22,  -22,  -22,  -22,
+      -22,  -22,  -22,  -22,  -22,  -22 },
 
-        9,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
+     {  9,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
@@ -923,9 +923,9 @@ static short int remote_nxt[][256] =
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
-      -23,  -23,  -23,  -23,  -23,  -23,
+      -23,  -23,  -23,  -23,  -23,  -23 },
 
-        9,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
+     {  9,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
@@ -952,9 +952,9 @@ static short int remote_nxt[][256] =
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
-      -24,  -24,  -24,  -24,  -24,  -24,
+      -24,  -24,  -24,  -24,  -24,  -24 },
 
-        9,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
+     {  9,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,   35,  -25,  -25,  -25,  -25,
@@ -981,9 +981,9 @@ static short int remote_nxt[][256] =
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
-      -25,  -25,  -25,  -25,  -25,  -25,
+      -25,  -25,  -25,  -25,  -25,  -25 },
 
-        9,   26,   26,   26,   26,   26,   26,   26,   26,   26,
+     {  9,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
@@ -1010,9 +1010,9 @@ static short int remote_nxt[][256] =
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
-       26,   26,   26,   26,   26,   26,
+       26,   26,   26,   26,   26,   26 },
 
-        9,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
+     {  9,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,   36,  -27,  -27,  -27,  -27,
@@ -1039,9 +1039,9 @@ static short int remote_nxt[][256] =
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
-      -27,  -27,  -27,  -27,  -27,  -27,
+      -27,  -27,  -27,  -27,  -27,  -27 },
 
-        9,   28,   28,   28,   28,   28,   28,   28,   28,   28,
+     {  9,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
@@ -1068,9 +1068,9 @@ static short int remote_nxt[][256] =
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
-       28,   28,   28,   28,   28,   28,
+       28,   28,   28,   28,   28,   28 },
 
-        9,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
+     {  9,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,   37,  -29,  -29,  -29,  -29,
@@ -1097,9 +1097,9 @@ static short int remote_nxt[][256] =
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
-      -29,  -29,  -29,  -29,  -29,  -29,
+      -29,  -29,  -29,  -29,  -29,  -29 },
 
-        9,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
+     {  9,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
@@ -1126,9 +1126,9 @@ static short int remote_nxt[][256] =
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
-      -30,  -30,  -30,  -30,  -30,  -30,
+      -30,  -30,  -30,  -30,  -30,  -30 },
 
-        9,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
+     {  9,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
@@ -1155,9 +1155,9 @@ static short int remote_nxt[][256] =
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
-      -31,  -31,  -31,  -31,  -31,  -31,
+      -31,  -31,  -31,  -31,  -31,  -31 },
 
-        9,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
+     {  9,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
@@ -1184,9 +1184,9 @@ static short int remote_nxt[][256] =
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
-      -32,  -32,  -32,  -32,  -32,  -32,
+      -32,  -32,  -32,  -32,  -32,  -32 },
 
-        9,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
+     {  9,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
@@ -1213,9 +1213,9 @@ static short int remote_nxt[][256] =
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
-      -33,  -33,  -33,  -33,  -33,  -33,
+      -33,  -33,  -33,  -33,  -33,  -33 },
 
-        9,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
+     {  9,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
@@ -1242,9 +1242,9 @@ static short int remote_nxt[][256] =
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
-      -34,  -34,  -34,  -34,  -34,  -34,
+      -34,  -34,  -34,  -34,  -34,  -34 },
 
-        9,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
+     {  9,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
@@ -1271,9 +1271,9 @@ static short int remote_nxt[][256] =
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
-      -35,  -35,  -35,  -35,  -35,  -35,
+      -35,  -35,  -35,  -35,  -35,  -35 },
 
-        9,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
+     {  9,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
@@ -1300,9 +1300,9 @@ static short int remote_nxt[][256] =
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
-      -36,  -36,  -36,  -36,  -36,  -36,
+      -36,  -36,  -36,  -36,  -36,  -36 },
 
-        9,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
+     {  9,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
@@ -1329,9 +1329,9 @@ static short int remote_nxt[][256] =
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
-      -37,  -37,  -37,  -37,  -37,  -37,
+      -37,  -37,  -37,  -37,  -37,  -37 },
 
-        9,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
+     {  9,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
@@ -1358,9 +1358,9 @@ static short int remote_nxt[][256] =
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
-      -38,  -38,  -38,  -38,  -38,  -38,
+      -38,  -38,  -38,  -38,  -38,  -38 },
 
-        9,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
+     {  9,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
@@ -1387,9 +1387,9 @@ static short int remote_nxt[][256] =
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
-      -39,  -39,  -39,  -39,  -39,  -39,
+      -39,  -39,  -39,  -39,  -39,  -39 },
 
-        9,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
+     {  9,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
@@ -1416,9 +1416,9 @@ static short int remote_nxt[][256] =
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
-      -40,  -40,  -40,  -40,  -40,  -40,
+      -40,  -40,  -40,  -40,  -40,  -40 },
 
-        9,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
+     {  9,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
@@ -1445,9 +1445,9 @@ static short int remote_nxt[][256] =
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
-      -41,  -41,  -41,  -41,  -41,  -41,
+      -41,  -41,  -41,  -41,  -41,  -41 },
 
-        9,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
+     {  9,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
@@ -1474,9 +1474,9 @@ static short int remote_nxt[][256] =
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
-      -42,  -42,  -42,  -42,  -42,  -42,
+      -42,  -42,  -42,  -42,  -42,  -42 },
 
-        9,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
+     {  9,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
@@ -1503,9 +1503,9 @@ static short int remote_nxt[][256] =
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
-      -43,  -43,  -43,  -43,  -43,  -43,
+      -43,  -43,  -43,  -43,  -43,  -43 },
 
-        9,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
+     {  9,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
@@ -1532,9 +1532,9 @@ static short int remote_nxt[][256] =
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
-      -44,  -44,  -44,  -44,  -44,  -44,
+      -44,  -44,  -44,  -44,  -44,  -44 },
 
-        9,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+     {  9,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
@@ -1561,9 +1561,9 @@ static short int remote_nxt[][256] =
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
-      -45,  -45,  -45,  -45,  -45,  -45,
+      -45,  -45,  -45,  -45,  -45,  -45 },
 
-        9,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
+     {  9,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
@@ -1590,9 +1590,9 @@ static short int remote_nxt[][256] =
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
-      -46,  -46,  -46,  -46,  -46,  -46,
+      -46,  -46,  -46,  -46,  -46,  -46 },
 
-        9,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
+     {  9,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
@@ -1619,9 +1619,9 @@ static short int remote_nxt[][256] =
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
-      -47,  -47,  -47,  -47,  -47,  -47,
+      -47,  -47,  -47,  -47,  -47,  -47 },
 
-        9,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
+     {  9,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
@@ -1648,9 +1648,9 @@ static short int remote_nxt[][256] =
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
-      -48,  -48,  -48,  -48,  -48,  -48,
+      -48,  -48,  -48,  -48,  -48,  -48 },
 
-        9,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
+     {  9,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
@@ -1677,9 +1677,9 @@ static short int remote_nxt[][256] =
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
-      -49,  -49,  -49,  -49,  -49,  -49,
+      -49,  -49,  -49,  -49,  -49,  -49 },
 
-        9,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
+     {  9,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
@@ -1706,9 +1706,9 @@ static short int remote_nxt[][256] =
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
-      -50,  -50,  -50,  -50,  -50,  -50,
+      -50,  -50,  -50,  -50,  -50,  -50 },
 
-        9,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
+     {  9,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
@@ -1735,9 +1735,9 @@ static short int remote_nxt[][256] =
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
-      -51,  -51,  -51,  -51,  -51,  -51,
+      -51,  -51,  -51,  -51,  -51,  -51 },
 
-        9,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
+     {  9,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
@@ -1764,9 +1764,9 @@ static short int remote_nxt[][256] =
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
-      -52,  -52,  -52,  -52,  -52,  -52,
+      -52,  -52,  -52,  -52,  -52,  -52 },
 
-        9,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
+     {  9,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
@@ -1793,9 +1793,9 @@ static short int remote_nxt[][256] =
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
-      -53,  -53,  -53,  -53,  -53,  -53,
+      -53,  -53,  -53,  -53,  -53,  -53 },
 
-        9,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
+     {  9,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
@@ -1822,9 +1822,9 @@ static short int remote_nxt[][256] =
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
-      -54,  -54,  -54,  -54,  -54,  -54,
+      -54,  -54,  -54,  -54,  -54,  -54 },
 
-        9,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
+     {  9,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
@@ -1851,9 +1851,9 @@ static short int remote_nxt[][256] =
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
-      -55,  -55,  -55,  -55,  -55,  -55,
+      -55,  -55,  -55,  -55,  -55,  -55 },
 
-        9,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
+     {  9,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
@@ -1880,9 +1880,9 @@ static short int remote_nxt[][256] =
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
-      -56,  -56,  -56,  -56,  -56,  -56,
+      -56,  -56,  -56,  -56,  -56,  -56 },
 
-        9,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
+     {  9,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
@@ -1909,9 +1909,9 @@ static short int remote_nxt[][256] =
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
-      -57,  -57,  -57,  -57,  -57,  -57,
+      -57,  -57,  -57,  -57,  -57,  -57 },
 
-        9,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
+     {  9,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
@@ -1938,9 +1938,9 @@ static short int remote_nxt[][256] =
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
-      -58,  -58,  -58,  -58,  -58,  -58,
+      -58,  -58,  -58,  -58,  -58,  -58 },
 
-        9,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
+     {  9,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
@@ -1967,9 +1967,9 @@ static short int remote_nxt[][256] =
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
-      -59,  -59,  -59,  -59,  -59,  -59,
+      -59,  -59,  -59,  -59,  -59,  -59 },
 
-        9,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
+     {  9,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
@@ -1996,9 +1996,9 @@ static short int remote_nxt[][256] =
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
-      -60,  -60,  -60,  -60,  -60,  -60,
+      -60,  -60,  -60,  -60,  -60,  -60 },
 
-        9,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
+     {  9,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
@@ -2025,9 +2025,9 @@ static short int remote_nxt[][256] =
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
-      -61,  -61,  -61,  -61,  -61,  -61,
+      -61,  -61,  -61,  -61,  -61,  -61 },
 
-        9,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
+     {  9,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
@@ -2054,9 +2054,9 @@ static short int remote_nxt[][256] =
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
-      -62,  -62,  -62,  -62,  -62,  -62,
+      -62,  -62,  -62,  -62,  -62,  -62 },
 
-        9,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
+     {  9,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
@@ -2083,7 +2083,7 @@ static short int remote_nxt[][256] =
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
-      -63,  -63,  -63,  -63,  -63,  -63
+      -63,  -63,  -63,  -63,  -63,  -63 }
 
     } ;
 
@@ -2221,7 +2221,9 @@ static int remote_did_buffer_switch_on_eof;
 static remote_state_type remote_get_previous_state remote_PROTO(( void ));
 static remote_state_type remote_try_NUL_trans remote_PROTO(( remote_state_type current_state ));
 static int remote_get_next_buffer remote_PROTO(( void ));
+#if 0
 static void remoteunput remote_PROTO(( remote_CHAR c, remote_CHAR *buf_ptr ));
+#endif
 void remoterestart remote_PROTO(( FILE *input_file ));
 void remote_switch_to_buffer remote_PROTO(( remote_BUFFER_STATE new_buffer ));
 void remote_load_buffer_state remote_PROTO(( void ));
@@ -2682,6 +2684,7 @@ register remote_state_type remote_current_state;
     }
 
 
+#if 0
 #ifdef remote_USE_PROTOS
 static void remoteunput( remote_CHAR c, register remote_CHAR *remote_bp )
 #else
@@ -2725,6 +2728,7 @@ register remote_CHAR *remote_bp;
      */
     remote_DO_BEFORE_ACTION; /* set up remotetext again */
     }
+#endif
 
 
 #ifdef __cplusplus
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/ReplaceIdIdref.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/ReplaceIdIdref.C
index 1ab488798c20c698b25b021e7a40237c21309eef..f628587d9c6ec937be78a16085c09d2b50b2a6e3 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/ReplaceIdIdref.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/ReplaceIdIdref.C
@@ -219,13 +219,12 @@ using namespace std;
 
 // Debugging macro
 #ifdef DEBUG
+static int dbgLevel=-1;
 #define DBG(level) if ( dbgLevel >= level)
 #else
 #define DBG(level) if (0)
 #endif
 
-static int dbgLevel=-1;
-
 /*
  * Forward declaration for my_input
  */
@@ -248,7 +247,7 @@ extern void replace_entity ( FlexBuffer *, const char *);
 #define XREF 4
 static short int nodedata_nxt[][256] =
     {
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+     {  0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
@@ -275,9 +274,9 @@ static short int nodedata_nxt[][256] =
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0 },
 
-       11,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+     { 11,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        13,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
@@ -304,9 +303,9 @@ static short int nodedata_nxt[][256] =
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
-       12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12 },
 
-       11,   12,   12,   12,   12,   12,   12,   12,   12,   12,
+     { 11,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        13,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
@@ -333,9 +332,9 @@ static short int nodedata_nxt[][256] =
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
-       12,   12,   12,   12,   12,   12,
+       12,   12,   12,   12,   12,   12 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -362,9 +361,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -391,9 +390,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -420,9 +419,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -449,9 +448,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -478,9 +477,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -507,9 +506,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -536,9 +535,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-       11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
+     { 11,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
@@ -565,9 +564,9 @@ static short int nodedata_nxt[][256] =
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-       15,   15,   15,   15,   15,   15,
+       15,   15,   15,   15,   15,   15 },
 
-      -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
+     {-11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
@@ -594,9 +593,9 @@ static short int nodedata_nxt[][256] =
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
-      -11,  -11,  -11,  -11,  -11,  -11,
+      -11,  -11,  -11,  -11,  -11,  -11 },
 
-       11,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
+     { 11,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
@@ -623,9 +622,9 @@ static short int nodedata_nxt[][256] =
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
-      -12,  -12,  -12,  -12,  -12,  -12,
+      -12,  -12,  -12,  -12,  -12,  -12 },
 
-       11,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
+     { 11,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
@@ -652,9 +651,9 @@ static short int nodedata_nxt[][256] =
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
-      -13,  -13,  -13,  -13,  -13,  -13,
+      -13,  -13,  -13,  -13,  -13,  -13 },
 
-       11,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
+     { 11,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,   24,  -14,  -14,  -14,  -14,
@@ -681,9 +680,9 @@ static short int nodedata_nxt[][256] =
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
-      -14,  -14,  -14,  -14,  -14,  -14,
+      -14,  -14,  -14,  -14,  -14,  -14 },
 
-       11,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
+     { 11,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
@@ -710,9 +709,9 @@ static short int nodedata_nxt[][256] =
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
-      -15,  -15,  -15,  -15,  -15,  -15,
+      -15,  -15,  -15,  -15,  -15,  -15 },
 
-       11,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
+     { 11,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
@@ -739,9 +738,9 @@ static short int nodedata_nxt[][256] =
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
-      -16,  -16,  -16,  -16,  -16,  -16,
+      -16,  -16,  -16,  -16,  -16,  -16 },
 
-       11,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
+     { 11,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
@@ -768,9 +767,9 @@ static short int nodedata_nxt[][256] =
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
-      -17,  -17,  -17,  -17,  -17,  -17,
+      -17,  -17,  -17,  -17,  -17,  -17 },
 
-       11,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
+     { 11,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
@@ -797,9 +796,9 @@ static short int nodedata_nxt[][256] =
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
-      -18,  -18,  -18,  -18,  -18,  -18,
+      -18,  -18,  -18,  -18,  -18,  -18 },
 
-       11,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
+     { 11,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
@@ -826,9 +825,9 @@ static short int nodedata_nxt[][256] =
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
-      -19,  -19,  -19,  -19,  -19,  -19,
+      -19,  -19,  -19,  -19,  -19,  -19 },
 
-       11,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
+     { 11,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
@@ -855,9 +854,9 @@ static short int nodedata_nxt[][256] =
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
-      -20,  -20,  -20,  -20,  -20,  -20,
+      -20,  -20,  -20,  -20,  -20,  -20 },
 
-       11,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
+     { 11,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
@@ -884,9 +883,9 @@ static short int nodedata_nxt[][256] =
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
-      -21,  -21,  -21,  -21,  -21,  -21,
+      -21,  -21,  -21,  -21,  -21,  -21 },
 
-       11,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
+     { 11,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
@@ -913,9 +912,9 @@ static short int nodedata_nxt[][256] =
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
-      -22,  -22,  -22,  -22,  -22,  -22,
+      -22,  -22,  -22,  -22,  -22,  -22 },
 
-       11,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
+     { 11,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
@@ -942,9 +941,9 @@ static short int nodedata_nxt[][256] =
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
-      -23,  -23,  -23,  -23,  -23,  -23,
+      -23,  -23,  -23,  -23,  -23,  -23 },
 
-       11,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
+     { 11,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
@@ -971,9 +970,9 @@ static short int nodedata_nxt[][256] =
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
-      -24,  -24,  -24,  -24,  -24,  -24,
+      -24,  -24,  -24,  -24,  -24,  -24 },
 
-       11,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
+     { 11,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
@@ -1000,9 +999,9 @@ static short int nodedata_nxt[][256] =
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
-      -25,  -25,  -25,  -25,  -25,  -25,
+      -25,  -25,  -25,  -25,  -25,  -25 },
 
-       11,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
+     { 11,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,   35,  -26,  -26,  -26,  -26,
@@ -1029,9 +1028,9 @@ static short int nodedata_nxt[][256] =
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
-      -26,  -26,  -26,  -26,  -26,  -26,
+      -26,  -26,  -26,  -26,  -26,  -26 },
 
-       11,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
+     { 11,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
@@ -1058,9 +1057,9 @@ static short int nodedata_nxt[][256] =
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
-      -27,  -27,  -27,  -27,  -27,  -27,
+      -27,  -27,  -27,  -27,  -27,  -27 },
 
-       11,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
+     { 11,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,   36,  -28,  -28,  -28,  -28,
@@ -1087,9 +1086,9 @@ static short int nodedata_nxt[][256] =
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
-      -28,  -28,  -28,  -28,  -28,  -28,
+      -28,  -28,  -28,  -28,  -28,  -28 },
 
-       11,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
+     { 11,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
@@ -1116,9 +1115,9 @@ static short int nodedata_nxt[][256] =
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
-      -29,  -29,  -29,  -29,  -29,  -29,
+      -29,  -29,  -29,  -29,  -29,  -29 },
 
-       11,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
+     { 11,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,   37,  -30,  -30,  -30,  -30,
@@ -1145,9 +1144,9 @@ static short int nodedata_nxt[][256] =
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
-      -30,  -30,  -30,  -30,  -30,  -30,
+      -30,  -30,  -30,  -30,  -30,  -30 },
 
-       11,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
+     { 11,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
@@ -1174,9 +1173,9 @@ static short int nodedata_nxt[][256] =
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
-      -31,  -31,  -31,  -31,  -31,  -31,
+      -31,  -31,  -31,  -31,  -31,  -31 },
 
-       11,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
+     { 11,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,   38,  -32,  -32,  -32,  -32,
@@ -1203,9 +1202,9 @@ static short int nodedata_nxt[][256] =
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
-      -32,  -32,  -32,  -32,  -32,  -32,
+      -32,  -32,  -32,  -32,  -32,  -32 },
 
-       11,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
+     { 11,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
@@ -1232,9 +1231,9 @@ static short int nodedata_nxt[][256] =
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
-      -33,  -33,  -33,  -33,  -33,  -33,
+      -33,  -33,  -33,  -33,  -33,  -33 },
 
-       11,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
+     { 11,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
@@ -1261,9 +1260,9 @@ static short int nodedata_nxt[][256] =
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
-      -34,  -34,  -34,  -34,  -34,  -34,
+      -34,  -34,  -34,  -34,  -34,  -34 },
 
-       11,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
+     { 11,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
@@ -1290,9 +1289,9 @@ static short int nodedata_nxt[][256] =
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
-      -35,  -35,  -35,  -35,  -35,  -35,
+      -35,  -35,  -35,  -35,  -35,  -35 },
 
-       11,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
+     { 11,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
@@ -1319,9 +1318,9 @@ static short int nodedata_nxt[][256] =
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
-      -36,  -36,  -36,  -36,  -36,  -36,
+      -36,  -36,  -36,  -36,  -36,  -36 },
 
-       11,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
+     { 11,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
@@ -1348,9 +1347,9 @@ static short int nodedata_nxt[][256] =
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
-      -37,  -37,  -37,  -37,  -37,  -37,
+      -37,  -37,  -37,  -37,  -37,  -37 },
 
-       11,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
+     { 11,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
@@ -1377,9 +1376,9 @@ static short int nodedata_nxt[][256] =
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
-      -38,  -38,  -38,  -38,  -38,  -38,
+      -38,  -38,  -38,  -38,  -38,  -38 },
 
-       11,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
+     { 11,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
@@ -1406,9 +1405,9 @@ static short int nodedata_nxt[][256] =
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
-      -39,  -39,  -39,  -39,  -39,  -39,
+      -39,  -39,  -39,  -39,  -39,  -39 },
 
-       11,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
+     { 11,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
@@ -1435,9 +1434,9 @@ static short int nodedata_nxt[][256] =
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
-      -40,  -40,  -40,  -40,  -40,  -40,
+      -40,  -40,  -40,  -40,  -40,  -40 },
 
-       11,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
+     { 11,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
@@ -1464,9 +1463,9 @@ static short int nodedata_nxt[][256] =
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
-      -41,  -41,  -41,  -41,  -41,  -41,
+      -41,  -41,  -41,  -41,  -41,  -41 },
 
-       11,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
+     { 11,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
@@ -1493,9 +1492,9 @@ static short int nodedata_nxt[][256] =
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
-      -42,  -42,  -42,  -42,  -42,  -42,
+      -42,  -42,  -42,  -42,  -42,  -42 },
 
-       11,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
+     { 11,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
@@ -1522,9 +1521,9 @@ static short int nodedata_nxt[][256] =
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
-      -43,  -43,  -43,  -43,  -43,  -43,
+      -43,  -43,  -43,  -43,  -43,  -43 },
 
-       11,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
+     { 11,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
@@ -1551,9 +1550,9 @@ static short int nodedata_nxt[][256] =
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
-      -44,  -44,  -44,  -44,  -44,  -44,
+      -44,  -44,  -44,  -44,  -44,  -44 },
 
-       11,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+     { 11,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
@@ -1580,9 +1579,9 @@ static short int nodedata_nxt[][256] =
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
-      -45,  -45,  -45,  -45,  -45,  -45,
+      -45,  -45,  -45,  -45,  -45,  -45 },
 
-       11,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
+     { 11,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
@@ -1609,9 +1608,9 @@ static short int nodedata_nxt[][256] =
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
-      -46,  -46,  -46,  -46,  -46,  -46,
+      -46,  -46,  -46,  -46,  -46,  -46 },
 
-       11,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
+     { 11,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
@@ -1638,9 +1637,9 @@ static short int nodedata_nxt[][256] =
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
-      -47,  -47,  -47,  -47,  -47,  -47,
+      -47,  -47,  -47,  -47,  -47,  -47 },
 
-       11,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
+     { 11,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
@@ -1667,9 +1666,9 @@ static short int nodedata_nxt[][256] =
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
-      -48,  -48,  -48,  -48,  -48,  -48,
+      -48,  -48,  -48,  -48,  -48,  -48 },
 
-       11,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
+     { 11,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
@@ -1696,9 +1695,9 @@ static short int nodedata_nxt[][256] =
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
-      -49,  -49,  -49,  -49,  -49,  -49,
+      -49,  -49,  -49,  -49,  -49,  -49 },
 
-       11,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
+     { 11,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
@@ -1725,9 +1724,9 @@ static short int nodedata_nxt[][256] =
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
-      -50,  -50,  -50,  -50,  -50,  -50,
+      -50,  -50,  -50,  -50,  -50,  -50 },
 
-       11,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
+     { 11,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
@@ -1754,9 +1753,9 @@ static short int nodedata_nxt[][256] =
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
-      -51,  -51,  -51,  -51,  -51,  -51,
+      -51,  -51,  -51,  -51,  -51,  -51 },
 
-       11,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
+     { 11,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
@@ -1783,9 +1782,9 @@ static short int nodedata_nxt[][256] =
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
       -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,  -52,
-      -52,  -52,  -52,  -52,  -52,  -52,
+      -52,  -52,  -52,  -52,  -52,  -52 },
 
-       11,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
+     { 11,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
@@ -1812,9 +1811,9 @@ static short int nodedata_nxt[][256] =
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
       -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,  -53,
-      -53,  -53,  -53,  -53,  -53,  -53,
+      -53,  -53,  -53,  -53,  -53,  -53 },
 
-       11,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
+     { 11,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
@@ -1841,9 +1840,9 @@ static short int nodedata_nxt[][256] =
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
       -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,  -54,
-      -54,  -54,  -54,  -54,  -54,  -54,
+      -54,  -54,  -54,  -54,  -54,  -54 },
 
-       11,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
+     { 11,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
@@ -1870,9 +1869,9 @@ static short int nodedata_nxt[][256] =
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
       -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,  -55,
-      -55,  -55,  -55,  -55,  -55,  -55,
+      -55,  -55,  -55,  -55,  -55,  -55 },
 
-       11,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
+     { 11,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
@@ -1899,9 +1898,9 @@ static short int nodedata_nxt[][256] =
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
       -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,  -56,
-      -56,  -56,  -56,  -56,  -56,  -56,
+      -56,  -56,  -56,  -56,  -56,  -56 },
 
-       11,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
+     { 11,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
@@ -1928,9 +1927,9 @@ static short int nodedata_nxt[][256] =
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
       -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,  -57,
-      -57,  -57,  -57,  -57,  -57,  -57,
+      -57,  -57,  -57,  -57,  -57,  -57 },
 
-       11,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
+     { 11,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
@@ -1957,9 +1956,9 @@ static short int nodedata_nxt[][256] =
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
       -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,  -58,
-      -58,  -58,  -58,  -58,  -58,  -58,
+      -58,  -58,  -58,  -58,  -58,  -58 },
 
-       11,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
+     { 11,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
@@ -1986,9 +1985,9 @@ static short int nodedata_nxt[][256] =
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
       -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,  -59,
-      -59,  -59,  -59,  -59,  -59,  -59,
+      -59,  -59,  -59,  -59,  -59,  -59 },
 
-       11,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
+     { 11,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
@@ -2015,9 +2014,9 @@ static short int nodedata_nxt[][256] =
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
       -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,  -60,
-      -60,  -60,  -60,  -60,  -60,  -60,
+      -60,  -60,  -60,  -60,  -60,  -60 },
 
-       11,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
+     { 11,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
@@ -2044,9 +2043,9 @@ static short int nodedata_nxt[][256] =
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
       -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,  -61,
-      -61,  -61,  -61,  -61,  -61,  -61,
+      -61,  -61,  -61,  -61,  -61,  -61 },
 
-       11,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
+     { 11,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
@@ -2073,9 +2072,9 @@ static short int nodedata_nxt[][256] =
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
       -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,  -62,
-      -62,  -62,  -62,  -62,  -62,  -62,
+      -62,  -62,  -62,  -62,  -62,  -62 },
 
-       11,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
+     { 11,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
@@ -2102,9 +2101,9 @@ static short int nodedata_nxt[][256] =
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
       -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,  -63,
-      -63,  -63,  -63,  -63,  -63,  -63,
+      -63,  -63,  -63,  -63,  -63,  -63 },
 
-       11,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
+     { 11,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
       -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
       -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
       -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
@@ -2131,9 +2130,9 @@ static short int nodedata_nxt[][256] =
       -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
       -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
       -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,  -64,
-      -64,  -64,  -64,  -64,  -64,  -64,
+      -64,  -64,  -64,  -64,  -64,  -64 },
 
-       11,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
+     { 11,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
       -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
       -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
       -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
@@ -2160,9 +2159,9 @@ static short int nodedata_nxt[][256] =
       -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
       -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
       -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,  -65,
-      -65,  -65,  -65,  -65,  -65,  -65,
+      -65,  -65,  -65,  -65,  -65,  -65 },
 
-       11,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
+     { 11,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
       -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
       -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
       -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
@@ -2189,9 +2188,9 @@ static short int nodedata_nxt[][256] =
       -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
       -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
       -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,  -66,
-      -66,  -66,  -66,  -66,  -66,  -66,
+      -66,  -66,  -66,  -66,  -66,  -66 },
 
-       11,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
+     { 11,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
       -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
       -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
       -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
@@ -2218,9 +2217,9 @@ static short int nodedata_nxt[][256] =
       -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
       -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
       -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,  -67,
-      -67,  -67,  -67,  -67,  -67,  -67,
+      -67,  -67,  -67,  -67,  -67,  -67 },
 
-       11,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
+     { 11,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
       -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
       -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
       -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
@@ -2247,9 +2246,9 @@ static short int nodedata_nxt[][256] =
       -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
       -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
       -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,  -68,
-      -68,  -68,  -68,  -68,  -68,  -68,
+      -68,  -68,  -68,  -68,  -68,  -68 },
 
-       11,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
+     { 11,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
       -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
       -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
       -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
@@ -2276,9 +2275,9 @@ static short int nodedata_nxt[][256] =
       -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
       -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
       -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,  -69,
-      -69,  -69,  -69,  -69,  -69,  -69,
+      -69,  -69,  -69,  -69,  -69,  -69 },
 
-       11,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
+     { 11,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
       -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
       -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
       -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
@@ -2305,9 +2304,9 @@ static short int nodedata_nxt[][256] =
       -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
       -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
       -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,  -70,
-      -70,  -70,  -70,  -70,  -70,  -70,
+      -70,  -70,  -70,  -70,  -70,  -70 },
 
-       11,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
+     { 11,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
       -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
       -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
       -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
@@ -2334,9 +2333,9 @@ static short int nodedata_nxt[][256] =
       -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
       -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
       -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,  -71,
-      -71,  -71,  -71,  -71,  -71,  -71,
+      -71,  -71,  -71,  -71,  -71,  -71 },
 
-       11,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
+     { 11,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
       -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
       -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
       -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
@@ -2363,9 +2362,9 @@ static short int nodedata_nxt[][256] =
       -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
       -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
       -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,  -72,
-      -72,  -72,  -72,  -72,  -72,  -72,
+      -72,  -72,  -72,  -72,  -72,  -72 },
 
-       11,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
+     { 11,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
       -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
       -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
       -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
@@ -2392,9 +2391,9 @@ static short int nodedata_nxt[][256] =
       -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
       -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
       -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,  -73,
-      -73,  -73,  -73,  -73,  -73,  -73,
+      -73,  -73,  -73,  -73,  -73,  -73 },
 
-       11,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
+     { 11,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
       -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
       -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
       -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
@@ -2421,9 +2420,9 @@ static short int nodedata_nxt[][256] =
       -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
       -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
       -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,  -74,
-      -74,  -74,  -74,  -74,  -74,  -74,
+      -74,  -74,  -74,  -74,  -74,  -74 },
 
-       11,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
+     { 11,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
       -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
       -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
       -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
@@ -2450,9 +2449,9 @@ static short int nodedata_nxt[][256] =
       -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
       -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
       -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,  -75,
-      -75,  -75,  -75,  -75,  -75,  -75,
+      -75,  -75,  -75,  -75,  -75,  -75 },
 
-       11,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
+     { 11,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
       -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
       -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
       -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
@@ -2479,9 +2478,9 @@ static short int nodedata_nxt[][256] =
       -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
       -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
       -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,  -76,
-      -76,  -76,  -76,  -76,  -76,  -76,
+      -76,  -76,  -76,  -76,  -76,  -76 },
 
-       11,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
+     { 11,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
       -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
       -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
       -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
@@ -2508,9 +2507,9 @@ static short int nodedata_nxt[][256] =
       -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
       -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
       -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,  -77,
-      -77,  -77,  -77,  -77,  -77,  -77,
+      -77,  -77,  -77,  -77,  -77,  -77 },
 
-       11,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
+     { 11,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
       -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
       -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
       -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
@@ -2537,9 +2536,9 @@ static short int nodedata_nxt[][256] =
       -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
       -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
       -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,  -78,
-      -78,  -78,  -78,  -78,  -78,  -78,
+      -78,  -78,  -78,  -78,  -78,  -78 },
 
-       11,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
+     { 11,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
       -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
       -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
       -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
@@ -2566,9 +2565,9 @@ static short int nodedata_nxt[][256] =
       -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
       -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
       -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,  -79,
-      -79,  -79,  -79,  -79,  -79,  -79,
+      -79,  -79,  -79,  -79,  -79,  -79 },
 
-       11,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
+     { 11,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
       -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
       -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
       -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
@@ -2595,9 +2594,9 @@ static short int nodedata_nxt[][256] =
       -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
       -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
       -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,  -80,
-      -80,  -80,  -80,  -80,  -80,  -80,
+      -80,  -80,  -80,  -80,  -80,  -80 },
 
-       11,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
+     { 11,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
       -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
       -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
       -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
@@ -2624,9 +2623,9 @@ static short int nodedata_nxt[][256] =
       -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
       -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
       -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,  -81,
-      -81,  -81,  -81,  -81,  -81,  -81,
+      -81,  -81,  -81,  -81,  -81,  -81 },
 
-       11,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
+     { 11,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
       -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
       -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
       -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
@@ -2653,9 +2652,9 @@ static short int nodedata_nxt[][256] =
       -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
       -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
       -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,  -82,
-      -82,  -82,  -82,  -82,  -82,  -82,
+      -82,  -82,  -82,  -82,  -82,  -82 },
 
-       11,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
+     { 11,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
       -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
       -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
       -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
@@ -2682,9 +2681,9 @@ static short int nodedata_nxt[][256] =
       -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
       -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
       -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,  -83,
-      -83,  -83,  -83,  -83,  -83,  -83,
+      -83,  -83,  -83,  -83,  -83,  -83 },
 
-       11,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
+     { 11,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
       -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
       -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
       -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
@@ -2711,9 +2710,9 @@ static short int nodedata_nxt[][256] =
       -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
       -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
       -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,  -84,
-      -84,  -84,  -84,  -84,  -84,  -84,
+      -84,  -84,  -84,  -84,  -84,  -84 },
 
-       11,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
+     { 11,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
       -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
       -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
       -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
@@ -2740,9 +2739,9 @@ static short int nodedata_nxt[][256] =
       -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
       -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
       -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,  -85,
-      -85,  -85,  -85,  -85,  -85,  -85,
+      -85,  -85,  -85,  -85,  -85,  -85 },
 
-       11,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
+     { 11,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
       -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
       -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
       -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
@@ -2769,9 +2768,9 @@ static short int nodedata_nxt[][256] =
       -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
       -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
       -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,  -86,
-      -86,  -86,  -86,  -86,  -86,  -86,
+      -86,  -86,  -86,  -86,  -86,  -86 },
 
-       11,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
+     { 11,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
       -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
       -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
       -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
@@ -2798,9 +2797,9 @@ static short int nodedata_nxt[][256] =
       -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
       -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
       -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,  -87,
-      -87,  -87,  -87,  -87,  -87,  -87,
+      -87,  -87,  -87,  -87,  -87,  -87 },
 
-       11,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
+     { 11,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
       -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
       -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
       -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
@@ -2827,9 +2826,9 @@ static short int nodedata_nxt[][256] =
       -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
       -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
       -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,  -88,
-      -88,  -88,  -88,  -88,  -88,  -88,
+      -88,  -88,  -88,  -88,  -88,  -88 },
 
-       11,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
+     { 11,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
       -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
       -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
       -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
@@ -2856,9 +2855,9 @@ static short int nodedata_nxt[][256] =
       -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
       -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
       -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,  -89,
-      -89,  -89,  -89,  -89,  -89,  -89,
+      -89,  -89,  -89,  -89,  -89,  -89 },
 
-       11,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
+     { 11,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
       -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
       -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
       -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
@@ -2885,7 +2884,7 @@ static short int nodedata_nxt[][256] =
       -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
       -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
       -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,  -90,
-      -90,  -90,  -90,  -90,  -90,  -90
+      -90,  -90,  -90,  -90,  -90,  -90 }
 
     } ;
 
@@ -3027,7 +3026,9 @@ static int nodedata_did_buffer_switch_on_eof;
 static nodedata_state_type nodedata_get_previous_state nodedata_PROTO(( void ));
 static nodedata_state_type nodedata_try_NUL_trans nodedata_PROTO(( nodedata_state_type current_state ));
 static int nodedata_get_next_buffer nodedata_PROTO(( void ));
+#if 0
 static void nodedataunput nodedata_PROTO(( nodedata_CHAR c, nodedata_CHAR *buf_ptr ));
+#endif
 void nodedatarestart nodedata_PROTO(( FILE *input_file ));
 void nodedata_switch_to_buffer nodedata_PROTO(( nodedata_BUFFER_STATE new_buffer ));
 void nodedata_load_buffer_state nodedata_PROTO(( void ));
@@ -3516,6 +3517,7 @@ register nodedata_state_type nodedata_current_state;
     }
 
 
+#if 0
 #ifdef nodedata_USE_PROTOS
 static void nodedataunput( nodedata_CHAR c, register nodedata_CHAR *nodedata_bp )
 #else
@@ -3559,6 +3561,7 @@ register nodedata_CHAR *nodedata_bp;
      */
     nodedata_DO_BEFORE_ACTION; /* set up nodedatatext again */
     }
+#endif
 
 
 #ifdef __cplusplus
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLDefn.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLDefn.C
index 56ee2b1e705d2b29eea07a7776064fea4136138f..9f151882ea5d9bd064ba89f8c8b93eb75523f1f8 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLDefn.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLDefn.C
@@ -60,10 +60,11 @@ SGMLDefn::store_sys_id( char *sid )
   if ( sid ) {
     delete sys_id;
 
-    sys_id = new char [ strlen(sid) + 1 ];
+    int len = strlen(sid);
+    sys_id = new char [len + 1];
     assert(sys_id != NULL);
     
-    strcpy ( sys_id , sid );
+    *((char *) memcpy(sys_id, sid, len) + len) = '\0';
   }
 }
 
@@ -73,10 +74,11 @@ SGMLDefn::store_pub_id( char *pid )
   if ( pid ) {
     delete pub_id;
 
-    pub_id = new char [ strlen(pid) + 1 ];
+    int len = strlen(pid);
+    pub_id = new char [len + 1];
     assert(pub_id != NULL);
     
-    strcpy ( pub_id, pid );
+    *((char *) memcpy(pub_id, pid, len) + len) = '\0';
   }
 }
 
@@ -98,10 +100,11 @@ SGMLDefn::store_file_name( char *fname )
   if ( fname ) {
     delete file_name;
 
-    file_name = new char [ strlen(fname) + 1 ];
+    int len = strlen(fname);
+    file_name = new char [len + 1];
     assert(file_name != NULL);
 
-    strcpy( file_name, fname );
+    *((char *) memcpy(file_name, fname, len) + len) = '\0';
   }
 }
 
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLName.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLName.C
index e8f9af49c75ba10524242a8dab6a61769e8196b9..a4e5a97910bb9eef90ae5ca195a2c060fd275b5a 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLName.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/SGMLName.C
@@ -123,8 +123,9 @@ StringToInt::intern(const char *name)
   if( (indx = whichString(name, items, used)) < 0){
     grow(used + 1);
 
-    char *p = new char[strlen(name)+1];
-    strcpy(p, name);
+    int len = strlen(name);
+    char *p = new char[len + 1];
+    *((char *) memcpy(p, name, len) + len) = '\0';
 
     indx = used;
 
@@ -161,7 +162,7 @@ void StringToInt::grow(size_t needed)
 
 const char* StringToInt::lookup(int indx)
 {
-  int i;
+  unsigned int i;
   
   for(i = 0; i < used; i++){
     if (items[i].code == indx) return items[i].string;
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchPath.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchPath.C
index 47644d9303d342662d51f5920170c52a229ffcb5..e33ed643527ca7d91b5a0d7b7f73aaf1eb960467 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchPath.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchPath.C
@@ -135,7 +135,7 @@ SearchPath::get_real_path( const char *file_name )
 
   // remove storage object specifier
   if (strncasecmp(file_name, "<OSFILE", 7) == 0) {
-    if (file_name = strchr(file_name, '>'))
+    if ((file_name = strchr(file_name, '>')))
       file_name++;
     else
       return NULL;
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchStorage.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchStorage.C
index 7ad7def038c44d8eec2ccfd046b3057a627f6b6c..658818b2cfbcb408d436e9b494e0577e2613e988 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchStorage.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/SearchStorage.C
@@ -97,15 +97,16 @@ SearchStorage::SearchStorage( const char *path, const char *name )
     makedir(path);
   }
 
-  filteredPath = new char [ strlen(path) + 1 + strlen("filtered") + 1 ];
+  int pathlen = strlen(path) + 1 + strlen("filtered") + 1;
+  filteredPath = new char [pathlen];
   /*
    * throw(ResourceExhausted)
    *
    */
   assert ( filteredPath != NULL );
-  
-  sprintf( filteredPath, "%s/filtered", path );
-  
+
+  snprintf( filteredPath, pathlen, "%s/filtered", path );
+
   if ( !isdir(filteredPath) ) {
     makedir(filteredPath);
   }
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/StringList.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/StringList.C
index 6b71cd417d31713d6fd5520beef21f7781dc6fd0..e7f8f8345a2b0f186447324b7197d60d78db4a01 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/StringList.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/StringList.C
@@ -57,8 +57,9 @@ void StringList::grow(size_t total)
 
 const char * StringList::append(const char *str)
 {
-  char *p = new char[strlen(str)+1];
-  strcpy(p, str);
+  int len = strlen(str);
+  char *p = new char[len + 1];
+  *((char *) memcpy(p, str, len) + len) = '\0';
   
   grow(used);
   
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTask.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTask.C
index c809fc2f3ea83aabe486bb52509987d52c076e9c..7c07b3eb026cd0b854430ec5006cd5d676195a5f 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTask.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTask.C
@@ -119,7 +119,7 @@ report_position(FlexBuffer *buffer, const char *file, int line)
 {
   char info[200]; //MAGIC
 
-  sprintf(info, "#file: %.150s line: %d\n", file, line);
+  snprintf(info, sizeof(info), "#file: %.150s line: %d\n", file, line);
   buffer->writeStr(info);
 }
 
@@ -138,7 +138,7 @@ write_array(FlexBuffer *buffer, const char *tokens, int quotes)
       buffer->writeStr( token );
       if (quotes) buffer->put( '\"' );
 
-      while ( token = strtok ( NULL, " \n\t" ) ) {
+      while ( (token = strtok ( NULL, " \n\t" )) ) {
        buffer->put(',');
         if (quotes) buffer->put( '\"' );
        buffer->writeStr( token );
@@ -329,7 +329,7 @@ StyleTask::markup( const Token &t )
         {
           const AttributeRec *arec;
           int id = SGMLName::intern("ID");
-          if(arec = t.LookupAttr(id)){
+          if((arec = t.LookupAttr(id))){
 
             if(f_dataMode == inContent){
               f_buffer->writeStr(" + ");
@@ -354,7 +354,7 @@ StyleTask::markup( const Token &t )
         /*
          * Is it an enumeration feature?
          */
-        if(arec = t.LookupAttr(OLAF::OL_Choice)){
+        if((arec = t.LookupAttr(OLAF::OL_Choice))){
 
            /* OL_Choice can only be applied to NAME attributes, hence
              we don't neet to worryabout "'s in the attribute value.
@@ -417,7 +417,7 @@ StyleTask::markup( const Token &t )
 
        int topelement;
        if ( !feature_depth->empty() ) {
-         if ( topelement = feature_depth->top() ) {
+         if ( (topelement = feature_depth->top()) ) {
            if ( topelement == t.level() ) {
              topelement = feature_depth->pop();
              write_tabs( f_buffer, feature_depth, '\t');
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTaskDB.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTaskDB.C
index c5146435b3578466624f651ea03c9527600f3e6d..9f6b4f0b7d650668bbb6f3856023bf6dbd197ddf 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTaskDB.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/StyleTaskDB.C
@@ -52,8 +52,8 @@ void StyleTaskDB::done(const char * name,
   DBTable *tbl = f_bookcase->table(BookCaseDB::StyleSheet);
   
   tbl->insert(STRING_CODE, name,
-             -STRING_CODE, online, online_len,
-             -STRING_CODE, print,  print_len,
+             -STRING_CODE, online, (size_t)online_len,
+             -STRING_CODE, print,  (size_t)print_len,
              NULL);
 
   reset();
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/TOCTask.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/TOCTask.C
index 60002678f5fc1f7376abc19a7ecb2e4285ea5050..927e86ef7201c5d29be93214db2c4febc9c363ca 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/TOCTask.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/TOCTask.C
@@ -62,10 +62,10 @@ int toc_depth(const Token& t)
   if( t.LookupAttr( OLAF::OL_ToC ) ){
     ret = 0;
   }
-  else if(a = t.LookupAttr( OLAF::OL_ToCEntry )){
+  else if((a = t.LookupAttr( OLAF::OL_ToCEntry ))){
     const char *val;
 
-    if(val = a->getAttrValueString()){
+    if((val = a->getAttrValueString())){
       ret = atoi(val);
     }
   }
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen b/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen
index 369501ae3a0713c01afb18748dd4c29d29d5917a..f85c6855cc26a8f41a9024d1facc90447385c6a8 100755 (executable)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen
@@ -222,11 +222,58 @@ case "$OS" in
        ;;
 
        Linux*)
-               ARCH=i386
+               case "`uname -i`" in
+
+                       i386*)
+                               ARCH=i386
+                       ;;
+
+                       x86_64*)
+                               ARCH=amd64
+                       ;;
+
+                       *)
+                               ARCH=unknown
+                       ;;
+               esac
        ;;
 
        FreeBSD*)
-               ARCH=i386
+               case "`uname -m`" in
+
+                       i386*)
+                               ARCH=i386
+                       ;;
+
+                       amd64*)
+                               ARCH=amd64
+                       ;;
+
+                       *)
+                               ARCH=unknown
+                       ;;
+               esac
+       ;;
+
+       OpenBSD*)
+               case "`uname -m`" in
+
+                       i386*)
+                               ARCH=i386
+                       ;;
+
+                       amd64*)
+                               ARCH=amd64
+                       ;;
+
+                       powerpc*)
+                               ARCH=powerpc
+                       ;;
+
+                       *)
+                               ARCH=unknown
+                       ;;
+               esac
        ;;
 
        *)
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen_worker.c b/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen_worker.c
index a6cb9597d22988019b45ccb179542a85cb1c9673..19d241d33f437b4c371bec485a9e65f6d5d0b30c 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen_worker.c
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/dtinfogen_worker.c
@@ -52,6 +52,10 @@
 #define LANG_COMMON    "C"             /* default os language */
 #define CLANG_COMMON   "C.ISO-8859-1"  /* default canonical language */
 
+#define XtsNewString(str) \
+    ((str) != NULL ? (char *)(memcpy(XtMalloc((unsigned)strlen(str) + 1), \
+     str, (unsigned)strlen(str) + 1)) : NULL)
+
 typedef enum
 {
     FSTAT_EXISTS        = 1 << 0,
@@ -172,13 +176,13 @@ typedef struct
 static
 t_entry langtbl[] =
 {
-  "C.ISO-8859-1",      1,      "eng.sfx",      "eng.stp",      NULL,
-  "es_ES.ISO-8859-1",  2,      "esp.sfx",      "esp.stp",      NULL,
-  "fr_FR.ISO-8859-1",  3,      "fra.sfx",      "fra.stp",      NULL,
-  "it_IT.ISO-8859-1",  4,      "ita.sfx",      "ita.stp",      NULL,
-  "de_DE.ISO-8859-1",  5,      "deu.sfx",      "deu.stp",      NULL,
-  "ja_JP.EUC-JP",      7,      NULL,           NULL,           "jpn.knj",
-  NULL,                        0,      NULL,           NULL,           NULL
+  { "C.ISO-8859-1",    1,      "eng.sfx",      "eng.stp",      NULL },
+  { "es_ES.ISO-8859-1",        2,      "esp.sfx",      "esp.stp",      NULL },
+  { "fr_FR.ISO-8859-1",        3,      "fra.sfx",      "fra.stp",      NULL },
+  { "it_IT.ISO-8859-1",        4,      "ita.sfx",      "ita.stp",      NULL },
+  { "de_DE.ISO-8859-1",        5,      "deu.sfx",      "deu.stp",      NULL },
+  { "ja_JP.EUC-JP",    7,      NULL,           NULL,           "jpn.knj" },
+  { NULL,              0,      NULL,           NULL,           NULL }
 };
 
 static char *usageMsg1 = "USAGE:\n\
@@ -189,9 +193,9 @@ static char *usageMsg1 = "USAGE:\n\
   " EXEC_NAME " tocgen [-h] [-T <tmpdir>] [-m <catalog>] -f <tocfile> [-id <tocid>]\n\
             [-title <toctitle>] <document>...\n\
   " EXEC_NAME " update [-h] [-m <catalog>] -l <library> -b <bookcase> <stylesheet>\n\
-  " EXEC_NAME " validate [-h] [-T <tmpdir>] [-m <catalog>] <document>...\n\
-\n\
-options:\n";
+  " EXEC_NAME " validate [-h] [-T <tmpdir>] [-m <catalog>] <document>...\n"
+  "\n"
+  "options:\n";
 
 static char *usageMsg2 = "\
     -T <tmpdir>          directory for intermediate processing files\n\
@@ -207,7 +211,6 @@ static void sigHandler(int sig);
 static void touchFile(char *fileName);
 static Boolean checkStat(char *fileName, unsigned int flags);
 static void checkDir(char *dirName);
-static Boolean textExec(char *execName);
 static void checkExec(char *execName);
 static char *makeTmpFile(void);
 static char *makeWorkDir(void);
@@ -270,7 +273,6 @@ static void
 dieRWD(int exitCode, char *format, ...)
 {
     va_list ap;
-    char *msg;
 
     va_start(ap, format);
     vfprintf(stderr, format, ap);
@@ -286,7 +288,6 @@ static void
 die(int exitCode, char *format, ...)
 {
     va_list ap;
-    char *msg;
 
     va_start(ap, format);
     vfprintf(stderr, format, ap);
@@ -418,7 +419,7 @@ checkDir(char *dirName)
        dieRWD(-1, "%s: %s not writable\n", EXEC_NAME, dirName);
     }
 
-    sprintf(cmdBuf, "mkdir -p %s", dirName);
+    snprintf(cmdBuf, sizeof(cmdBuf), "mkdir -p %s", dirName);
     runShellCmd(cmdBuf);
 }
 
@@ -437,12 +438,12 @@ testExec(char *execName, Boolean tellIt)
     if ((path = getenv("PATH")) == (char *)NULL)
        return True;
 
-    path = XtNewString(path);
+    path = XtsNewString(path);
     pathVector = _DtVectorizeInPlace(path, ':');
 
     for (i = 0; pathVector[i] != (char *)NULL; i++)
     {
-       sprintf(execBuf, "%s/%s", pathVector[i], execName);
+       snprintf(execBuf, sizeof(execBuf), "%s/%s", pathVector[i], execName);
        if (checkStat(execBuf, FSTAT_IS_EXECUTABLE))
            break;
     }
@@ -510,7 +511,7 @@ makeWorkDir(void)
        workDir = buildPath("%s/otk.%d", gStruct->tmpDir, i);
        if (!checkStat(workDir, FSTAT_EXISTS))
        {
-           sprintf(cmdBuf, "mkdir -p %s", workDir);
+           snprintf(cmdBuf, sizeof(cmdBuf), "mkdir -p %s", workDir);
            runShellCmd(cmdBuf);
            gStruct->workDir = workDir;
 
@@ -534,8 +535,9 @@ removeWorkDir(void)
 
     if (gStruct->workDir)
     {
-       sprintf(cmdBuf, "rm -rf %s", gStruct->workDir);
+       snprintf(cmdBuf, sizeof(cmdBuf), "rm -rf %s", gStruct->workDir);
        ret = system(cmdBuf);
+       if(ret != 0) die(-1, "system for rm failed; exiting...\n");
        XtFree(gStruct->workDir);
        gStruct->workDir = (char *)NULL;
     }
@@ -604,10 +606,10 @@ doBuild(int argc, char *argv[])
                dieRWD(-1, "%s: %s: %s\n",
                       EXEC_NAME, bookcase, strerror(errno));
 
-           bcCopy = XtNewString(bookcase);
+           bcCopy = XtsNewString(bookcase);
            if ((dirName = dirname(bcCopy)) == (char *)NULL)
                dirName = ".";
-           dirName = XtNewString(dirName);
+           dirName = XtsNewString(dirName);
            XtFree(bcCopy);
 
            if (gStruct->loadESIS)
@@ -688,7 +690,8 @@ doUpdate(int argc, char *argv[])
 
        if (!gStruct->bookCase)
            printUsage(EXEC_NAME ": -b required\n", -1);
-       sprintf(bookCaseBuf, "%s/%s", gStruct->library, gStruct->bookCase);
+       snprintf(bookCaseBuf, sizeof(bookCaseBuf), "%s/%s",
+                               gStruct->library, gStruct->bookCase);
        if (!checkStat(bookCaseBuf, FSTAT_IS_DIR))
            die(-1, "%s: No such bookcase: %s\n", EXEC_NAME,
                gStruct->bookCase);
@@ -793,7 +796,7 @@ appendStr(char **str, int *curLen, int *maxLen, char *strToAppend)
        *maxLen += MAXPATHLEN;
     }
 
-    strcpy(&((*str)[*curLen]), strToAppend);
+    *((char *) memcpy (&((*str)[*curLen]), strToAppend, len) + len) = '\0';
     *curLen += len;
 }
 
@@ -802,6 +805,7 @@ makeAbsPathEnv(char *var)
 {
     char *oldPath, *newPath = NULL;
     char *newVar;
+    int pathlen;
 
     if (!var)
        return (char *)NULL;
@@ -816,8 +820,9 @@ makeAbsPathEnv(char *var)
        fprintf(stdout, "Expanding %s\n  from %s\n  to %s\n",
                var, oldPath, newPath);
 
-    newVar = XtMalloc(strlen(var) + strlen(newPath) + 2);
-    sprintf(newVar, "%s=%s", var, newPath);
+    pathlen = strlen(var) + strlen(newPath) + 2;
+    newVar = XtMalloc(pathlen);
+    snprintf(newVar, pathlen, "%s=%s", var, newPath);
     putenv(newVar);
 
     if (newPath)
@@ -841,7 +846,7 @@ makeAbsPathStr(char *str)
 
     if (str == (char *)NULL)
        return (char *)NULL;
-    str = XtNewString(str);
+    str = XtsNewString(str);
 
     if (!getcwd(cwd, MAXPATHLEN))
        cwd[0] = '\0';
@@ -909,7 +914,7 @@ static char *
 addToEnv(char *var, char *addMe, Boolean prepend)
 {
     char *envStr;
-    int len;
+    int len, ptrlen;
     char *ptr;
 
     if (!var)
@@ -917,25 +922,26 @@ addToEnv(char *var, char *addMe, Boolean prepend)
     envStr = getenv(var);
 
     if (!addMe)
-       return XtNewString(envStr);
+       return XtsNewString(envStr);
 
     len = strlen(var) + strlen(STR(envStr)) + strlen(addMe) + 3;
+    ptrlen = len * sizeof(char);
 
-    if ((ptr = XtMalloc(len * sizeof(char))) != (char *)NULL)
+    if ((ptr = XtMalloc(ptrlen)) != (char *)NULL)
     {
        if (envStr)
        {
            if (prepend)
-               sprintf(ptr, "%s=%s:%s", var, addMe, envStr);
-           else sprintf(ptr, "%s=%s:%s", var, envStr, addMe);
+               snprintf(ptr, ptrlen, "%s=%s:%s", var, addMe, envStr);
+           else snprintf(ptr, ptrlen, "%s=%s:%s", var, envStr, addMe);
        }
-       else sprintf(ptr, "%s=%s", var, addMe);
+       else snprintf(ptr, ptrlen, "%s=%s", var, addMe);
 
        putenv(ptr);
        return ptr;
     }
 
-    return XtNewString(envStr);
+    return XtsNewString(envStr);
 }
 
 static char *
@@ -945,10 +951,10 @@ buildPath(char *format, ...)
     va_list ap;
 
     va_start(ap, format);
-    vsprintf(pathBuf, format, ap);
+    vsnprintf(pathBuf, sizeof(pathBuf), format, ap);
     va_end(ap);
 
-    return XtNewString(pathBuf);
+    return XtsNewString(pathBuf);
 }
 
 /* Assumes gStruct->install and gStruct->clang */
@@ -1102,12 +1108,14 @@ static void
 checkGlobals(void)
 {
     if ((!gStruct->install) || (!checkStat(gStruct->install, FSTAT_IS_DIR)))
-       die(-1, "%s: Cannot find DtInfo Toolkit installation directory.\n\
-\n\
-The DTINFO_HOME variable must be set to the directory where the DtInfo\n\
-toolkit is installed.\n\
-\n\
-You probably invoked this script in an unsupported manner.\n", EXEC_NAME);
+       die(-1, "%s: Cannot find DtInfo Toolkit installation directory.\n"
+               "\n"
+               "The DTINFO_HOME variable must be set to the directory "
+               "where the DtInfo\n"
+               "toolkit is installed.\n"
+               "\n"
+               "You probably invoked this script in an unsupported manner.\n",
+           EXEC_NAME);
 
     if (!gStruct->arch)
        die(-1, "%s: ARCH not set\n", EXEC_NAME);
@@ -1179,7 +1187,7 @@ addCatFile(char *catalog, Bool needed)
     if (parserIsNSGMLS)
     {
        ptr1 = makeAbsPathStr(catalog);
-       sprintf(pathBuf, "-c%s ", ptr1);
+       snprintf(pathBuf, sizeof(pathBuf), "-c%s ", ptr1);
        appendStr(&gStruct->sgmlCatFiles, &gStruct->sgmlCatFilesLen,
                  &gStruct->sgmlCatFilesMaxLen, pathBuf);
        XtFree(ptr1);
@@ -1190,7 +1198,8 @@ addCatFile(char *catalog, Bool needed)
        catlen = strlen(catalog);
        if (ptr1)
            catlen -= strlen(ptr1);
-       sprintf(pathBuf, "%.*s/%%P:%.*s/%%S", catlen, catalog, catlen, catalog);
+       snprintf(pathBuf, sizeof(pathBuf), "%.*s/%%P:%.*s/%%S",
+                               catlen, catalog, catlen, catalog);
        ptr1 = makeAbsPathStr(pathBuf);
        ptr2 = addToEnv("SGML_PATH", ptr1, False);
        if (gStruct->sgmlPathEnv)
@@ -1230,7 +1239,7 @@ parseArgs(int argc, char *argv[])
            {
                int j;
 
-               gStruct->libDesc = XtNewString(argv[i]);
+               gStruct->libDesc = XtsNewString(argv[i]);
 
                /* Change TABs to SPACEs */
                for (j = 0; gStruct->libDesc[j] != '\0'; j++)
@@ -1246,8 +1255,8 @@ parseArgs(int argc, char *argv[])
            {
                gStruct->libName = argv[i];
                if (strlen(gStruct->libName) > 8)
-                   dieRWD(-1, "%s: information library name must be \n\
-less than or equal to eight characters.\n", EXEC_NAME);
+                   dieRWD(-1, "%s: information library name must be \n"
+                              "less than or equal to eight characters.\n", EXEC_NAME);
            }
        }
        else if (strcmp(argv[i], "-f") == 0)
@@ -1349,7 +1358,7 @@ static char *
 parseDocument(Boolean runCmd, ...)
 {
     va_list ap;
-    char *ptr, *ptr2;
+    char *ptr;
     char *cmd = (char *)NULL;
     int cmdLen = 0;
     int maxLen = 0;
@@ -1458,7 +1467,7 @@ buildBookcase(char *cmdSrc, char *dirName)
     {
        fprintf(stderr, "%s: deleting existing %s ...\n",
                EXEC_NAME, bookCaseDir);
-       sprintf(cmd, "rm -rf %s", bookCaseDir);
+       snprintf(cmd, sizeof(cmd), "rm -rf %s", bookCaseDir);
        runShellCmd(cmd);
 
        if (checkStat(bookCaseDir, FSTAT_IS_DIR))
@@ -1466,7 +1475,7 @@ buildBookcase(char *cmdSrc, char *dirName)
                   EXEC_NAME, bookCaseDir);
     }
 
-    sprintf(cmd, "dbdrv define %s %s \"%s\"",
+    snprintf(cmd, sizeof(cmd), "dbdrv define %s %s \"%s\"",
            gStruct->spec, bookCaseName, bookCaseDesc);
     runShellCmd(cmd);
 
@@ -1480,42 +1489,62 @@ buildBookcase(char *cmdSrc, char *dirName)
 
       const char* style_file = makeTmpFile();
 
-      sprintf(cmd, "NCFGen -load-style %s %s > %s",
+      snprintf(cmd, sizeof(cmd), "NCFGen -load-style %s %s > %s",
                        bookCaseName, dataBase, style_file);
 
       runShellCmd(cmd);
 
-      sprintf(cmd, "cat %s | dbdrv stdin_load %s %s.stylesheet",
+      snprintf(cmd, sizeof(cmd), "cat %s | dbdrv stdin_load %s %s.stylesheet",
                        style_file, bookCaseName, bookCaseName);
       runShellCmd(cmd);
 
       XtFree((char*)style_file);
 
-      sprintf(cmd, "rm -f %s", style_file);
+      snprintf(cmd, sizeof(cmd), "rm -f %s", style_file);
       ret1 = system(cmd);
+      if(ret1 != 0) die(-1, "system for rm failed; exiting...\n");
+    }
+
+
+    {
+
+      const char* compress_file = makeTmpFile();
+
+      snprintf(cmd, sizeof(cmd), "NCFGen -compressed %s %s > %s",
+                       bookCaseName, dataBase, compress_file);
+
+      runShellCmd(cmd);
+
+      snprintf(cmd, sizeof(cmd), "cat %s | dbdrv stdin_load %s %s.node",
+                       compress_file, bookCaseName, bookCaseName);
+      runShellCmd(cmd);
+
+      XtFree((char*)compress_file);
+
+      snprintf(cmd, sizeof(cmd), "rm -f %s", compress_file);
+      ret1 = system(cmd);
+      if(ret1 != 0) die(-1, "system for rm failed; exiting...\n");
     }
 
-    sprintf(cmd, "NCFGen -compressed %s %s |\
- dbdrv stdin_load %s %s.node",
-                   bookCaseName, dataBase, bookCaseName, bookCaseName);
-    runShellCmd(cmd);
 
     {
       const char* anonym_file = makeTmpFile();
 
-      sprintf(cmd, "MixedGen -compressed %s %s > %s",
+      snprintf(cmd, sizeof(cmd), "MixedGen -compressed %s %s > %s",
                        dataBase, bookCaseDir, anonym_file);
 
       runShellCmd(cmd);
 
-      sprintf(cmd, "cat %s | dbdrv mixed_load %s", anonym_file, bookCaseName);
+      snprintf(cmd, sizeof(cmd), "cat %s | dbdrv mixed_load %s",
+                                       anonym_file, bookCaseName);
 
       runShellCmd(cmd);
 
       XtFree((char*)anonym_file);
 
-      sprintf(cmd, "rm -f %s", anonym_file);
+      snprintf(cmd, sizeof(cmd), "rm -f %s", anonym_file);
       ret1 = system(cmd);
+      if(ret1 != 0) die(-1, "system for rm failed; exiting...\n");
     }
 
     validateBookCase(bookCaseMap, bookCaseName);
@@ -1527,35 +1556,35 @@ buildBookcase(char *cmdSrc, char *dirName)
        char newDir[MAXPATHLEN + 1];
        const char *dtsr_stp, *dtsr_sfx, *dtsr_knj;
 
-       sprintf(cmd, "mkdir -p %s/%s",
+       snprintf(cmd, sizeof(cmd), "mkdir -p %s/%s",
                bookCaseDir, gStruct->searchEngine);
        runShellCmd(cmd);
 
-       sprintf(cmd, "cp %s/%s/%s.fzk %s/%s",
+       snprintf(cmd, sizeof(cmd), "cp %s/%s/%s.fzk %s/%s",
                dataBase, gStruct->searchEngine, bookCaseName,
                bookCaseDir, gStruct->searchEngine);
        runShellCmd(cmd);
 
-       sprintf(cmd, "cp %s %s/%s",
+       snprintf(cmd, sizeof(cmd), "cp %s %s/%s",
                gStruct->dbdfile, bookCaseDir, gStruct->searchEngine);
        runShellCmd(cmd);
 
-       if (dtsr_stp = langtbl[gStruct->dtsridx].stp) {
-           sprintf(cmd, "cp %s/%s %s/%s/%s.stp",
+       if ((dtsr_stp = langtbl[gStruct->dtsridx].stp)) {
+           snprintf(cmd, sizeof(cmd), "cp %s/%s %s/%s/%s.stp",
                    gStruct->dtsrlib, dtsr_stp, bookCaseDir,
                    gStruct->searchEngine, bookCaseName);
            runShellCmd(cmd);
        }
 
-       if (dtsr_sfx = langtbl[gStruct->dtsridx].sfx) {
-           sprintf(cmd, "cp %s/%s %s/%s/%s.sfx",
+       if ((dtsr_sfx = langtbl[gStruct->dtsridx].sfx)) {
+           snprintf(cmd, sizeof(cmd), "cp %s/%s %s/%s/%s.sfx",
                    gStruct->dtsrlib, dtsr_sfx, bookCaseDir,
                    gStruct->searchEngine, bookCaseName);
            runShellCmd(cmd);
        }
 
-       if (dtsr_knj = langtbl[gStruct->dtsridx].knj) {
-           sprintf(cmd, "cp %s/%s %s/%s/%s.knj",
+       if ((dtsr_knj = langtbl[gStruct->dtsridx].knj)) {
+           snprintf(cmd, sizeof(cmd), "cp %s/%s %s/%s/%s.knj",
                    gStruct->dtsrlib, dtsr_knj, bookCaseDir,
                    gStruct->searchEngine, bookCaseName);
            runShellCmd(cmd);
@@ -1563,31 +1592,33 @@ buildBookcase(char *cmdSrc, char *dirName)
 
        curDir[0] = '\0';
        ret2 = getcwd(curDir, MAXPATHLEN);
-       sprintf(newDir, "%s/%s", bookCaseDir, gStruct->searchEngine);
+       if(ret2 == (char *)NULL) die(-1, "getcwd failed; exiting...\n");
+       snprintf(newDir, sizeof(newDir), "%s/%s",
+                               bookCaseDir, gStruct->searchEngine);
        if (chdir(newDir) != 0)
            dieRWD(-1, "%s: Cannot find %s: %s\n",
                   EXEC_NAME, newDir, strerror(errno));
 
-       sprintf(cmd, "dtsrcreate %s-o -l%d %s",
+       snprintf(cmd, sizeof(cmd), "dtsrcreate %s-o -l%d %s",
                (gStruct->verbose) ? "" : "-q ",
                langtbl[gStruct->dtsridx].dtsrlang, bookCaseName);
        runShellCmd(cmd);
 
-       sprintf(cmd, "dtsrload -d%s '-t\n' %s",
+       snprintf(cmd, sizeof(cmd), "dtsrload -d%s '-t\n' %s",
                bookCaseName, bookCaseName);
        runShellCmd(cmd);
 
-       sprintf(cmd, "dtsrindex -d%s '-t\n' %s",
+       snprintf(cmd, sizeof(cmd), "dtsrindex -d%s '-t\n' %s",
                bookCaseName, bookCaseName);
        runShellCmd(cmd);
 
-       sprintf(cmd, "echo keytypes %s = %s > %s.ocf",
+       snprintf(cmd, sizeof(cmd), "echo keytypes %s = %s > %s.ocf",
                bookCaseName, gStruct->keytypes, gStruct->searchEngine);
        runShellCmd(cmd);
 
-       sprintf(cmd, "%s.fzk", bookCaseName);
+       snprintf(cmd, sizeof(cmd), "%s.fzk", bookCaseName);
        unlink(cmd);
-       sprintf(cmd, "%s.dbd", gStruct->searchEngine);
+       snprintf(cmd, sizeof(cmd), "%s.dbd", gStruct->searchEngine);
        unlink(cmd);
 
        if (chdir(curDir) != 0)
@@ -1606,11 +1637,32 @@ storeBookCase(char *cmdSrc, char *tocOpt, char *dbName,
 {
     char *tmpFile;
     char *cmd;
+    int ret;
+
+    /*
+     * changed not to use pipe for better error handling
+     */
+    {
+
+      const char* nsgmls_file = makeTmpFile();
+
+      cmd = buildPath("%s > %s;echo", cmdSrc, nsgmls_file);
+
+      runShellCmd(cmd);
+
+      tmpFile = makeTmpFile();
+
+      cmd = buildPath("cat %s | NodeParser %s %s %s > %s",
+                       nsgmls_file, tocOpt, dbName, dirName, tmpFile);
+      runShellCmd(cmd);
+
+      XtFree((char*)nsgmls_file);
+
+      cmd = buildPath("rm -f %s", nsgmls_file);
+      ret = system(cmd);
+      if(ret != 0) die(-1, "system for rm failed; exiting...\n");
+    }
 
-    tmpFile = makeTmpFile();
-    cmd = buildPath("%s | NodeParser %s %s %s > %s",
-                   cmdSrc, tocOpt, dbName, dirName, tmpFile);
-    runShellCmd(cmd);
     XtFree(cmd);
 
     return tmpFile;
@@ -1625,6 +1677,7 @@ findBookCaseNameAndDesc(char *tmpFile, char *bookCaseName,
     char *p1, *p2;
     static char *patt1 = "BookCase name: `";
     static char *patt2 = "' desc: `";
+    unsigned int len;
 
     if ((fp = fopen(tmpFile, "r")) == (FILE *)NULL)
        dieRWD(-1, "%s: opening %s: %s\n",
@@ -1637,14 +1690,14 @@ findBookCaseNameAndDesc(char *tmpFile, char *bookCaseName,
            p1 += strlen(patt1);
            if ((p2 = strstr(p1, patt2)) != (char *)NULL)
            {
-               strncpy(bookCaseName, p1, p2 - p1);
-               bookCaseName[p2 - p1] = '\0';
+               len = p2 - p1;
+               *((char *) memcpy(bookCaseName, p1, len) + len) = '\0';
                validateBookCaseName(bookCaseName);
                p1 = p2 + strlen(patt2);
                if ((p2 = strchr(p1, '\'')) != (char *)NULL)
                {
-                   strncpy(bookCaseDesc, p1, p2 - p1);
-                   bookCaseDesc[p2 - p1] = '\0';
+                   len = p2 - p1;
+                   *((char *) memcpy(bookCaseDesc, p1, len) + len) = '\0';
                    fclose(fp);
 
                    return True;
@@ -1676,8 +1729,8 @@ validateBookCaseName(char *bookCaseName)
     }
 
     if (!isOk)
-       dieRWD(-1, "%s: Bookcase name `%s' is not valid;\n\
-only 8 alphanumeric characters are allowed\n",
+       dieRWD(-1, "%s: Bookcase name `%s' is not valid;\n"
+                  "only 8 alphanumeric characters are allowed\n",
               EXEC_NAME, bookCaseName);
 }
 
@@ -1695,13 +1748,16 @@ validateBookCase(char *mapFile, char *bookCaseName)
               EXEC_NAME, strerror(errno));
 
     ret = fgets(lineBuf, MAXPATHLEN, fp); /* Skip first line. */
+    if(ret == (char *)NULL) die(-1, "fgets failed; exiting...\n");
+
     while (fgets(lineBuf, MAXPATHLEN, fp) != (char *)NULL)
     {
        if ((bcName = strtok(lineBuf, "\t\n")) != (char *)NULL)
        {
            if (strcmp(bcName, bookCaseName) != 0)
            {
-               sprintf(cmdBuf, "valBase %s %s", bookCaseName, bcName);
+               snprintf(cmdBuf, sizeof(cmdBuf), "valBase %s %s",
+                                       bookCaseName, bcName);
 
                /* Should this return an error code instead of */
                /* exiting so that we can cleanup the bookcase? */
@@ -1718,7 +1774,7 @@ editMapFile(char *bookCaseName, char *bookCaseMap)
 {
     size_t ret;
     struct stat statBuf;
-    FILE *fp;
+    FILE *fp = NULL;
     char *file;
     char **fileVector;
     char *libDesc;
@@ -1737,6 +1793,7 @@ editMapFile(char *bookCaseName, char *bookCaseMap)
 
     file = XtMalloc((statBuf.st_size + 1) * sizeof(char));
     ret = fread(file, statBuf.st_size, sizeof(char), fp);
+    if(ret == 0) die(-1, "fread failed; exiting...\n");
     if (file[statBuf.st_size - 1] == '\n')
        file[statBuf.st_size - 1] = '\0';
     else file[statBuf.st_size] = '\0';
@@ -1744,7 +1801,7 @@ editMapFile(char *bookCaseName, char *bookCaseMap)
 
     fileVector = _DtVectorizeInPlace(file, '\n');
 
-    firstLine = XtNewString(fileVector[0]);
+    firstLine = XtsNewString(fileVector[0]);
     lineVector = _DtVectorizeInPlace(firstLine, '\t');
     if ((oldDesc = lineVector[0]) != (char *)NULL)
        libID = lineVector[1];
@@ -1805,13 +1862,17 @@ buildTOC(int argc, char *argv[])
     char *tocBC;
     char *tocDir;
     char *cmdSrc;
+    unsigned int len;
     static char *patt1start = "<TOC id=\"";
     static char *patt1end = "\">";
     static char *patt2start = "<TITLE>";
     static char *patt2end = "</TITLE>";
 
-    strcpy(idBuf, gStruct->id);
-    strcpy(titleBuf, gStruct->title);
+    len = MIN(strlen(gStruct->id), MAXPATHLEN);
+    *((char *) memcpy (idBuf, gStruct->id, len) + len) = '\0';
+    len = MIN(strlen(gStruct->title), MAXPATHLEN);
+    *((char *) memcpy (titleBuf, gStruct->id, len) + len) = '\0';
+
     if (checkStat(gStruct->outFile, FSTAT_IS_FILE))
     {
        if ((fp = fopen(gStruct->outFile, "r")) == (FILE *)NULL)
@@ -1826,8 +1887,8 @@ buildTOC(int argc, char *argv[])
                p1 += strlen(patt1start);
                if ((p2 = strstr(p1, patt1end)) != (char *)NULL)
                {
-                   strncpy(idBuf, p1, p2 - p1);
-                   idBuf[p2 - p1] = '\0';
+                   len = p2 - p1;
+                   *((char *) memcpy(idBuf, p1, len) + len) = '\0';
                }
            }
            if ((p1 = strstr(lineBuf, patt2start)) != (char *)NULL)
@@ -1835,8 +1896,8 @@ buildTOC(int argc, char *argv[])
                p1 += strlen(patt2start);
                if ((p2 = strstr(p1, patt2end)) != (char *)NULL)
                {
-                   strncpy(titleBuf, p1, p2 - p1);
-                   titleBuf[p2 - p1] = '\0';
+                   len = p2 - p1;
+                   *((char *) memcpy(titleBuf, p1, len) + len) = '\0';
                }
            }
        }
@@ -1852,7 +1913,7 @@ buildTOC(int argc, char *argv[])
     cmdSrc = parseDocument(False, tocBC, 0);
     if ((tocDir = dirname(tocBC)) == (char *)NULL)
        tocDir = ".";
-    tocDir = XtNewString(tocDir);
+    tocDir = XtsNewString(tocDir);
     p1 = storeBookCase(cmdSrc, "toc", makeWorkDir(), tocDir);
     XtFree(p1);
     XtFree(tocDir);
@@ -1880,10 +1941,11 @@ tocBookcase(int argc, char *argv[])
        dieRWD(-1, "%s: %s: %s\n", EXEC_NAME,
               tmpFile, strerror(errno));
 
-    fputs("<!DOCTYPE Bookcase PUBLIC \n\
-\"-//Common Desktop Environment//DTD DtInfo Bookcase Description//EN\" \n\
-[\n\
-        <!-- Books -->\n",
+    fputs("<!DOCTYPE Bookcase PUBLIC \n"
+         "\"-//Common Desktop Environment//"
+         "DTD DtInfo Bookcase Description//EN\" \n"
+         "[\n"
+         "        <!-- Books -->\n",
          fp);
 
     for (i = 0; i < argc; i++)
@@ -1892,14 +1954,15 @@ tocBookcase(int argc, char *argv[])
                i + 1, argv[i]);
     }
 
-    fputs("]>\n\
-<BOOKCASE StyleSheet=dummySty>\n\
-        <BOOKCASENAME>TOCDummy</>\n\
-        <BOOKCASEDESC>Dummy Bookcase for TOC Generation</>\n\
-        <StyleSheet name=\"dummySty\"><path>*</><online><linebreak after></></>\n\
-       <BOOK>\n\
-       <TITLE>Dummy Book for TOC Generation</>\n\
-       <TOCFILE></>\n",
+    fputs("]>\n"
+         "<BOOKCASE StyleSheet=dummySty>\n"
+         "        <BOOKCASENAME>TOCDummy</>\n"
+         "        <BOOKCASEDESC>Dummy Bookcase for TOC Generation</>\n"
+         "        <StyleSheet name=\"dummySty\"><path>*</>"
+         "<online><linebreak after></></>\n"
+         "     <BOOK>\n"
+         "     <TITLE>Dummy Book for TOC Generation</>\n"
+         "     <TOCFILE></>\n",
          fp);
 
     for (i = 0; i < argc; i++)
@@ -1907,8 +1970,8 @@ tocBookcase(int argc, char *argv[])
        fprintf(fp, "\t<FILE>&book%d;</>\n", i + 1);
     }
 
-    fputs("    </BOOK>\n\
-</BOOKCASE>\n",
+    fputs("    </BOOK>\n"
+         "</BOOKCASE>\n",
          fp);
 
     fclose(fp);
@@ -1950,7 +2013,7 @@ makeTOC(char *id, char *title)
        dieRWD(-1, "%s: %s: %s\n",
               EXEC_NAME, gStruct->outFile, strerror(errno));
 
-    while (tocRecord = getTOCRecord(fpIn))
+    while ((tocRecord = getTOCRecord(fpIn)))
     {
        char lineBuf[MAXPATHLEN + 1];
 
@@ -1963,7 +2026,8 @@ makeTOC(char *id, char *title)
        ptr2 = replaceData(ptr1, "\"", "&#34;");
        XtFree(ptr1);
 
-       sprintf(lineBuf, "<TOCEntry LinkEnd=\"%s\">%s</> <!-- %s:%s -->\n",
+       snprintf(lineBuf, sizeof(lineBuf),
+               "<TOCEntry LinkEnd=\"%s\">%s</> <!-- %s:%s -->\n",
                ptr2, trTitle, STR(tocRecord->file),
                STR(tocRecord->line));
        XtFree(ptr2);
@@ -1979,10 +2043,11 @@ makeTOC(char *id, char *title)
 
     fclose(fpIn);
 
-    fprintf(fpOut, "<!DOCTYPE TOC PUBLIC\n\
-    \"-//Common Desktop Environment//DTD DtInfo Table of Contents//EN\">\n\
-<TOC id=\"%s\">\n\
-<TITLE>%s</TITLE>\n",
+    fprintf(fpOut, "<!DOCTYPE TOC PUBLIC\n"
+                  "    \"-//Common Desktop Environment//"
+                  "DTD DtInfo Table of Contents//EN\">\n"
+                  "<TOC id=\"%s\">\n"
+                  "<TITLE>%s</TITLE>\n",
            id, tocTitle);
     XtFree(tocTitle);
 
@@ -2054,7 +2119,7 @@ sgmlData(char *inData)
 static char *
 replaceData(char *inData, char *replaceMe, char *replacement)
 {
-    int i;
+    int i, slen, len;
     int newLen;
     int replaceMeLen = strlen(replaceMe);
     char *p, *endP;
@@ -2069,7 +2134,7 @@ replaceData(char *inData, char *replaceMe, char *replacement)
     }
 
     if (i == 0)
-       return XtNewString(inData);
+       return XtsNewString(inData);
 
     newLen = strlen(inData) + (i * (strlen(replacement) - replaceMeLen));
     newData = XtMalloc((newLen + 1) * sizeof(char));
@@ -2077,11 +2142,18 @@ replaceData(char *inData, char *replaceMe, char *replacement)
     p = inData;
     while ((endP = strstr(p, replaceMe)) != (char *)NULL)
     {
-       strncat(newData, p, endP - p);
-       strcat(newData, replacement);
+       slen = strlen(newData);
+       len = endP - p;
+       *((char *) memcpy(newData + slen, p, len) + len) = '\0';
+
+       slen = strlen(newData);
+       len = MIN(strlen(replacement), (newLen - slen) * sizeof(char));
+       *((char *) memcpy(newData + slen, replacement, len) + len) = '\0';
        p = endP + replaceMeLen;
     }
-    strcat(newData, p);
+    slen = strlen(newData);
+    len = MIN(strlen(p), (newLen - slen) * sizeof(char));
+    *((char *) memcpy(newData + slen, p, len) + len) = '\0';
 
     return newData;
 }
@@ -2104,8 +2176,8 @@ addTOCEntry(TOCEntry **tocEntries, int *nTOCEntries, int *maxEntries,
        *maxEntries += 10;
     }
 
-    (*tocEntries)[*nTOCEntries].ord = XtNewString(newEntry->ord);
-    (*tocEntries)[*nTOCEntries].entry = XtNewString(newEntry->entry);
+    (*tocEntries)[*nTOCEntries].ord = XtsNewString(newEntry->ord);
+    (*tocEntries)[*nTOCEntries].entry = XtsNewString(newEntry->entry);
     (*nTOCEntries)++;
 }
 
@@ -2314,7 +2386,7 @@ getTOCField(FILE *fp)
        if ((ptrLen > 0) && (ptr[ptrLen - 1] == '\n'))
            ptr[ptrLen - 1] = '\0';
 
-       ptr = XtNewString(ptr);
+       ptr = XtsNewString(ptr);
 
        if (longField != (char *)NULL)
            XtFree(longField);
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/gr_type.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/gr_type.C
index e55fdb43770190a46937a1f9fb6374ce77d9dbe7..31ab30daf9b999d850da688dabd95c9436c113a7 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/gr_type.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/gr_type.C
@@ -219,7 +219,7 @@ extern GR_TYPE gtype;
 
 static short int graphics_task_nxt[][256] =
     {
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+     {  0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
@@ -246,9 +246,9 @@ static short int graphics_task_nxt[][256] =
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0 },
 
-        3,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+     {  3,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         5,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
@@ -275,9 +275,9 @@ static short int graphics_task_nxt[][256] =
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    4,    4,    4,    4,
+        4,    4,    4,    4,    4,    4 },
 
-        3,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+     {  3,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         5,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    7,    4,    8,    4,    4,
@@ -304,9 +304,9 @@ static short int graphics_task_nxt[][256] =
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
-        4,    4,    4,    4,    4,   13,
+        4,    4,    4,    4,    4,   13 },
 
-       -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
+     { -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
@@ -333,9 +333,9 @@ static short int graphics_task_nxt[][256] =
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
        -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
-       -3,   -3,   -3,   -3,   -3,   -3,
+       -3,   -3,   -3,   -3,   -3,   -3 },
 
-        3,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
+     {  3,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
        -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
        -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
        -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
@@ -362,9 +362,9 @@ static short int graphics_task_nxt[][256] =
        -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
        -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
        -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,
-       -4,   -4,   -4,   -4,   -4,   -4,
+       -4,   -4,   -4,   -4,   -4,   -4 },
 
-        3,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
+     {  3,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
@@ -391,9 +391,9 @@ static short int graphics_task_nxt[][256] =
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
-       -5,   -5,   -5,   -5,   -5,   -5,
+       -5,   -5,   -5,   -5,   -5,   -5 },
 
-        3,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
+     {  3,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
@@ -420,9 +420,9 @@ static short int graphics_task_nxt[][256] =
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
-       -6,   -6,   -6,   -6,   -6,   -6,
+       -6,   -6,   -6,   -6,   -6,   -6 },
 
-        3,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
+     {  3,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
@@ -449,9 +449,9 @@ static short int graphics_task_nxt[][256] =
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
-       -7,   -7,   -7,   -7,   -7,   -7,
+       -7,   -7,   -7,   -7,   -7,   -7 },
 
-        3,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,
+     {  3,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,
        -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,
        -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,
        -8,   -8,   -8,   16,   -8,   -8,   -8,   -8,   -8,   -8,
@@ -478,9 +478,9 @@ static short int graphics_task_nxt[][256] =
        -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,
        -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,
        -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,   -8,
-       -8,   -8,   -8,   -8,   -8,   -8,
+       -8,   -8,   -8,   -8,   -8,   -8 },
 
-        3,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
+     {  3,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
@@ -507,9 +507,9 @@ static short int graphics_task_nxt[][256] =
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
        -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,   -9,
-       -9,   -9,   -9,   -9,   -9,   -9,
+       -9,   -9,   -9,   -9,   -9,   -9 },
 
-        3,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
+     {  3,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
@@ -536,9 +536,9 @@ static short int graphics_task_nxt[][256] =
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
       -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,  -10,
-      -10,  -10,  -10,  -10,  -10,  -10,
+      -10,  -10,  -10,  -10,  -10,  -10 },
 
-        3,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
+     {  3,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
@@ -565,9 +565,9 @@ static short int graphics_task_nxt[][256] =
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
-      -11,  -11,  -11,  -11,  -11,  -11,
+      -11,  -11,  -11,  -11,  -11,  -11 },
 
-        3,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
+     {  3,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
@@ -594,9 +594,9 @@ static short int graphics_task_nxt[][256] =
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
       -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,  -12,
-      -12,  -12,  -12,  -12,  -12,  -12,
+      -12,  -12,  -12,  -12,  -12,  -12 },
 
-        3,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
+     {  3,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
@@ -623,9 +623,9 @@ static short int graphics_task_nxt[][256] =
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
       -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,  -13,
-      -13,  -13,  -13,  -13,  -13,  -13,
+      -13,  -13,  -13,  -13,  -13,  -13 },
 
-        3,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
+     {  3,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
@@ -652,9 +652,9 @@ static short int graphics_task_nxt[][256] =
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
-      -14,  -14,  -14,  -14,  -14,  -14,
+      -14,  -14,  -14,  -14,  -14,  -14 },
 
-        3,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
+     {  3,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
@@ -681,9 +681,9 @@ static short int graphics_task_nxt[][256] =
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
       -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,  -15,
-      -15,  -15,  -15,  -15,  -15,  -15,
+      -15,  -15,  -15,  -15,  -15,  -15 },
 
-        3,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
+     {  3,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
@@ -710,9 +710,9 @@ static short int graphics_task_nxt[][256] =
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
       -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,  -16,
-      -16,  -16,  -16,  -16,  -16,  -16,
+      -16,  -16,  -16,  -16,  -16,  -16 },
 
-        3,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
+     {  3,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
@@ -739,9 +739,9 @@ static short int graphics_task_nxt[][256] =
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
-      -17,  -17,  -17,  -17,  -17,  -17,
+      -17,  -17,  -17,  -17,  -17,  -17 },
 
-        3,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
+     {  3,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
@@ -768,9 +768,9 @@ static short int graphics_task_nxt[][256] =
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
-      -18,  -18,  -18,  -18,  -18,  -18,
+      -18,  -18,  -18,  -18,  -18,  -18 },
 
-        3,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
+     {  3,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
@@ -797,9 +797,9 @@ static short int graphics_task_nxt[][256] =
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
       -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,  -19,
-      -19,  -19,  -19,  -19,  -19,  -19,
+      -19,  -19,  -19,  -19,  -19,  -19 },
 
-        3,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
+     {  3,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
@@ -826,9 +826,9 @@ static short int graphics_task_nxt[][256] =
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
-      -20,  -20,  -20,  -20,  -20,  -20,
+      -20,  -20,  -20,  -20,  -20,  -20 },
 
-        3,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
+     {  3,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
@@ -855,9 +855,9 @@ static short int graphics_task_nxt[][256] =
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
-      -21,  -21,  -21,  -21,  -21,  -21,
+      -21,  -21,  -21,  -21,  -21,  -21 },
 
-        3,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
+     {  3,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
@@ -884,9 +884,9 @@ static short int graphics_task_nxt[][256] =
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
       -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,  -22,
-      -22,  -22,  -22,  -22,  -22,  -22,
+      -22,  -22,  -22,  -22,  -22,  -22 },
 
-        3,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
+     {  3,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
@@ -913,9 +913,9 @@ static short int graphics_task_nxt[][256] =
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
       -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,  -23,
-      -23,  -23,  -23,  -23,  -23,   29,
+      -23,  -23,  -23,  -23,  -23,   29 },
 
-        3,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
+     {  3,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
@@ -942,9 +942,9 @@ static short int graphics_task_nxt[][256] =
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
       -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,  -24,
-      -24,  -24,  -24,  -24,  -24,  -24,
+      -24,  -24,  -24,  -24,  -24,  -24 },
 
-        3,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
+     {  3,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
@@ -971,9 +971,9 @@ static short int graphics_task_nxt[][256] =
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
       -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,  -25,
-      -25,  -25,  -25,  -25,  -25,  -25,
+      -25,  -25,  -25,  -25,  -25,  -25 },
 
-        3,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
+     {  3,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
@@ -1000,9 +1000,9 @@ static short int graphics_task_nxt[][256] =
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
       -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,  -26,
-      -26,  -26,  -26,  -26,  -26,  -26,
+      -26,  -26,  -26,  -26,  -26,  -26 },
 
-        3,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
+     {  3,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
@@ -1029,9 +1029,9 @@ static short int graphics_task_nxt[][256] =
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
-      -27,  -27,  -27,  -27,  -27,  -27,
+      -27,  -27,  -27,  -27,  -27,  -27 },
 
-        3,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
+     {  3,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
@@ -1058,9 +1058,9 @@ static short int graphics_task_nxt[][256] =
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
       -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,  -28,
-      -28,  -28,  -28,  -28,  -28,  -28,
+      -28,  -28,  -28,  -28,  -28,  -28 },
 
-        3,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
+     {  3,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
@@ -1087,9 +1087,9 @@ static short int graphics_task_nxt[][256] =
       -29,  -29,  -29,  -29,   34,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
       -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,  -29,
-      -29,  -29,  -29,  -29,  -29,  -29,
+      -29,  -29,  -29,  -29,  -29,  -29 },
 
-        3,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
+     {  3,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
@@ -1116,9 +1116,9 @@ static short int graphics_task_nxt[][256] =
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
       -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,  -30,
-      -30,  -30,  -30,  -30,  -30,  -30,
+      -30,  -30,  -30,  -30,  -30,  -30 },
 
-        3,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
+     {  3,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
@@ -1145,9 +1145,9 @@ static short int graphics_task_nxt[][256] =
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
-      -31,  -31,  -31,  -31,  -31,  -31,
+      -31,  -31,  -31,  -31,  -31,  -31 },
 
-        3,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
+     {  3,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
@@ -1174,9 +1174,9 @@ static short int graphics_task_nxt[][256] =
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
-      -32,  -32,  -32,  -32,  -32,  -32,
+      -32,  -32,  -32,  -32,  -32,  -32 },
 
-        3,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
+     {  3,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
@@ -1203,9 +1203,9 @@ static short int graphics_task_nxt[][256] =
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
-      -33,  -33,  -33,  -33,  -33,  -33,
+      -33,  -33,  -33,  -33,  -33,  -33 },
 
-        3,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
+     {  3,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
@@ -1232,9 +1232,9 @@ static short int graphics_task_nxt[][256] =
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
-      -34,  -34,  -34,  -34,  -34,  -34,
+      -34,  -34,  -34,  -34,  -34,  -34 },
 
-        3,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
+     {  3,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
@@ -1261,9 +1261,9 @@ static short int graphics_task_nxt[][256] =
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
       -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,  -35,
-      -35,  -35,  -35,  -35,  -35,  -35,
+      -35,  -35,  -35,  -35,  -35,  -35 },
 
-        3,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
+     {  3,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
@@ -1290,9 +1290,9 @@ static short int graphics_task_nxt[][256] =
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
-      -36,  -36,  -36,  -36,  -36,  -36,
+      -36,  -36,  -36,  -36,  -36,  -36 },
 
-        3,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
+     {  3,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
@@ -1319,9 +1319,9 @@ static short int graphics_task_nxt[][256] =
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
-      -37,  -37,  -37,  -37,  -37,  -37,
+      -37,  -37,  -37,  -37,  -37,  -37 },
 
-        3,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
+     {  3,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
@@ -1348,9 +1348,9 @@ static short int graphics_task_nxt[][256] =
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
       -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,  -38,
-      -38,  -38,  -38,  -38,  -38,  -38,
+      -38,  -38,  -38,  -38,  -38,  -38 },
 
-        3,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
+     {  3,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,   40,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
@@ -1377,9 +1377,9 @@ static short int graphics_task_nxt[][256] =
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
-      -39,  -39,  -39,  -39,  -39,  -39,
+      -39,  -39,  -39,  -39,  -39,  -39 },
 
-        3,   41,   41,   41,   41,   41,   41,   41,   41,   41,
+     {  3,   41,   41,   41,   41,   41,   41,   41,   41,   41,
       -40,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,  -40,   41,   41,   41,   41,   41,   41,   41,
@@ -1406,9 +1406,9 @@ static short int graphics_task_nxt[][256] =
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
-       41,   41,   41,   41,   41,   41,
+       41,   41,   41,   41,   41,   41 },
 
-        3,   41,   41,   41,   41,   41,   41,   41,   41,   41,
+     {  3,   41,   41,   41,   41,   41,   41,   41,   41,   41,
       -41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,  -41,   41,   41,   41,   41,   41,   41,   41,
@@ -1435,9 +1435,9 @@ static short int graphics_task_nxt[][256] =
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
-       41,   41,   41,   41,   41,   41,
+       41,   41,   41,   41,   41,   41 },
 
-        3,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
+     {  3,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
@@ -1464,9 +1464,9 @@ static short int graphics_task_nxt[][256] =
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
-      -42,  -42,  -42,  -42,  -42,  -42,
+      -42,  -42,  -42,  -42,  -42,  -42 },
 
-        3,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
+     {  3,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
@@ -1493,9 +1493,9 @@ static short int graphics_task_nxt[][256] =
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
-      -43,  -43,  -43,  -43,  -43,  -43,
+      -43,  -43,  -43,  -43,  -43,  -43 },
 
-        3,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
+     {  3,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
@@ -1522,9 +1522,9 @@ static short int graphics_task_nxt[][256] =
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
-      -44,  -44,  -44,  -44,  -44,  -44,
+      -44,  -44,  -44,  -44,  -44,  -44 },
 
-        3,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+     {  3,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
@@ -1551,9 +1551,9 @@ static short int graphics_task_nxt[][256] =
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
-      -45,  -45,  -45,  -45,  -45,  -45,
+      -45,  -45,  -45,  -45,  -45,  -45 },
 
-        3,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
+     {  3,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
@@ -1580,9 +1580,9 @@ static short int graphics_task_nxt[][256] =
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
-      -46,  -46,  -46,  -46,  -46,  -46,
+      -46,  -46,  -46,  -46,  -46,  -46 },
 
-        3,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
+     {  3,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
@@ -1609,9 +1609,9 @@ static short int graphics_task_nxt[][256] =
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
       -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,  -47,
-      -47,  -47,  -47,  -47,  -47,  -47,
+      -47,  -47,  -47,  -47,  -47,  -47 },
 
-        3,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
+     {  3,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
@@ -1638,9 +1638,9 @@ static short int graphics_task_nxt[][256] =
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
       -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,  -48,
-      -48,  -48,  -48,  -48,  -48,  -48,
+      -48,  -48,  -48,  -48,  -48,  -48 },
 
-        3,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
+     {  3,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
@@ -1667,9 +1667,9 @@ static short int graphics_task_nxt[][256] =
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
       -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,  -49,
-      -49,  -49,  -49,  -49,  -49,  -49,
+      -49,  -49,  -49,  -49,  -49,  -49 },
 
-        3,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
+     {  3,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
@@ -1696,9 +1696,9 @@ static short int graphics_task_nxt[][256] =
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
       -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,  -50,
-      -50,  -50,  -50,  -50,  -50,  -50,
+      -50,  -50,  -50,  -50,  -50,  -50 },
 
-        3,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
+     {  3,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
@@ -1725,7 +1725,7 @@ static short int graphics_task_nxt[][256] =
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
       -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,  -51,
-      -51,  -51,  -51,  -51,  -51,  -51
+      -51,  -51,  -51,  -51,  -51,  -51 }
 
     } ;
 
@@ -1861,7 +1861,9 @@ static int graphics_task_did_buffer_switch_on_eof;
 static graphics_task_state_type graphics_task_get_previous_state graphics_task_PROTO(( void ));
 static graphics_task_state_type graphics_task_try_NUL_trans graphics_task_PROTO(( graphics_task_state_type current_state ));
 static int graphics_task_get_next_buffer graphics_task_PROTO(( void ));
+#if 0
 static void graphics_taskunput graphics_task_PROTO(( graphics_task_CHAR c, graphics_task_CHAR *buf_ptr ));
+#endif
 void graphics_taskrestart graphics_task_PROTO(( FILE *input_file ));
 void graphics_task_switch_to_buffer graphics_task_PROTO(( graphics_task_BUFFER_STATE new_buffer ));
 void graphics_task_load_buffer_state graphics_task_PROTO(( void ));
@@ -2300,6 +2302,7 @@ register graphics_task_state_type graphics_task_current_state;
     }
 
 
+#if 0
 #ifdef graphics_task_USE_PROTOS
 static void graphics_taskunput( graphics_task_CHAR c, register graphics_task_CHAR *graphics_task_bp )
 #else
@@ -2343,6 +2346,7 @@ register graphics_task_CHAR *graphics_task_bp;
      */
     graphics_task_DO_BEFORE_ACTION; /* set up graphics_tasktext again */
     }
+#endif
 
 
 #ifdef __cplusplus
diff --git a/cde/programs/dtinfo/dtinfogen/infolib/etc/lex.C b/cde/programs/dtinfo/dtinfogen/infolib/etc/lex.C
index d7d39e824b5e7963cfeffbe0fa6eec5083d5dfa6..4f0393902c81cb5bd3104f34c21c952220c95d8f 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/infolib/etc/lex.C
+++ b/cde/programs/dtinfo/dtinfogen/infolib/etc/lex.C
@@ -243,7 +243,7 @@ unsigned char oct2dec( const char *str )
 #define ProcessData 1
 static short int yy_nxt[][256] =
     {
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+     {  0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
@@ -270,9 +270,9 @@ static short int yy_nxt[][256] =
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0 },
 
-        5,    6,    6,    6,    6,    6,    6,    6,    6,    6,
+     {  5,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         7,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
@@ -299,9 +299,9 @@ static short int yy_nxt[][256] =
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
-        6,    6,    6,    6,    6,    6,
+        6,    6,    6,    6,    6,    6 },
 
-        5,    6,    6,    6,    6,    6,    6,    6,    6,    6,
+     {  5,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         7,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    8,    6,
@@ -328,9 +328,9 @@ static short int yy_nxt[][256] =
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
-        6,    6,    6,    6,    6,    6,
+        6,    6,    6,    6,    6,    6 },
 
-        5,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+     {  5,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        20,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
@@ -357,9 +357,9 @@ static short int yy_nxt[][256] =
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
-       19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19 },
 
-        5,   19,   19,   19,   19,   19,   19,   19,   19,   19,
+     {  5,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        20,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
@@ -386,9 +386,9 @@ static short int yy_nxt[][256] =
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
        19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
-       19,   19,   19,   19,   19,   19,
+       19,   19,   19,   19,   19,   19 },
 
-       -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
+     { -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
@@ -415,9 +415,9 @@ static short int yy_nxt[][256] =
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
        -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,   -5,
-       -5,   -5,   -5,   -5,   -5,   -5,
+       -5,   -5,   -5,   -5,   -5,   -5 },
 
-        5,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
+     {  5,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
@@ -444,9 +444,9 @@ static short int yy_nxt[][256] =
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
        -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,   -6,
-       -6,   -6,   -6,   -6,   -6,   -6,
+       -6,   -6,   -6,   -6,   -6,   -6 },
 
-        5,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
+     {  5,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
@@ -473,9 +473,9 @@ static short int yy_nxt[][256] =
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
        -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,   -7,
-       -7,   -7,   -7,   -7,   -7,   -7,
+       -7,   -7,   -7,   -7,   -7,   -7 },
 
-        5,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+     {  5,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        -8,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
@@ -502,9 +502,9 @@ static short int yy_nxt[][256] =
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
-       22,   22,   22,   22,   22,   22,
+       22,   22,   22,   22,   22,   22 },
 
-        5,   23,   23,   23,   23,   23,   23,   23,   23,   -9,
+     {  5,   23,   23,   23,   23,   23,   23,   23,   23,   -9,
        -9,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   -9,   23,   23,   23,   23,   23,   23,   23,
@@ -531,9 +531,9 @@ static short int yy_nxt[][256] =
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
-       23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23 },
 
-        5,   24,   24,   24,   24,   24,   24,   24,   24,  -10,
+     {  5,   24,   24,   24,   24,   24,   24,   24,   24,  -10,
       -10,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,  -10,   24,   24,   24,   24,   24,   24,   24,
@@ -560,9 +560,9 @@ static short int yy_nxt[][256] =
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
-       24,   24,   24,   24,   24,   24,
+       24,   24,   24,   24,   24,   24 },
 
-        5,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
+     {  5,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
@@ -589,9 +589,9 @@ static short int yy_nxt[][256] =
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
       -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,  -11,
-      -11,  -11,  -11,  -11,  -11,  -11,
+      -11,  -11,  -11,  -11,  -11,  -11 },
 
-        5,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+     {  5,   25,   25,   25,   25,   25,   25,   25,   25,   25,
       -12,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
@@ -618,9 +618,9 @@ static short int yy_nxt[][256] =
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
-       25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25 },
 
-        5,   26,   26,   26,   26,   26,   26,   26,   26,   26,
+     {  5,   26,   26,   26,   26,   26,   26,   26,   26,   26,
       -13,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
@@ -647,9 +647,9 @@ static short int yy_nxt[][256] =
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
-       26,   26,   26,   26,   26,   26,
+       26,   26,   26,   26,   26,   26 },
 
-        5,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
+     {  5,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
@@ -676,9 +676,9 @@ static short int yy_nxt[][256] =
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
       -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,  -14,
-      -14,  -14,  -14,  -14,  -14,  -14,
+      -14,  -14,  -14,  -14,  -14,  -14 },
 
-        5,   28,   28,   28,   28,   28,   28,   28,   28,   28,
+     {  5,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       -15,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
@@ -705,9 +705,9 @@ static short int yy_nxt[][256] =
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
-       28,   28,   28,   28,   28,   28,
+       28,   28,   28,   28,   28,   28 },
 
-        5,   29,   29,   29,   29,   29,   29,   29,   29,   29,
+     {  5,   29,   29,   29,   29,   29,   29,   29,   29,   29,
       -16,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
@@ -734,9 +734,9 @@ static short int yy_nxt[][256] =
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
-       29,   29,   29,   29,   29,   29,
+       29,   29,   29,   29,   29,   29 },
 
-        5,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
+     {  5,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
@@ -763,9 +763,9 @@ static short int yy_nxt[][256] =
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
       -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,  -17,
-      -17,  -17,  -17,  -17,  -17,  -17,
+      -17,  -17,  -17,  -17,  -17,  -17 },
 
-        5,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
+     {  5,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
@@ -792,9 +792,9 @@ static short int yy_nxt[][256] =
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
       -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,  -18,
-      -18,  -18,  -18,  -18,  -18,  -18,
+      -18,  -18,  -18,  -18,  -18,  -18 },
 
-        5,   30,   30,   30,   30,   30,   30,   30,   30,   30,
+     {  5,   30,   30,   30,   30,   30,   30,   30,   30,   30,
       -19,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
@@ -821,9 +821,9 @@ static short int yy_nxt[][256] =
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,
+       30,   30,   30,   30,   30,   30 },
 
-        5,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
+     {  5,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
@@ -850,9 +850,9 @@ static short int yy_nxt[][256] =
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
       -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,  -20,
-      -20,  -20,  -20,  -20,  -20,  -20,
+      -20,  -20,  -20,  -20,  -20,  -20 },
 
-        5,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
+     {  5,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
@@ -879,9 +879,9 @@ static short int yy_nxt[][256] =
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
       -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,  -21,
-      -21,  -21,  -21,  -21,  -21,  -21,
+      -21,  -21,  -21,  -21,  -21,  -21 },
 
-        5,   22,   22,   22,   22,   22,   22,   22,   22,   22,
+     {  5,   22,   22,   22,   22,   22,   22,   22,   22,   22,
       -22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
@@ -908,9 +908,9 @@ static short int yy_nxt[][256] =
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
-       22,   22,   22,   22,   22,   22,
+       22,   22,   22,   22,   22,   22 },
 
-        5,   23,   23,   23,   23,   23,   23,   23,   23,  -23,
+     {  5,   23,   23,   23,   23,   23,   23,   23,   23,  -23,
       -23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,  -23,   23,   23,   23,   23,   23,   23,   23,
@@ -937,9 +937,9 @@ static short int yy_nxt[][256] =
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
        23,   23,   23,   23,   23,   23,   23,   23,   23,   23,
-       23,   23,   23,   23,   23,   23,
+       23,   23,   23,   23,   23,   23 },
 
-        5,   24,   24,   24,   24,   24,   24,   24,   24,  -24,
+     {  5,   24,   24,   24,   24,   24,   24,   24,   24,  -24,
       -24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,  -24,   24,   24,   24,   24,   24,   24,   24,
@@ -966,9 +966,9 @@ static short int yy_nxt[][256] =
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
        24,   24,   24,   24,   24,   24,   24,   24,   24,   24,
-       24,   24,   24,   24,   24,   24,
+       24,   24,   24,   24,   24,   24 },
 
-        5,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+     {  5,   25,   25,   25,   25,   25,   25,   25,   25,   25,
       -25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
@@ -995,9 +995,9 @@ static short int yy_nxt[][256] =
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
-       25,   25,   25,   25,   25,   25,
+       25,   25,   25,   25,   25,   25 },
 
-        5,   26,   26,   26,   26,   26,   26,   26,   26,   26,
+     {  5,   26,   26,   26,   26,   26,   26,   26,   26,   26,
       -26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
@@ -1024,9 +1024,9 @@ static short int yy_nxt[][256] =
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
        26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
-       26,   26,   26,   26,   26,   26,
+       26,   26,   26,   26,   26,   26 },
 
-        5,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
+     {  5,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,   35,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
@@ -1053,9 +1053,9 @@ static short int yy_nxt[][256] =
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
       -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,  -27,
-      -27,  -27,  -27,  -27,  -27,  -27,
+      -27,  -27,  -27,  -27,  -27,  -27 },
 
-        5,   28,   28,   28,   28,   28,   28,   28,   28,   28,
+     {  5,   28,   28,   28,   28,   28,   28,   28,   28,   28,
       -28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
@@ -1082,9 +1082,9 @@ static short int yy_nxt[][256] =
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
        28,   28,   28,   28,   28,   28,   28,   28,   28,   28,
-       28,   28,   28,   28,   28,   28,
+       28,   28,   28,   28,   28,   28 },
 
-        5,   29,   29,   29,   29,   29,   29,   29,   29,   29,
+     {  5,   29,   29,   29,   29,   29,   29,   29,   29,   29,
       -29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
@@ -1111,9 +1111,9 @@ static short int yy_nxt[][256] =
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
-       29,   29,   29,   29,   29,   29,
+       29,   29,   29,   29,   29,   29 },
 
-        5,   30,   30,   30,   30,   30,   30,   30,   30,   30,
+     {  5,   30,   30,   30,   30,   30,   30,   30,   30,   30,
       -30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
@@ -1140,9 +1140,9 @@ static short int yy_nxt[][256] =
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
-       30,   30,   30,   30,   30,   30,
+       30,   30,   30,   30,   30,   30 },
 
-        5,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
+     {  5,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
@@ -1169,9 +1169,9 @@ static short int yy_nxt[][256] =
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
       -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,  -31,
-      -31,  -31,  -31,  -31,  -31,  -31,
+      -31,  -31,  -31,  -31,  -31,  -31 },
 
-        5,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
+     {  5,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
@@ -1198,9 +1198,9 @@ static short int yy_nxt[][256] =
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
       -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,  -32,
-      -32,  -32,  -32,  -32,  -32,  -32,
+      -32,  -32,  -32,  -32,  -32,  -32 },
 
-        5,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
+     {  5,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
@@ -1227,9 +1227,9 @@ static short int yy_nxt[][256] =
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
       -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,  -33,
-      -33,  -33,  -33,  -33,  -33,  -33,
+      -33,  -33,  -33,  -33,  -33,  -33 },
 
-        5,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
+     {  5,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
@@ -1256,9 +1256,9 @@ static short int yy_nxt[][256] =
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
       -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,  -34,
-      -34,  -34,  -34,  -34,  -34,  -34,
+      -34,  -34,  -34,  -34,  -34,  -34 },
 
-        5,   38,   38,   38,   38,   38,   38,   38,   38,   38,
+     {  5,   38,   38,   38,   38,   38,   38,   38,   38,   38,
       -35,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,  -35,   38,   38,   38,   38,   38,   38,   38,
@@ -1285,9 +1285,9 @@ static short int yy_nxt[][256] =
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-       38,   38,   38,   38,   38,   38,
+       38,   38,   38,   38,   38,   38 },
 
-        5,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
+     {  5,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
@@ -1314,9 +1314,9 @@ static short int yy_nxt[][256] =
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
       -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,  -36,
-      -36,  -36,  -36,  -36,  -36,  -36,
+      -36,  -36,  -36,  -36,  -36,  -36 },
 
-        5,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
+     {  5,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
@@ -1343,9 +1343,9 @@ static short int yy_nxt[][256] =
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
       -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,  -37,
-      -37,  -37,  -37,  -37,  -37,  -37,
+      -37,  -37,  -37,  -37,  -37,  -37 },
 
-        5,   38,   38,   38,   38,   38,   38,   38,   38,   38,
+     {  5,   38,   38,   38,   38,   38,   38,   38,   38,   38,
       -38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,  -38,   38,   38,   38,   38,   38,   38,   38,
@@ -1372,9 +1372,9 @@ static short int yy_nxt[][256] =
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
        38,   38,   38,   38,   38,   38,   38,   38,   38,   38,
-       38,   38,   38,   38,   38,   38,
+       38,   38,   38,   38,   38,   38 },
 
-        5,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
+     {  5,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
@@ -1401,9 +1401,9 @@ static short int yy_nxt[][256] =
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
       -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,  -39,
-      -39,  -39,  -39,  -39,  -39,  -39,
+      -39,  -39,  -39,  -39,  -39,  -39 },
 
-        5,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
+     {  5,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
@@ -1430,9 +1430,9 @@ static short int yy_nxt[][256] =
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
       -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,  -40,
-      -40,  -40,  -40,  -40,  -40,  -40,
+      -40,  -40,  -40,  -40,  -40,  -40 },
 
-        5,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
+     {  5,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
@@ -1459,9 +1459,9 @@ static short int yy_nxt[][256] =
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
       -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,  -41,
-      -41,  -41,  -41,  -41,  -41,  -41,
+      -41,  -41,  -41,  -41,  -41,  -41 },
 
-        5,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
+     {  5,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
@@ -1488,9 +1488,9 @@ static short int yy_nxt[][256] =
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
       -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,  -42,
-      -42,  -42,  -42,  -42,  -42,  -42,
+      -42,  -42,  -42,  -42,  -42,  -42 },
 
-        5,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
+     {  5,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
@@ -1517,9 +1517,9 @@ static short int yy_nxt[][256] =
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
       -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,  -43,
-      -43,  -43,  -43,  -43,  -43,  -43,
+      -43,  -43,  -43,  -43,  -43,  -43 },
 
-        5,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
+     {  5,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
@@ -1546,9 +1546,9 @@ static short int yy_nxt[][256] =
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
       -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,  -44,
-      -44,  -44,  -44,  -44,  -44,  -44,
+      -44,  -44,  -44,  -44,  -44,  -44 },
 
-        5,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
+     {  5,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
@@ -1575,9 +1575,9 @@ static short int yy_nxt[][256] =
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
       -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,  -45,
-      -45,  -45,  -45,  -45,  -45,  -45,
+      -45,  -45,  -45,  -45,  -45,  -45 },
 
-        5,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
+     {  5,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
@@ -1604,7 +1604,7 @@ static short int yy_nxt[][256] =
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
       -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,  -46,
-      -46,  -46,  -46,  -46,  -46,  -46
+      -46,  -46,  -46,  -46,  -46,  -46 }
 
     } ;
 
@@ -1738,7 +1738,9 @@ static int yy_did_buffer_switch_on_eof;
 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 static int yy_get_next_buffer YY_PROTO(( void ));
+#if 0
 static void yyunput YY_PROTO(( YY_CHAR c, YY_CHAR *buf_ptr ));
+#endif
 void yyrestart YY_PROTO(( FILE *input_file ));
 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 void yy_load_buffer_state YY_PROTO(( void ));
@@ -2273,6 +2275,7 @@ register yy_state_type yy_current_state;
     }
 
 
+#if 0
 #ifdef YY_USE_PROTOS
 static void yyunput( YY_CHAR c, register YY_CHAR *yy_bp )
 #else
@@ -2316,6 +2319,7 @@ register YY_CHAR *yy_bp;
      */
     YY_DO_BEFORE_ACTION; /* set up yytext again */
     }
+#endif
 
 
 #ifdef __cplusplus
diff --git a/cde/programs/dtinfo/dtinfogen/install/valBase.C b/cde/programs/dtinfo/dtinfogen/install/valBase.C
index 7f04e7d30d80f16ff5657551da0c36e30b3b9dc3..6e1e299dc5bca2d677bb7368e70dfe5b1e65b50e 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/install/valBase.C
+++ b/cde/programs/dtinfo/dtinfogen/install/valBase.C
@@ -78,7 +78,7 @@ int dbgInit()
 }
 
 //------------------------------------------------
-main(int argc, char **argv)
+int main(int argc, char **argv)
 {
   
   INIT_EXCEPTIONS();
@@ -126,8 +126,9 @@ main(int argc, char **argv)
    short major_version_check = checkVersion.major_version();
    short minor_version_check = checkVersion.minor_version();
 
-   sprintf ( checkVersionStr, "%d%d", major_version_check,
-                                     minor_version_check );
+   snprintf (checkVersionStr, sizeof(checkVersionStr),
+                             "%d%d", major_version_check,
+                                     minor_version_check);
    
    int checkVersionNum = atoi ( checkVersionStr );
 
@@ -137,8 +138,9 @@ main(int argc, char **argv)
    short major_version_install = installVersion.major_version();
    short minor_version_install = installVersion.minor_version();
 
-   sprintf ( installVersionStr, "%d%d", major_version_install,
-                                       minor_version_install );
+   snprintf (installVersionStr, sizeof(installVersionStr),
+                               "%d%d", major_version_install,
+                                       minor_version_install);
    int installVersionNum = atoi ( installVersionStr );
 
    DBG(10) cerr << "(DEBUG) installVersionNum = " << installVersionNum << endl;
@@ -176,7 +178,9 @@ main(int argc, char **argv)
 
      locator_smart_ptr x(checkBase, checkBase->get_oid(*it));
 
-     strcpy ( locatorStr, x.inside_node_locator_str() );
+     int len = MIN(strlen(x.inside_node_locator_str()), 64 - 1);
+     *((char *) memcpy (locatorStr,
+                       x.inside_node_locator_str(), len) + len) = '\0';
 
      DBG(10) cerr << "(DEBUG) locatorStr = " << locatorStr
                  << endl;
diff --git a/cde/programs/dtinfo/dtinfogen/mmdb/Imakefile b/cde/programs/dtinfo/dtinfogen/mmdb/Imakefile
index 48d326d00923819b3eb6ff269be4afa1990363c3..057f8c2398da8459621acec6f92969bacd15a7ac 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/mmdb/Imakefile
+++ b/cde/programs/dtinfo/dtinfogen/mmdb/Imakefile
@@ -8,9 +8,9 @@ SUBDIRS=src StyleSheet
 XCOMM redefine TopLevelProject to build DtInfo with standard CDE config dir
 #undef  TopLevelProject
 #define TopLevelProject                DtInfo
-IMAKE_DEFINES = -DTopLevelProject=TopLevelProject \
-               -DProjectTmplFile='<DtInfo.tmpl>' \
-               -DProjectRulesFile='<DtInfo.rules>'
+IMAKE_DEF_DTINFO =  -DTopLevelProject=TopLevelProject \
+                   -DProjectTmplFile='<DtInfo.tmpl>' \
+                   -DProjectRulesFile='<DtInfo.rules>'
 
 XCOMM Variables to switch on debug mode temporarily
 XCOMM CDEBUGFLAGS = -g -DDEBUG
diff --git a/cde/programs/dtinfo/dtinfogen/mmdb/StyleSheet/validator.C b/cde/programs/dtinfo/dtinfogen/mmdb/StyleSheet/validator.C
index 4224726a09dc9d599c1ea4953a7220b776d6cbb8..f3d27839810eeae8a3256753fe438569127d05de 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/mmdb/StyleSheet/validator.C
+++ b/cde/programs/dtinfo/dtinfogen/mmdb/StyleSheet/validator.C
@@ -77,7 +77,7 @@ void quit(int code)
    exit(code);
 }
 
-main(int argc, char** argv )
+int main(int argc, char** argv )
 {
   INIT_EXCEPTIONS();
 
diff --git a/cde/programs/dtinfo/dtinfogen/mmdb/src/Imakefile b/cde/programs/dtinfo/dtinfogen/mmdb/src/Imakefile
index 5f7ad2bda9165f48529e8778c286860c4592485c..e9120fcb48ba8704368f3ceb820388bda841d32d 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/mmdb/src/Imakefile
+++ b/cde/programs/dtinfo/dtinfogen/mmdb/src/Imakefile
@@ -196,7 +196,7 @@ Libs_C_API = $(MMDB_LIBS_C_API) $(DTSVCLIB) $(TTLIB) $(XLIB) $(MATH_LIB)
 SimpleCPlusPlusProgram(dbdrv,main.o,$(Libs))
 SimpleCPlusPlusProgram(restore,restore.o,$(Libs))
 
-#if defined(USLArchitecture) || defined(LinuxArchitecture) || defined(FreeBSDArchitecture)
+#if defined(USLArchitecture) || defined(LinuxArchitecture) || defined(FreeBSDArchitecture) || defined(OpenBSDArchitecture)
 SimpleCPlusPlusProgram(dbdrv_c_api,main_c_api.o,$(Libs_C_API))
 #else
 SimpleCProgram(dbdrv_c_api,main_c_api.o,$(Libs_C_API))
diff --git a/cde/programs/dtinfo/dtinfogen/mmdb/src/main.C b/cde/programs/dtinfo/dtinfogen/mmdb/src/main.C
index e66664c6687b107fbedd290f82d06d40ff633226..5ea287202aff10c5e4fd1b4f297b9e156ef6a0b1 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/mmdb/src/main.C
+++ b/cde/programs/dtinfo/dtinfogen/mmdb/src/main.C
@@ -142,7 +142,7 @@ int select_and_process( int argc, char** argv )
    return (ok);
 }
 
-main( int argc, char** argv )
+int main( int argc, char** argv )
 {
    //quantify_clear_data();
    INIT_EXCEPTIONS();
diff --git a/cde/programs/dtinfo/dtinfogen/mmdb/src/main_c_api.c b/cde/programs/dtinfo/dtinfogen/mmdb/src/main_c_api.c
index 1f20817bda02a9280da19a1deda2a909441a2c74..ae7a6c84cb1c791fe36c345f3f261ff4cdc4fad5 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/mmdb/src/main_c_api.c
+++ b/cde/programs/dtinfo/dtinfogen/mmdb/src/main_c_api.c
@@ -25,9 +25,10 @@
 #include "oliasdb/Mmdb.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include <ctype.h>
 
 
-usage(int argc, char** argv)
+void usage(int argc, char** argv)
 {
    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "   %s 0 libpath [bookcaseName]\n", argv[0]);
@@ -67,7 +68,7 @@ extern int test_book2(int argc, char** argv);
 extern int test_book3(int argc, char** argv);
 extern int auto_test_c_api(int argc, char** argv);
 
-main( int argc, char** argv )
+int main( int argc, char** argv )
 {
    int ok = 0;
    DtMmdbInit();
diff --git a/cde/programs/dtinfo/dtinfogen/mmdb/src/restore.C b/cde/programs/dtinfo/dtinfogen/mmdb/src/restore.C
index 43586209df308d2a7f3ca2c170701087998f8c88..0a71d3d7e2e58892eb031d402108c16fb5b30e56 100644 (file)
--- a/cde/programs/dtinfo/dtinfogen/mmdb/src/restore.C
+++ b/cde/programs/dtinfo/dtinfogen/mmdb/src/restore.C
@@ -38,7 +38,7 @@ using namespace std;
 #include "utility/const.h"
 #include "utility/randomize.h"
 
-main(int argc, char** argv)
+int main(int argc, char** argv)
 {
   if (argc < 2) {
     cerr << "usage: " << *argv << " filename\n" << flush;
Unnamed repository; edit this file 'description' to name the repository.