Address Copilot review comments for codepage implementation

- Change UTF-16 BOM handling from IgnoreBOM to UseBOM for codepages
  1200 (UTF-16 LE) and 1201 (UTF-16 BE) to properly strip BOMs on
  decode (pkg/sqlcmd/codepage.go)

- Eliminate redundant CodePage parsing by storing parsed settings
  in codePageSettings field after validation in Validate(), then
  reusing in run() (cmd/sqlcmd/sqlcmd.go)

- Add comprehensive Code Page Support documentation section to
  README.md with format guide, common codepages table, practical
  examples, and notes on default behavior

Note: Integration test for IncludeFile with non-UTF8 input already
exists in TestIncludeFileWithInputCodePage (pkg/sqlcmd/sqlcmd_test.go)

Author: dlevy-msft-sql

README.md

@@ -133,7 +133,7 @@ The following switches have different behavior in this version of `sqlcmd` compa
   - To provide the value of the host name in the server certificate when using strict encryption, pass the host name with `-F`. Example: `-Ns -F myhost.domain.com`
   - More information about client/server encryption negotiation can be found at <https://docs.microsoft.com/openspecs/windows_protocols/ms-tds/60f56408-0188-4cd5-8b90-25c6f2423868>
 - `-u` The generated Unicode output file will have the UTF16 Little-Endian Byte-order mark (BOM) written to it.
-- `-f` Specifies the code page for input and output files. Format: `codepage | i:codepage[,o:codepage] | o:codepage[,i:codepage]`. Use `65001` for UTF-8. Supported codepages include Unicode (65001, 1200, 1201), Windows (874, 1250-1258), OEM/DOS (437, 850, etc.), ISO-8859 (28591-28606), CJK (932, 936, 949, 950), and EBCDIC (37, 1047, 1140). On Windows, additional codepages installed on the system (such as Japanese EBCDIC) are also available. Use `--list-codepages` to see all supported code pages.
+- `-f` Specifies the code page for input and output files. See [Code Page Support](#code-page-support) below for details and examples.
 - Some behaviors that were kept to maintain compatibility with `OSQL` may be changed, such as alignment of column headers for some data types.
 - All commands must fit on one line, even `EXIT`. Interactive mode will not check for open parentheses or quotes for commands and prompt for successive lines. The ODBC sqlcmd allows the query run by `EXIT(query)` to span multiple lines.
 - `-i` doesn't handle a comma `,` in a file name correctly unless the file name argument is triple quoted. For example:
@@ -238,6 +238,68 @@ To see a list of available styles along with colored syntax samples, use this co
 :list color
 ```
 
+### Code Page Support
+
+The `-f` flag specifies the code page for reading input files and writing output. This is useful when working with SQL scripts saved in legacy encodings or when output needs to be in a specific encoding.
+
+#### Format
+
+```
+-f codepage                         # Set both input and output to the same codepage
+-f i:codepage                       # Set input codepage only  
+-f o:codepage                       # Set output codepage only
+-f i:codepage,o:codepage            # Set input and output to different codepages
+-f o:codepage,i:codepage            # Same as above (order doesn't matter)
+```
+
+#### Common Code Pages
+
+| Code Page | Name | Description |
+|-----------|------|-------------|
+| 65001 | UTF-8 | Unicode (UTF-8) - default for most modern systems |
+| 1200 | UTF-16LE | Unicode (UTF-16 Little-Endian) |
+| 1201 | UTF-16BE | Unicode (UTF-16 Big-Endian) |
+| 1252 | Windows-1252 | Western European (Windows) |
+| 932 | Shift_JIS | Japanese |
+| 936 | GBK | Chinese Simplified |
+| 949 | EUC-KR | Korean |
+| 950 | Big5 | Chinese Traditional |
+| 437 | CP437 | OEM United States (DOS) |
+
+#### Examples
+
+**Run a script saved in Windows-1252 encoding:**
+```bash
+sqlcmd -S myserver -i legacy_script.sql -f 1252
+```
+
+**Read UTF-16 input file and write UTF-8 output:**
+```bash
+sqlcmd -S myserver -i unicode_script.sql -o results.txt -f i:1200,o:65001
+```
+
+**Process a Japanese Shift-JIS encoded script:**
+```bash
+sqlcmd -S myserver -i japanese_data.sql -f 932
+```
+
+**Write output in Windows-1252 for legacy applications:**
+```bash
+sqlcmd -S myserver -Q "SELECT * FROM Products" -o report.txt -f o:1252
+```
+
+**List all supported code pages:**
+```bash
+sqlcmd --list-codepages
+```
+
+#### Notes
+
+- When no `-f` flag is specified, sqlcmd auto-detects UTF-16 BOM (Byte Order Mark) in input files and falls back to UTF-8.
+- UTF-8 input files with BOM are handled automatically.
+- On Windows, additional codepages installed on the system are also available via the Windows API.
+- Use `--list-codepages` to see all supported code pages with their names and descriptions.
+
 ### Packages
 
 #### sqlcmd executable

cmd/sqlcmd/sqlcmd.go

@@ -83,7 +83,10 @@ type SQLCmdArguments struct {
 	ChangePasswordAndExit       string
 	TraceFile                   string
 	CodePage                    string
-	ListCodePages               bool
+	// codePageSettings stores the parsed CodePageSettings after validation.
+	// This avoids parsing CodePage twice (in Validate and run).
+	codePageSettings *sqlcmd.CodePageSettings
+	ListCodePages    bool
 	// Keep Help at the end of the list
 	Help bool
 }
@@ -174,8 +177,10 @@ func (a *SQLCmdArguments) Validate(c *cobra.Command) (err error) {
 		case a.ServerCertificate != "" && !encryptConnectionAllowsTLS(a.EncryptConnection):
 			err = localizer.Errorf("The -J parameter requires encryption to be enabled (-N true, -N mandatory, or -N strict).")
 		case a.CodePage != "":
-			if _, parseErr := sqlcmd.ParseCodePage(a.CodePage); parseErr != nil {
+			if codePageSettings, parseErr := sqlcmd.ParseCodePage(a.CodePage); parseErr != nil {
 				err = localizer.Errorf(`'-f %s': %v`, a.CodePage, parseErr)
+			} else {
+				a.codePageSettings = codePageSettings
 			}
 		}
 	}
@@ -832,13 +837,9 @@ func run(vars *sqlcmd.Variables, args *SQLCmdArguments) (int, error) {
 	defer s.StopCloseHandler()
 	s.UnicodeOutputFile = args.UnicodeOutputFile
 
-	// Parse and apply codepage settings
-	if args.CodePage != "" {
-		codePageSettings, err := sqlcmd.ParseCodePage(args.CodePage)
-		if err != nil {
-			return 1, localizer.Errorf("Invalid code page: %v", err)
-		}
-		s.CodePage = codePageSettings
+	// Apply codepage settings (already parsed and validated in Validate)
+	if args.codePageSettings != nil {
+		s.CodePage = args.codePageSettings
 	}
 
 	if args.DisableCmd != nil {

pkg/sqlcmd/codepage.go

@@ -32,8 +32,8 @@ type codepageEntry struct {
 var codepageRegistry = map[int]codepageEntry{
 	// Unicode
 	65001: {nil, "UTF-8", "Unicode (UTF-8)"},
-	1200:  {unicode.UTF16(unicode.LittleEndian, unicode.IgnoreBOM), "UTF-16LE", "Unicode (UTF-16 Little-Endian)"},
-	1201:  {unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM), "UTF-16BE", "Unicode (UTF-16 Big-Endian)"},
+	1200:  {unicode.UTF16(unicode.LittleEndian, unicode.UseBOM), "UTF-16LE", "Unicode (UTF-16 Little-Endian)"},
+	1201:  {unicode.UTF16(unicode.BigEndian, unicode.UseBOM), "UTF-16BE", "Unicode (UTF-16 Big-Endian)"},
 
 	// OEM/DOS codepages
 	437: {charmap.CodePage437, "CP437", "OEM United States"},