Microsoft TechNet ITHome - Microsoft Year 2000 Product Guide
Microsoft Products
Product Entry Guide Detail

The Microsoft Year 2000 Resource Center Product Guide details specific Year 2000 information concerning Microsoft products. The information in the product guide is presented to assist IT professionals in planning their transition to the Year 2000. If you cannot find a specific product and it is not on the "Microsoft Products: Testing Yet to be Completed" list, you can assume it will NOT be tested for compliancy.
Microsoft will continually update the Year 2000 Product Guide with the most current Year 2000 test information. Visit the Year 2000 Product Guide for more details regarding the Microsoft Compliance Categories.

------------------------
Microsoft Year 2000 Resource Center
Visual Basic (32-bit)  6.0   (Korean)

Product Summary
Product: Visual Basic (32-bit) Version: 6.0 Category:Compliant*#
Language: Korean OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See Below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95 (+ year 2000 software updates), Windows 98 (+ year 2000 software updates), SQL Server 6.5 Service Pack 5, MDAC 2.0 Service Pack 2 or greater, Visual Database Tools 6.0
Clock Dependencies: System Clock, Visual Basic runtime, (OLE) Automation Libraries
Last Updated: 26 Oct 1999
Product Details

This report applies to:

Introductory, Enterprise, Learning, Professional, and Standard editions.

Operational Range for Data: 1930 through 2029 using 2-digit shortcuts or user configurable.

Czech, Hungarian, Polish, Portuguese (Brazil), Romanian, and Russian versions contain US software.

Developing Year 2000 Compliant Software

How the product runtime handles dates:

Visual Basic 6.0 stores year-dates internally as 4-digits.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date.

The rule is:

2-digit dates between 00-29 are assumed to occur in the 2000s (2000-2029).

2-digit dates between 30-99 are assumed to occur in the 1900s (1930-1999).

NOTE: This string to date conversion is done by OLE-Automation. Starting from the version of OLE Automation shipped with Visual Studio 6 (Fall 98), OLE-Automation (32-bit and beyond) will allow the user or administrator to set the 100-year window for parsing 2-digit dates. (The default will be as stated above, 1930 - 2029).

Outlook Express 4.01 date handling:

Outlook Express 4.01 (OE) is included with, but not a requirement forVisual Basic 6.0. If Outlook Express 4.01 receives an IMAP mail message or a News message with a 2-digit year as the sent date, the date can be misinterpreted under certain conditions. If the 2-digit year is anything other than 99, OE will assume the century value is the same as the current century. If the current year is 2000, and a 2-digit date is received as 97, then the year will be interpreted as 2097. However, there is one special case when different logic is applied. If the 2-digit year 99 is received and current year is a multiple of 100 (e.g. 2000), the year will be interpreted as the current year plus 98 (e.g. 2098). You can find more information about this in the Internet Explorer (32-bit) 4.0x Year 2000 disclosure document.

Recommended practices to develop year 2000 compliant applications with this Development Tool:

The product has known issues when dates are stored as strings. It is recommended that all dates are stored using Date data type as opposed to strings.

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also be a problem if there is an error in the information. Visual Basic will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found.

For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates even though the month/day/year order have changed. For more information on which occasions might result in a date conversion error, please see the OLE Automation compliance document

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Common development errors dealing with year 2000 date issues:

Please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Other design time issues to be aware of when using this tool:

If the following products or technologies are installed, they should be updated to ensure proper functioning:

Product

Version

Location of Update

Internet Explorer 4.x

Service Pack 1

http://www.microsoft.com/windows/ie/download/windows.htm

OLE DB

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

SQL 6.5

Service Pack 5

http://support.microsoft.com/support/downloads/

ODBC

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

Windows NT 4.0

Service Pack 5

http://www.microsoft.com/ntserver

Oracle Issues

There is an issue regarding 2-digit year parsing in the Visual Database Tools when connecting to an Oracle database with a system configured for 2-digit year format. If the year entered into the Grid Pane’s Criteria cell is between 2029 and 2000 (the system default 2-digit year window for year 2000 dates) the date will be converted by OLEAUT32 into a 2-digit value when parsed into the SQL Pane. Oracle will interpret this as a year between 1929 and 1900.

The recommended work-around for this is to set your system’s Short Date format to include a 4-digit year.

A design-time update to the Visual Database Tools that addresses this issue is available for download as a part of Visual Studio 6.0 Service Pack 3.

 

Testing guidelines and recommendations:

Chapter 9 of Visual Basic documentation on MSDN has several examples of how to test for Year 2000 problems in Visual Basic applications. This is available on http://msdn.microsoft.com/library/books/advnvb5/html/Ch09.htm



Users testing applications written in Visual Basic should be especially careful to test the following problem areas:

User-defined functions: Many applications contain user-defined functions written in Visual Basic to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.

The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since Visual Basic rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.


Code Example:

The following example illustrates the date window in action with various input dates.

Sub TestDate()
Dim MyDate As Date
MyDate = "1/1/00"
Format MyDate, "mm/dd/yyyy"
MsgBox MyDate
End Sub

MyDate input

Expected behavior

1/1/00 1/1/1 1/1/9 1/1/2000 4/1/98 10/24/29 7/4/30 2/29/00 2/29/1900

1/1/2000 1/1/2001 1/1/2009 1/1/2000 4/1/1998 10/24/2029 7/4/1930 2/29/2000 error- Type mismatch (1900 not a leap year)

 

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic (32-bit)  6.0   (Polish)

Product Summary
Product: Visual Basic (32-bit) Version: 6.0 Category:Compliant*#
Language: Polish OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See Below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95 (+ year 2000 software updates), Windows 98 (+ year 2000 software updates), SQL Server 6.5 Service Pack 5, MDAC 2.0 Service Pack 2 or greater, Visual Database Tools 6.0
Clock Dependencies: System Clock, Visual Basic runtime, (OLE) Automation Libraries
Last Updated: 26 Oct 1999
Product Details

This report applies to:

Introductory, Enterprise, Learning, Professional, and Standard editions.

Operational Range for Data: 1930 through 2029 using 2-digit shortcuts or user configurable.

Czech, Hungarian, Polish, Portuguese (Brazil), Romanian, and Russian versions contain US software.

Developing Year 2000 Compliant Software

How the product runtime handles dates:

Visual Basic 6.0 stores year-dates internally as 4-digits.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date.

The rule is:

2-digit dates between 00-29 are assumed to occur in the 2000s (2000-2029).

2-digit dates between 30-99 are assumed to occur in the 1900s (1930-1999).

NOTE: This string to date conversion is done by OLE-Automation. Starting from the version of OLE Automation shipped with Visual Studio 6 (Fall 98), OLE-Automation (32-bit and beyond) will allow the user or administrator to set the 100-year window for parsing 2-digit dates. (The default will be as stated above, 1930 - 2029).

Outlook Express 4.01 date handling:

Outlook Express 4.01 (OE) is included with, but not a requirement forVisual Basic 6.0. If Outlook Express 4.01 receives an IMAP mail message or a News message with a 2-digit year as the sent date, the date can be misinterpreted under certain conditions. If the 2-digit year is anything other than 99, OE will assume the century value is the same as the current century. If the current year is 2000, and a 2-digit date is received as 97, then the year will be interpreted as 2097. However, there is one special case when different logic is applied. If the 2-digit year 99 is received and current year is a multiple of 100 (e.g. 2000), the year will be interpreted as the current year plus 98 (e.g. 2098). You can find more information about this in the Internet Explorer (32-bit) 4.0x Year 2000 disclosure document.

Recommended practices to develop year 2000 compliant applications with this Development Tool:

The product has known issues when dates are stored as strings. It is recommended that all dates are stored using Date data type as opposed to strings.

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also be a problem if there is an error in the information. Visual Basic will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found.

For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates even though the month/day/year order have changed. For more information on which occasions might result in a date conversion error, please see the OLE Automation compliance document

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Common development errors dealing with year 2000 date issues:

Please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Other design time issues to be aware of when using this tool:

If the following products or technologies are installed, they should be updated to ensure proper functioning:

Product

Version

Location of Update

Internet Explorer 4.x

Service Pack 1

http://www.microsoft.com/windows/ie/download/windows.htm

OLE DB

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

SQL 6.5

Service Pack 5

http://support.microsoft.com/support/downloads/

ODBC

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

Windows NT 4.0

Service Pack 5

http://www.microsoft.com/ntserver

Oracle Issues

There is an issue regarding 2-digit year parsing in the Visual Database Tools when connecting to an Oracle database with a system configured for 2-digit year format. If the year entered into the Grid Pane’s Criteria cell is between 2029 and 2000 (the system default 2-digit year window for year 2000 dates) the date will be converted by OLEAUT32 into a 2-digit value when parsed into the SQL Pane. Oracle will interpret this as a year between 1929 and 1900.

The recommended work-around for this is to set your system’s Short Date format to include a 4-digit year.

A design-time update to the Visual Database Tools that addresses this issue is available for download as a part of Visual Studio 6.0 Service Pack 3.

 

Testing guidelines and recommendations:

Chapter 9 of Visual Basic documentation on MSDN has several examples of how to test for Year 2000 problems in Visual Basic applications. This is available on http://msdn.microsoft.com/library/books/advnvb5/html/Ch09.htm



Users testing applications written in Visual Basic should be especially careful to test the following problem areas:

User-defined functions: Many applications contain user-defined functions written in Visual Basic to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.

The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since Visual Basic rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.


Code Example:

The following example illustrates the date window in action with various input dates.

Sub TestDate()
Dim MyDate As Date
MyDate = "1/1/00"
Format MyDate, "mm/dd/yyyy"
MsgBox MyDate
End Sub

MyDate input

Expected behavior

1/1/00 1/1/1 1/1/9 1/1/2000 4/1/98 10/24/29 7/4/30 2/29/00 2/29/1900

1/1/2000 1/1/2001 1/1/2009 1/1/2000 4/1/1998 10/24/2029 7/4/1930 2/29/2000 error- Type mismatch (1900 not a leap year)

 

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic (32-bit)  6.0   (Portuguese (Brazil))

Product Summary
Product: Visual Basic (32-bit) Version: 6.0 Category:Compliant*#
Language: Portuguese (Brazil) OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See Below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95 (+ year 2000 software updates), Windows 98 (+ year 2000 software updates), SQL Server 6.5 Service Pack 5, MDAC 2.0 Service Pack 2 or greater, Visual Database Tools 6.0
Clock Dependencies: System Clock, Visual Basic runtime, (OLE) Automation Libraries
Last Updated: 26 Oct 1999
Product Details

This report applies to:

Introductory, Enterprise, Learning, Professional, and Standard editions.

Operational Range for Data: 1930 through 2029 using 2-digit shortcuts or user configurable.

Czech, Hungarian, Polish, Portuguese (Brazil), Romanian, and Russian versions contain US software.

Developing Year 2000 Compliant Software

How the product runtime handles dates:

Visual Basic 6.0 stores year-dates internally as 4-digits.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date.

The rule is:

2-digit dates between 00-29 are assumed to occur in the 2000s (2000-2029).

2-digit dates between 30-99 are assumed to occur in the 1900s (1930-1999).

NOTE: This string to date conversion is done by OLE-Automation. Starting from the version of OLE Automation shipped with Visual Studio 6 (Fall 98), OLE-Automation (32-bit and beyond) will allow the user or administrator to set the 100-year window for parsing 2-digit dates. (The default will be as stated above, 1930 - 2029).

Outlook Express 4.01 date handling:

Outlook Express 4.01 (OE) is included with, but not a requirement forVisual Basic 6.0. If Outlook Express 4.01 receives an IMAP mail message or a News message with a 2-digit year as the sent date, the date can be misinterpreted under certain conditions. If the 2-digit year is anything other than 99, OE will assume the century value is the same as the current century. If the current year is 2000, and a 2-digit date is received as 97, then the year will be interpreted as 2097. However, there is one special case when different logic is applied. If the 2-digit year 99 is received and current year is a multiple of 100 (e.g. 2000), the year will be interpreted as the current year plus 98 (e.g. 2098). You can find more information about this in the Internet Explorer (32-bit) 4.0x Year 2000 disclosure document.

Recommended practices to develop year 2000 compliant applications with this Development Tool:

The product has known issues when dates are stored as strings. It is recommended that all dates are stored using Date data type as opposed to strings.

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also be a problem if there is an error in the information. Visual Basic will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found.

For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates even though the month/day/year order have changed. For more information on which occasions might result in a date conversion error, please see the OLE Automation compliance document

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Common development errors dealing with year 2000 date issues:

Please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Other design time issues to be aware of when using this tool:

If the following products or technologies are installed, they should be updated to ensure proper functioning:

Product

Version

Location of Update

Internet Explorer 4.x

Service Pack 1

http://www.microsoft.com/windows/ie/download/windows.htm

OLE DB

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

SQL 6.5

Service Pack 5

http://support.microsoft.com/support/downloads/

ODBC

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

Windows NT 4.0

Service Pack 5

http://www.microsoft.com/ntserver

Oracle Issues

There is an issue regarding 2-digit year parsing in the Visual Database Tools when connecting to an Oracle database with a system configured for 2-digit year format. If the year entered into the Grid Pane’s Criteria cell is between 2029 and 2000 (the system default 2-digit year window for year 2000 dates) the date will be converted by OLEAUT32 into a 2-digit value when parsed into the SQL Pane. Oracle will interpret this as a year between 1929 and 1900.

The recommended work-around for this is to set your system’s Short Date format to include a 4-digit year.

A design-time update to the Visual Database Tools that addresses this issue is available for download as a part of Visual Studio 6.0 Service Pack 3.

 

Testing guidelines and recommendations:

Chapter 9 of Visual Basic documentation on MSDN has several examples of how to test for Year 2000 problems in Visual Basic applications. This is available on http://msdn.microsoft.com/library/books/advnvb5/html/Ch09.htm



Users testing applications written in Visual Basic should be especially careful to test the following problem areas:

User-defined functions: Many applications contain user-defined functions written in Visual Basic to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.

The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since Visual Basic rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.


Code Example:

The following example illustrates the date window in action with various input dates.

Sub TestDate()
Dim MyDate As Date
MyDate = "1/1/00"
Format MyDate, "mm/dd/yyyy"
MsgBox MyDate
End Sub

MyDate input

Expected behavior

1/1/00 1/1/1 1/1/9 1/1/2000 4/1/98 10/24/29 7/4/30 2/29/00 2/29/1900

1/1/2000 1/1/2001 1/1/2009 1/1/2000 4/1/1998 10/24/2029 7/4/1930 2/29/2000 error- Type mismatch (1900 not a leap year)

 

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic (32-bit)  6.0   (Romanian)

Product Summary
Product: Visual Basic (32-bit) Version: 6.0 Category:Compliant*#
Language: Romanian OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See Below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95 (+ year 2000 software updates), Windows 98 (+ year 2000 software updates), SQL Server 6.5 Service Pack 5, MDAC 2.0 Service Pack 2 or greater, Visual Database Tools 6.0
Clock Dependencies: System Clock, Visual Basic runtime, (OLE) Automation Libraries
Last Updated: 26 Oct 1999
Product Details

This report applies to:

Introductory, Enterprise, Learning, Professional, and Standard editions.

Operational Range for Data: 1930 through 2029 using 2-digit shortcuts or user configurable.

Czech, Hungarian, Polish, Portuguese (Brazil), Romanian, and Russian versions contain US software.

Developing Year 2000 Compliant Software

How the product runtime handles dates:

Visual Basic 6.0 stores year-dates internally as 4-digits.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date.

The rule is:

2-digit dates between 00-29 are assumed to occur in the 2000s (2000-2029).

2-digit dates between 30-99 are assumed to occur in the 1900s (1930-1999).

NOTE: This string to date conversion is done by OLE-Automation. Starting from the version of OLE Automation shipped with Visual Studio 6 (Fall 98), OLE-Automation (32-bit and beyond) will allow the user or administrator to set the 100-year window for parsing 2-digit dates. (The default will be as stated above, 1930 - 2029).

Outlook Express 4.01 date handling:

Outlook Express 4.01 (OE) is included with, but not a requirement forVisual Basic 6.0. If Outlook Express 4.01 receives an IMAP mail message or a News message with a 2-digit year as the sent date, the date can be misinterpreted under certain conditions. If the 2-digit year is anything other than 99, OE will assume the century value is the same as the current century. If the current year is 2000, and a 2-digit date is received as 97, then the year will be interpreted as 2097. However, there is one special case when different logic is applied. If the 2-digit year 99 is received and current year is a multiple of 100 (e.g. 2000), the year will be interpreted as the current year plus 98 (e.g. 2098). You can find more information about this in the Internet Explorer (32-bit) 4.0x Year 2000 disclosure document.

Recommended practices to develop year 2000 compliant applications with this Development Tool:

The product has known issues when dates are stored as strings. It is recommended that all dates are stored using Date data type as opposed to strings.

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also be a problem if there is an error in the information. Visual Basic will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found.

For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates even though the month/day/year order have changed. For more information on which occasions might result in a date conversion error, please see the OLE Automation compliance document

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Common development errors dealing with year 2000 date issues:

Please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Other design time issues to be aware of when using this tool:

If the following products or technologies are installed, they should be updated to ensure proper functioning:

Product

Version

Location of Update

Internet Explorer 4.x

Service Pack 1

http://www.microsoft.com/windows/ie/download/windows.htm

OLE DB

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

SQL 6.5

Service Pack 5

http://support.microsoft.com/support/downloads/

ODBC

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

Windows NT 4.0

Service Pack 5

http://www.microsoft.com/ntserver

Oracle Issues

There is an issue regarding 2-digit year parsing in the Visual Database Tools when connecting to an Oracle database with a system configured for 2-digit year format. If the year entered into the Grid Pane’s Criteria cell is between 2029 and 2000 (the system default 2-digit year window for year 2000 dates) the date will be converted by OLEAUT32 into a 2-digit value when parsed into the SQL Pane. Oracle will interpret this as a year between 1929 and 1900.

The recommended work-around for this is to set your system’s Short Date format to include a 4-digit year.

A design-time update to the Visual Database Tools that addresses this issue is available for download as a part of Visual Studio 6.0 Service Pack 3.

 

Testing guidelines and recommendations:

Chapter 9 of Visual Basic documentation on MSDN has several examples of how to test for Year 2000 problems in Visual Basic applications. This is available on http://msdn.microsoft.com/library/books/advnvb5/html/Ch09.htm



Users testing applications written in Visual Basic should be especially careful to test the following problem areas:

User-defined functions: Many applications contain user-defined functions written in Visual Basic to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.

The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since Visual Basic rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.


Code Example:

The following example illustrates the date window in action with various input dates.

Sub TestDate()
Dim MyDate As Date
MyDate = "1/1/00"
Format MyDate, "mm/dd/yyyy"
MsgBox MyDate
End Sub

MyDate input

Expected behavior

1/1/00 1/1/1 1/1/9 1/1/2000 4/1/98 10/24/29 7/4/30 2/29/00 2/29/1900

1/1/2000 1/1/2001 1/1/2009 1/1/2000 4/1/1998 10/24/2029 7/4/1930 2/29/2000 error- Type mismatch (1900 not a leap year)

 

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic (32-bit)  6.0   (Russian)

Product Summary
Product: Visual Basic (32-bit) Version: 6.0 Category:Compliant*#
Language: Russian OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See Below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95 (+ year 2000 software updates), Windows 98 (+ year 2000 software updates), SQL Server 6.5 Service Pack 5, MDAC 2.0 Service Pack 2 or greater, Visual Database Tools 6.0
Clock Dependencies: System Clock, Visual Basic runtime, (OLE) Automation Libraries
Last Updated: 26 Oct 1999
Product Details

This report applies to:

Introductory, Enterprise, Learning, Professional, and Standard editions.

Operational Range for Data: 1930 through 2029 using 2-digit shortcuts or user configurable.

Czech, Hungarian, Polish, Portuguese (Brazil), Romanian, and Russian versions contain US software.

Developing Year 2000 Compliant Software

How the product runtime handles dates:

Visual Basic 6.0 stores year-dates internally as 4-digits.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date.

The rule is:

2-digit dates between 00-29 are assumed to occur in the 2000s (2000-2029).

2-digit dates between 30-99 are assumed to occur in the 1900s (1930-1999).

NOTE: This string to date conversion is done by OLE-Automation. Starting from the version of OLE Automation shipped with Visual Studio 6 (Fall 98), OLE-Automation (32-bit and beyond) will allow the user or administrator to set the 100-year window for parsing 2-digit dates. (The default will be as stated above, 1930 - 2029).

Outlook Express 4.01 date handling:

Outlook Express 4.01 (OE) is included with, but not a requirement forVisual Basic 6.0. If Outlook Express 4.01 receives an IMAP mail message or a News message with a 2-digit year as the sent date, the date can be misinterpreted under certain conditions. If the 2-digit year is anything other than 99, OE will assume the century value is the same as the current century. If the current year is 2000, and a 2-digit date is received as 97, then the year will be interpreted as 2097. However, there is one special case when different logic is applied. If the 2-digit year 99 is received and current year is a multiple of 100 (e.g. 2000), the year will be interpreted as the current year plus 98 (e.g. 2098). You can find more information about this in the Internet Explorer (32-bit) 4.0x Year 2000 disclosure document.

Recommended practices to develop year 2000 compliant applications with this Development Tool:

The product has known issues when dates are stored as strings. It is recommended that all dates are stored using Date data type as opposed to strings.

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also be a problem if there is an error in the information. Visual Basic will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found.

For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates even though the month/day/year order have changed. For more information on which occasions might result in a date conversion error, please see the OLE Automation compliance document

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Common development errors dealing with year 2000 date issues:

Please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Other design time issues to be aware of when using this tool:

If the following products or technologies are installed, they should be updated to ensure proper functioning:

Product

Version

Location of Update

Internet Explorer 4.x

Service Pack 1

http://www.microsoft.com/windows/ie/download/windows.htm

OLE DB

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

SQL 6.5

Service Pack 5

http://support.microsoft.com/support/downloads/

ODBC

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

Windows NT 4.0

Service Pack 5

http://www.microsoft.com/ntserver

Oracle Issues

There is an issue regarding 2-digit year parsing in the Visual Database Tools when connecting to an Oracle database with a system configured for 2-digit year format. If the year entered into the Grid Pane’s Criteria cell is between 2029 and 2000 (the system default 2-digit year window for year 2000 dates) the date will be converted by OLEAUT32 into a 2-digit value when parsed into the SQL Pane. Oracle will interpret this as a year between 1929 and 1900.

The recommended work-around for this is to set your system’s Short Date format to include a 4-digit year.

A design-time update to the Visual Database Tools that addresses this issue is available for download as a part of Visual Studio 6.0 Service Pack 3.

 

Testing guidelines and recommendations:

Chapter 9 of Visual Basic documentation on MSDN has several examples of how to test for Year 2000 problems in Visual Basic applications. This is available on http://msdn.microsoft.com/library/books/advnvb5/html/Ch09.htm



Users testing applications written in Visual Basic should be especially careful to test the following problem areas:

User-defined functions: Many applications contain user-defined functions written in Visual Basic to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.

The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since Visual Basic rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.


Code Example:

The following example illustrates the date window in action with various input dates.

Sub TestDate()
Dim MyDate As Date
MyDate = "1/1/00"
Format MyDate, "mm/dd/yyyy"
MsgBox MyDate
End Sub

MyDate input

Expected behavior

1/1/00 1/1/1 1/1/9 1/1/2000 4/1/98 10/24/29 7/4/30 2/29/00 2/29/1900

1/1/2000 1/1/2001 1/1/2009 1/1/2000 4/1/1998 10/24/2029 7/4/1930 2/29/2000 error- Type mismatch (1900 not a leap year)

 

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic (32-bit)  6.0   (Spanish)

Product Summary
Product: Visual Basic (32-bit) Version: 6.0 Category:Compliant*#
Language: Spanish OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See Below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95 (+ year 2000 software updates), Windows 98 (+ year 2000 software updates), SQL Server 6.5 Service Pack 5, MDAC 2.0 Service Pack 2 or greater, Visual Database Tools 6.0
Clock Dependencies: System Clock, Visual Basic runtime, (OLE) Automation Libraries
Last Updated: 26 Oct 1999
Product Details

This report applies to:

Introductory, Enterprise, Learning, Professional, and Standard editions.

Operational Range for Data: 1930 through 2029 using 2-digit shortcuts or user configurable.

Czech, Hungarian, Polish, Portuguese (Brazil), Romanian, and Russian versions contain US software.

Developing Year 2000 Compliant Software

How the product runtime handles dates:

Visual Basic 6.0 stores year-dates internally as 4-digits.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date.

The rule is:

2-digit dates between 00-29 are assumed to occur in the 2000s (2000-2029).

2-digit dates between 30-99 are assumed to occur in the 1900s (1930-1999).

NOTE: This string to date conversion is done by OLE-Automation. Starting from the version of OLE Automation shipped with Visual Studio 6 (Fall 98), OLE-Automation (32-bit and beyond) will allow the user or administrator to set the 100-year window for parsing 2-digit dates. (The default will be as stated above, 1930 - 2029).

Outlook Express 4.01 date handling:

Outlook Express 4.01 (OE) is included with, but not a requirement forVisual Basic 6.0. If Outlook Express 4.01 receives an IMAP mail message or a News message with a 2-digit year as the sent date, the date can be misinterpreted under certain conditions. If the 2-digit year is anything other than 99, OE will assume the century value is the same as the current century. If the current year is 2000, and a 2-digit date is received as 97, then the year will be interpreted as 2097. However, there is one special case when different logic is applied. If the 2-digit year 99 is received and current year is a multiple of 100 (e.g. 2000), the year will be interpreted as the current year plus 98 (e.g. 2098). You can find more information about this in the Internet Explorer (32-bit) 4.0x Year 2000 disclosure document.

Recommended practices to develop year 2000 compliant applications with this Development Tool:

The product has known issues when dates are stored as strings. It is recommended that all dates are stored using Date data type as opposed to strings.

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also be a problem if there is an error in the information. Visual Basic will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found.

For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates even though the month/day/year order have changed. For more information on which occasions might result in a date conversion error, please see the OLE Automation compliance document

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Common development errors dealing with year 2000 date issues:

Please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

Other design time issues to be aware of when using this tool:

If the following products or technologies are installed, they should be updated to ensure proper functioning:

Product

Version

Location of Update

Internet Explorer 4.x

Service Pack 1

http://www.microsoft.com/windows/ie/download/windows.htm

OLE DB

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

SQL 6.5

Service Pack 5

http://support.microsoft.com/support/downloads/

ODBC

MDAC 2.0 Service Pack 2 or greater

http://www.microsoft.com/data/download.htm

Windows NT 4.0

Service Pack 5

http://www.microsoft.com/ntserver

Oracle Issues

There is an issue regarding 2-digit year parsing in the Visual Database Tools when connecting to an Oracle database with a system configured for 2-digit year format. If the year entered into the Grid Pane’s Criteria cell is between 2029 and 2000 (the system default 2-digit year window for year 2000 dates) the date will be converted by OLEAUT32 into a 2-digit value when parsed into the SQL Pane. Oracle will interpret this as a year between 1929 and 1900.

The recommended work-around for this is to set your system’s Short Date format to include a 4-digit year.

A design-time update to the Visual Database Tools that addresses this issue is available for download as a part of Visual Studio 6.0 Service Pack 3.

 

Testing guidelines and recommendations:

Chapter 9 of Visual Basic documentation on MSDN has several examples of how to test for Year 2000 problems in Visual Basic applications. This is available on http://msdn.microsoft.com/library/books/advnvb5/html/Ch09.htm



Users testing applications written in Visual Basic should be especially careful to test the following problem areas:

User-defined functions: Many applications contain user-defined functions written in Visual Basic to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.

The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since Visual Basic rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.


Code Example:

The following example illustrates the date window in action with various input dates.

Sub TestDate()
Dim MyDate As Date
MyDate = "1/1/00"
Format MyDate, "mm/dd/yyyy"
MsgBox MyDate
End Sub

MyDate input

Expected behavior

1/1/00 1/1/1 1/1/9 1/1/2000 4/1/98 10/24/29 7/4/30 2/29/00 2/29/1900

1/1/2000 1/1/2001 1/1/2009 1/1/2000 4/1/1998 10/24/2029 7/4/1930 2/29/2000 error- Type mismatch (1900 not a leap year)

 

For more information, please refer to the white paper, "Developing Y2K Compliant Applications with Visual Basic"

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Chinese - Simplified)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Chinese - Simplified OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Chinese - Traditional)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Chinese - Traditional OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Czech)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Czech OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Danish)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Danish OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Dutch)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Dutch OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (English)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: English OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Finnish)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Finnish OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (French)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: French OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (German)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: German OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Greek)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Greek OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Hungarian)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Hungarian OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Italian)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Italian OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Japanese)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Japanese OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Korean)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Korean OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Norwegian)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Norwegian OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Polish)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Polish OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Portuguese (Brazil))

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Portuguese (Brazil) OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Portuguese)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Portuguese OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Russian)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Russian OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Slovenian)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Slovenian OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Spanish)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Spanish OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 10 May 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Swedish)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Swedish OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  5.0   (Turkish)

Product Summary
Product: Visual Basic for Applications Version: 5.0 Category:Compliant
Language: Turkish OS: 32-Bit Win Release Date: 01 May 1997
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT 3.51 with Service Pack 5 or greater, or Windows NT 4.0 (Service Pack 2+ recommended)
Clock Dependencies: System Clock
Last Updated: 21 Sep 1999
Product Details

Visual Basic for Applications (VBA) 5.0 32-Bit Win

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes, provided the developer relies on the built-in Date data type and built-in date handling functions, and that data passed by applications that use Visual Basic for Applications (VBA) use 4-digit years to represent dates.

Products that have shipped with Visual Basic for Applications 5.0, include but are not limited to, the following: Excel 97, Access 97, Word 97, PowerPoint 97, and Project 98.

Operational Range for Data: System Dependent

How the product runtime handles dates:

VBA stores dates internally as an 8-byte floating-point value that represents the number of days (whole and fractional) since midnight, December 30, 1899. The integer portion represents the number of whole days and the decimal portion represents the fraction of a day. For example May 22, 1997 at 3:00pm would be stored as 35572.625 since May 22, 1997 is 35,572 days after December 30, 1899 and 3:00pm is 625/1000 of one day. VBA is capable of storing dates from January 1, 100 to through December 31, 9999.

VBA includes numerous date manipulation functions, which are designed to accurately handle dates within VBA’s operational range. These intrinsic functions for date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

Year()

Time()

Dates and times returned by the Now(), Date(), and Time() functions are obtained from the operating system clock.

A date may be displayed in 2-digit-year format (by using the Visual Basic format function, for example) but the value is carried as a long 4-digit-year value.

When only given 2 digits for the year, the product interprets the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are assumed to be 20XX.
  • 2-digit dates between 30-99 are assumed to be 19XX.

These are the defaults that most users running Windows 95 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. With machines that have older versions of OLE Automation (prior to version 2.30.00.0000), they may assume the current century given a 2-digit year and with newer versions of OLE Automation, this 100-year window can be set through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Recommended practices to develop year 2000 compliant applications:

To create year 2000 compliant applications developers should focus on three areas:

  1. How dates are passed into VBA functions
  2. How dates are manipulated within VBA functions
  3. How dates are returned or displayed by VBA functions

When passing date values into VBA functions developers should use the intrinsic Date data type. For example, the following function accepts a date value as input:

Function DaysInMonth(AnyDate As Date) As Integer

DaysInMonth = DateSerial(Year(AnyDate), Month(AnyDate) + 1, 1) - _

DateSerial(Year(AnyDate), Month(AnyDate), 1)

End Function

VBA will perform resolution routines on data being passed into the procedure and raise a runtime error if the value is not a date.

Furthermore, developers should make sure that if a user-entered value is passed into functions (either directly or though a custom user interface) that 4 digits represent the year portion of the date.

Regarding date manipulation within functions developers should ensure that only intrinsic VBA functions are used. The example above uses the DateSerial, Year, and Month functions to compute the number of dates in a month.

Finally when data is returned by a VBA function it should also be defined using the intrinsic Date data type.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems. Developers should follow the guidelines outlined in the previous section.

Dates that are stored as strings are particularly prone to producing unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 187) are valid dates even though the month/day/year order has changed.

Manipulating dates using string functions should also be avoided since the date’s format (2- or 4-digit years) can affect the result.

In general, custom VBA routines should use the intrinsic Date data type when storing date values.

 

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Chinese - Simplified)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Chinese - Simplified OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Chinese - Traditional)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Chinese - Traditional OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Dutch)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Dutch OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (English)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: English OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 19 Jul 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (French)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: French OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (German)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: German OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Italian)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Italian OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Japanese)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Japanese OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Korean)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Korean OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Portuguese (Brazil))

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Portuguese (Brazil) OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Spanish)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Spanish OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic for Applications  6.0   (Swedish)

Product Summary
Product: Visual Basic for Applications Version: 6.0 Category:Compliant
Language: Swedish OS: 32-Bit Win Release Date: 25 Mar 1999
Operational Range: -
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows 95, or Windows NT4 (Service Pack 3 or greater recommended)
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

Visual Basic for Applications (VBA) 6.0

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

Products that have shipped with Visual Basic for Applications 6.0, include but are not limited to, the following: Excel 2000, Access 2000, Word 2000, Outlook 2000, PowerPoint 2000, Project 2000, FrontPage 2000

Since a common programming language (VBA 6.0) is used by Visual Basic, testing the intrinsic commands for date handling can test dates. These intrinsic functions for explicit date handling include:

Now ()

CDate()

CVDate()

DateValue()

Date()

Date$()

Format()

DateAdd()

DateDiff()

DatePart()

IsDate()

Day()

Month()

Weekday()

FormatDateTime()

Year()

VBA also performs implicit string to date conversions as in the following:

CStr(Variant that contains a VT_DATE)

A$ = Variant that contains a VT_DATE

Dim datevar as Date; A$ = datevar

Get #1, nPosition, theDate (where theDate has been defined as a VT_DATE)

Dates and times displayed can be obtained from the operating system clock, from user input, from date literals (eg #01/01/1999#) or from user data files. Dates are stored as part of a floating point number with the value to the left of the decimal representing the number of days past December 30, 1899. A date may be displayed in 2-digit format (by using the Visual Basic Format() function, for example) but the value is carried as a long 4-digit value.

When only given 2 digits, the product assumes the first 2 digits of the year according to a rule described below.

Two-digit shortcut handling:

The first 2 digits are assumed according to a specific rule in cases where only 2 digits are supplied for the date. The general rule is:

  • 2-digit dates between 00-29 are mapped to (2000-2029).
  • 2-digit dates between 30-99 are mapped to (1930-1999).

These are the defaults that users running Windows 95, Windows 98 and Windows NT4 experience. However, VBA uses OLE Automation for parsing dates and consequently, uses OLE Automation’s rules for handling years that have only 2 digits. The 100-year window illustrated above can be adjusted from the default through a control panel setting.

See the OLE Automation web site at: http://www.microsoft.com/technet/year2k/white/auto.htm to learn more about this behavior.

Common development errors dealing with year 2000 date issues:

User-defined functions are a prime area of date handling errors. A poorly written function may lead to problems.

Dates that are stored as strings can also produce unexpected results if the information is not input in an appropriate format. VBA will interpret a string as a date if, by rearranging the month/day/year order, a valid date can be found. For example, both 3/30/98 (March 30, 1998) and 87/3/1 (March 1, 1987) are valid dates although the month/day/year order has changed.

In general, custom VBA routines should use the intrinsic Date data type when storing date values, instead of using strings.

Testing guidelines and recommendations:

The MSDN on-line library includes information on developing Year 2000 compliant applications with Visual Studio and Visual Basic (see http://msdn.microsoft.com/library/techart/msdn_vs6y2k.htm). The guidelines described in this document apply equally to VBA as well as VB.

Users testing applications written in VBA should be especially careful to test the following problem areas:

  1. User-defined functions: Many applications contain user-defined functions written in Visual Basic for Applications to deal with dates in various ways. Many of these functions store date values as strings or write data to a disk file using the Put statement. Manipulating these values improperly can result in date handling errors that are outside of the scope of the testing that was done at Microsoft on the Year 2000 issue.
  2. The date usage error described above can cause problems if an error handling routine is meant to catch improperly entered dates. Since VBA rarely generates an error when a string date is used as an input, an error handling routine is unlikely to be called. In this case the proper programming technique would be to validate the data using code instead of relying on a runtime error to signal an improper date.

Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  3.1   (English)

Product Summary
Product: Visual Basic Scripting Language Version: 3.1 Category:Compliant*
Language: English OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System clock
Last Updated: 05 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

For suggestions, see http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Arabic)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Arabic OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Catalan)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Catalan OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Chinese - Simplified)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Chinese - Simplified OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Chinese - Traditional)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Chinese - Traditional OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Czech)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Czech OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Danish)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Danish OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Dutch)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Dutch OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (English)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: English OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Finnish)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Finnish OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (French)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: French OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (German)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: German OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Greek)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Greek OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Hebrew)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Hebrew OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Hungarian)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Hungarian OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Italian)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Italian OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Japanese)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Japanese OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Korean)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Korean OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Norwegian)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Norwegian OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Polish)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Polish OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Portuguese (Brazil))

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Portuguese (Brazil) OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Portuguese)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Portuguese OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Russian)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Russian OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Slovak)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Slovak OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Slovenian)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Slovenian OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Spanish)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Spanish OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Swedish)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Swedish OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual Basic Scripting Language  5.0   (Turkish)

Product Summary
Product: Visual Basic Scripting Language Version: 5.0 Category:Compliant*
Language: Turkish OS: 32-Bit Win Release Date: N/A
Operational Range: 01 Jan 100 - 31 Dec 9999
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: OLE Automation
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

VBScript stores dates internally in OLE’s date format. Virtually all date functions are supplied by OLE automation.

Two-digit shortcut handling:

See under Common development errors, below.

Recommended practices to develop year 2000 compliant applications:

See http://msdn.microsoft.com/workshop/languages/clinic/y2kscript.asp for suggestions.

Common development errors dealing with year 2000 date issues:

Since VBScript uses date conventions similar to Visual Basic, and based on OLE, it is tempting to enter hard dates using two numbers for the year, e.g. #2-14-99#. Developers should make a habit of using 4-digit years, e.g. #2-14-1999#.

Testing guidelines and recommendations:

Since VBScript is a programming language, developers should test their individual programs as appropriate for date issues. There are no general concerns common to all VBScript programs.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  1.51   (Japanese)

Product Summary
Product: Visual C++ Version: 1.51 Category:Compliant
Language: Japanese OS: 16-Bit Win Release Date: 08 Dec 1993
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: MS-DOS 6.22, Windows 3.1, Windows 95, Windows 98, ODBC and Windows NT
Clock Dependencies: System clock
Last Updated: 13 Sep 1999
Product Details

This report applies to:

Professional and Standard editions.

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

Visual C++ 1.51 uses the following data types for dates:

Data type

Range

Time_t

1/1/1970 through 1/18/2038

DOS DateTime

1/1/1980 through 12/31/2108

Struct FILETIME

100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

Known Issues:
There is a known cosmetic issue: if the system clock is set to 2000 and you create a default Microsoft Foundation Classes (MFC) AppWizard application, the generated copyright reads "1900". This will not impact the functionality of the generated program but should be corrected using the resource editor, as it may cause confusion as to when the document was actually written.

 

Two-digit shortcut handling:

Two-digit dates are for display only.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are:

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime – given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example:

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

 

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  1.52   (English)

Product Summary
Product: Visual C++ Version: 1.52 Category:Compliant
Language: English OS: 16-Bit Win Release Date: 03 Apr 1995
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: MS-DOS 6.22, Windows 3.1, Windows 95, Windows 98, ODBC and Windows NT
Clock Dependencies: System clock
Last Updated: 13 Sep 1999
Product Details

This report applies to:

Professional and Standard editions.

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

Visual C++ 1.52 uses the following data types for dates:

Data type

Range

Time_t

1/1/1970 through 1/18/2038

DOS DateTime

1/1/1980 through 12/31/2108

Struct FILETIME

100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

Known Issues:
There is a known cosmetic issue: if the system clock is set to 2000 and you create a default Microsoft Foundation Classes (MFC) AppWizard application, the generated copyright reads "1900". This will not impact the functionality of the generated program but should be corrected using the resource editor, as it may cause confusion as to when the document was actually written.

 

Two-digit shortcut handling:

Two-digit dates are for display only.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

 

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  4.2   (English)

Product Summary
Product: Visual C++ Version: 4.2 Category:Compliant#
Language: English OS: 32-Bit Win Release Date: 01 Aug 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 3.51, Windows NT 4.0, Windows 95, Internet Explorer 3.02, Acme Setup, ODBC driver, SQL Server, Microsoft Visual SourceSafe 5.0 (see the Visual Source Safe 5.0 compliance document for more details).
Clock Dependencies: System Clock
Last Updated: 15 Sep 1999
Product Details

This report applies to:

Enterprise and Professional Editions.

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.


How the product runtime handles dates:

Visual C++ 4.2 uses the following base data types for dates.

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

struct SYSTEMTIME

The year (since 0 A.D.) in an unsigned 16-bit value

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

 

Known Issues:
There is a known cosmetic issue: if the system clock is set to 2000 and you create a default Microsoft Foundation Classes (MFC) AppWizard application, the generated copyright reads "1900". This will not impact the functionality of the generated program but should be corrected using the resource editor, as it may cause confusion as to when the document was actually written.

The Microsoft C Runtime Library (MSVCRT) prior to version 4.2 6.00.8397.0 exhibited a daylight savings time bug - Applications that utilize this runtime library may behave as if current time is one hour earlier than the correct time shown on the Windows clock. The problem will continue for one week from April 1 through April 8, 2001, after which these applications will shift to daylight savings time and again be in sync with the operating system. This is not a year 2000 issue but rather a daylight savings time issue. It could occur in the years 1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, and 2035. The common thing about these years is that April 1 falls on a Sunday. A fix for this issue is available in Visual Studio 6.0 Service Pack 3 and Windows Update.

Two-digit shortcut handling:

The product provides 2-digit shortcuts for display only.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

 

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Non-Microsoft components (these are not covered by this document):
Oracle ODBC driver
"TimeLock" timebomb component (used in demo versions only)
InstallShield

Product includes non-Visual C++ components with which the user can build applications (these are not covered by this document):
ODBC, OLE DB (Data Access Group)

OLEAUT32.DLL
Month Calendar Control, Access Calendar Control (Office Group)
MS Month View Control, DBGrid, DBCombo, DBList, DataGrid, DataCombo, DataList, FlexGrid, Hierarchical FlexGrid (Visual Basic Group)
Database engines (DAO, Access Jet)
Component Gallery: status bar

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  4.2   (Japanese)

Product Summary
Product: Visual C++ Version: 4.2 Category:Compliant#
Language: Japanese OS: 32-Bit Win Release Date: 01 Aug 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 3.51, Windows NT 4.0, Windows 95, Internet Explorer 3.02, Acme Setup, ODBC driver, SQL Server, Microsoft Visual SourceSafe 5.0 (see the Visual Source Safe 5.0 compliance document for more details).
Clock Dependencies: System Clock
Last Updated: 15 Sep 1999
Product Details

This report applies to:

Enterprise and Professional Editions.

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.


How the product runtime handles dates:

Visual C++ 4.2 uses the following base data types for dates.

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

struct SYSTEMTIME

The year (since 0 A.D.) in an unsigned 16-bit value

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

 

Known Issues:
There is a known cosmetic issue: if the system clock is set to 2000 and you create a default Microsoft Foundation Classes (MFC) AppWizard application, the generated copyright reads "1900". This will not impact the functionality of the generated program but should be corrected using the resource editor, as it may cause confusion as to when the document was actually written.

The Microsoft C Runtime Library (MSVCRT) prior to version 4.2 6.00.8397.0 exhibited a daylight savings time bug - Applications that utilize this runtime library may behave as if current time is one hour earlier than the correct time shown on the Windows clock. The problem will continue for one week from April 1 through April 8, 2001, after which these applications will shift to daylight savings time and again be in sync with the operating system. This is not a year 2000 issue but rather a daylight savings time issue. It could occur in the years 1973, 1979, 1984, 1990, 2001, 2007, 2012, 2018, 2029, and 2035. The common thing about these years is that April 1 falls on a Sunday. A fix for this issue is available in Visual Studio 6.0 Service Pack 3 and Windows Update.

Two-digit shortcut handling:

The product provides 2-digit shortcuts for display only.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

 

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Non-Microsoft components (these are not covered by this document):
Oracle ODBC driver
"TimeLock" timebomb component (used in demo versions only)
InstallShield

Product includes non-Visual C++ components with which the user can build applications (these are not covered by this document):
ODBC, OLE DB (Data Access Group)

OLEAUT32.DLL
Month Calendar Control, Access Calendar Control (Office Group)
MS Month View Control, DBGrid, DBCombo, DBList, DataGrid, DataCombo, DataList, FlexGrid, Hierarchical FlexGrid (Visual Basic Group)
Database engines (DAO, Access Jet)
Component Gallery: status bar

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  5.0   (English)

Product Summary
Product: Visual C++ Version: 5.0 Category:Compliant*#
Language: English OS: 32-Bit Win Release Date: 01 Feb 1997
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 3.51, Windows NT 4.0, Windows 95, Internet Explorer 3.02, Acme Setup, ODBC driver, SQL Server, Microsoft Visual SourceSafe 5.0 (see the Visual Source Safe 5.0 compliance document for more details).
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, and Learning editions.

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.


How the product runtime handles dates:

Visual C++ 5.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

struct SYSTEMTIME

The year (since 0 A.D.) in an unsigned 16-bit value

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

Known Issues:
There is a known date related issue: if the system clock is set to 2000 and the user creates a default Microsoft Foundation Classes (MFC) AppWizard application, the generated program date reads "1900". This does not impact the functionality of the generated program but should be corrected using the resource editor to avoid confusion as to the date the application was created.

Two-digit shortcut handling:

The product provides 2-digit shortcuts for display only.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Non-Microsoft components:
Oracle ODBC driver
"TimeLock" timebomb component (used in demo versions only)
InstallShield

Product includes non-Visual C++ components with which the user can build applications:
ODBC, OLE DB (Data Access Group)
Month Calendar Control, Access Calendar Control (Office Group)
OLEAUT32.DLL, MS Month View Control, DBGrid, DBCombo, DBList, DataGrid, DataCombo, DataList, FlexGrid, Hierarchical FlexGrid (Visual Basic Group)
Database engines (DAO, Access Jet)
Component Gallery: status bar

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  5.0   (French)

Product Summary
Product: Visual C++ Version: 5.0 Category:Compliant*#
Language: French OS: 32-Bit Win Release Date: 01 Feb 1997
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 3.51, Windows NT 4.0, Windows 95, Internet Explorer 3.02, Acme Setup, ODBC driver, SQL Server, Microsoft Visual SourceSafe 5.0 (see the Visual Source Safe 5.0 compliance document for more details).
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, and Learning editions.

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.


How the product runtime handles dates:

Visual C++ 5.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

struct SYSTEMTIME

The year (since 0 A.D.) in an unsigned 16-bit value

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

Known Issues:
There is a known date related issue: if the system clock is set to 2000 and the user creates a default Microsoft Foundation Classes (MFC) AppWizard application, the generated program date reads "1900". This does not impact the functionality of the generated program but should be corrected using the resource editor to avoid confusion as to the date the application was created.

Two-digit shortcut handling:

The product provides 2-digit shortcuts for display only.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Non-Microsoft components:
Oracle ODBC driver
"TimeLock" timebomb component (used in demo versions only)
InstallShield

Product includes non-Visual C++ components with which the user can build applications:
ODBC, OLE DB (Data Access Group)
Month Calendar Control, Access Calendar Control (Office Group)
OLEAUT32.DLL, MS Month View Control, DBGrid, DBCombo, DBList, DataGrid, DataCombo, DataList, FlexGrid, Hierarchical FlexGrid (Visual Basic Group)
Database engines (DAO, Access Jet)
Component Gallery: status bar

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  5.0   (German)

Product Summary
Product: Visual C++ Version: 5.0 Category:Compliant*#
Language: German OS: 32-Bit Win Release Date: 01 Feb 1997
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 3.51, Windows NT 4.0, Windows 95, Internet Explorer 3.02, Acme Setup, ODBC driver, SQL Server, Microsoft Visual SourceSafe 5.0 (see the Visual Source Safe 5.0 compliance document for more details).
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, and Learning editions.

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.


How the product runtime handles dates:

Visual C++ 5.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

struct SYSTEMTIME

The year (since 0 A.D.) in an unsigned 16-bit value

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

Known Issues:
There is a known date related issue: if the system clock is set to 2000 and the user creates a default Microsoft Foundation Classes (MFC) AppWizard application, the generated program date reads "1900". This does not impact the functionality of the generated program but should be corrected using the resource editor to avoid confusion as to the date the application was created.

Two-digit shortcut handling:

The product provides 2-digit shortcuts for display only.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Non-Microsoft components:
Oracle ODBC driver
"TimeLock" timebomb component (used in demo versions only)
InstallShield

Product includes non-Visual C++ components with which the user can build applications:
ODBC, OLE DB (Data Access Group)
Month Calendar Control, Access Calendar Control (Office Group)
OLEAUT32.DLL, MS Month View Control, DBGrid, DBCombo, DBList, DataGrid, DataCombo, DataList, FlexGrid, Hierarchical FlexGrid (Visual Basic Group)
Database engines (DAO, Access Jet)
Component Gallery: status bar

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  5.0   (Japanese)

Product Summary
Product: Visual C++ Version: 5.0 Category:Compliant*#
Language: Japanese OS: 32-Bit Win Release Date: 01 Feb 1997
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 3.51, Windows NT 4.0, Windows 95, Internet Explorer 3.02, Acme Setup, ODBC driver, SQL Server, Microsoft Visual SourceSafe 5.0 (see the Visual Source Safe 5.0 compliance document for more details).
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, and Learning editions.

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that any available and appropriate software updates or service packs have been applied.


How the product runtime handles dates:

Visual C++ 5.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 A.D. (a 64-bit value)

struct SYSTEMTIME

The year (since 0 A.D.) in an unsigned 16-bit value

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

Known Issues:
There is a known date related issue: if the system clock is set to 2000 and the user creates a default Microsoft Foundation Classes (MFC) AppWizard application, the generated program date reads "1900". This does not impact the functionality of the generated program but should be corrected using the resource editor to avoid confusion as to the date the application was created.

Two-digit shortcut handling:

The product provides 2-digit shortcuts for display only.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Non-Microsoft components:
Oracle ODBC driver
"TimeLock" timebomb component (used in demo versions only)
InstallShield

Product includes non-Visual C++ components with which the user can build applications:
ODBC, OLE DB (Data Access Group)
Month Calendar Control, Access Calendar Control (Office Group)
OLEAUT32.DLL, MS Month View Control, DBGrid, DBCombo, DBList, DataGrid, DataCombo, DataList, FlexGrid, Hierarchical FlexGrid (Visual Basic Group)
Database engines (DAO, Access Jet)
Component Gallery: status bar

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  6.0   (English)

Product Summary
Product: Visual C++ Version: 6.0 Category:Compliant*
Language: English OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95, Windows 98 with software updates
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, Standard, and Introductory editions.

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that the following prerequisites have been satisfied:

Prerequisites:

 

How the product runtime handles dates:

Visual C++ 6.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 AD (a 64-bit value)

struct tm

1/1/1900 through 12/31/2147483647

struct SYSTEMTIME

1/1/1900 through 12/31/32767

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

 

Two-digit shortcut handling:

Internet Explorer’s Date/Time Picker and Month Calendar common controls:

0 < year < 35: 2000 to 2035;

36 < year < 99: 1936 to 1999

Visual Basic’s date picker common control:

0 < year < 29: 2000 to 2029;

30 < year < 99: 1930 to 1999

SQL debugging/Visual Database Tools:

0 < year < 49: 2000 to 2049;

50 < year < 99: 1950 to 1999 (only in the Enterprise Edition)

Known Issues:

The Internet Explorer 4 (32-bit) Date/Time Picker and Month Calendar common controls shipped with this release do not permit direct entry of leap days (including leap day 2000). User can work around this by: 1) using the drop down calendar, or 2) by setting the year to 00, moving focus to a different control, then returning focus to the Date/Time-Picker or Month Calendar control, then entering 2/29 for the month/day. Visual Basic’s versions of the Date/Time Picker and Month Calendar common controls do not have this issue. The direct entry of leap days has been enabled in the latest version of comctl32.dll, which can be downloaded from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp.

Recommended practices to develop year 2000 compliant applications:

  1. Microsoft Windows NT 4.0 requires Service Pack 3, included in this release of Visual C++, as well as software updates which can be found at: http://microsoft.com/NTServer/all/downloads.asp for compliance. Windows NT 4.0 Service Pack 4.0 also contains the Year 2000 updates necessary for Windows NT 4.0 and is recommended for installation.
  2. Install Microsoft SQL Server 6.5 Service Pack 5. More details are available in the SQL Server Compliance document available on this web site.
  3. Install the latest version of the Microsoft comctl32.dll or update comctl32.dll to the latest version from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp to update the Internet Explorer 4.0 Date/Time Picker and Month Calendar to address leap day issues.
  4. Install the update for the Microsoft Data Access Components shipped as part of Windows NT 4.0 Service Pack 4.
  5. Install the updated Microsoft Virtual Machine, version 2436 or 3165 or newer, from http://www.microsoft.com/java/download.htm.

Common development errors dealing with year 2000 date issues:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  6.0   (French)

Product Summary
Product: Visual C++ Version: 6.0 Category:Compliant*
Language: French OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95, Windows 98 with software updates
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, Standard, and Introductory editions.

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that the following prerequisites have been satisfied:

Prerequisites:

 

How the product runtime handles dates:

Visual C++ 6.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 AD (a 64-bit value)

struct tm

1/1/1900 through 12/31/2147483647

struct SYSTEMTIME

1/1/1900 through 12/31/32767

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

 

Two-digit shortcut handling:

Internet Explorer’s Date/Time Picker and Month Calendar common controls:

0 < year < 35: 2000 to 2035;

36 < year < 99: 1936 to 1999

Visual Basic’s date picker common control:

0 < year < 29: 2000 to 2029;

30 < year < 99: 1930 to 1999

SQL debugging/Visual Database Tools:

0 < year < 49: 2000 to 2049;

50 < year < 99: 1950 to 1999 (only in the Enterprise Edition)

Known Issues:

The Internet Explorer 4 (32-bit) Date/Time Picker and Month Calendar common controls shipped with this release do not permit direct entry of leap days (including leap day 2000). User can work around this by: 1) using the drop down calendar, or 2) by setting the year to 00, moving focus to a different control, then returning focus to the Date/Time-Picker or Month Calendar control, then entering 2/29 for the month/day. Visual Basic’s versions of the Date/Time Picker and Month Calendar common controls do not have this issue. The direct entry of leap days has been enabled in the latest version of comctl32.dll, which can be downloaded from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp.

Recommended practices to develop year 2000 compliant applications:

  1. Microsoft Windows NT 4.0 requires Service Pack 3, included in this release of Visual C++, as well as software updates which can be found at: http://microsoft.com/NTServer/all/downloads.asp for compliance. Windows NT 4.0 Service Pack 4.0 also contains the Year 2000 updates necessary for Windows NT 4.0 and is recommended for installation.
  2. Install Microsoft SQL Server 6.5 Service Pack 5. More details are available in the SQL Server Compliance document available on this web site.
  3. Install the latest version of the Microsoft comctl32.dll or update comctl32.dll to the latest version from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp to update the Internet Explorer 4.0 Date/Time Picker and Month Calendar to address leap day issues.
  4. Install the update for the Microsoft Data Access Components shipped as part of Windows NT 4.0 Service Pack 4.
  5. Install the updated Microsoft Virtual Machine, version 2436 or 3165 or newer, from http://www.microsoft.com/java/download.htm.

Common development errors dealing with year 2000 date issues:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  6.0   (German)

Product Summary
Product: Visual C++ Version: 6.0 Category:Compliant*
Language: German OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95, Windows 98 with software updates
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, Standard, and Introductory editions.

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that the following prerequisites have been satisfied:

Prerequisites:

 

How the product runtime handles dates:

Visual C++ 6.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 AD (a 64-bit value)

struct tm

1/1/1900 through 12/31/2147483647

struct SYSTEMTIME

1/1/1900 through 12/31/32767

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

 

Two-digit shortcut handling:

Internet Explorer’s Date/Time Picker and Month Calendar common controls:

0 < year < 35: 2000 to 2035;

36 < year < 99: 1936 to 1999

Visual Basic’s date picker common control:

0 < year < 29: 2000 to 2029;

30 < year < 99: 1930 to 1999

SQL debugging/Visual Database Tools:

0 < year < 49: 2000 to 2049;

50 < year < 99: 1950 to 1999 (only in the Enterprise Edition)

Known Issues:

The Internet Explorer 4 (32-bit) Date/Time Picker and Month Calendar common controls shipped with this release do not permit direct entry of leap days (including leap day 2000). User can work around this by: 1) using the drop down calendar, or 2) by setting the year to 00, moving focus to a different control, then returning focus to the Date/Time-Picker or Month Calendar control, then entering 2/29 for the month/day. Visual Basic’s versions of the Date/Time Picker and Month Calendar common controls do not have this issue. The direct entry of leap days has been enabled in the latest version of comctl32.dll, which can be downloaded from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp.

Recommended practices to develop year 2000 compliant applications:

  1. Microsoft Windows NT 4.0 requires Service Pack 3, included in this release of Visual C++, as well as software updates which can be found at: http://microsoft.com/NTServer/all/downloads.asp for compliance. Windows NT 4.0 Service Pack 4.0 also contains the Year 2000 updates necessary for Windows NT 4.0 and is recommended for installation.
  2. Install Microsoft SQL Server 6.5 Service Pack 5. More details are available in the SQL Server Compliance document available on this web site.
  3. Install the latest version of the Microsoft comctl32.dll or update comctl32.dll to the latest version from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp to update the Internet Explorer 4.0 Date/Time Picker and Month Calendar to address leap day issues.
  4. Install the update for the Microsoft Data Access Components shipped as part of Windows NT 4.0 Service Pack 4.
  5. Install the updated Microsoft Virtual Machine, version 2436 or 3165 or newer, from http://www.microsoft.com/java/download.htm.

Common development errors dealing with year 2000 date issues:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++  6.0   (Japanese)

Product Summary
Product: Visual C++ Version: 6.0 Category:Compliant*
Language: Japanese OS: 32-Bit Win Release Date: 01 Sep 1998
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: See below
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 95, Windows 98 with software updates
Clock Dependencies: System Clock
Last Updated: 11 Sep 1999
Product Details

This report applies to:

Enterprise, Professional, Standard, and Introductory editions.

 

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: This requires that the following prerequisites have been satisfied:

Prerequisites:

 

How the product runtime handles dates:

Visual C++ 6.0 uses the following data types for dates:

Data type

Range

time_t

1/1/1970 through 1/18/2038

DATE VARIANT

1/1/100 through 12/31/9999

struct FILETIME

The number of 100 nanosecond intervals since 1601 and until the year 58,457,005 AD (a 64-bit value)

struct tm

1/1/1900 through 12/31/2147483647

struct SYSTEMTIME

1/1/1900 through 12/31/32767

DOS DateTime

1/1/1980 through 12/31/2108

SQL_DATE & SQL_TIMESTAMP (ODBC)

1/1/1970 through 12/31/9999

 

Two-digit shortcut handling:

Internet Explorer’s Date/Time Picker and Month Calendar common controls:

0 < year < 35: 2000 to 2035;

36 < year < 99: 1936 to 1999

Visual Basic’s date picker common control:

0 < year < 29: 2000 to 2029;

30 < year < 99: 1930 to 1999

SQL debugging/Visual Database Tools:

0 < year < 49: 2000 to 2049;

50 < year < 99: 1950 to 1999 (only in the Enterprise Edition)

Known Issues:

The Internet Explorer 4 (32-bit) Date/Time Picker and Month Calendar common controls shipped with this release do not permit direct entry of leap days (including leap day 2000). User can work around this by: 1) using the drop down calendar, or 2) by setting the year to 00, moving focus to a different control, then returning focus to the Date/Time-Picker or Month Calendar control, then entering 2/29 for the month/day. Visual Basic’s versions of the Date/Time Picker and Month Calendar common controls do not have this issue. The direct entry of leap days has been enabled in the latest version of comctl32.dll, which can be downloaded from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp.

Recommended practices to develop year 2000 compliant applications:

  1. Microsoft Windows NT 4.0 requires Service Pack 3, included in this release of Visual C++, as well as software updates which can be found at: http://microsoft.com/NTServer/all/downloads.asp for compliance. Windows NT 4.0 Service Pack 4.0 also contains the Year 2000 updates necessary for Windows NT 4.0 and is recommended for installation.
  2. Install Microsoft SQL Server 6.5 Service Pack 5. More details are available in the SQL Server Compliance document available on this web site.
  3. Install the latest version of the Microsoft comctl32.dll or update comctl32.dll to the latest version from http://www.microsoft.com/msdownload/ieplatform/ie/comctrlx86.asp to update the Internet Explorer 4.0 Date/Time Picker and Month Calendar to address leap day issues.
  4. Install the update for the Microsoft Data Access Components shipped as part of Windows NT 4.0 Service Pack 4.
  5. Install the updated Microsoft Virtual Machine, version 2436 or 3165 or newer, from http://www.microsoft.com/java/download.htm.

Common development errors dealing with year 2000 date issues:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++ C Run-time library  (msvcrt.dll) 4.2   (English)

Product Summary
Product: Visual C++ C Run-time library Version: (msvcrt.dll) 4.2 Category:Compliant
Language: English OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4 or Windows 98
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

The Visual C++ C Run-time library has numerous functions for date and time calculations. These functions are valid from January 1, 1970 to January 18, 2038. These functions can take Time Zones and Daylight Saving Time into account in their calculations. More information is available in the Visual C++ documentation.

Two-digit shortcut handling:

Years are represented relative to 1900 in all cases.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

 

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white

 

Additional date related information

Applications that utilize the runtime libraries date functions to identify when US daylight savings time begins may behave as if current time is one hour earlier than the correct time shown on the Windows clock. The problem will continue for one week from April 1 through April 8, 2001, after which these applications will shift to daylight savings time and again be in sync with the operating system. The problem results from the fact that the first Sunday in April 2001, is also the first day of April 2001 and an internal calculation doesn't handle that situation. This issue is fixed in the Visual Studio 6 Service Pack 3.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++ C Run-time library  (msvcrt.dll) 4.2   (Japanese)

Product Summary
Product: Visual C++ C Run-time library Version: (msvcrt.dll) 4.2 Category:Compliant
Language: Japanese OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4 or Windows 98
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

The Visual C++ C Run-time library has numerous functions for date and time calculations. These functions are valid from January 1, 1970 to January 18, 2038. These functions can take Time Zones and Daylight Saving Time into account in their calculations. More information is available in the Visual C++ documentation.

Two-digit shortcut handling:

Years are represented relative to 1900 in all cases.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

 

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white

 

Additional date related information

Applications that utilize the runtime libraries date functions to identify when US daylight savings time begins may behave as if current time is one hour earlier than the correct time shown on the Windows clock. The problem will continue for one week from April 1 through April 8, 2001, after which these applications will shift to daylight savings time and again be in sync with the operating system. The problem results from the fact that the first Sunday in April 2001, is also the first day of April 2001 and an internal calculation doesn't handle that situation. This issue is fixed in the Visual Studio 6 Service Pack 3.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++ C Run-time library  (msvcrt20.dll) 2.0   (English)

Product Summary
Product: Visual C++ C Run-time library Version: (msvcrt20.dll) 2.0 Category:Compliant
Language: English OS: 32-Bit Win Release Date: 01 Feb 1995
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: None
Clock Dependencies: System Clock
Last Updated: 07 Oct 1999
Product Details

Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

The Visual C++ C Run-time library has numerous functions for date and time calculations. These functions are valid from January 1, 1970 to January 18, 2038. These functions can take Time Zones and Daylight Saving Time into account in their calculations. More information is available in the Visual C++ documentation.

Two-digit shortcut handling:

Years are represented relative to 1900.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

 

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++ C Run-time library  (msvcrt40.dll) 4.0, 4.1   (English)

Product Summary
Product: Visual C++ C Run-time library Version: (msvcrt40.dll) 4.0, 4.1 Category:Compliant
Language: English OS: 32-Bit Win Release Date: 01 Jan 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4 or Windows 98
Clock Dependencies: system clock
Last Updated: 14 Sep 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

The Visual C++ C Run-time library has numerous functions for date and time calculations. These functions are valid from January 1, 1970 to January 18, 2038. These functions can take Time Zones and Daylight Saving Time into account in their calculations. More information is available in the Visual C++ documentation.

Two-digit shortcut handling:

Years are represented relative to 1900.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Additional date related information

Applications that utilize the runtime libraries date functions to identify when US daylight savings time begins may behave as if current time is one hour earlier than the correct time shown on the Windows clock. The problem will continue for one week from April 1 through April 8, 2001, after which these applications will shift to daylight savings time and again be in sync with the operating system. The problem results from the fact that the first Sunday in April 2001, is also the first day of April 2001 and an internal calculation doesn't handle that situation. This issue is fixed in the Visual Studio 6 Service Pack 3.



Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++ C Run-time library  (msvcrt40.dll) 4.0, 4.1   (Japanese)

Product Summary
Product: Visual C++ C Run-time library Version: (msvcrt40.dll) 4.0, 4.1 Category:Compliant
Language: Japanese OS: 32-Bit Win Release Date: 01 Jan 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4 or Windows 98
Clock Dependencies: system clock
Last Updated: 14 Sep 1999
Product Details

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes

How the product runtime handles dates:

The Visual C++ C Run-time library has numerous functions for date and time calculations. These functions are valid from January 1, 1970 to January 18, 2038. These functions can take Time Zones and Daylight Saving Time into account in their calculations. More information is available in the Visual C++ documentation.

Two-digit shortcut handling:

Years are represented relative to 1900.

The Microsoft C Run Time provides two ANSI-C data structures to track time. These are

  1. struct tm
  2. time_t

ANSI types: struct tm and time_t

The ANSI C standard has established these types, their meaning and to some extent, the underlying type of each. In Visual C++, the type of time_t is long and it represents seconds since January 1, 1970 when used with the ANSI C functions that utilize variables of this type. The type struct tm is used to track the components of a date. The struct tm uses internal variables to store years as the number of years since 1900, the month of the year, day of the week, day of the month, day of the year, hour of the day, minute of the hour, and seconds of the minute are accounted for in this structure as well as if Daylight Savings Time is in effect. These members are of type int. These types are what ANSI functions use to manipulate, input, and output times. The Visual C++ documentation has more information on these types.

Avoiding issues with ANSI time functions

An application can appear to have a year 2000 issue because of how ANSI functions are permitted to behave. You can create year 2000 compliant applications and avoid confusing output from your programs if you follow some simple guidelines when using ANSI functions, primarily the strftime and wcsftime functions.

  1. Present 4-digit years when displaying dates to users of your application. When using the strftime and wcsftime functions, use %Y to display a 4-digit year instead %y (lowercase) which displays a 2-digit year. For example:

    #include <time.h>

    #include <stdio.h>

    const int BUFSIZE = 256;

    char buf[BUFSIZE];

    int main()

    {

    struct tm now;

    time_t tmp = time(0); // get current time

    now = *localtime(&tmp); // get components

    // 2-digit vs. 4-digit year

    char fmt[] = " %m/%d/%y \n %m/%d/%Y ";

    strftime( buf, BUFSIZ, fmt, &now );

    printf(buf);

    return 0;

    }

  2. Require users of your application to provide fully qualified dates (using 4-digit years) when accepting date input into your application.
  3. Avoid using the %x or %c format, or if used, use # to get the long date version when using strftime and wcsftime. The %x and %c formatting codes default to printing a 2-digit year. Change the initialization of fmt in the above program to " %x \n %#x " to see the difference.
  4. Keep your times in a time_t variable or a struct tm and manipulate them there. ANSI C mandates some other time functions to aid in this task. Here is a list and brief description of these functions. See your Visual C++ documentation for more details.
  • time – gets the current calendar time in a time_t
  • difftime – computes the difference between two time_t’s
  • gmtime – converts a time_t to a struct tm, in terms of Coordinated Universal Time (UTC)
  • localtime – converts a time_t to a struct tm, in terms of local time
  • asctime, _wasctime – returns a string corresponding to the passed struct tm*. The string is of the form "DDD MMM dd HH:MM:SS YYYY\n\0" and is always 26 characters.
  • ctime, _wctime– given a time_t, returns the local time in the form of a string. Exactly the same as asctime( localtime( time_t_val ))
  • mktime – returns a locally adjusted time_t given a struct tm*, which is updated so values fall into appropriate ranges. For example

#include <time.h>

#include <stdio.h>

const int BUFSIZE = 1024;

char buf[BUFSIZE];

int main()

{

struct tm now;

time_t tmp = time(0); // current time

now = *localtime(&tmp);

size_t len = strftime(buf, BUFSIZE, "%#c\n", &now);

now.tm_hour += 48; //jump ahead two days

// should get a bogus hour value

len += strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

mktime(&now); // mktime will correct

strftime(buf+len, BUFSIZE-len, "%#c\n", &now);

printf(buf);

return 0;

}
  1. Although not an ANSI function, the _strdate and _wstrdate functions generates a 9-character string to a buffer that it receives a pointer to as a parameter. The output has the form "MM/DD/YY". Use the strftime or wcsftime function instead.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/vstudio/y2k/visualcy2k.asp#white.

Additional date related information

Applications that utilize the runtime libraries date functions to identify when US daylight savings time begins may behave as if current time is one hour earlier than the correct time shown on the Windows clock. The problem will continue for one week from April 1 through April 8, 2001, after which these applications will shift to daylight savings time and again be in sync with the operating system. The problem results from the fact that the first Sunday in April 2001, is also the first day of April 2001 and an internal calculation doesn't handle that situation. This issue is fixed in the Visual Studio 6 Service Pack 3.



Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (Chinese - Simplified)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: Chinese - Simplified OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (English)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: English OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (French)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: French OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (German)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: German OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (Italian)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: Italian OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (Japanese)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: Japanese OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (Korean)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: Korean OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.1   (Spanish)

Product Summary
Product: Visual C++: MFC Version: 4.1 Category:Compliant*
Language: Spanish OS: 32-Bit Win Release Date: 02 Apr 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: Version 4.1.6140 of MFC40.dll & MFC40U.dll
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows NT 3.51 Service Pack 5, Windows 98
Clock Dependencies: System Clock
Last Updated: 04 Nov 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC) 40.dll and

Visual C++: Microsoft Foundation Classes (MFC) 40U.dll 4.1

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

COleDateTime stores dates based on the DATE data type used in OLE Automation, and covers 1/1/100 through 12/31/9999. The COleDateTime::operator= function has an override which takes a time_t data type from the C run-time. This data type can only represent dates from 1/1/1970 to 1/18/2038. When using this operator after 1/1/2000 the COleDateTime object returns the year 100 instead of 2000.

This has been changed in the latest versions of MFC40.DLL and MFC40U.DLL. You should be sure you are distributing version 4.10.6140 or later for the update to be included.

Two-digit shortcut handling:

The COleDateTime object allows creation by specifying a 2-digit year. When you create the object this way the year is assumed to be 1900s. So after the year 2000, creating a COleDateTime object with the year of 95, the object will represent 1995.

To remove ambiguities and assumptions of run-time libraries and tools, it is recommended to use a complete year specifier.

Recommended practices to develop year 2000 compliant applications:

Version 4.10.6140 of MFC40.dll and MFC40u.dll are needed for applications that use DLLs in operation to properly work past 1999. To update your machine to these versions of the files please go to http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp. These versions of MFC40.dll and MFC40u.dll are also included in Windows 98 Service Pack 1, Windows 98 Second Edition, Service Pack 3 for Visual Studio 6.0 and Windows Update. The update at http://msdn.microsoft.com/visualc/downloads/MFCy2k/default.asp can update Windows NT 3.51, Windows NT 4.0, Windows 95 and Windows 98.

Please see the "Visual C++ and the Year 2000" best practices article.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.2   (Chinese - Simplified)

Product Summary
Product: Visual C++: MFC Version: 4.2 Category:Compliant
Language: Chinese - Simplified OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 98 Service Pack 1
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC)42.DLL

and

Visual C++: Microsoft Foundation Classes (MFC)42U.DLL 4.2

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

There are no known problems with how MFC42 handles dates. MFC has a CTime class and a COleDateTime class.

CTime can represent dates from 1/1/1970 to 1/18/2038, as it is basically under the same restrictions as the underlying C run-time library.

COleDateTime uses the DATE type used for OLE Automation, and can represent dates from 1/1/100 through 12/31/9999.

Two-digit shortcut handling:

There is no 2-digit shortcut handling of years. Years must be completely specified.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.2   (Chinese - Traditional)

Product Summary
Product: Visual C++: MFC Version: 4.2 Category:Compliant
Language: Chinese - Traditional OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 98 Service Pack 1
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC)42.DLL

and

Visual C++: Microsoft Foundation Classes (MFC)42U.DLL 4.2

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

There are no known problems with how MFC42 handles dates. MFC has a CTime class and a COleDateTime class.

CTime can represent dates from 1/1/1970 to 1/18/2038, as it is basically under the same restrictions as the underlying C run-time library.

COleDateTime uses the DATE type used for OLE Automation, and can represent dates from 1/1/100 through 12/31/9999.

Two-digit shortcut handling:

There is no 2-digit shortcut handling of years. Years must be completely specified.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.2   (English)

Product Summary
Product: Visual C++: MFC Version: 4.2 Category:Compliant
Language: English OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 98 Service Pack 1
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC)42.DLL

and

Visual C++: Microsoft Foundation Classes (MFC)42U.DLL 4.2

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

There are no known problems with how MFC42 handles dates. MFC has a CTime class and a COleDateTime class.

CTime can represent dates from 1/1/1970 to 1/18/2038, as it is basically under the same restrictions as the underlying C run-time library.

COleDateTime uses the DATE type used for OLE Automation, and can represent dates from 1/1/100 through 12/31/9999.

Two-digit shortcut handling:

There is no 2-digit shortcut handling of years. Years must be completely specified.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.2   (French)

Product Summary
Product: Visual C++: MFC Version: 4.2 Category:Compliant
Language: French OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 98 Service Pack 1
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC)42.DLL

and

Visual C++: Microsoft Foundation Classes (MFC)42U.DLL 4.2

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

There are no known problems with how MFC42 handles dates. MFC has a CTime class and a COleDateTime class.

CTime can represent dates from 1/1/1970 to 1/18/2038, as it is basically under the same restrictions as the underlying C run-time library.

COleDateTime uses the DATE type used for OLE Automation, and can represent dates from 1/1/100 through 12/31/9999.

Two-digit shortcut handling:

There is no 2-digit shortcut handling of years. Years must be completely specified.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.2   (German)

Product Summary
Product: Visual C++: MFC Version: 4.2 Category:Compliant
Language: German OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 98 Service Pack 1
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC)42.DLL

and

Visual C++: Microsoft Foundation Classes (MFC)42U.DLL 4.2

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

There are no known problems with how MFC42 handles dates. MFC has a CTime class and a COleDateTime class.

CTime can represent dates from 1/1/1970 to 1/18/2038, as it is basically under the same restrictions as the underlying C run-time library.

COleDateTime uses the DATE type used for OLE Automation, and can represent dates from 1/1/100 through 12/31/9999.

Two-digit shortcut handling:

There is no 2-digit shortcut handling of years. Years must be completely specified.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.

Microsoft Year 2000 Resource Center
Visual C++: MFC  4.2   (Italian)

Product Summary
Product: Visual C++: MFC Version: 4.2 Category:Compliant
Language: Italian OS: 32-Bit Win Release Date: 01 Jul 1996
Operational Range: 01 Jan 1980 - 18 Jan 2038
Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement? Yes
Prerequisites: None
Product Dependencies: Windows NT 4.0 Service Pack 4, Windows 98 Service Pack 1
Clock Dependencies: System Clock
Last Updated: 14 Sep 1999
Product Details

Visual C++: Microsoft Foundation Classes (MFC)42.DLL

and

Visual C++: Microsoft Foundation Classes (MFC)42U.DLL 4.2

Can applications be built with this tool that adhere to the Microsoft Year 2000 Compliance Statement?

Yes.

Note: this requires that any available and appropriate software updates or service packs have been applied.

How the product runtime handles dates:

There are no known problems with how MFC42 handles dates. MFC has a CTime class and a COleDateTime class.

CTime can represent dates from 1/1/1970 to 1/18/2038, as it is basically under the same restrictions as the underlying C run-time library.

COleDateTime uses the DATE type used for OLE Automation, and can represent dates from 1/1/100 through 12/31/9999.

Two-digit shortcut handling:

There is no 2-digit shortcut handling of years. Years must be completely specified.

Recommended practices to develop year 2000 compliant applications:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Common development errors dealing with year 2000 date issues:

The most likely area for concern arises if users write their own date handling routines. Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

Testing guidelines and recommendations:

Please see the "Visual C++ and the Year 2000" best practices article located at http://www.msdn.microsoft.com/visualc.

 

 


Legend of Symbols:
*The product is compliant. User action is recommended, which may include loading a software update or assessing shared technology.
#The product is compliant with an acceptable deviation from Microsoft's standard of compliance. An acceptable deviation does not affect the core functionality, data integrity, stability or reliability of the product.
+The product is compliant . Software updates are pending. Future maintenance actions will be recommended shortly.
Note: Compliance ratings given for each product assume that all recommended actions have been taken.


Itemized List of products in each Volume

YEAR 2000 READINESS DISCLOSURE

ALL COMMUNICATIONS OR CONVEYANCES OF INFORMATION TO YOU CONCERNING MICROSOFT AND THE YEAR 2000, INCLUDING BUT NOT LIMITED TO THIS DOCUMENT OR ANY OTHER PAST, PRESENT OR FUTURE INFORMATION REGARDING YEAR 2000 TESTING, ASSESSMENTS, READINESS, TIME TABLES, OBJECTIVES, OR OTHER (COLLECTIVELY THE "MICROSOFT YEAR 2000 STATEMENT"), ARE PROVIDED AS A "YEAR 2000 READINESS DISCLOSURE" (AS DEFINED BY THE YEAR 2000 INFORMATION AND READINESS DISCLOSURE ACT) AND CAN BE FOUND AT MICROSOFT'S YEAR 2000 WEBSITE LOCATED AT http://microsoft.com/year2000/ (the "Y2K WEBSITE"). EACH MICROSOFT YEAR 2000 STATEMENT IS PROVIDED PURSUANT TO THE TERMS HEREOF, THE TERMS OF THE Y2K WEBSITE, AND THE YEAR 2000 INFORMATION AND READINESS DISCLOSURE ACT FOR THE SOLE PURPOSE OF ASSISTING THE PLANNING FOR THE TRANSITION TO THE YEAR 2000. EACH MICROSOFT YEAR 2000 STATEMENT CONTAINS INFORMATION CURRENTLY AVAILABLE AND IS UPDATED REGULARLY AND SUBJECT TO CHANGE. MICROSOFT THEREFORE RECOMMENDS THAT YOU CHECK THE Y2K WEBSITE REGULARLY FOR ANY CHANGES TO ANY MICROSOFT YEAR 2000 STATEMENT. EACH MICROSOFT YEAR 2000 STATEMENT IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. CONSEQUENTLY, MICROSOFT DISCLAIMS ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. MOREOVER, MICROSOFT DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OR THE RESULTS OF THE USE OF ANY MICROSOFT YEAR 2000 STATEMENT IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY, OR OTHERWISE. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY MICROSOFT OR ITS AUTHORIZED REPRESENTATIVES SHALL CREATE A WARRANTY OR IN ANY WAY DECREASE THE SCOPE OF THIS WARRANTY DISCLAIMER. IN NO EVENT SHALL MICROSOFT OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER REGARDING ANY MICROSOFT YEAR 2000 STATEMENT INCLUDING DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS OF BUSINESS PROFITS, PUNITIVE OR SPECIAL DAMAGES, EVEN IF MICROSOFT OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, SO THE FOREGOING LIMITATION MAY NOT APPLY TO YOU. THE INFORMATION CONTAINED IN EACH MICROSOFT YEAR 2000 STATEMENT IS FOUND AT THE Y2K WEBSITE AND IS INTENDED TO BE READ IN CONJUNCTION WITH OTHER INFORMATION LOCATED AT THE Y2K WEBSITE, INCLUDING BUT NOT LIMITED TO MICROSOFT'S YEAR 2000 COMPLIANCE STATEMENT, THE DESCRIPTION OF THE CATEGORIES OF COMPLIANCE INTO WHICH MICROSOFT HAS CLASSIFIED ITS PRODUCTS IN ITS YEAR 2000 PRODUCT GUIDE, AND THE MICROSOFT YEAR 2000 TEST CRITERIA.

ANY MICROSOFT YEAR 2000 STATEMENTS MADE TO YOU IN THE COURSE OF PROVIDING YEAR 2000 RELATED UPDATES, YEAR 2000 DIAGNOSTIC TOOLS, OR REMEDIATION SERVICES (IF ANY) ARE SUBJECT TO THE YEAR 2000 INFORMATION AND READINESS DISCLOSURE ACT (112 STAT. 2386). IN CASE OF A DISPUTE, THIS ACT MAY REDUCE YOUR LEGAL RIGHTS REGARDING THE USE OF ANY SUCH STATEMENTS, UNLESS OTHERWISE SPECIFIED BY YOUR CONTRACT OR TARIFF.

Wednesday, November 17, 1999
© 1999 Microsoft Corporation. All rights reserved. Terms of use.

This site is being designated as a Year 2000 Readiness Disclosure and the information contained herein is provided pursuant to the terms hereof and the Year 2000 Information and Readiness Disclosure Act.