← Back to branch summary

~libecbufr-dev/libecbufr/trunk

« back to all changes in this revision

Viewing changes to API/Sources/bufr_dataset.c

  • Committer: Michel Van Eeckhout
  • Date: 2010-03-12 16:37:56 UTC
  • mto: This revision was merged to the branch mainline in revision 109.
  • Revision ID: afsmmve@corbeau-20100312163756-n9fpy2r26y19ttxr
Modified sources for internationalisation + added m4 and po directories.

Show diffs side-by-side

added added

removed removed

Lines of Context:
API/Sources/bufr_dataset.c
38
38
#include "bufr_desc.h"
39
39
#include "bufr_sequence.h"
40
40
#include "bufr_dataset.h"
 
41
#include "bufr_i18n.h"
41
42
 
42
43
static uint64_t    bufr_value2bits           ( BufrDescriptor *code );
43
44
static void        bufr_empty_datasubsets    ( BUFR_Dataset *dts );
112
113
 
113
114
   if ((tmplt == NULL) || (tmplt->gabarit == NULL))
114
115
      {
115
 
      bufr_print_debug( "Warning: cannot create dataset, template not finalized\n" );
 
116
      bufr_print_debug( _("Warning: cannot create dataset, template not finalized\n") );
116
117
      return NULL;
117
118
      }
118
119
 
220
221
 
221
222
   if (dts->tmplte == NULL)
222
223
      {
223
 
      bufr_print_debug( "Error: cannot create datasubset, template not defined in dataset\n" );
 
224
      bufr_print_debug( _("Error: cannot create datasubset, template not defined in dataset\n") );
224
225
      return -1;
225
226
      }
226
227
 
685
686
   debug = bufr_is_debug();
686
687
   verbose = bufr_is_verbose();
687
688
 
688
 
   strcpy( errmsg, "### Creating BUFR Message with Dataset\n" );
 
689
   strcpy( errmsg, _("### Creating BUFR Message with Dataset\n") );
689
690
   if (debug)
690
691
      bufr_print_debug( errmsg );
691
692
   if (verbose)
712
713
         {
713
714
         x_compress = bufr_dataset_compressible( dts );
714
715
         if (debug && !x_compress)
715
 
         bufr_print_debug( "### Data not not compressible\n" );
 
716
         bufr_print_debug( _("### Data not not compressible\n") );
716
717
         }
717
718
      }
718
719
 
786
787
         count = bufr_datasubset_count_descriptor( subset );
787
788
         if (debug)
788
789
            {
789
 
            sprintf( errmsg, "Storing Subset # %d\n", i+1 );
 
790
            sprintf( errmsg, _("Storing Subset # %d\n"), i+1 );
790
791
            bufr_print_debug( errmsg );
791
792
            }
792
793
         for ( j = 0 ; j < count ; j++ )
807
808
      count = bufr_datasubset_count_descriptor( subset );
808
809
      if (debug)
809
810
         {
810
 
         sprintf( errmsg, "Storing %d Subsets compressed of %d items\n", nb_subsets, count );
 
811
         sprintf( errmsg, _("Storing %d Subsets compressed of %d items\n"), nb_subsets, count );
811
812
         bufr_print_debug( errmsg );
812
813
         }
813
814
      for ( j = 0 ; j < count ; j++ )
858
859
 
859
860
   if (msg->len_msg > BUFR_MAX_MSG_LEN)
860
861
      {
861
 
      sprintf( errmsg, "Warning: BUFR message length %lld octets exceeded the max allowed of %d octets\n", 
 
862
      sprintf( errmsg, _("Warning: BUFR message length %lld octets exceeded the max allowed of %d octets\n"), 
862
863
                  msg->len_msg, BUFR_MAX_MSG_LEN );
863
864
      bufr_print_debug( errmsg );
864
865
      fprintf( stderr, errmsg );
929
930
         bufr_print_debug( "   " );
930
931
         if (bufr_print_dscptr_value( errmsg, bcv ))
931
932
            bufr_print_debug( errmsg );
932
 
         sprintf( errmsg, " -> R0=0x%llx (%d bits) NBINC=%d (%d bits) \n", 
 
933
         sprintf( errmsg, _(" -> R0=0x%llx (%d bits) NBINC=%d (%d bits) \n"), 
933
934
               imin, bcv->encoding.nbits, 0, 6 );
934
935
         bufr_print_debug( errmsg );
935
936
         }
946
947
         bufr_print_debug( "   " );
947
948
         if (bufr_print_dscptr_value( errmsg, bcv ))
948
949
            bufr_print_debug( errmsg );
949
 
         sprintf( errmsg, " -> R0=0x%llx (%d bits) NBINC=%d (%d bits)\n", 
 
950
         sprintf( errmsg, _(" -> R0=0x%llx (%d bits) NBINC=%d (%d bits)\n"), 
950
951
               imin, bcv->encoding.nbits, nbinc, 6 );
951
952
         bufr_print_debug( errmsg );
952
953
         }
965
966
            bufr_print_debug( "   " );
966
967
            if (bufr_print_dscptr_value( errmsg, bcv ))
967
968
               bufr_print_debug( errmsg );
968
 
            sprintf( errmsg, " -> R(%d)=0x%llx (%d bits)\n", i+1, ival, nbinc );
 
969
            sprintf( errmsg, _(" -> R(%d)=0x%llx (%d bits)\n"), i+1, ival, nbinc );
969
970
            bufr_print_debug( errmsg );
970
971
            }
971
972
         }
1030
1031
         bufr_putbits( msg, uval, 64 );     /* REF */
1031
1032
         if (debug)
1032
1033
            {
1033
 
            sprintf( errmsg, "   %E -> R0=%llx (%d bits) NBINC=0 (%d bits)\n", 
 
1034
            sprintf( errmsg, _("   %E -> R0=%llx (%d bits) NBINC=0 (%d bits)\n"), 
1034
1035
                  dval0, uval, 64, 6 );
1035
1036
            bufr_print_debug( errmsg );
1036
1037
            }
1041
1042
         bufr_putbits( msg, uval, 32 );     /* REF */
1042
1043
         if (debug)
1043
1044
            {
1044
 
            sprintf( errmsg, "   %E -> R0=%llx (%d bits) NBINC=0 (%d bits)\n", 
 
1045
            sprintf( errmsg, _("   %E -> R0=%llx (%d bits) NBINC=0 (%d bits)\n"), 
1045
1046
                  fval0, uval, 32, 6 );
1046
1047
            bufr_print_debug( errmsg );
1047
1048
            }
1057
1058
         bufr_putbits( msg, 8, 6 );         /* NBINC */
1058
1059
         if (debug)
1059
1060
            {
1060
 
            sprintf( errmsg, "   %E -> R0=0x%llx (%d bits) NBINC=%d (%d bits)\n", 
 
1061
            sprintf( errmsg, _("   %E -> R0=0x%llx (%d bits) NBINC=%d (%d bits)\n"), 
1061
1062
                  dval0, uval, 64, 8, 6  );
1062
1063
            bufr_print_debug( errmsg );
1063
1064
            }
1069
1070
         bufr_putbits( msg, 4, 6 );         /* NBINC */
1070
1071
         if (debug)
1071
1072
            {
1072
 
            sprintf( errmsg, "   %E -> R0=0x%llx (%d bits) NBINC=%d (%d bits)\n", 
 
1073
            sprintf( errmsg, _("   %E -> R0=0x%llx (%d bits) NBINC=%d (%d bits)\n"), 
1073
1074
                  fval0, uval, 32, 4, 6 );
1074
1075
            bufr_print_debug( errmsg );
1075
1076
            }
1086
1087
            bufr_putbits( msg, uval, 64 );
1087
1088
            if (debug)
1088
1089
               {
1089
 
               sprintf( errmsg, "   %E -> R(%d)=0x%llx (%d bits)\n", dval, i+1, uval, 64 );
 
1090
               sprintf( errmsg, _("   %E -> R(%d)=0x%llx (%d bits)\n"), dval, i+1, uval, 64 );
1090
1091
               bufr_print_debug( errmsg );
1091
1092
               }
1092
1093
            }
1097
1098
            bufr_putbits( msg, uval, 32 );
1098
1099
            if (debug)
1099
1100
               {
1100
 
               sprintf( errmsg, "   %E ->  R(%d)=0x%llx (%d bits)\n", fval, i, uval, 32 );
 
1101
               sprintf( errmsg, _("   %E ->  R(%d)=0x%llx (%d bits)\n"), fval, i, uval, 32 );
1101
1102
               bufr_print_debug( errmsg );
1102
1103
               }
1103
1104
            }
1149
1150
      bufr_putbits( msg, 0, 6 );                       /* NBINC */
1150
1151
      if (debug)
1151
1152
         {
1152
 
         sprintf( errmsg, "   AF0=0x%llx (%d bits) NBINC=%d (%d bits) \n", 
 
1153
         sprintf( errmsg, _("   AF0=0x%llx (%d bits) NBINC=%d (%d bits) \n"), 
1153
1154
                     umin, bcv->value->af->nbits, 0, 6 );
1154
1155
         bufr_print_debug( errmsg );
1155
1156
         }
1162
1163
      bufr_putbits( msg, nbinc, 6 );          /* NBINC */
1163
1164
      if (debug)
1164
1165
         {
1165
 
         sprintf( errmsg, "   AF0=0x%llx (%d bits) NBINC=%d (%d bits)\n", 
 
1166
         sprintf( errmsg, _("   AF0=0x%llx (%d bits) NBINC=%d (%d bits)\n"), 
1166
1167
                     umin, bcv->encoding.nbits, nbinc, 6 );
1167
1168
         bufr_print_debug( errmsg );
1168
1169
         }
1177
1178
            bufr_putbits( msg, uval, nbinc );     /* Inc 's */
1178
1179
            if (debug)
1179
1180
               {
1180
 
               sprintf( errmsg, "   0x%llx -> AF(%d)=0x%llx (%d bits)\n", uval2, i+1, uval, nbinc );
 
1181
               sprintf( errmsg, _("   0x%llx -> AF(%d)=0x%llx (%d bits)\n"), uval2, i+1, uval, nbinc );
1181
1182
               bufr_print_debug( errmsg );
1182
1183
               }
1183
1184
            }
1248
1249
         bufr_print_debug( " R0=" );
1249
1250
         if (bufr_print_dscptr_value( errmsg, bcv ))
1250
1251
            bufr_print_debug( errmsg );
1251
 
         sprintf( errmsg, " NBINC=0 (%d bits)\n", 6 );
 
1252
         sprintf( errmsg, _(" NBINC=0 (%d bits)\n"), 6 );
1252
1253
         bufr_print_debug( errmsg );
1253
1254
         }
1254
1255
      }
1263
1264
         bufr_print_debug( " R0=" );
1264
1265
         if (bufr_print_value( errmsg, bv ))
1265
1266
            bufr_print_debug( errmsg );
1266
 
         sprintf( errmsg, " NBINC=%d (%d bits)\n", bcv->encoding.nbits/8, 6 );
 
1267
         sprintf( errmsg, _(" NBINC=%d (%d bits)\n"), bcv->encoding.nbits/8, 6 );
1267
1268
         bufr_print_debug( errmsg );
1268
1269
         }
1269
1270
      bufr_free_value( bv );
1280
1281
            bufr_print_debug( errmsg );
1281
1282
            if (bufr_print_dscptr_value( errmsg, bcv ))
1282
1283
               bufr_print_debug( errmsg );
1283
 
            sprintf( errmsg, " (%d bits)\n", bcv->encoding.nbits );
 
1284
            sprintf( errmsg, _(" (%d bits)\n"), bcv->encoding.nbits );
1284
1285
            bufr_print_debug( errmsg );
1285
1286
            }
1286
1287
         }
1392
1393
      case TYPE_IEEE_FP   :
1393
1394
      case TYPE_CCITT_IA5 :
1394
1395
      default :
1395
 
         fprintf( stderr, "Error: internal problem in bufr_value2bits(), wrong type:%.6d (%d)", 
 
1396
         fprintf( stderr, _("Error: internal problem in bufr_value2bits(), wrong type:%.6d (%d)"), 
1396
1397
                  bd->descriptor, bd->encoding.type );
1397
1398
         bufr_print_descriptor( errmsg, bd );
1398
1399
         fprintf( stderr, "%s ", errmsg );
1437
1438
      {
1438
1439
      if (isdebug)
1439
1440
         {
1440
 
         sprintf( errmsg, "#Code: %.6d (0 bits)\n", bd->descriptor );
 
1441
         sprintf( errmsg, _("#Code: %.6d (0 bits)\n"), bd->descriptor );
1441
1442
         bufr_print_debug( errmsg );
1442
1443
         }
1443
1444
      return;
1446
1447
      {
1447
1448
      if (isdebug)
1448
1449
         {
1449
 
         sprintf( errmsg, "Code: %.6d ", bd->descriptor );
 
1450
         sprintf( errmsg, _("Code: %.6d "), bd->descriptor );
1450
1451
         bufr_print_debug( errmsg );
1451
1452
         if ( bd->s_descriptor != 0 )
1452
1453
            {
1460
1461
      {
1461
1462
      if (isdebug)
1462
1463
         {
1463
 
         sprintf( errmsg, "AFD: 0x%llx (%d bits) ", 
 
1464
         sprintf( errmsg, _("AFD: 0x%llx (%d bits) "), 
1464
1465
               bd->value->af->bits, bd->value->af->nbits );
1465
1466
         bufr_print_debug( errmsg );
1466
1467
         }
1476
1477
            {
1477
1478
            if (isdebug)
1478
1479
               {
1479
 
               sprintf( errmsg, "Warning: expecting string but is null: descriptor=%d\n", 
 
1480
               sprintf( errmsg, _("Warning: expecting string but is null: descriptor=%d\n"), 
1480
1481
                                 bd->descriptor );
1481
1482
               bufr_print_debug( errmsg );
1482
1483
               }
1486
1487
            }
1487
1488
         if (isdebug)
1488
1489
            {
1489
 
            sprintf( errmsg, "STR: \"%s\" (%d bits) ", strval, bd->encoding.nbits );
 
1490
            sprintf( errmsg, _("STR: \"%s\" (%d bits) "), strval, bd->encoding.nbits );
1490
1491
            bufr_print_debug( errmsg );
1491
1492
            }
1492
1493
         bufr_putstring( bufr, strval, bd->encoding.nbits/8 );
1499
1500
      case TYPE_IEEE_FP :
1500
1501
         if (isdebug)
1501
1502
            {
1502
 
            sprintf( errmsg, "IEEE FP(%d bits) ", bd->encoding.nbits );
 
1503
            sprintf( errmsg, _("IEEE FP(%d bits) "), bd->encoding.nbits );
1503
1504
            bufr_print_debug( errmsg );
1504
1505
            }
1505
1506
         if (bd->encoding.nbits == 64)
1527
1528
         break;
1528
1529
      case TYPE_NUMERIC :
1529
1530
         if (isdebug)
1530
 
            bufr_print_debug( "NUM: " );
 
1531
            bufr_print_debug( _("NUM: ") );
1531
1532
         if (bd->encoding.nbits <= 32)
1532
1533
            {
1533
1534
            if (bd->value->type == VALTYPE_INT32)
1550
1551
               if (isdebug)
1551
1552
                  {
1552
1553
                  if (bufr_is_missing_float( fval ))
1553
 
                     sprintf( errmsg, "MSNG --> %lld", ival );
 
1554
                     sprintf( errmsg, _("MSNG --> %lld"), ival );
1554
1555
                  else
1555
 
                     sprintf( errmsg, "%f --> %lld", fval, ival );
 
1556
                     sprintf( errmsg, _("%f --> %lld"), fval, ival );
1556
1557
                  bufr_print_debug( errmsg );
1557
1558
                  }
1558
1559
               }
1564
1565
               ival = bufr_value_get_int64( bd->value );
1565
1566
               if (isdebug)
1566
1567
                  {
1567
 
                  sprintf( errmsg, "%lld", ival );
 
1568
                  sprintf( errmsg, _("%lld"), ival );
1568
1569
                  bufr_print_debug( errmsg );
1569
1570
                  }
1570
1571
               if ((bd->encoding.reference != 0)||(bd->encoding.scale != 0))
1580
1581
               if (isdebug)
1581
1582
                  {
1582
1583
                  if (bufr_is_missing_double( fval ))
1583
 
                     sprintf( errmsg, "MSNG --> %lld", ival );
 
1584
                     sprintf( errmsg, _("MSNG --> %lld"), ival );
1584
1585
                  else
1585
 
                     sprintf( errmsg, "%f --> %lld", dval, ival );
 
1586
                     sprintf( errmsg, _("%f --> %lld"), dval, ival );
1586
1587
                  bufr_print_debug( errmsg );
1587
1588
                  }
1588
1589
               }
1589
1590
            }
1590
1591
         if (isdebug)
1591
1592
            {
1592
 
            sprintf( errmsg, " (%d bits) ", bd->encoding.nbits );
 
1593
            sprintf( errmsg, _(" (%d bits) "), bd->encoding.nbits );
1593
1594
            bufr_print_debug( errmsg );
1594
1595
            }
1595
1596
         bufr_putbits( bufr, ival, bd->encoding.nbits );
1598
1599
         ival = bufr_value_get_int32( bd->value );
1599
1600
         if (isdebug)
1600
1601
            {
1601
 
            sprintf( errmsg, "INT: %lld ", ival );
 
1602
            sprintf( errmsg, _("INT: %lld "), ival );
1602
1603
            bufr_print_debug( errmsg );
1603
1604
            }
1604
1605
         if (ival < 0)
1606
1607
            ival = bufr_negative_ivalue( ival, bd->encoding.nbits );
1607
1608
            if (isdebug)
1608
1609
               {
1609
 
               sprintf( errmsg, "--> %lld ", ival );
 
1610
               sprintf( errmsg, _("--> %lld "), ival );
1610
1611
               bufr_print_debug( errmsg );
1611
1612
               }
1612
1613
            }
1613
1614
         if (isdebug)
1614
1615
            {
1615
 
            sprintf( errmsg, "(%d bits) ", bd->encoding.nbits );
 
1616
            sprintf( errmsg, _("(%d bits) "), bd->encoding.nbits );
1616
1617
            bufr_print_debug( errmsg );
1617
1618
            }
1618
1619
         bufr_putbits( bufr, ival, bd->encoding.nbits );
1622
1623
         ival = bufr_value_get_int32( bd->value );
1623
1624
         if (isdebug)
1624
1625
            {
1625
 
            sprintf( errmsg, "INT: %lld ", ival );
 
1626
            sprintf( errmsg, _("INT: %lld "), ival );
1626
1627
            bufr_print_debug( errmsg );
1627
1628
            }
1628
1629
         if (ival < -1)
1630
1631
            ival = -1;
1631
1632
            if (isdebug)
1632
1633
               {
1633
 
               sprintf( errmsg, "-> %lld ", ival );
 
1634
               sprintf( errmsg, _("-> %lld "), ival );
1634
1635
               bufr_print_debug( errmsg );
1635
1636
               }
1636
1637
            }
1637
1638
         if (isdebug)
1638
1639
            {
1639
 
            sprintf( errmsg, "(%d bits) ", bd->encoding.nbits );
 
1640
            sprintf( errmsg, _("(%d bits) "), bd->encoding.nbits );
1640
1641
            bufr_print_debug( errmsg );
1641
1642
            }
1642
1643
         bufr_putbits( bufr, ival, bd->encoding.nbits );
1644
1645
      default :
1645
1646
         if (isdebug)
1646
1647
            {
1647
 
            bufr_print_debug( "(0 bits) " );
 
1648
            bufr_print_debug( _("(0 bits) ") );
1648
1649
            }
1649
1650
      break;
1650
1651
      }
1686
1687
      {
1687
1688
      if (isdebug)
1688
1689
         {
1689
 
         sprintf( errmsg, "#Code: %.6d (0 bits)\n", bd->descriptor );
 
1690
         sprintf( errmsg, _("#Code: %.6d (0 bits)\n"), bd->descriptor );
1690
1691
         bufr_print_debug( errmsg );
1691
1692
         }
1692
1693
      return 0;
1695
1696
      {
1696
1697
      if (isdebug)
1697
1698
         {
1698
 
         sprintf( errmsg, "Code: %.6d ", bd->descriptor );
 
1699
         sprintf( errmsg, _("Code: %.6d "), bd->descriptor );
1699
1700
         bufr_print_debug( errmsg );
1700
1701
         }
1701
1702
      }
1713
1714
 
1714
1715
   if (isdebug)
1715
1716
      {
1716
 
      sprintf( errmsg, "AFD: (%d bits) ", 
 
1717
      sprintf( errmsg, _("AFD: (%d bits) "), 
1717
1718
            bd->encoding.af_nbits );
1718
1719
      bufr_print_debug( errmsg );
1719
1720
      }
1723
1724
      bd->value->af->bits = bufr_getbits( bufr, bd->value->af->nbits, &errcode );
1724
1725
      if (isdebug)
1725
1726
         {
1726
 
         sprintf( errmsg, "AFD: 0x%llx (%d bits) ", 
 
1727
         sprintf( errmsg, _("AFD: 0x%llx (%d bits) "), 
1727
1728
               bd->value->af->bits, bd->value->af->nbits );
1728
1729
         bufr_print_debug( errmsg );
1729
1730
         }
1768
1769
            bufr_value_set_int32( bd->value, ival );
1769
1770
            if (isdebug)
1770
1771
               {
1771
 
               sprintf( errmsg, "IVAL=%lld ", ival );
 
1772
               sprintf( errmsg, _("IVAL=%lld "), ival );
1772
1773
               bufr_print_debug( errmsg );
1773
1774
               }
1774
1775
            }
1779
1780
            if (isdebug)
1780
1781
               {
1781
1782
               if (bufr_is_missing_float( fval ))
1782
 
                  strcpy( errmsg, "FVAL=MISSING " );
 
1783
                  strcpy( errmsg, _("FVAL=MISSING ") );
1783
1784
               else
1784
 
                  sprintf( errmsg, "FVAL=%E IVAL=%lld ", fval, ival );
 
1785
                  sprintf( errmsg, _("FVAL=%E IVAL=%lld "), fval, ival );
1785
1786
               bufr_print_debug( errmsg );
1786
1787
               }
1787
1788
            }
1791
1792
            bufr_value_set_double( bd->value, dval );
1792
1793
            if (isdebug)
1793
1794
               {
1794
 
               sprintf( errmsg, "DVAL=%E", dval );
 
1795
               sprintf( errmsg, _("DVAL=%E"), dval );
1795
1796
               bufr_print_debug( errmsg );
1796
1797
               }
1797
1798
            }
1798
1799
 
1799
1800
         if (isdebug)
1800
1801
            {
1801
 
            sprintf( errmsg, " (%d bits)", bd->encoding.nbits );
 
1802
            sprintf( errmsg, _(" (%d bits)"), bd->encoding.nbits );
1802
1803
            bufr_print_debug( errmsg );
1803
1804
            }
1804
1805
         break;
1808
1809
         ival2 = bufr_cvt_ivalue( ival, bd->encoding.nbits );
1809
1810
         if (isdebug)
1810
1811
            {
1811
 
            sprintf( errmsg, "IVAL=%lld INT: %lld (%d bits) ", 
 
1812
            sprintf( errmsg, _("IVAL=%lld INT: %lld (%d bits) "), 
1812
1813
                  ival2, ival, bd->encoding.nbits );
1813
1814
            bufr_print_debug( errmsg );
1814
1815
            }
1822
1823
         if (ival == ival2) ival = -1;
1823
1824
         if (isdebug)
1824
1825
            {
1825
 
            sprintf( errmsg, "IVAL=%lld (%d bits) ", ival, bd->encoding.nbits );
 
1826
            sprintf( errmsg, _("IVAL=%lld (%d bits) "), ival, bd->encoding.nbits );
1826
1827
            bufr_print_debug( errmsg );
1827
1828
            }
1828
1829
         bufr_value_set_int32( bd->value, ival );
1830
1831
      default :
1831
1832
         if (isdebug)
1832
1833
            {
1833
 
            bufr_print_debug( "(0 bits) " );
 
1834
            bufr_print_debug( _("(0 bits) ") );
1834
1835
            }
1835
1836
      break;
1836
1837
      }
1866
1867
      {
1867
1868
      char errmsg[256];
1868
1869
 
1869
 
      sprintf( errmsg, "STR: [%s] (%d bits) ", strval, bd->encoding.nbits );
 
1870
      sprintf( errmsg, _("STR: [%s] (%d bits) "), strval, bd->encoding.nbits );
1870
1871
      bufr_print_debug( errmsg );
1871
1872
      }
1872
1873
   free( strval );
1902
1903
      bufr_value_set_double( bd->value, dval );
1903
1904
      if (bufr_is_debug())
1904
1905
         {
1905
 
         sprintf( errmsg, "DVAL=%E (%d bits)", dval, 64 );
 
1906
         sprintf( errmsg, _("DVAL=%E (%d bits)"), dval, 64 );
1906
1907
         bufr_print_debug( errmsg );
1907
1908
         }
1908
1909
      }
1912
1913
      bufr_value_set_float( bd->value, fval );
1913
1914
      if (bufr_is_debug())
1914
1915
         {
1915
 
         sprintf( errmsg, "FVAL=%E (%d bits)", fval, 32 );
 
1916
         sprintf( errmsg, _("FVAL=%E (%d bits)"), fval, 32 );
1916
1917
         bufr_print_debug( errmsg );
1917
1918
         }
1918
1919
      }
1961
1962
   LinkedList     *tmplist;
1962
1963
 
1963
1964
   if (debug)
1964
 
      bufr_print_debug( "### Converting BUFR Message into Dataset\n" );
 
1965
      bufr_print_debug( _("### Converting BUFR Message into Dataset\n") );
1965
1966
 
1966
1967
   if (tables->master.version <= 13)
1967
1968
      {
1969
1970
         {
1970
1971
         if (debug)
1971
1972
            {
1972
 
            sprintf( errmsg, "Warning: master Table B version: %d less than message: %d\n", 
 
1973
            sprintf( errmsg, _("Warning: master Table B version: %d less than message: %d\n"), 
1973
1974
                  tables->master.version, msg->s1.master_table_version );
1974
1975
            bufr_print_debug( errmsg );
1975
1976
            }
1980
1981
      {
1981
1982
      if (debug)
1982
1983
         {
1983
 
         sprintf( errmsg, "Warning: master Table B version: %d differs message's: %d\n", 
 
1984
         sprintf( errmsg, _("Warning: master Table B version: %d differs message's: %d\n"), 
1984
1985
               tables->master.version, msg->s1.master_table_version );
1985
1986
         bufr_print_debug( errmsg );
1986
1987
         }
1998
1999
 
1999
2000
   if (tables == NULL) 
2000
2001
      {
2001
 
      bufr_print_debug( "Error: a BUFR_Tables is required to decode BUFR Message into Dataset\n" );
 
2002
      bufr_print_debug( _("Error: a BUFR_Tables is required to decode BUFR Message into Dataset\n") );
2002
2003
      return NULL;
2003
2004
      }
2004
2005
/*
2058
2059
   if (!compressed)
2059
2060
      {
2060
2061
      if (debug)
2061
 
         bufr_print_debug( "### Message is not compressed\n" );
 
2062
         bufr_print_debug( _("### Message is not compressed\n") );
2062
2063
/*
2063
2064
 * loop as many times as specified to fill in all the datasubsets
2064
2065
 
2148
2149
      ListNode       **nodes;
2149
2150
 
2150
2151
      if (debug)
2151
 
         bufr_print_debug( "### Message is compressed\n" );
 
2152
         bufr_print_debug( _("### Message is compressed\n") );
2152
2153
/*
2153
2154
 * allocates all subsets
2154
2155
 
2346
2347
      {
2347
2348
      if (bufr_print_value( errmsg, cb->value ))
2348
2349
         bufr_print_debug( errmsg );
2349
 
      sprintf( errmsg, " NBINC=%d (%d bits)\n", nbinc, 6 );
 
2350
      sprintf( errmsg, _(" NBINC=%d (%d bits)\n"), nbinc, 6 );
2350
2351
      bufr_print_debug( errmsg );
2351
2352
      }
2352
2353
   for (i = 0; i < nbsubset ; i++)
2413
2414
      {
2414
2415
      if (bufr_print_value( errmsg, cb->value ))
2415
2416
         bufr_print_debug( errmsg );
2416
 
      sprintf( errmsg, " NBINC=%d (%d bits)\n", nbinc, 6 );
 
2417
      sprintf( errmsg, _(" NBINC=%d (%d bits)\n"), nbinc, 6 );
2417
2418
      bufr_print_debug( errmsg );
2418
2419
      }
2419
2420
   if (errcode < 0) return errcode;
2481
2482
   imin = bufr_getbits( msg, cb->encoding.nbits, &errcode );
2482
2483
   if (debug)
2483
2484
      {
2484
 
      sprintf( errmsg, "   R0=%lld (%d bits)", 
 
2485
      sprintf( errmsg, _("   R0=%lld (%d bits)"), 
2485
2486
            imin, cb->encoding.nbits );
2486
2487
      bufr_print_debug( errmsg );
2487
2488
      }
2489
2490
   nbinc = bufr_getbits( msg, 6, &errcode );
2490
2491
   if (debug)
2491
2492
      {
2492
 
      sprintf( errmsg, " NBINC=%d (%d bits)\n", 
 
2493
      sprintf( errmsg, _(" NBINC=%d (%d bits)\n"), 
2493
2494
            nbinc, 6 );
2494
2495
      bufr_print_debug( errmsg );
2495
2496
      }
2531
2532
         bufr_descriptor_set_bitsvalue( cb2, ival2 );
2532
2533
         if (debug)
2533
2534
            {
2534
 
            sprintf( errmsg, "   R(%d)=%llx(%llx) (%d bits)", i+1, ival2, ival, nbinc );
 
2535
            sprintf( errmsg, _("   R(%d)=%llx(%llx) (%d bits)"), i+1, ival2, ival, nbinc );
2535
2536
            bufr_print_debug( errmsg );
2536
2537
            if (bufr_print_dscptr_value( errmsg, cb2 ))
2537
2538
               bufr_print_debug( errmsg );
2579
2580
   imin = bufr_getbits( msg, cb->value->af->nbits, &errcode );
2580
2581
   if (debug)
2581
2582
      {
2582
 
      sprintf( errmsg, " A0=%llx (%d bits)", 
 
2583
      sprintf( errmsg, _(" A0=%llx (%d bits)"), 
2583
2584
            imin, cb->value->af->nbits );
2584
2585
      bufr_print_debug( errmsg );
2585
2586
      }
2587
2588
   nbinc = bufr_getbits( msg, 6, &errcode );
2588
2589
   if (debug)
2589
2590
      {
2590
 
      sprintf( errmsg, " NBINC=%d (%d bits)\n", 
 
2591
      sprintf( errmsg, _(" NBINC=%d (%d bits)\n"), 
2591
2592
            nbinc, 6 );
2592
2593
      bufr_print_debug( errmsg );
2593
2594
      }
2603
2604
         cb2->value->af->bits = imin;
2604
2605
         if (debug && cb2->value)
2605
2606
            {
2606
 
            sprintf( errmsg, " A(%d)=%llx", i+1, imin );
 
2607
            sprintf( errmsg, _(" A(%d)=%llx"), i+1, imin );
2607
2608
            bufr_print_debug( errmsg );
2608
2609
            bufr_print_debug( "\n" );
2609
2610
            }
2623
2624
         cb2->value->af->bits = ival;
2624
2625
         if (debug)
2625
2626
            {
2626
 
            sprintf( errmsg, "   A(%d)=%llx (%d bits)", i+1, ival, nbinc );
 
2627
            sprintf( errmsg, _("   A(%d)=%llx (%d bits)"), i+1, ival, nbinc );
2627
2628
            bufr_print_debug( errmsg );
2628
2629
            bufr_print_debug( "\n" );
2629
2630
            }
2703
2704
               {
2704
2705
               if (bufr_is_debug())
2705
2706
                  {
2706
 
                  bufr_print_debug( "### Dataset not compressible, delayed replication count differs\n");
 
2707
                  bufr_print_debug( _("### Dataset not compressible, delayed replication count differs\n"));
2707
2708
                  sprintf( errmsg, "### %d  %d (0)=%d  (%d)=%d\n", d1, d2, nrep1, j, nrep2 );
2708
2709
                  bufr_print_debug( errmsg );
2709
2710
                  }
2829
2830
   fp = fopen ( infile, "r" ) ;
2830
2831
   if (fp == NULL) 
2831
2832
      {
2832
 
      sprintf( errmsg, "Error: can't open Datafile file %s\n", infile );
 
2833
      sprintf( errmsg, _("Error: can't open Datafile file %s\n"), infile );
2833
2834
      bufr_print_debug( errmsg );
2834
2835
      return -1;
2835
2836
      }
2946
2947
      if (strncmp( ligne, "DATASUBSET", 10 ) == 0)
2947
2948
         {
2948
2949
         if (bufr_is_verbose())
2949
 
            fprintf( stderr, "Loading: %s\n", ligne );
 
2950
            fprintf( stderr, _("Loading: %s\n"), ligne );
2950
2951
 
2951
2952
         if (bsq2) 
2952
2953
            bufr_add_datasubset( dts, bsq2, ddo );
2974
2975
 
2975
2976
      if (debug)
2976
2977
         {
2977
 
         sprintf( errmsg, "*** Input for: %d\n", icode );
 
2978
         sprintf( errmsg, _("*** Input for: %d\n"), icode );
2978
2979
         bufr_print_debug( errmsg );
2979
2980
         }
2980
2981
 
2988
2989
         }
2989
2990
      if (node == NULL)
2990
2991
         {
2991
 
         sprintf( errmsg, "Error: no more descriptors for data\n" );
 
2992
         sprintf( errmsg, _("Error: no more descriptors for data\n") );
2992
2993
         bufr_print_debug( errmsg );
2993
2994
         break;
2994
2995
         }
3000
3001
         }
3001
3002
      if (icode != cb->descriptor)
3002
3003
         {
3003
 
         sprintf( errmsg, "Error: data descriptor %d mismatch with template %d\n", 
 
3004
         sprintf( errmsg, _("Error: data descriptor %d mismatch with template %d\n"), 
3004
3005
                  icode, cb->descriptor );
3005
3006
         bufr_print_debug( errmsg );
3006
3007
         return -1;
3032
3033
         int j = len-1;
3033
3034
         if (debug)
3034
3035
            {
3035
 
            sprintf( errmsg, "   *** skipping comment: '%s'", ptr );
 
3036
            sprintf( errmsg, _("   *** skipping comment: '%s'"), ptr );
3036
3037
            bufr_print_debug( errmsg );
3037
3038
            }
3038
3039
         while ((ptr[j] != '}') && (j >= i)) --j;
3059
3060
         sscanf( tok, "%llx", &afbits );
3060
3061
         if (debug)
3061
3062
            {
3062
 
            sprintf( errmsg, "   *** has AF: %s -> %llx\n", tok, afbits );
 
3063
            sprintf( errmsg, _("   *** has AF: %s -> %llx\n"), tok, afbits );
3063
3064
            bufr_print_debug( errmsg );
3064
3065
            }
3065
3066
         cb->value->af->bits = afbits;
3070
3071
 
3071
3072
         if (debug)
3072
3073
            {
3073
 
            sprintf( errmsg, "   *** found value: '%s'\n", ptr+i );
 
3074
            sprintf( errmsg, _("   *** found value: '%s'\n"), ptr+i );
3074
3075
            bufr_print_debug( errmsg );
3075
3076
            }
3076
3077
         }
3123
3124
               if (debug)
3124
3125
                  {
3125
3126
                  int l;
3126
 
                  sprintf( errmsg, "   *** has value: '%s' -> '%s'\n", 
 
3127
                  sprintf( errmsg, _("   *** has value: '%s' -> '%s'\n"), 
3127
3128
                        tok, bufr_descriptor_get_svalue( cb, &l ) );
3128
3129
                  bufr_print_debug( errmsg );
3129
3130
                  }
3141
3142
               bufr_descriptor_set_ivalue( cb, ival32 );
3142
3143
               if (debug)
3143
3144
                  {
3144
 
                  sprintf( errmsg, "   *** has value: %s -> %d\n", tok, ival32 );
 
3145
                  sprintf( errmsg, _("   *** has value: %s -> %d\n"), tok, ival32 );
3145
3146
                  bufr_print_debug( errmsg );
3146
3147
                  }
3147
3148
               break;
3153
3154
                     bufr_descriptor_set_dvalue( cb, dval );
3154
3155
                  if (debug)
3155
3156
                     {
3156
 
                     sprintf( errmsg, "   *** has value: %s -> %f\n", tok, dval );
 
3157
                     sprintf( errmsg, _("   *** has value: %s -> %f\n"), tok, dval );
3157
3158
                     bufr_print_debug( errmsg );
3158
3159
                     }
3159
3160
                  }
3166
3167
                     bufr_descriptor_set_fvalue( cb, fval );
3167
3168
                  if (debug)
3168
3169
                     {
3169
 
                     sprintf( errmsg, "   *** has value: %s -> %f\n", tok, fval );
 
3170
                     sprintf( errmsg, _("   *** has value: %s -> %f\n"), tok, fval );
3170
3171
                     bufr_print_debug( errmsg );
3171
3172
                     }
3172
3173
                  }
3250
3251
            int ed = atoi( tok );
3251
3252
            if (dts->tmplte->edition != ed)
3252
3253
               {
3253
 
               sprintf( errmsg, "Warning: datafile bufr edition %d differs with template's %d\n", 
 
3254
               sprintf( errmsg, _("Warning: datafile bufr edition %d differs with template's %d\n"), 
3254
3255
                     ed, dts->tmplte->edition );
3255
3256
               bufr_print_debug( errmsg );
3256
3257
               }
3632
3633
   fpi = fopen ( infile, "r" ) ;
3633
3634
   if (fpi == NULL) 
3634
3635
      {
3635
 
      sprintf( errmsg, "Error: can't open input file %s\n", infile );
 
3636
      sprintf( errmsg, _("Error: can't open input file %s\n"), infile );
3636
3637
      bufr_print_debug( errmsg );
3637
3638
      return -1;
3638
3639
      }
3640
3641
   fpo = fopen ( outfile, "w" ) ;
3641
3642
   if (fpo == NULL) 
3642
3643
      {
3643
 
      sprintf( errmsg, "Error: can't open output file %s\n", outfile );
 
3644
      sprintf( errmsg, _("Error: can't open output file %s\n"), outfile );
3644
3645
      bufr_print_debug( errmsg );
3645
3646
      fclose( fpi );
3646
3647
      return -1;
3662
3663
         {
3663
3664
         if (debug)
3664
3665
            {
3665
 
            sprintf( errmsg, "Saving message with %d subsets\n", bufr_count_datasubset( dts ) );
 
3666
            sprintf( errmsg, _("Saving message with %d subsets\n"), bufr_count_datasubset( dts ) );
3666
3667
            bufr_print_debug( errmsg );
3667
3668
            }
3668
3669
         bufr_write_message( fpo, msg );