updated more display filters per checkfiltername.pl

svn path=/trunk/; revision=44178

1 files changed, 69 insertions, 69 deletions

diff --git a/epan/dissectors/packet-fcsb3.c b/epan/dissectors/packet-fcsb3.c
index b0e1f40380..7bb7a84a83 100644
--- a/epan/dissectors/packet-fcsb3.c
+++ b/epan/dissectors/packet-fcsb3.c
@@ -1077,342 +1077,342 @@ proto_register_fcsbccs (void)
     /* Setup list of header fields  See Section 1.6.1 for details*/
     static hf_register_info hf[] = {
         { &hf_sbccs_chid,
-          { "Channel Image ID", "sbccs.chid",
+          { "Channel Image ID", "fcsb3.chid",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_cuid,
-          { "Control Unit Image ID", "sbccs.cuid",
+          { "Control Unit Image ID", "fcsb3.cuid",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_devaddr,
-          { "Device Address", "sbccs.devaddr",
+          { "Device Address", "fcsb3.devaddr",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_iui,
-          { "Information Unit Identifier", "sbccs.iui",
+          { "Information Unit Identifier", "fcsb3.iui",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags,
-          { "DH Flags", "sbccs.dhflags",
+          { "DH Flags", "fcsb3.dhflags",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_ccw,
-          { "CCW Number", "sbccs.ccw",
+          { "CCW Number", "fcsb3.ccw",
             FT_UINT16, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_token,
-          { "Token", "sbccs.token",
+          { "Token", "fcsb3.token",
             FT_UINT24, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_iucnt,
-          { "DIB IU Count", "sbccs.iucnt",
+          { "DIB IU Count", "fcsb3.iucnt",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_datacnt,
-          { "DIB Data Byte Count", "sbccs.databytecnt",
+          { "DIB Data Byte Count", "fcsb3.databytecnt",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_cmd,
-          { "CCW Command", "sbccs.ccwcmd",
+          { "CCW Command", "fcsb3.ccwcmd",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_cmd_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_cnt,
-          { "CCW Count", "sbccs.ccwcnt",
+          { "CCW Count", "fcsb3.ccwcnt",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ioprio,
-          { "I/O Priority", "sbccs.ioprio",
+          { "I/O Priority", "fcsb3.ioprio",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status,
-          { "Status", "sbccs.status",
+          { "Status", "fcsb3.status",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_residualcnt,
-          { "Residual Count", "sbccs.residualcnt",
+          { "Residual Count", "fcsb3.residualcnt",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_iupacing,
-          { "IU Pacing", "sbccs.iupacing",
+          { "IU Pacing", "fcsb3.iupacing",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_qtuf,
-          { "Queue-Time Unit Factor", "sbccs.qtuf",
+          { "Queue-Time Unit Factor", "fcsb3.qtuf",
             FT_UINT8, BASE_DEC, NULL, 0xF0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_qtu,
-          { "Queue-Time Unit", "sbccs.qtu",
+          { "Queue-Time Unit", "fcsb3.qtu",
             FT_UINT16, BASE_DEC, NULL, 0xFFF,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_dtuf,
-          { "Defer-Time Unit Function", "sbccs.dtuf",
+          { "Defer-Time Unit Function", "fcsb3.dtuf",
             FT_UINT8, BASE_DEC, NULL, 0xF0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_dtu,
-          { "Defer-Time Unit", "sbccs.dtu",
+          { "Defer-Time Unit", "fcsb3.dtu",
             FT_UINT16, BASE_DEC, NULL, 0xFFF,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlfn,
-          { "Control Function", "sbccs.ctlfn",
+          { "Control Function", "fcsb3.ctlfn",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_ctl_fn_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlfn,
-          { "Link Control Function", "sbccs.linkctlfn",
+          { "Link Control Function", "fcsb3.linkctlfn",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_link_ctl_fn_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctccntr,
-          { "CTC Counter", "sbccs.ctccntr",
+          { "CTC Counter", "fcsb3.ctccntr",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_lrc,
-          { "LRC", "sbccs.lrc",
+          { "LRC", "fcsb3.lrc",
             FT_UINT32, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dev_xcp_code,
-          { "Device Level Exception Code", "sbccs.dip.xcpcode",
+          { "Device Level Exception Code", "fcsb3.dip.xcpcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_dev_xcpcode_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_prg_pth_errcode,
-          { "Purge Path Error Code", "sbccs.purgepathcode",
+          { "Purge Path Error Code", "fcsb3.purgepathcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_purge_path_err_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_prg_rsp_errcode,
-          { "Purge Path Response Error Code", "sbccs.purgepathrspcode",
+          { "Purge Path Response Error Code", "fcsb3.purgepathrspcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_purge_path_rsp_err_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_lprcode,
-          { "LPR Reason Code", "sbccs.lprcode",
+          { "LPR Reason Code", "fcsb3.lprcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_lpr_errcode_val), 0xF,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_tin_imgid_cnt,
-          { "TIN Image ID", "sbccs.tinimageidcnt",
+          { "TIN Image ID", "fcsb3.tinimageidcnt",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_lrjcode,
-          { "LRJ Reaspn Code", "sbccs.lrjcode",
+          { "LRJ Reaspn Code", "fcsb3.lrjcode",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_lrj_errcode_val), 0x7F,
             NULL, HFILL}},
 
         { &hf_sbccs_iui_as,
-          { "AS", "sbccs.iui.as",
+          { "AS", "fcsb3.iui.as",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_iui_as), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_iui_es,
-          { "ES", "sbccs.iui.es",
+          { "ES", "fcsb3.iui.es",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_iui_es), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_iui_val,
-          { "Val", "sbccs.iui.val",
+          { "Val", "fcsb3.iui.val",
             FT_UINT8, BASE_HEX, VALS(fc_sbccs_iu_val), 0x07,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_end,
-          { "End", "sbccs.dhflags.end",
+          { "End", "fcsb3.dhflags.end",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_end), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_chaining,
-          { "Chaining", "sbccs.dhflags.chaining",
+          { "Chaining", "fcsb3.dhflags.chaining",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_chaining), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_earlyend,
-          { "Early End", "sbccs.dhflags.earlyend",
+          { "Early End", "fcsb3.dhflags.earlyend",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_earlyend), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_nocrc,
-          { "No CRC", "sbccs.dhflags.nocrc",
+          { "No CRC", "fcsb3.dhflags.nocrc",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_nocrc), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags,
-          { "CCW Control Flags", "sbccs.ccwflags",
+          { "CCW Control Flags", "fcsb3.ccwflags",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_cd,
-          { "CD", "sbccs.ccwflags.cd",
+          { "CD", "fcsb3.ccwflags.cd",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_cd), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_cc,
-          { "CC", "sbccs.ccwflags.cc",
+          { "CC", "fcsb3.ccwflags.cc",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_cc), 0x40,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_sli,
-          { "SLI", "sbccs.ccwflags.sli",
+          { "SLI", "fcsb3.ccwflags.sli",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_sli), 0x20,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_crr,
-          { "CRR", "sbccs.ccwflags.crr",
+          { "CRR", "fcsb3.ccwflags.crr",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_crr), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags,
-          { "Command Flags", "sbccs.cmdflags",
+          { "Command Flags", "fcsb3.cmdflags",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_du,
-          { "DU", "sbccs.cmdflags.du",
+          { "DU", "fcsb3.cmdflags.du",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_du), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_coc,
-          { "COC", "sbccs.cmdflags.coc",
+          { "COC", "fcsb3.cmdflags.coc",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_coc), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_syr,
-          { "SYR", "sbccs.cmdflags.syr",
+          { "SYR", "fcsb3.cmdflags.syr",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_syr), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_rex,
-          { "REX", "sbccs.cmdflags.rex",
+          { "REX", "fcsb3.cmdflags.rex",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_rex), 0x02,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_sss,
-          { "SSS", "sbccs.cmdflags.sss",
+          { "SSS", "fcsb3.cmdflags.sss",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_sss), 0x01,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags,
-          { "Status Flags", "sbccs.statusflags",
+          { "Status Flags", "fcsb3.statusflags",
             FT_UINT8, BASE_HEX, NULL, 0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_ffc,
-          { "FFC", "sbccs.statusflags.ffc",
+          { "FFC", "fcsb3.statusflags.ffc",
             FT_UINT8, BASE_HEX, VALS(status_ffc_val), 0xE0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_ci,
-          { "CI", "sbccs.statusflags.ci",
+          { "CI", "fcsb3.statusflags.ci",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_ci), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_cr,
-          { "CR", "sbccs.statusflags.cr",
+          { "CR", "fcsb3.statusflags.cr",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_cr), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_lri,
-          { "LRI", "sbccs.statusflags.lri",
+          { "LRI", "fcsb3.statusflags.lri",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_lri), 0x02,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_rv,
-          { "RV", "sbccs.statusflags.rv",
+          { "RV", "fcsb3.statusflags.rv",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_rv), 0x01,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_attention,
-          { "Attention", "sbccs.status.attention",
+          { "Attention", "fcsb3.status.attention",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_attention), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_modifier,
-          { "Status Modifier", "sbccs.status.modifier",
+          { "Status Modifier", "fcsb3.status.modifier",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_modifier), 0x40,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_cue,
-          { "Control-Unit End", "sbccs.status.cue",
+          { "Control-Unit End", "fcsb3.status.cue",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_cue), 0x20,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_busy,
-          { "Busy", "sbccs.status.busy",
+          { "Busy", "fcsb3.status.busy",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_busy), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_channelend,
-          { "Channel End", "sbccs.status.channel_end",
+          { "Channel End", "fcsb3.status.channel_end",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_channelend), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_deviceend,
-          { "Device End", "sbccs.status.device_end",
+          { "Device End", "fcsb3.status.device_end",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_deviceend), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_unit_check,
-          { "Unit Check", "sbccs.status.unit_check",
+          { "Unit Check", "fcsb3.status.unit_check",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_unitcheck), 0x02,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_unit_exception,
-          { "Unit Exception", "sbccs.status.unitexception",
+          { "Unit Exception", "fcsb3.status.unitexception",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_unitexception), 0x01,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam,
-          { "Control Parameters", "sbccs.ctlparam",
+          { "Control Parameters", "fcsb3.ctlparam",
             FT_UINT24, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam_rc,
-          { "RC", "sbccs.ctlparam.rc",
+          { "RC", "fcsb3.ctlparam.rc",
             FT_BOOLEAN, 24, TFS(&tfs_sbccs_ctlparam_rc), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam_ru,
-          { "RU", "sbccs.ctlparam.ru",
+          { "RU", "fcsb3.ctlparam.ru",
             FT_BOOLEAN, 24, TFS(&tfs_sbccs_ctlparam_ru), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam_ro,
-          { "RO", "sbccs.ctlparam.ro",
+          { "RO", "fcsb3.ctlparam.ro",
             FT_BOOLEAN, 24, TFS(&tfs_sbccs_ctlparam_ro), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlinfo,
-          { "Link Control Information", "sbccs.linkctlinfo",
+          { "Link Control Information", "fcsb3.linkctlinfo",
             FT_UINT16, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlinfo_ctcconn,
-          { "CTC Conn", "sbccs.linkctlinfo.ctc_conn",
+          { "CTC Conn", "fcsb3.linkctlinfo.ctc_conn",
             FT_BOOLEAN, 16, TFS(&tfs_sbccs_linkctlinfo_ctcconn), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlinfo_ecrcg,
-          { "Enhanced CRC Generation", "sbccs.linkctlinfo.ecrcg",
+          { "Enhanced CRC Generation", "fcsb3.linkctlinfo.ecrcg",
             FT_BOOLEAN, 16, TFS(&tfs_sbccs_linkctlinfo_ecrcg), 0x01,
             NULL, HFILL}},
     };
@@ -1433,7 +1433,7 @@ proto_register_fcsbccs (void)
 
     /* Register the protocol name and description */
     proto_fc_sbccs = proto_register_protocol ("Fibre Channel Single Byte Command",
-                                              "FC-SB3", "sb3");
+                                              "FC-SB3", "fcsb3");
 
     proto_register_field_array(proto_fc_sbccs, hf, array_length(hf));
     proto_register_subtree_array(ett, array_length(ett));