home *** CD-ROM | disk | FTP | other *** search
/ Troubleshooting Netware Systems / CSTRIAL0196.BIN / attach / msj / v10n04 / multilin.exe / PICTURE.CPP < prev    next >
C/C++ Source or Header  |  1995-04-01  |  9KB  |  393 lines
  1. // Implement Numeric pictures
  2.  
  3. #include "stdafx.h"
  4. #include "picture.h"
  5.  
  6.  
  7. // 
  8. // This file implements the class CPicture that can convert
  9. // between the NUMBERFMT struct and a "picture" format of
  10. // expressing numeric formatting. It is used by the overloaded
  11. // GetNumberFormat() function in numform.cpp
  12. // 
  13. // Pieces of the lpInput string that form the picture for 
  14. // an individual number    and are converted to the lpInput
  15. // required by the built-in GetNumberFormat. The CPicture
  16. // class, and which is derived form the NUMBERFMT class that
  17. // is the lpInput to the built-in GetNumberFormat handles the
  18. // conversion. The constructor 
  19. // CPicture::CPicture is where the picture definition is
  20. // parsed and translated into the field values in the 
  21. // NUMBERFMT structure. This is the syntax for numeric
  22. // pictures
  23. // [-][(][{#|0},][{#|0}+][.][{#|0}+][)][-]     
  24. // where 
  25. //   0 means a digit position including leading zeros
  26. //   # means a non-zero digit position    
  27. //      . means the decimal separator of the active locale
  28. //   , means the thousands separator ...
  29. //   - means placeholder for the sign string
  30. //     ( means use of () instead of - sign
  31. //   and the number of repetitions (+ in syntax)
  32. //     is counted to determine grouping and fraction 
  33. //   width.
  34. // The default constructor creates a picture from the active
  35. // locale. Another overloaded constructor is provided to create
  36. // pictures for any given locale. This latter constructor is
  37. // used when GetNumberFormat is called without an lpFormat string.
  38.  
  39. /* As a reminder: this is the NUMBERFMT structure
  40. typedef struct _NUMBERFMT { 
  41.  
  42.     UINT      NumDigits;     // number of fractional digits
  43.     UINT      LeadingZero;     // Boolean for leading 0
  44.     UINT      Grouping;         // Grouping 0-9 (3 or 4 are common)
  45.     LPTSTR    lpDecimalSep;     // string for same
  46.     LPTSTR    lpThousandSep; // string for same
  47.     UINT      NegativeOrder;  //??
  48. } NUMBERFMT;
  49. */
  50.  
  51. // Default constructor contructs picture from
  52. // GetLocaleInfo
  53. CPicture::CPicture(LCID lcid/*=LOCALE_SYSTEMDEFAULT*/, DWORD dwFlags /*=LOCALE_WITHOVERRIDE*/)
  54. {
  55.     if( lcid == LOCALE_SYSTEM_DEFAULT)
  56.     {
  57.         lcid = GetThreadLocale();  // NT only
  58.         // put Chicago specific code here
  59.     }
  60.     GetFieldValue(lcid,LOCALE_IDIGITS|dwFlags, NumDigits);
  61.     GetFieldValue(lcid,LOCALE_ILZERO|dwFlags, LeadingZero);
  62.     GetFieldValue(LOCALE_INEGNUMBER|dwFlags, NegativeOrder);
  63.     // Grouping is really a string value as LCTYPE
  64.     // just use the first entry in the Grouping string
  65.     GetFieldValue(LOCALE_SGROUPING|dwFlags, Grouping);
  66.     // These are string values
  67.     lpDecimalSep = m_DecSep;
  68.     lpThousandSep = m_ThouSep;
  69.     GetFieldValue(LOCALE_SDECIMAL|dwFlags, lpDecimalSep);
  70.     GetFieldValue(LOCALE_STHOUSAND|dwFlags, lpThousandSep);
  71.     m_Length = BuildUp();    // if we can delay build-up we can overload
  72. }
  73.  
  74. void CPicture::GetFieldValue(LCTYPE lctype, UINT& uiVal)
  75. {
  76.     LCID lcid = GetThreadLocale(); 
  77.     GetFieldValue(lcid, lctype, uiVal);
  78. }
  79.  
  80. void CPicture::GetFieldValue(LCID lcid, LCTYPE lctype, UINT& uiVal)
  81. {
  82.     const int cch=8 ;
  83.     TCHAR ach[cch];
  84.     GetLocaleInfo(lcid, lctype, ach, cch);
  85.     uiVal = _ttoi(ach);
  86. }
  87.  
  88. void CPicture::GetFieldValue(LCTYPE lctype, LPTSTR str)
  89. {
  90.     LCID lcid = GetThreadLocale();
  91.     GetFieldValue(lcid, lctype, str);
  92. }
  93.                                                       
  94. void CPicture::GetFieldValue(LCID lcid, LCTYPE lctype, LPTSTR str)
  95. {
  96.     GetLocaleInfo(lcid, lctype, str, MAXSEP );
  97. }
  98.  
  99. int CPicture::BuildUp()
  100. {                   
  101.     int count=0;
  102.     switch(NegativeOrder)
  103.     {
  104.     case 0:
  105.         m_Picture[count++]=_T('(');
  106.         BuildUpPositive(count);    
  107.         m_Picture[count++]=_T(')');
  108.         break;
  109.     case 1:
  110.         m_Picture[count++]=_T('-');
  111.         BuildUpPositive(count);    
  112.         break;
  113.     case 2:                 
  114.         m_Picture[count++]=_T('-');
  115.         m_Picture[count++]=_T(' ');
  116.         BuildUpPositive(count);    
  117.         break;
  118.     case 3:
  119.         BuildUpPositive(count);    
  120.         m_Picture[count++]=_T('-');
  121.         break;
  122.     case 4:
  123.         BuildUpPositive(count);
  124.         m_Picture[count++]=_T(' ');
  125.         m_Picture[count++]=_T('-');
  126.         break;
  127.     default:
  128.         ASSERT(0);    // Can't happen
  129.     }
  130.     m_Picture[count]=_T('\0');    //TERMINATE
  131.     return count;
  132. }
  133.                                            
  134. void CPicture::BuildUpPositive(int& count)
  135. {
  136.     TCHAR ch;
  137.     if( LeadingZero )
  138.     {
  139.         ch=    _T('0');
  140.     }
  141.     else
  142.     {
  143.         ch=    _T('#');
  144.     }
  145.     
  146.     m_Picture[count++]=ch;
  147.  
  148.     int j=Grouping; 
  149.     if( j )
  150.     {
  151.         m_Picture[count++]=_T(',');
  152.         while(j-->0)
  153.         {
  154.             m_Picture[count++]=ch;
  155.         }
  156.     }  
  157.  
  158.     int k= NumDigits;
  159.     if(k)
  160.     {
  161.         m_Picture[count++]=_T('.');
  162.         while(k-->0)
  163.         {
  164.             m_Picture[count++]=ch;
  165.         }
  166.     }
  167. }
  168.  
  169.  
  170. CPicture::CPicture( LPCTSTR lpInp, LCID lcid, DWORD dwFlags)
  171. { 
  172.     dwFlags &= ~LOCALE_NOUSEROVERRIDE; // limit to this flag
  173.  
  174.     if( lcid == LOCALE_SYSTEM_DEFAULT )
  175.     {
  176.         lcid=GetThreadLocale();
  177.     }
  178.     // These are string values    
  179.     lpDecimalSep = m_DecSep;
  180.     lpThousandSep = m_ThouSep;
  181.     GetFieldValue(lcid, LOCALE_SDECIMAL|dwFlags, lpDecimalSep);
  182.     GetFieldValue(LOCALE_STHOUSAND|dwFlags, lpThousandSep);
  183.     
  184.     if(lpInp)
  185.     {
  186.         m_Length=Parse(lpInp);
  187.     }
  188.     else
  189.     {
  190.         GetFieldValue(lcid,LOCALE_IDIGITS|dwFlags, NumDigits);
  191.         GetFieldValue(lcid,LOCALE_ILZERO|dwFlags, LeadingZero);
  192.         GetFieldValue(LOCALE_INEGNUMBER|dwFlags, NegativeOrder);
  193.         // Grouping is really a string value as LCTYPE
  194.         // just use the first entry in the Grouping string
  195.         GetFieldValue(LOCALE_SGROUPING|dwFlags, Grouping);
  196.     }
  197. }
  198. // This and the next few functions parse the number specifier
  199. // They return the number of character consumed from the input
  200. // specification in lpInp
  201.  
  202.  
  203. int CPicture::Parse(LPCTSTR lpInp)
  204. {
  205.     const unsigned int UNDEFINED = 5;
  206.  
  207.     // Sign part
  208.     NegativeOrder=UNDEFINED;    // == no sign seen so far
  209.     
  210.     int    count=Sign(lpInp);
  211.  
  212.     // Number part
  213.     TCHAR chDigit=_T('#');
  214.     count+=Integer(lpInp, chDigit);
  215.     LeadingZero=(chDigit==_T('0')? 1 : 0);
  216.  
  217.     // Fraction part
  218.     count+=Fraction(lpInp, chDigit);
  219.     
  220.     // Check for trailing sign
  221.     if( NegativeOrder == UNDEFINED )
  222.     {
  223.         count+=AltSign(lpInp);
  224.     }
  225.     else if( NegativeOrder == 0)
  226.     {
  227.         count=ParSign(lpInp, count);
  228.     }
  229.     NegativeOrder%=4;    // 1 is default, use if no sign specified
  230.     return count;
  231. }
  232.  
  233. int CPicture::Sign(LPCTSTR& lpInp)
  234. {
  235.     int count=0;
  236.        if( *lpInp == _T('-') )
  237.     {
  238.         lpInp++;
  239.         count++;
  240.         NegativeOrder=1;
  241.         if(*lpInp==_T(' '))
  242.         {
  243.             count++;
  244.             lpInp++;
  245.             NegativeOrder=2;
  246.         }
  247.     }
  248.     else if( *lpInp == _T('('))
  249.     {
  250.         NegativeOrder=0;
  251.         lpInp++;
  252.         count++;
  253.     }
  254.     return count;
  255. }
  256.     
  257. int CPicture::ParSign(LPCTSTR& lpInp,int count)
  258. {
  259.     if    (NegativeOrder==0)
  260.     {
  261.         if(*lpInp == _T(')'))
  262.         {
  263.             lpInp++;
  264.             count++    ;
  265.             return count;
  266.         }
  267.         else
  268.         {
  269.             lpInp-=count;
  270.             return (-count);
  271.         }
  272.     } 
  273.     return(0);
  274. }
  275. int CPicture::AltSign(LPCTSTR& lpInp)
  276. {     
  277.     int count=0;
  278.     if( *lpInp == _T(' ') )
  279.     {
  280.         lpInp++;
  281.         count++;
  282.         if(*lpInp==_T('-'))
  283.         {
  284.             count++;
  285.             lpInp++;
  286.             NegativeOrder=4;                               
  287.         }
  288.         else
  289.         {
  290.             count--;
  291.             lpInp--;
  292.         }
  293.     } 
  294.     else if(*lpInp ==_T('-') )
  295.     {
  296.         lpInp++;
  297.         count++;
  298.         NegativeOrder=3;
  299.     } 
  300.     return count;
  301. }
  302.  
  303. int    CPicture::Integer(LPCTSTR& lpInp, TCHAR& chDigit)
  304. {
  305.     int count=0;
  306.     Grouping=0;
  307.     if( *lpInp == _T('0') )
  308.     {
  309.         chDigit=*lpInp;
  310.         count = PosNum(lpInp, chDigit);
  311.     }
  312.     else if( *lpInp == _T('#') )
  313.     {
  314.         chDigit=*lpInp;
  315.         count = PosNum(lpInp, chDigit);
  316.     }
  317.     else
  318.     {
  319.         return(0);
  320.     } 
  321.  
  322.     ASSERT(count>=1);
  323.  
  324.     if(*lpInp==_T(',') )
  325.     {
  326.          lpInp++;
  327.          count++;
  328.          Grouping=PosNum(lpInp, chDigit);
  329.          if(Grouping ==0)
  330.          {
  331.              // back up over ','
  332.             lpInp--;
  333.             count--;
  334.          }
  335.     }
  336.     return(count+Grouping);
  337. }
  338.     
  339. int    CPicture::PosNum(LPCTSTR& lpInp, TCHAR chDigit)
  340. {       
  341.     int count = 0;
  342.     while(*lpInp == chDigit)
  343.     {
  344.         count++;
  345.         lpInp++;
  346.     }
  347.     return count;
  348. }
  349.  
  350. int CPicture::Fraction(LPCTSTR& lpInp, TCHAR chDigit)
  351. {
  352.     NumDigits=0;
  353.     if(*lpInp == _T('.'))
  354.     {
  355.         lpInp++ ;
  356.         return (NumDigits=PosNum(lpInp, chDigit))+1;
  357.     }
  358.     return 0;
  359. }
  360.  
  361. #if _DEBUG
  362. #ifndef _UNICODE
  363. // Test works for ANSI only
  364. void Test()
  365. {
  366.     TCHAR test[25];
  367.     CPicture pc;
  368.     ::MessageBox(NULL, pc.m_Picture, "TEST", MB_OK);
  369.     CPicture pc0("(00.00)");
  370.     GetNumberFormat(GetThreadLocale(),NULL, 
  371.         _T("-123456789"),&pc0,  test, 25);
  372.     ::MessageBox(NULL, test, "TEST", MB_OK);
  373.     CPicture pc1("-00,00)");
  374.     GetNumberFormat(GetThreadLocale(),NULL, 
  375.         _T("-123456789"), &pc1,test, 25);
  376.     ::MessageBox(NULL, test, "TEST", MB_OK);      
  377.     CPicture pc2("- 0,0#0)");
  378.     GetNumberFormat(GetThreadLocale(),NULL,  
  379.         _T("-123456789"),&pc2, test, 25);
  380.     ::MessageBox(NULL, test, "TEST", MB_OK);
  381.     CPicture pc3("0,0.00-");
  382.     GetNumberFormat(GetThreadLocale(),NULL, 
  383.         _T("-123456789"),&pc3, test, 25);
  384.     ::MessageBox(NULL, test, "TEST", MB_OK);
  385.     CPicture pc4(".######### -");
  386.     GetNumberFormat(GetThreadLocale(),NULL,
  387.         _T("-.123456789"), &pc4, test, 25);
  388.     ::MessageBox(NULL, test, "TEST", MB_OK);
  389. }
  390. #endif
  391. #endif //DEBUG
  392.  
  393.