开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
MSNULL.C
资源名称：VirtualPrinter.v1.0.Source.Code.zip　[点击查看]
上传用户：yuandong
上传日期：2022-08-08
资源大小：954k
文件大小：22k
源码类别：

Delphi控件源码

开发平台：

C++ Builder

MSNULL.C：源码内容
  1. /*++
  3. Copyright (c) 1990-1994  Microsoft Corporation
  4. All rights reserved
  6. Module Name:
  8.     MsNull.c
  10. Abstract:
  12.     Implements lanman's msnull type parsing for FFs.
  14. Author:
  16. Environment:
  18.     User Mode -Win32
  20. Revision History:
  22. --*/
  24. #include <windows.h>
  25. #include "winprint.h"
  26. #include "msnull.h"
  28. #define sgn(x) (((x)>0) ? 1:-1)
  30. struct EscapeSequence EscapeStrings[] =
  32.     {
  33.         { "-",prdg_ActConstIgnore, 1},
  34.         { "0",prdg_ActNull,0},
  35.         { "1",prdg_ActNull,0},
  36.         { "2",prdg_ActNull,0},
  37.         { "3",prdg_ActConstIgnore, 1},
  38.         { "4",prdg_ActNull,0},
  39.         { "5",prdg_ActConstIgnore, 1},
  40.         { "6",prdg_ActNull,0},
  41.         { "7",prdg_ActNull,0},
  42.         { ":",prdg_ActNull,0},
  43.         { "=",prdg_ActNull,0},
  44.         { "A",prdg_ActConstIgnore, 1},
  45.         { "B",prdg_ActDelimited, ''},
  46.         { "C",prdg_ActConstIgnore, 1},
  47.         { "D",prdg_ActDelimited, ''},
  48.         { "E",prdg_ActReset,0},
  49.         { "F",prdg_ActNull,0},
  50.         { "G",prdg_ActNull,0},
  51.         { "H",prdg_ActNull,0},
  52.         { "I",prdg_ActConstIgnore, 1},
  53.         { "J",prdg_ActConstIgnore, 1},
  54.         { "K",prdg_ActCountIgnore, 0},
  55.         { "L",prdg_ActCountIgnore, 0},
  56.         { "N",prdg_ActConstIgnore, 1},
  57.         { "O",prdg_ActNull,0},
  58.         { "P",prdg_ActConstIgnore, 1},
  59.         { "Q",prdg_ActConstIgnore, 1},
  60.         { "R",prdg_ActNull,0},
  61.         { "S",prdg_ActConstIgnore, 1},
  62.         { "T",prdg_ActNull,0},
  63.         { "U",prdg_ActConstIgnore, 1},
  64.         { "W",prdg_ActConstIgnore, 1},
  65.         { "X",prdg_ActConstIgnore, 2},
  66.         { "Y",prdg_ActCountIgnore, 0},
  67.         { "Z",prdg_ActCountIgnore, 0},
  68.         { "[@",prdg_ActCountIgnore, 0},
  69.         { "[C",prdg_ActCountIgnore, 0},
  70.         { "[F",prdg_ActCountIgnore, 0},
  71.         { "[I",prdg_ActCountIgnore, 0},
  72.         { "[S",prdg_ActCountIgnore, 0},
  73.         { "[T",prdg_ActCountIgnore, 0},
  74.         { "[\",prdg_ActCountIgnore, 0},
  75.         { "[g",prdg_ActCountIgnore, 0},
  76.         { "\",prdg_ActCountIgnore, 0},
  77.         { "]",prdg_ActNull,0},
  78.         { "^",prdg_ActNull,0},
  79.         { "_",prdg_ActConstIgnore, 1},
  80.         { "d",prdg_ActConstIgnore, 2},
  81.         { "e",prdg_ActConstIgnore, 2},
  82.         { "j",prdg_ActNull,0},
  83.         { "n",prdg_ActNull,0},
  84.         { "x6f", prdg_ActFF, 0}
  85.     };
  89. VOID
  90. CheckFormFeedStream(
  91.     lpDCI           pDCIData,
  92.     unsigned char   inch)
  94. /**********************************************************************/
  95. /*                                                                    */
  96. /*   FUNCTION: prdg_ParseRawData                                      */
  97. /*                                                                    */
  98. /*   PARAMETERS:                                                      */
  99. /*                                                                    */
  100. /*   lpDCI           pDCIData;  Pointer to DC instance data           */
  101. /*   unsigned char   inch;     The next byte in data stream           */
  102. /*                                                                    */
  103. /*   DESCRIPTION:                                                     */
  104. /*                                                                    */
  105. /*   This function parses the stream of raw data which is being       */
  106. /*   passed to the printer so that the driver can handle form feeds   */
  107. /*   correctly.  The function must follow all the escape sequences    */
  108. /*   which occur in the sequence of raw data.                         */
  109. /*                                                                    */
  110. /*   CHANGES:                                                         */
  111. /*                                                                    */
  112. /*   This function is table driven (from the table in in the ddata    */
  113. /*   module) so it should hopefully only require this to be changed   */
  114. /*   to reflect the escape sequences for a different printer.  If     */
  115. /*   however there are escape sequneces which don't fall into the     */
  116. /*   categories this parser can handle then extra code will have      */
  117. /*   to be written to handle them.  The parser can handle escape      */
  118. /*   sequences with any number of unique identifying characters       */
  119. /*   possibly followed by: a count then the number of charcters given */
  120. /*   in the count; a fixed number of characters; a stream of          */
  121. /*   characters followed by a delimeter.                              */
  122. /*                                                                    */
  123. /**********************************************************************/
  125. {
  126.     /******************************************************************/
  127.     /* Local Variables                                                */
  128.     /******************************************************************/
  129.     INT                    Direction;   /* Variables used in the      */
  130.     UINT                   HiIndex;     /* binary chop routine for    */
  131.     UINT                   LoIndex;     /* searching for a matching   */
  132.     UINT                   Index;       /* escape sequence            */
  133.     UINT                   PrevIndex;
  134.     char *                 optr;        /* Pointers to access the     */
  135.     char *                 nptr;        /* escape sequence strings    */
  136.     struct EscapeSequence *NewSequence; /* Pointer to an escape       */
  137.                                         /* sequence                   */
  139.     /******************************************************************/
  140.     /* Process the input character through the parsing function.      */
  141.     /* Switch depending on which state we are currently in.  One of   */
  142.     /* prdg_Text, prdg_ESC_match, prdg_ESC_n_ignore, prdg_ESC_d_ignore*/
  143.     /* prdg_ESC_read_lo_count, prdg_ESC_read_hi_count.                */
  144.     /******************************************************************/
  145.     switch (pDCIData->ParserState)
  146.     {
  147.         case prdg_Text:
  148.             /**********************************************************/
  149.             /* Text state. Usual state, handled in line by a macro.   */
  150.             /* The code is included here for completeness only.       */
  151.             /* The FFaction (Form Feed action) state is maintained -  */
  152.             /* if the character is text (ie >= 0x20) then set it to   */
  153.             /* prdg_FFstate, if the character is a FF then set it to  */
  154.             /* prdg_FFx0c.  If the input character is an escape then  */
  155.             /* start up the sequence matching mode.                   */
  156.             /**********************************************************/
  157.             if (inch >= 0x20)
  158.                 pDCIData->FFstate = prdg_FFtext;
  160.             else if (inch == 0x0c)
  161.                 pDCIData->FFstate = prdg_FFx0c;
  163.             else if (inch == 0x1b)
  164.             {
  165.                 /******************************************************/
  166.                 /* The character is an escape so set ParserState and  */
  167.                 /* indicate we have not matched a sequence yet by     */
  168.                 /* setting ParserSequence to NULL.                    */
  169.                 /******************************************************/
  170.                 pDCIData->ParserState = prdg_ESC_match;
  171.                 pDCIData->ParserSequence = NULL;
  172.             }
  174.             break;
  176.         case prdg_ESC_match:
  177.             /**********************************************************/
  178.             /* Matching an escape sequence so try to match a new      */
  179.             /* character.                                             */
  180.             /**********************************************************/
  181.             if (!pDCIData->ParserSequence)
  182.             {
  183.                 /******************************************************/
  184.                 /* ParserSequence is NULL indicating that this is the */
  185.                 /* first character of an escape sequence so use a     */
  186.                 /* binary chop to get to the correct area of the      */
  187.                 /* table of escape sequences (based on the first      */
  188.                 /* character of the escape sequence which is the      */
  189.                 /* cuurent input character).                          */
  190.                 /******************************************************/
  191.                 HiIndex = MaxEscapeStrings;
  192.                 LoIndex = 0;
  193.                 Index = (LoIndex + HiIndex)/2;
  194.                 PrevIndex = MaxEscapeStrings;
  196.                 /******************************************************/
  197.                 /* while inch does not match the first character of   */
  198.                 /* the sequence indicated by Index move up or down    */
  199.                 /* the table depending on whether inch is < or > the  */
  200.                 /* first character of the escape sequence at Index.   */
  201.                 /******************************************************/
  202.                 while (Direction =
  203.                                (inch - *EscapeStrings[Index].ESCString))
  204.                 {
  205.                     if (Direction > 0)
  206.                     {
  207.                         LoIndex = Index;
  208.                     }
  209.                     else
  210.                     {
  211.                         HiIndex = Index;
  212.                     };
  213.                     PrevIndex = Index;
  214.                     if (PrevIndex == (Index = (LoIndex + HiIndex)/2))
  215.                     {
  216.                         /**********************************************/
  217.                         /* There is no escape sequence with a first   */
  218.                         /* character matching the current input       */
  219.                         /* character so resume text mode.             */
  220.                         /**********************************************/
  221.                         pDCIData->ParserState = prdg_Text;
  222.                         return;
  223.                     }
  225.                 }
  226.                 /*.. while (Direction = ...no match yet...............*/
  228.                 /******************************************************/
  229.                 /* Set up the ParserSequence and ParserString for the */
  230.                 /* first match found.                                 */
  231.                 /******************************************************/
  232.                 pDCIData->ParserSequence = &EscapeStrings[Index];
  233.                 pDCIData->ParserString = EscapeStrings[Index].ESCString;
  234.             };
  235.             /*.. if (!pDCIData->ParserSequence) .......................*/
  237.             /**********************************************************/
  238.             /* Loop forever trying to match escape sequences.         */
  239.             /* First, try the new character against the current       */
  240.             /* escape sequence and if it matches then check if it is  */
  241.             /* the end of the sequence and if it is switch to the     */
  242.             /* appropriate matching mode.  If the new character does  */
  243.             /* not match try the next escape sequence (in either      */
  244.             /* ascending or descending order depending on whether the */
  245.             /* current character was < or > the character we were     */
  246.             /* trying to match it to).  If the new sequence we are    */
  247.             /* trying to match against does not exist (ie we are at   */
  248.             /* one end of the table) or it does not match upto (but   */
  249.             /* not including) the position we are currently at then   */
  250.             /* the escape sequence in the raw data we are trying to   */
  251.             /* match is invalid so revert to prdg_Text mode.  If it   */
  252.             /* does match upto (but not including) the position we    */
  253.             /* are currently trying to match then go back to try and  */
  254.             /* match.                                                 */
  255.             /**********************************************************/
  256.             for (Direction = sgn(inch - *pDCIData->ParserString);;)
  257.             {
  258.                 /******************************************************/
  259.                 /* Partway along a sequence, try the new character and*/
  260.                 /* if it matches then check for end of string.        */
  261.                 /******************************************************/
  262.                 if (!(inch - *pDCIData->ParserString))
  263.                 {
  264.                     if (*++pDCIData->ParserString != '')
  265.                         /**********************************************/
  266.                         /* Escape sequence not finished yet so return */
  267.                         /* and wait for the next character.  Note that*/
  268.                         /* this is where the pointer to the position  */
  269.                         /* in the escape sequence we are checking is  */
  270.                         /* updated.                                   */
  271.                         /**********************************************/
  272.                         return;
  273.                     else
  274.                         /**********************************************/
  275.                         /* The escape sequence has matched till the   */
  276.                         /* end so break to the next section which will*/
  277.                         /* take the appropriate action.               */
  278.                         /**********************************************/
  279.                         break;
  280.                 }
  281.                 /*.. if (!(inch - *pDCIData->ParserString)) ...match...*/
  283.                 else
  284.                 {
  285.                     /**************************************************/
  286.                     /* The current sequence does not match so we must */
  287.                     /* try another sequence.  Direction determines    */
  288.                     /* which way in the table we should go.           */
  289.                     /**************************************************/
  290.                     NewSequence = pDCIData->ParserSequence + Direction;
  292.                     if (NewSequence < EscapeStrings ||
  293.                         NewSequence> &EscapeStrings[MaxEscapeStrings-1])
  294.                     {
  295.                         /**********************************************/
  296.                         /* The new sequence is beyond one end of the  */
  297.                         /* table so revert to prdg_Text mode because  */
  298.                         /* we will not be able to find a match.       */
  299.                         /**********************************************/
  300.                         pDCIData->ParserState = prdg_Text;
  301.                         return;
  302.                     }
  304.                     /**************************************************/
  305.                     /* Check that all the characters in the new       */
  306.                     /* escape sequence upto (but not including) the   */
  307.                     /* current one match the old escape sequence      */
  308.                     /* (because those characters from the old escape  */
  309.                     /* sequence have already been matched to the      */
  310.                     /* raw data).                                     */
  311.                     /**************************************************/
  312.                     for (optr=pDCIData->ParserSequence->ESCString,
  313.                          nptr=NewSequence->ESCString;
  314.                          optr<pDCIData->ParserString; ++optr,++nptr)
  316.                          if (*nptr != *optr)
  317.                          {
  318.                              /*****************************************/
  319.                              /* If the new sequence does not match the*/
  320.                              /* old then a match is not possible so   */
  321.                              /* return.                               */
  322.                              /*****************************************/
  323.                              pDCIData->ParserState = prdg_Text;
  324.                              return;
  325.                          }
  327.                     /**************************************************/
  328.                     /* The new sequence is correct upto the character */
  329.                     /* before the current character so loop back and  */
  330.                     /* check the current character.                   */
  331.                     /**************************************************/
  332.                     pDCIData->ParserSequence = NewSequence;
  333.                     pDCIData->ParserString = nptr;
  336.                 }
  337.                 /*.. else ! (!(inch - *pDCIData->ParserString.no match.*/
  339.             }
  340.             /*.. for ( ... ;;) ....for ever...........................*/
  342.             /**********************************************************/
  343.             /* The escape sequence has been matched from our table of */
  344.             /* escape sequences so take the appropriate action for    */
  345.             /* the particular sequence.                               */
  346.             /**********************************************************/
  347.             switch (pDCIData->ParserSequence->ESCAction)
  348.             {
  349.                 case prdg_ActNull:
  350.                     /**************************************************/
  351.                     /* No further action so revert to prdg_Text mode  */
  352.                     /**************************************************/
  353.                     pDCIData->ParserState = prdg_Text;
  354.                     break;
  356.                 case prdg_ActDelimited:
  357.                     /**************************************************/
  358.                     /* Ignore subsequent characters upto a specified  */
  359.                     /* delimeter.                                     */
  360.                     /**************************************************/
  361.                     pDCIData->ParserState = prdg_ESC_d_ignore;
  362.                     pDCIData->ParserDelimiter =
  363.                                (char)pDCIData->ParserSequence->ESCValue;
  364.                     break;
  366.                 case prdg_ActConstIgnore:
  367.                     /**************************************************/
  368.                     /* Ignore a specified number of characters.       */
  369.                     /**************************************************/
  370.                     pDCIData->ParserState = prdg_ESC_n_ignore;
  371.                     pDCIData->ParserCount =
  372.                                       pDCIData->ParserSequence->ESCValue;
  373.                     break;
  375.                 case prdg_ActCountIgnore:
  376.                     /**************************************************/
  377.                     /* A two byte count follows so prepare to read it */
  378.                     /* in.                                            */
  379.                     /**************************************************/
  380.                     pDCIData->ParserState = prdg_ESC_read_lo_count;
  381.                     break;
  383.                 case prdg_ActFF:
  384.                     /**************************************************/
  385.                     /* A special action for recognising the 0x1b6f    */
  386.                     /* "No Formfeed" sequence                         */
  387.                     /**************************************************/
  388.                     pDCIData->ParserState = prdg_Text;
  389.                     pDCIData->FFstate = prdg_FFx1b6f;
  390.                     break;
  392.                 case prdg_ActReset:
  393.                     /**************************************************/
  394.                     /* On Esc-E (reset) don't eject a page if this is */
  395.                     /* the last sequence in the stream.               */
  396.                     /**************************************************/
  397.                     pDCIData->ParserState = prdg_Text;
  398.                     pDCIData->FFstate = prdg_FFx1b45;
  399.                     break;
  400.             }
  401.             /*.. switch (pDCIData->ParserSequence->ESCAction) .........*/
  403.             break;
  405.         case prdg_ESC_n_ignore:
  406.             /**********************************************************/
  407.             /* Ignoring n characters. Decrement the count, move back  */
  408.             /* to text state if all ignored.                          */
  409.             /**********************************************************/
  410.             if (!(--pDCIData->ParserCount))
  411.                 pDCIData->ParserState = prdg_Text;
  412.             break;
  414.         case prdg_ESC_d_ignore:
  415.             /**********************************************************/
  416.             /* Ignoring up to a delimiter. If this is it, then stop   */
  417.             /* ignoring.                                              */
  418.             /**********************************************************/
  419.             if (inch == pDCIData->ParserDelimiter)
  420.                 pDCIData->ParserState = prdg_Text;
  421.             break;
  423.         case prdg_ESC_read_lo_count:
  424.             /**********************************************************/
  425.             /* Reading first byte of count. Save it, advance state.   */
  426.             /**********************************************************/
  427.             pDCIData->ParserCount = (UINT)inch;
  428.             pDCIData->ParserState = prdg_ESC_read_hi_count;
  429.             break;
  431.         case prdg_ESC_read_hi_count:
  432.             /**********************************************************/
  433.             /* Reading second byte of count. Save it, move to ignore  */
  434.             /* a specified number of characters if there are any.     */
  435.             /**********************************************************/
  436.             pDCIData->ParserCount += 256*(UINT)inch;
  437.             if (pDCIData->ParserCount)
  438.                 pDCIData->ParserState = prdg_ESC_n_ignore;
  439.             else
  440.                 pDCIData->ParserState = prdg_Text;
  441.             break;
  443.     };
  444.     /*.. switch (pDCIData->ParserState) ...............................*/
  446.     return;
  447. }
  450. BOOL
  451. CheckFormFeed(
  452.     lpDCI pDCIData)
  453. {
  454.     return FALSE;
  455. }