drivers/acpi/acpica/dsmthdat.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /*******************************************************************************
   3  *
   4  * Module Name: dsmthdat - control method arguments and local variables
   5  *
   6  ******************************************************************************/
   7
   8 #include <acpi/acpi.h>
   9 #include "accommon.h"
  10 #include "acdispat.h"
  11 #include "acnamesp.h"
  12 #include "acinterp.h"
  13
  14 #define _COMPONENT          ACPI_DISPATCHER
  15 ACPI_MODULE_NAME("dsmthdat")
  16
  17 /* Local prototypes */
  18 static void
  19 acpi_ds_method_data_delete_value(u8 type,
  20                                  u32 index, struct acpi_walk_state *walk_state);
  21
  22 static acpi_status
  23 acpi_ds_method_data_set_value(u8 type,
  24                               u32 index,
  25                               union acpi_operand_object *object,
  26                               struct acpi_walk_state *walk_state);
  27
  28 #ifdef ACPI_OBSOLETE_FUNCTIONS
  29 acpi_object_type
  30 acpi_ds_method_data_get_type(u16 opcode,
  31                              u32 index, struct acpi_walk_state *walk_state);
  32 #endif
  33
  34 /*******************************************************************************
  35  *
  36  * FUNCTION:    acpi_ds_method_data_init
  37  *
  38  * PARAMETERS:  walk_state          - Current walk state object
  39  *
  40  * RETURN:      Status
  41  *
  42  * DESCRIPTION: Initialize the data structures that hold the method's arguments
  43  *              and locals. The data struct is an array of namespace nodes for
  44  *              each - this allows ref_of and de_ref_of to work properly for these
  45  *              special data types.
  46  *
  47  * NOTES:       walk_state fields are initialized to zero by the
  48  *              ACPI_ALLOCATE_ZEROED().
  49  *
  50  *              A pseudo-Namespace Node is assigned to each argument and local
  51  *              so that ref_of() can return a pointer to the Node.
  52  *
  53  ******************************************************************************/
  54
  55 void acpi_ds_method_data_init(struct acpi_walk_state *walk_state)
  56 {
  57         u32 i;
  58
  59         ACPI_FUNCTION_TRACE(ds_method_data_init);
  60
  61         /* Init the method arguments */
  62
  63         for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++) {
  64                 ACPI_MOVE_32_TO_32(&walk_state->arguments[i].name,
  65                                    NAMEOF_ARG_NTE);
  66
  67                 walk_state->arguments[i].name.integer |= (i << 24);
  68                 walk_state->arguments[i].descriptor_type = ACPI_DESC_TYPE_NAMED;
  69                 walk_state->arguments[i].type = ACPI_TYPE_ANY;
  70                 walk_state->arguments[i].flags = ANOBJ_METHOD_ARG;
  71         }
  72
  73         /* Init the method locals */
  74
  75         for (i = 0; i < ACPI_METHOD_NUM_LOCALS; i++) {
  76                 ACPI_MOVE_32_TO_32(&walk_state->local_variables[i].name,
  77                                    NAMEOF_LOCAL_NTE);
  78
  79                 walk_state->local_variables[i].name.integer |= (i << 24);
  80                 walk_state->local_variables[i].descriptor_type =
  81                     ACPI_DESC_TYPE_NAMED;
  82                 walk_state->local_variables[i].type = ACPI_TYPE_ANY;
  83                 walk_state->local_variables[i].flags = ANOBJ_METHOD_LOCAL;
  84         }
  85
  86         return_VOID;
  87 }
  88
  89 /*******************************************************************************
  90  *
  91  * FUNCTION:    acpi_ds_method_data_delete_all
  92  *
  93  * PARAMETERS:  walk_state          - Current walk state object
  94  *
  95  * RETURN:      None
  96  *
  97  * DESCRIPTION: Delete method locals and arguments. Arguments are only
  98  *              deleted if this method was called from another method.
  99  *
 100  ******************************************************************************/
 101
 102 void acpi_ds_method_data_delete_all(struct acpi_walk_state *walk_state)
 103 {
 104         u32 index;
 105
 106         ACPI_FUNCTION_TRACE(ds_method_data_delete_all);
 107
 108         /* Detach the locals */
 109
 110         for (index = 0; index < ACPI_METHOD_NUM_LOCALS; index++) {
 111                 if (walk_state->local_variables[index].object) {
 112                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Deleting Local%u=%p\n",
 113                                           index,
 114                                           walk_state->local_variables[index].
 115                                           object));
 116
 117                         /* Detach object (if present) and remove a reference */
 118
 119                         acpi_ns_detach_object(&walk_state->
 120                                               local_variables[index]);
 121                 }
 122         }
 123
 124         /* Detach the arguments */
 125
 126         for (index = 0; index < ACPI_METHOD_NUM_ARGS; index++) {
 127                 if (walk_state->arguments[index].object) {
 128                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Deleting Arg%u=%p\n",
 129                                           index,
 130                                           walk_state->arguments[index].object));
 131
 132                         /* Detach object (if present) and remove a reference */
 133
 134                         acpi_ns_detach_object(&walk_state->arguments[index]);
 135                 }
 136         }
 137
 138         return_VOID;
 139 }
 140
 141 /*******************************************************************************
 142  *
 143  * FUNCTION:    acpi_ds_method_data_init_args
 144  *
 145  * PARAMETERS:  *params         - Pointer to a parameter list for the method
 146  *              max_param_count - The arg count for this method
 147  *              walk_state      - Current walk state object
 148  *
 149  * RETURN:      Status
 150  *
 151  * DESCRIPTION: Initialize arguments for a method. The parameter list is a list
 152  *              of ACPI operand objects, either null terminated or whose length
 153  *              is defined by max_param_count.
 154  *
 155  ******************************************************************************/
 156
 157 acpi_status
 158 acpi_ds_method_data_init_args(union acpi_operand_object **params,
 159                               u32 max_param_count,
 160                               struct acpi_walk_state *walk_state)
 161 {
 162         acpi_status status;
 163         u32 index = 0;
 164
 165         ACPI_FUNCTION_TRACE_PTR(ds_method_data_init_args, params);
 166
 167         if (!params) {
 168                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 169                                   "No parameter list passed to method\n"));
 170                 return_ACPI_STATUS(AE_OK);
 171         }
 172
 173         /* Copy passed parameters into the new method stack frame */
 174
 175         while ((index < ACPI_METHOD_NUM_ARGS) &&
 176                (index < max_param_count) && params[index]) {
 177                 /*
 178                  * A valid parameter.
 179                  * Store the argument in the method/walk descriptor.
 180                  * Do not copy the arg in order to implement call by reference
 181                  */
 182                 status =
 183                     acpi_ds_method_data_set_value(ACPI_REFCLASS_ARG, index,
 184                                                   params[index], walk_state);
 185                 if (ACPI_FAILURE(status)) {
 186                         return_ACPI_STATUS(status);
 187                 }
 188
 189                 index++;
 190         }
 191
 192         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%u args passed to method\n", index));
 193         return_ACPI_STATUS(AE_OK);
 194 }
 195
 196 /*******************************************************************************
 197  *
 198  * FUNCTION:    acpi_ds_method_data_get_node
 199  *
 200  * PARAMETERS:  type                - Either ACPI_REFCLASS_LOCAL or
 201  *                                    ACPI_REFCLASS_ARG
 202  *              index               - Which Local or Arg whose type to get
 203  *              walk_state          - Current walk state object
 204  *              node                - Where the node is returned.
 205  *
 206  * RETURN:      Status and node
 207  *
 208  * DESCRIPTION: Get the Node associated with a local or arg.
 209  *
 210  ******************************************************************************/
 211
 212 acpi_status
 213 acpi_ds_method_data_get_node(u8 type,
 214                              u32 index,
 215                              struct acpi_walk_state *walk_state,
 216                              struct acpi_namespace_node **node)
 217 {
 218         ACPI_FUNCTION_TRACE(ds_method_data_get_node);
 219
 220         /*
 221          * Method Locals and Arguments are supported
 222          */
 223         switch (type) {
 224         case ACPI_REFCLASS_LOCAL:
 225
 226                 if (index > ACPI_METHOD_MAX_LOCAL) {
 227                         ACPI_ERROR((AE_INFO,
 228                                     "Local index %u is invalid (max %u)",
 229                                     index, ACPI_METHOD_MAX_LOCAL));
 230                         return_ACPI_STATUS(AE_AML_INVALID_INDEX);
 231                 }
 232
 233                 /* Return a pointer to the pseudo-node */
 234
 235                 *node = &walk_state->local_variables[index];
 236                 break;
 237
 238         case ACPI_REFCLASS_ARG:
 239
 240                 if (index > ACPI_METHOD_MAX_ARG) {
 241                         ACPI_ERROR((AE_INFO,
 242                                     "Arg index %u is invalid (max %u)",
 243                                     index, ACPI_METHOD_MAX_ARG));
 244                         return_ACPI_STATUS(AE_AML_INVALID_INDEX);
 245                 }
 246
 247                 /* Return a pointer to the pseudo-node */
 248
 249                 *node = &walk_state->arguments[index];
 250                 break;
 251
 252         default:
 253
 254                 ACPI_ERROR((AE_INFO, "Type %u is invalid", type));
 255                 return_ACPI_STATUS(AE_TYPE);
 256         }
 257
 258         return_ACPI_STATUS(AE_OK);
 259 }
 260
 261 /*******************************************************************************
 262  *
 263  * FUNCTION:    acpi_ds_method_data_set_value
 264  *
 265  * PARAMETERS:  type                - Either ACPI_REFCLASS_LOCAL or
 266  *                                    ACPI_REFCLASS_ARG
 267  *              index               - Which Local or Arg to get
 268  *              object              - Object to be inserted into the stack entry
 269  *              walk_state          - Current walk state object
 270  *
 271  * RETURN:      Status
 272  *
 273  * DESCRIPTION: Insert an object onto the method stack at entry Opcode:Index.
 274  *              Note: There is no "implicit conversion" for locals.
 275  *
 276  ******************************************************************************/
 277
 278 static acpi_status
 279 acpi_ds_method_data_set_value(u8 type,
 280                               u32 index,
 281                               union acpi_operand_object *object,
 282                               struct acpi_walk_state *walk_state)
 283 {
 284         acpi_status status;
 285         struct acpi_namespace_node *node;
 286
 287         ACPI_FUNCTION_TRACE(ds_method_data_set_value);
 288
 289         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 290                           "NewObj %p Type %2.2X, Refs=%u [%s]\n", object,
 291                           type, object->common.reference_count,
 292                           acpi_ut_get_type_name(object->common.type)));
 293
 294         /* Get the namespace node for the arg/local */
 295
 296         status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
 297         if (ACPI_FAILURE(status)) {
 298                 return_ACPI_STATUS(status);
 299         }
 300
 301         /*
 302          * Increment ref count so object can't be deleted while installed.
 303          * NOTE: We do not copy the object in order to preserve the call by
 304          * reference semantics of ACPI Control Method invocation.
 305          * (See ACPI Specification 2.0C)
 306          */
 307         acpi_ut_add_reference(object);
 308
 309         /* Install the object */
 310
 311         node->object = object;
 312         return_ACPI_STATUS(status);
 313 }
 314
 315 /*******************************************************************************
 316  *
 317  * FUNCTION:    acpi_ds_method_data_get_value
 318  *
 319  * PARAMETERS:  type                - Either ACPI_REFCLASS_LOCAL or
 320  *                                    ACPI_REFCLASS_ARG
 321  *              index               - Which localVar or argument to get
 322  *              walk_state          - Current walk state object
 323  *              dest_desc           - Where Arg or Local value is returned
 324  *
 325  * RETURN:      Status
 326  *
 327  * DESCRIPTION: Retrieve value of selected Arg or Local for this method
 328  *              Used only in acpi_ex_resolve_to_value().
 329  *
 330  ******************************************************************************/
 331
 332 acpi_status
 333 acpi_ds_method_data_get_value(u8 type,
 334                               u32 index,
 335                               struct acpi_walk_state *walk_state,
 336                               union acpi_operand_object **dest_desc)
 337 {
 338         acpi_status status;
 339         struct acpi_namespace_node *node;
 340         union acpi_operand_object *object;
 341
 342         ACPI_FUNCTION_TRACE(ds_method_data_get_value);
 343
 344         /* Validate the object descriptor */
 345
 346         if (!dest_desc) {
 347                 ACPI_ERROR((AE_INFO, "Null object descriptor pointer"));
 348                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 349         }
 350
 351         /* Get the namespace node for the arg/local */
 352
 353         status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
 354         if (ACPI_FAILURE(status)) {
 355                 return_ACPI_STATUS(status);
 356         }
 357
 358         /* Get the object from the node */
 359
 360         object = node->object;
 361
 362         /* Examine the returned object, it must be valid. */
 363
 364         if (!object) {
 365                 /*
 366                  * Index points to uninitialized object.
 367                  * This means that either 1) The expected argument was
 368                  * not passed to the method, or 2) A local variable
 369                  * was referenced by the method (via the ASL)
 370                  * before it was initialized. Either case is an error.
 371                  */
 372
 373                 /* If slack enabled, init the local_x/arg_x to an Integer of value zero */
 374
 375                 if (acpi_gbl_enable_interpreter_slack) {
 376                         object = acpi_ut_create_integer_object((u64) 0);
 377                         if (!object) {
 378                                 return_ACPI_STATUS(AE_NO_MEMORY);
 379                         }
 380
 381                         node->object = object;
 382                 }
 383
 384                 /* Otherwise, return the error */
 385
 386                 else
 387                         switch (type) {
 388                         case ACPI_REFCLASS_ARG:
 389
 390                                 ACPI_ERROR((AE_INFO,
 391                                             "Uninitialized Arg[%u] at node %p",
 392                                             index, node));
 393
 394                                 return_ACPI_STATUS(AE_AML_UNINITIALIZED_ARG);
 395
 396                         case ACPI_REFCLASS_LOCAL:
 397                                 /*
 398                                  * No error message for this case, will be trapped again later to
 399                                  * detect and ignore cases of Store(local_x,local_x)
 400                                  */
 401                                 return_ACPI_STATUS(AE_AML_UNINITIALIZED_LOCAL);
 402
 403                         default:
 404
 405                                 ACPI_ERROR((AE_INFO,
 406                                             "Not a Arg/Local opcode: 0x%X",
 407                                             type));
 408                                 return_ACPI_STATUS(AE_AML_INTERNAL);
 409                         }
 410         }
 411
 412         /*
 413          * The Index points to an initialized and valid object.
 414          * Return an additional reference to the object
 415          */
 416         *dest_desc = object;
 417         acpi_ut_add_reference(object);
 418
 419         return_ACPI_STATUS(AE_OK);
 420 }
 421
 422 /*******************************************************************************
 423  *
 424  * FUNCTION:    acpi_ds_method_data_delete_value
 425  *
 426  * PARAMETERS:  type                - Either ACPI_REFCLASS_LOCAL or
 427  *                                    ACPI_REFCLASS_ARG
 428  *              index               - Which localVar or argument to delete
 429  *              walk_state          - Current walk state object
 430  *
 431  * RETURN:      None
 432  *
 433  * DESCRIPTION: Delete the entry at Opcode:Index. Inserts
 434  *              a null into the stack slot after the object is deleted.
 435  *
 436  ******************************************************************************/
 437
 438 static void
 439 acpi_ds_method_data_delete_value(u8 type,
 440                                  u32 index, struct acpi_walk_state *walk_state)
 441 {
 442         acpi_status status;
 443         struct acpi_namespace_node *node;
 444         union acpi_operand_object *object;
 445
 446         ACPI_FUNCTION_TRACE(ds_method_data_delete_value);
 447
 448         /* Get the namespace node for the arg/local */
 449
 450         status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
 451         if (ACPI_FAILURE(status)) {
 452                 return_VOID;
 453         }
 454
 455         /* Get the associated object */
 456
 457         object = acpi_ns_get_attached_object(node);
 458
 459         /*
 460          * Undefine the Arg or Local by setting its descriptor
 461          * pointer to NULL. Locals/Args can contain both
 462          * ACPI_OPERAND_OBJECTS and ACPI_NAMESPACE_NODEs
 463          */
 464         node->object = NULL;
 465
 466         if ((object) &&
 467             (ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_OPERAND)) {
 468                 /*
 469                  * There is a valid object.
 470                  * Decrement the reference count by one to balance the
 471                  * increment when the object was stored.
 472                  */
 473                 acpi_ut_remove_reference(object);
 474         }
 475
 476         return_VOID;
 477 }
 478
 479 /*******************************************************************************
 480  *
 481  * FUNCTION:    acpi_ds_store_object_to_local
 482  *
 483  * PARAMETERS:  type                - Either ACPI_REFCLASS_LOCAL or
 484  *                                    ACPI_REFCLASS_ARG
 485  *              index               - Which Local or Arg to set
 486  *              obj_desc            - Value to be stored
 487  *              walk_state          - Current walk state
 488  *
 489  * RETURN:      Status
 490  *
 491  * DESCRIPTION: Store a value in an Arg or Local. The obj_desc is installed
 492  *              as the new value for the Arg or Local and the reference count
 493  *              for obj_desc is incremented.
 494  *
 495  ******************************************************************************/
 496
 497 acpi_status
 498 acpi_ds_store_object_to_local(u8 type,
 499                               u32 index,
 500                               union acpi_operand_object *obj_desc,
 501                               struct acpi_walk_state *walk_state)
 502 {
 503         acpi_status status;
 504         struct acpi_namespace_node *node;
 505         union acpi_operand_object *current_obj_desc;
 506         union acpi_operand_object *new_obj_desc;
 507
 508         ACPI_FUNCTION_TRACE(ds_store_object_to_local);
 509         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Type=%2.2X Index=%u Obj=%p\n",
 510                           type, index, obj_desc));
 511
 512         /* Parameter validation */
 513
 514         if (!obj_desc) {
 515                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 516         }
 517
 518         /* Get the namespace node for the arg/local */
 519
 520         status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
 521         if (ACPI_FAILURE(status)) {
 522                 return_ACPI_STATUS(status);
 523         }
 524
 525         current_obj_desc = acpi_ns_get_attached_object(node);
 526         if (current_obj_desc == obj_desc) {
 527                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p already installed!\n",
 528                                   obj_desc));
 529                 return_ACPI_STATUS(status);
 530         }
 531
 532         /*
 533          * If the reference count on the object is more than one, we must
 534          * take a copy of the object before we store. A reference count
 535          * of exactly 1 means that the object was just created during the
 536          * evaluation of an expression, and we can safely use it since it
 537          * is not used anywhere else.
 538          */
 539         new_obj_desc = obj_desc;
 540         if (obj_desc->common.reference_count > 1) {
 541                 status =
 542                     acpi_ut_copy_iobject_to_iobject(obj_desc, &new_obj_desc,
 543                                                     walk_state);
 544                 if (ACPI_FAILURE(status)) {
 545                         return_ACPI_STATUS(status);
 546                 }
 547         }
 548
 549         /*
 550          * If there is an object already in this slot, we either
 551          * have to delete it, or if this is an argument and there
 552          * is an object reference stored there, we have to do
 553          * an indirect store!
 554          */
 555         if (current_obj_desc) {
 556                 /*
 557                  * Check for an indirect store if an argument
 558                  * contains an object reference (stored as an Node).
 559                  * We don't allow this automatic dereferencing for
 560                  * locals, since a store to a local should overwrite
 561                  * anything there, including an object reference.
 562                  *
 563                  * If both Arg0 and Local0 contain ref_of (Local4):
 564                  *
 565                  * Store (1, Arg0)             - Causes indirect store to local4
 566                  * Store (1, Local0)           - Stores 1 in local0, overwriting
 567                  *                                  the reference to local4
 568                  * Store (1, de_refof (Local0)) - Causes indirect store to local4
 569                  *
 570                  * Weird, but true.
 571                  */
 572                 if (type == ACPI_REFCLASS_ARG) {
 573                         /*
 574                          * If we have a valid reference object that came from ref_of(),
 575                          * do the indirect store
 576                          */
 577                         if ((ACPI_GET_DESCRIPTOR_TYPE(current_obj_desc) ==
 578                              ACPI_DESC_TYPE_OPERAND) &&
 579                             (current_obj_desc->common.type ==
 580                              ACPI_TYPE_LOCAL_REFERENCE) &&
 581                             (current_obj_desc->reference.class ==
 582                              ACPI_REFCLASS_REFOF)) {
 583                                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 584                                                   "Arg (%p) is an ObjRef(Node), storing in node %p\n",
 585                                                   new_obj_desc,
 586                                                   current_obj_desc));
 587
 588                                 /*
 589                                  * Store this object to the Node (perform the indirect store)
 590                                  * NOTE: No implicit conversion is performed, as per the ACPI
 591                                  * specification rules on storing to Locals/Args.
 592                                  */
 593                                 status =
 594                                     acpi_ex_store_object_to_node(new_obj_desc,
 595                                                                  current_obj_desc->
 596                                                                  reference.
 597                                                                  object,
 598                                                                  walk_state,
 599                                                                  ACPI_NO_IMPLICIT_CONVERSION);
 600
 601                                 /* Remove local reference if we copied the object above */
 602
 603                                 if (new_obj_desc != obj_desc) {
 604                                         acpi_ut_remove_reference(new_obj_desc);
 605                                 }
 606
 607                                 return_ACPI_STATUS(status);
 608                         }
 609                 }
 610
 611                 /* Delete the existing object before storing the new one */
 612
 613                 acpi_ds_method_data_delete_value(type, index, walk_state);
 614         }
 615
 616         /*
 617          * Install the Obj descriptor (*new_obj_desc) into
 618          * the descriptor for the Arg or Local.
 619          * (increments the object reference count by one)
 620          */
 621         status =
 622             acpi_ds_method_data_set_value(type, index, new_obj_desc,
 623                                           walk_state);
 624
 625         /* Remove local reference if we copied the object above */
 626
 627         if (new_obj_desc != obj_desc) {
 628                 acpi_ut_remove_reference(new_obj_desc);
 629         }
 630
 631         return_ACPI_STATUS(status);
 632 }
 633
 634 #ifdef ACPI_OBSOLETE_FUNCTIONS
 635 /*******************************************************************************
 636  *
 637  * FUNCTION:    acpi_ds_method_data_get_type
 638  *
 639  * PARAMETERS:  opcode              - Either AML_FIRST LOCAL_OP or
 640  *                                    AML_FIRST_ARG_OP
 641  *              index               - Which Local or Arg whose type to get
 642  *              walk_state          - Current walk state object
 643  *
 644  * RETURN:      Data type of current value of the selected Arg or Local
 645  *
 646  * DESCRIPTION: Get the type of the object stored in the Local or Arg
 647  *
 648  ******************************************************************************/
 649
 650 acpi_object_type
 651 acpi_ds_method_data_get_type(u16 opcode,
 652                              u32 index, struct acpi_walk_state *walk_state)
 653 {
 654         acpi_status status;
 655         struct acpi_namespace_node *node;
 656         union acpi_operand_object *object;
 657
 658         ACPI_FUNCTION_TRACE(ds_method_data_get_type);
 659
 660         /* Get the namespace node for the arg/local */
 661
 662         status = acpi_ds_method_data_get_node(opcode, index, walk_state, &node);
 663         if (ACPI_FAILURE(status)) {
 664                 return_VALUE((ACPI_TYPE_NOT_FOUND));
 665         }
 666
 667         /* Get the object */
 668
 669         object = acpi_ns_get_attached_object(node);
 670         if (!object) {
 671
 672                 /* Uninitialized local/arg, return TYPE_ANY */
 673
 674                 return_VALUE(ACPI_TYPE_ANY);
 675         }
 676
 677         /* Get the object type */
 678
 679         return_VALUE(object->type);
 680 }
 681 #endif