Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /******************************************************************************
  2.  *
  3.  * Module Name: aslbtypes - Support for bitfield types
  4.  *
  5.  *****************************************************************************/
  6.  
  7. /******************************************************************************
  8.  *
  9.  * 1. Copyright Notice
  10.  *
  11.  * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  12.  * All rights reserved.
  13.  *
  14.  * 2. License
  15.  *
  16.  * 2.1. This is your license from Intel Corp. under its intellectual property
  17.  * rights.  You may have additional license terms from the party that provided
  18.  * you this software, covering your right to use that party's intellectual
  19.  * property rights.
  20.  *
  21.  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22.  * copy of the source code appearing in this file ("Covered Code") an
  23.  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24.  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25.  * make derivatives, distribute, use and display any portion of the Covered
  26.  * Code in any form, with the right to sublicense such rights; and
  27.  *
  28.  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29.  * license (with the right to sublicense), under only those claims of Intel
  30.  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31.  * offer to sell, and import the Covered Code and derivative works thereof
  32.  * solely to the minimum extent necessary to exercise the above copyright
  33.  * license, and in no event shall the patent license extend to any additions
  34.  * to or modifications of the Original Intel Code.  No other license or right
  35.  * is granted directly or by implication, estoppel or otherwise;
  36.  *
  37.  * The above copyright and patent license is granted only if the following
  38.  * conditions are met:
  39.  *
  40.  * 3. Conditions
  41.  *
  42.  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43.  * Redistribution of source code of any substantial portion of the Covered
  44.  * Code or modification with rights to further distribute source must include
  45.  * the above Copyright Notice, the above License, this list of Conditions,
  46.  * and the following Disclaimer and Export Compliance provision.  In addition,
  47.  * Licensee must cause all Covered Code to which Licensee contributes to
  48.  * contain a file documenting the changes Licensee made to create that Covered
  49.  * Code and the date of any change.  Licensee must include in that file the
  50.  * documentation of any changes made by any predecessor Licensee.  Licensee
  51.  * must include a prominent statement that the modification is derived,
  52.  * directly or indirectly, from Original Intel Code.
  53.  *
  54.  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55.  * Redistribution of source code of any substantial portion of the Covered
  56.  * Code or modification without rights to further distribute source must
  57.  * include the following Disclaimer and Export Compliance provision in the
  58.  * documentation and/or other materials provided with distribution.  In
  59.  * addition, Licensee may not authorize further sublicense of source of any
  60.  * portion of the Covered Code, and must include terms to the effect that the
  61.  * license from Licensee to its licensee is limited to the intellectual
  62.  * property embodied in the software Licensee provides to its licensee, and
  63.  * not to intellectual property embodied in modifications its licensee may
  64.  * make.
  65.  *
  66.  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67.  * substantial portion of the Covered Code or modification must reproduce the
  68.  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69.  * provision in the documentation and/or other materials provided with the
  70.  * distribution.
  71.  *
  72.  * 3.4. Intel retains all right, title, and interest in and to the Original
  73.  * Intel Code.
  74.  *
  75.  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76.  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77.  * other dealings in products derived from or relating to the Covered Code
  78.  * without prior written authorization from Intel.
  79.  *
  80.  * 4. Disclaimer and Export Compliance
  81.  *
  82.  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83.  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84.  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85.  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86.  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87.  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88.  * PARTICULAR PURPOSE.
  89.  *
  90.  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91.  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92.  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93.  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94.  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95.  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96.  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97.  * LIMITED REMEDY.
  98.  *
  99.  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  100.  * software or system incorporating such software without first obtaining any
  101.  * required license or other approval from the U. S. Department of Commerce or
  102.  * any other agency or department of the United States Government.  In the
  103.  * event Licensee exports any such software from the United States or
  104.  * re-exports any such software from a foreign destination, Licensee shall
  105.  * ensure that the distribution and export/re-export of the software is in
  106.  * compliance with all laws, regulations, orders, or other restrictions of the
  107.  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  108.  * any of its subsidiaries will export/re-export any technical data, process,
  109.  * software, or service, directly or indirectly, to any country for which the
  110.  * United States government or any agency thereof requires an export license,
  111.  * other governmental approval, or letter of assurance, without first obtaining
  112.  * such license, approval or letter.
  113.  *
  114.  *****************************************************************************/
  115.  
  116.  
  117. #include "aslcompiler.h"
  118. #include "aslcompiler.y.h"
  119. #include "amlcode.h"
  120.  
  121.  
  122. #define _COMPONENT          ACPI_COMPILER
  123.         ACPI_MODULE_NAME    ("aslbtypes")
  124.  
  125. /* Local prototypes */
  126.  
  127. static UINT32
  128. AnMapEtypeToBtype (
  129.     UINT32                  Etype);
  130.  
  131.  
  132. /*******************************************************************************
  133.  *
  134.  * FUNCTION:    AnMapArgTypeToBtype
  135.  *
  136.  * PARAMETERS:  ArgType             - The ARGI required type(s) for this
  137.  *                                    argument, from the opcode info table
  138.  *
  139.  * RETURN:      The corresponding Bit-encoded types
  140.  *
  141.  * DESCRIPTION: Convert an encoded ARGI required argument type code into a
  142.  *              bitfield type code. Implements the implicit source conversion
  143.  *              rules.
  144.  *
  145.  ******************************************************************************/
  146.  
  147. UINT32
  148. AnMapArgTypeToBtype (
  149.     UINT32                  ArgType)
  150. {
  151.  
  152.     switch (ArgType)
  153.     {
  154.  
  155.     /* Simple types */
  156.  
  157.     case ARGI_ANYTYPE:
  158.         return (ACPI_BTYPE_OBJECTS_AND_REFS);
  159.  
  160.     case ARGI_PACKAGE:
  161.         return (ACPI_BTYPE_PACKAGE);
  162.  
  163.     case ARGI_EVENT:
  164.         return (ACPI_BTYPE_EVENT);
  165.  
  166.     case ARGI_MUTEX:
  167.         return (ACPI_BTYPE_MUTEX);
  168.  
  169.     case ARGI_DDBHANDLE:
  170.         /*
  171.          * DDBHandleObject := SuperName
  172.          * ACPI_BTYPE_REFERENCE: Index reference as parameter of Load/Unload
  173.          */
  174.         return (ACPI_BTYPE_DDB_HANDLE | ACPI_BTYPE_REFERENCE);
  175.  
  176.     /* Interchangeable types */
  177.     /*
  178.      * Source conversion rules:
  179.      * Integer, String, and Buffer are all interchangeable
  180.      */
  181.     case ARGI_INTEGER:
  182.     case ARGI_STRING:
  183.     case ARGI_BUFFER:
  184.     case ARGI_BUFFER_OR_STRING:
  185.     case ARGI_COMPUTEDATA:
  186.         return (ACPI_BTYPE_COMPUTE_DATA);
  187.  
  188.     /* References */
  189.  
  190.     case ARGI_INTEGER_REF:
  191.         return (ACPI_BTYPE_INTEGER);
  192.  
  193.     case ARGI_OBJECT_REF:
  194.         return (ACPI_BTYPE_ALL_OBJECTS);
  195.  
  196.     case ARGI_DEVICE_REF:
  197.         return (ACPI_BTYPE_DEVICE_OBJECTS);
  198.  
  199.     case ARGI_REFERENCE:
  200.         return (ACPI_BTYPE_REFERENCE);
  201.  
  202.     case ARGI_TARGETREF:
  203.     case ARGI_FIXED_TARGET:
  204.     case ARGI_SIMPLE_TARGET:
  205.         return (ACPI_BTYPE_OBJECTS_AND_REFS);
  206.  
  207.     /* Complex types */
  208.  
  209.     case ARGI_DATAOBJECT:
  210.  
  211.         /*
  212.          * Buffer, string, package or reference to a Op -
  213.          * Used only by SizeOf operator
  214.          */
  215.         return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
  216.             ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE);
  217.  
  218.     case ARGI_COMPLEXOBJ:
  219.  
  220.         /* Buffer, String, or package */
  221.  
  222.         return (ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER | ACPI_BTYPE_PACKAGE);
  223.  
  224.     case ARGI_REF_OR_STRING:
  225.         return (ACPI_BTYPE_STRING | ACPI_BTYPE_REFERENCE);
  226.  
  227.     case ARGI_REGION_OR_BUFFER:
  228.  
  229.         /* Used by Load() only. Allow buffers in addition to regions/fields */
  230.  
  231.         return (ACPI_BTYPE_REGION | ACPI_BTYPE_BUFFER | ACPI_BTYPE_FIELD_UNIT);
  232.  
  233.     case ARGI_DATAREFOBJ:
  234.         return (ACPI_BTYPE_INTEGER |ACPI_BTYPE_STRING | ACPI_BTYPE_BUFFER |
  235.             ACPI_BTYPE_PACKAGE | ACPI_BTYPE_REFERENCE | ACPI_BTYPE_DDB_HANDLE);
  236.  
  237.     default:
  238.         break;
  239.     }
  240.  
  241.     return (ACPI_BTYPE_OBJECTS_AND_REFS);
  242. }
  243.  
  244.  
  245. /*******************************************************************************
  246.  *
  247.  * FUNCTION:    AnMapEtypeToBtype
  248.  *
  249.  * PARAMETERS:  Etype               - Encoded ACPI Type
  250.  *
  251.  * RETURN:      Btype corresponding to the Etype
  252.  *
  253.  * DESCRIPTION: Convert an encoded ACPI type to a bitfield type applying the
  254.  *              operand conversion rules. In other words, returns the type(s)
  255.  *              this Etype is implicitly converted to during interpretation.
  256.  *
  257.  ******************************************************************************/
  258.  
  259. static UINT32
  260. AnMapEtypeToBtype (
  261.     UINT32                  Etype)
  262. {
  263.  
  264.  
  265.     if (Etype == ACPI_TYPE_ANY)
  266.     {
  267.         return (ACPI_BTYPE_OBJECTS_AND_REFS);
  268.     }
  269.  
  270.     /* Try the standard ACPI data types */
  271.  
  272.     if (Etype <= ACPI_TYPE_EXTERNAL_MAX)
  273.     {
  274.         /*
  275.          * This switch statement implements the allowed operand conversion
  276.          * rules as per the "ASL Data Types" section of the ACPI
  277.          * specification.
  278.          */
  279.         switch (Etype)
  280.         {
  281.         case ACPI_TYPE_INTEGER:
  282.             return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_DDB_HANDLE);
  283.  
  284.         case ACPI_TYPE_STRING:
  285.         case ACPI_TYPE_BUFFER:
  286.             return (ACPI_BTYPE_COMPUTE_DATA);
  287.  
  288.         case ACPI_TYPE_PACKAGE:
  289.             return (ACPI_BTYPE_PACKAGE);
  290.  
  291.         case ACPI_TYPE_FIELD_UNIT:
  292.             return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
  293.  
  294.         case ACPI_TYPE_BUFFER_FIELD:
  295.             return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_BUFFER_FIELD);
  296.  
  297.         case ACPI_TYPE_DDB_HANDLE:
  298.             return (ACPI_BTYPE_INTEGER | ACPI_BTYPE_DDB_HANDLE);
  299.  
  300.         case ACPI_BTYPE_DEBUG_OBJECT:
  301.  
  302.             /* Cannot be used as a source operand */
  303.  
  304.             return (0);
  305.  
  306.         default:
  307.             return (1 << (Etype - 1));
  308.         }
  309.     }
  310.  
  311.     /* Try the internal data types */
  312.  
  313.     switch (Etype)
  314.     {
  315.     case ACPI_TYPE_LOCAL_REGION_FIELD:
  316.     case ACPI_TYPE_LOCAL_BANK_FIELD:
  317.     case ACPI_TYPE_LOCAL_INDEX_FIELD:
  318.  
  319.         /* Named fields can be either Integer/Buffer/String */
  320.  
  321.         return (ACPI_BTYPE_COMPUTE_DATA | ACPI_BTYPE_FIELD_UNIT);
  322.  
  323.     case ACPI_TYPE_LOCAL_ALIAS:
  324.  
  325.         return (ACPI_BTYPE_INTEGER);
  326.  
  327.  
  328.     case ACPI_TYPE_LOCAL_RESOURCE:
  329.     case ACPI_TYPE_LOCAL_RESOURCE_FIELD:
  330.  
  331.         return (ACPI_BTYPE_REFERENCE);
  332.  
  333.     default:
  334.         printf ("Unhandled encoded type: %X\n", Etype);
  335.         return (0);
  336.     }
  337. }
  338.  
  339.  
  340. /*******************************************************************************
  341.  *
  342.  * FUNCTION:    AnFormatBtype
  343.  *
  344.  * PARAMETERS:  Btype               - Bitfield of ACPI types
  345.  *              Buffer              - Where to put the ascii string
  346.  *
  347.  * RETURN:      None.
  348.  *
  349.  * DESCRIPTION: Convert a Btype to a string of ACPI types
  350.  *
  351.  ******************************************************************************/
  352.  
  353. void
  354. AnFormatBtype (
  355.     char                    *Buffer,
  356.     UINT32                  Btype)
  357. {
  358.     UINT32                  Type;
  359.     BOOLEAN                 First = TRUE;
  360.  
  361.  
  362.     *Buffer = 0;
  363.  
  364.     if (Btype == 0)
  365.     {
  366.         strcat (Buffer, "NoReturnValue");
  367.         return;
  368.     }
  369.  
  370.     for (Type = 1; Type <= ACPI_TYPE_EXTERNAL_MAX; Type++)
  371.     {
  372.         if (Btype & 0x00000001)
  373.         {
  374.             if (!First)
  375.             {
  376.                 strcat (Buffer, "|");
  377.             }
  378.             First = FALSE;
  379.             strcat (Buffer, AcpiUtGetTypeName (Type));
  380.         }
  381.         Btype >>= 1;
  382.     }
  383.  
  384.     if (Btype & 0x00000001)
  385.     {
  386.         if (!First)
  387.         {
  388.             strcat (Buffer, "|");
  389.         }
  390.         First = FALSE;
  391.         strcat (Buffer, "Reference");
  392.     }
  393.  
  394.     Btype >>= 1;
  395.     if (Btype & 0x00000001)
  396.     {
  397.         if (!First)
  398.         {
  399.             strcat (Buffer, "|");
  400.         }
  401.         First = FALSE;
  402.         strcat (Buffer, "Resource");
  403.     }
  404. }
  405.  
  406.  
  407. /*******************************************************************************
  408.  *
  409.  * FUNCTION:    AnGetBtype
  410.  *
  411.  * PARAMETERS:  Op                  - Parse node whose type will be returned.
  412.  *
  413.  * RETURN:      The Btype associated with the Op.
  414.  *
  415.  * DESCRIPTION: Get the (bitfield) ACPI type associated with the parse node.
  416.  *              Handles the case where the node is a name or method call and
  417.  *              the actual type must be obtained from the namespace node.
  418.  *
  419.  ******************************************************************************/
  420.  
  421. UINT32
  422. AnGetBtype (
  423.     ACPI_PARSE_OBJECT       *Op)
  424. {
  425.     ACPI_NAMESPACE_NODE     *Node;
  426.     ACPI_PARSE_OBJECT       *ReferencedNode;
  427.     UINT32                  ThisNodeBtype = 0;
  428.  
  429.  
  430.     if ((Op->Asl.ParseOpcode == PARSEOP_NAMESEG)     ||
  431.         (Op->Asl.ParseOpcode == PARSEOP_NAMESTRING)  ||
  432.         (Op->Asl.ParseOpcode == PARSEOP_METHODCALL))
  433.     {
  434.         Node = Op->Asl.Node;
  435.         if (!Node)
  436.         {
  437.             DbgPrint (ASL_DEBUG_OUTPUT,
  438.                 "No attached Nsnode: [%s] at line %u name [%s], ignoring typecheck\n",
  439.                 Op->Asl.ParseOpName, Op->Asl.LineNumber,
  440.                 Op->Asl.ExternalName);
  441.             return (ACPI_UINT32_MAX);
  442.         }
  443.  
  444.         ThisNodeBtype = AnMapEtypeToBtype (Node->Type);
  445.         if (!ThisNodeBtype)
  446.         {
  447.             AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
  448.                 "could not map type");
  449.         }
  450.  
  451.         /*
  452.          * Since it was a named reference, enable the
  453.          * reference bit also
  454.          */
  455.         ThisNodeBtype |= ACPI_BTYPE_REFERENCE;
  456.  
  457.         if (Op->Asl.ParseOpcode == PARSEOP_METHODCALL)
  458.         {
  459.             ReferencedNode = Node->Op;
  460.             if (!ReferencedNode)
  461.             {
  462.                 /* Check for an internal method */
  463.  
  464.                 if (AnIsInternalMethod (Op))
  465.                 {
  466.                     return (AnGetInternalMethodReturnType (Op));
  467.                 }
  468.  
  469.                 AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, Op,
  470.                     "null Op pointer");
  471.                 return (ACPI_UINT32_MAX);
  472.             }
  473.  
  474.             if (ReferencedNode->Asl.CompileFlags & NODE_METHOD_TYPED)
  475.             {
  476.                 ThisNodeBtype = ReferencedNode->Asl.AcpiBtype;
  477.             }
  478.             else
  479.             {
  480.                 return (ACPI_UINT32_MAX -1);
  481.             }
  482.         }
  483.     }
  484.     else
  485.     {
  486.         ThisNodeBtype = Op->Asl.AcpiBtype;
  487.     }
  488.  
  489.     return (ThisNodeBtype);
  490. }
  491.  
  492.  
  493. /*******************************************************************************
  494.  *
  495.  * FUNCTION:    AnMapObjTypeToBtype
  496.  *
  497.  * PARAMETERS:  Op                  - A parse node
  498.  *
  499.  * RETURN:      A Btype
  500.  *
  501.  * DESCRIPTION: Map object to the associated "Btype"
  502.  *
  503.  ******************************************************************************/
  504.  
  505. UINT32
  506. AnMapObjTypeToBtype (
  507.     ACPI_PARSE_OBJECT       *Op)
  508. {
  509.  
  510.     switch (Op->Asl.ParseOpcode)
  511.     {
  512.     case PARSEOP_OBJECTTYPE_BFF:        /* "BuffFieldObj" */
  513.         return (ACPI_BTYPE_BUFFER_FIELD);
  514.  
  515.     case PARSEOP_OBJECTTYPE_BUF:        /* "BuffObj" */
  516.         return (ACPI_BTYPE_BUFFER);
  517.  
  518.     case PARSEOP_OBJECTTYPE_DDB:        /* "DDBHandleObj" */
  519.         return (ACPI_BTYPE_DDB_HANDLE);
  520.  
  521.     case PARSEOP_OBJECTTYPE_DEV:        /* "DeviceObj" */
  522.         return (ACPI_BTYPE_DEVICE);
  523.  
  524.     case PARSEOP_OBJECTTYPE_EVT:        /* "EventObj" */
  525.         return (ACPI_BTYPE_EVENT);
  526.  
  527.     case PARSEOP_OBJECTTYPE_FLD:        /* "FieldUnitObj" */
  528.         return (ACPI_BTYPE_FIELD_UNIT);
  529.  
  530.     case PARSEOP_OBJECTTYPE_INT:        /* "IntObj" */
  531.         return (ACPI_BTYPE_INTEGER);
  532.  
  533.     case PARSEOP_OBJECTTYPE_MTH:        /* "MethodObj" */
  534.         return (ACPI_BTYPE_METHOD);
  535.  
  536.     case PARSEOP_OBJECTTYPE_MTX:        /* "MutexObj" */
  537.         return (ACPI_BTYPE_MUTEX);
  538.  
  539.     case PARSEOP_OBJECTTYPE_OPR:        /* "OpRegionObj" */
  540.         return (ACPI_BTYPE_REGION);
  541.  
  542.     case PARSEOP_OBJECTTYPE_PKG:        /* "PkgObj" */
  543.         return (ACPI_BTYPE_PACKAGE);
  544.  
  545.     case PARSEOP_OBJECTTYPE_POW:        /* "PowerResObj" */
  546.         return (ACPI_BTYPE_POWER);
  547.  
  548.     case PARSEOP_OBJECTTYPE_STR:        /* "StrObj" */
  549.         return (ACPI_BTYPE_STRING);
  550.  
  551.     case PARSEOP_OBJECTTYPE_THZ:        /* "ThermalZoneObj" */
  552.         return (ACPI_BTYPE_THERMAL);
  553.  
  554.     case PARSEOP_OBJECTTYPE_UNK:        /* "UnknownObj" */
  555.         return (ACPI_BTYPE_OBJECTS_AND_REFS);
  556.  
  557.     default:
  558.         return (0);
  559.     }
  560. }
  561.  
  562.  
  563. #ifdef ACPI_OBSOLETE_FUNCTIONS
  564. /*******************************************************************************
  565.  *
  566.  * FUNCTION:    AnMapBtypeToEtype
  567.  *
  568.  * PARAMETERS:  Btype               - Bitfield of ACPI types
  569.  *
  570.  * RETURN:      The Etype corresponding the the Btype
  571.  *
  572.  * DESCRIPTION: Convert a bitfield type to an encoded type
  573.  *
  574.  ******************************************************************************/
  575.  
  576. UINT32
  577. AnMapBtypeToEtype (
  578.     UINT32              Btype)
  579. {
  580.     UINT32              i;
  581.     UINT32              Etype;
  582.  
  583.  
  584.     if (Btype == 0)
  585.     {
  586.         return (0);
  587.     }
  588.  
  589.     Etype = 1;
  590.     for (i = 1; i < Btype; i *= 2)
  591.     {
  592.         Etype++;
  593.     }
  594.  
  595.     return (Etype);
  596. }
  597. #endif
  598.