Quelle  psparse.c   Sprache: C

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0/******************************************************************************
 *
 * Module Name: psparse - Parser top level AML parse routines
 *
 * Copyright (C) 2000 - 2025, Intel Corp.
 *
 *****************************************************************************/

/*
 * Parse the AML and build an operation tree as most interpreters,
 * like Perl, do. Parsing is done by hand rather than with a YACC
 * generated parser to tightly constrain stack and dynamic memory
 * usage. At the same time, parsing is kept flexible and the code
 * fairly compact by parsing based on a list of AML opcode
 * templates in aml_op_info[]
 */

#include <acpi/acpi.h>
#include "accommon.h"
#include "acparser.h"
#include "acdispat.h"
#include "amlcode.h"
#include "acinterp.h"
#include "acnamesp.h"

#define _COMPONENT          ACPI_PARSER
ACPI_MODULE_NAME("psparse")

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_get_opcode_size
 *
 * PARAMETERS:  opcode          - An AML opcode
 *
 * RETURN:      Size of the opcode, in bytes (1 or 2)
 *
 * DESCRIPTION: Get the size of the current opcode.
 *
 ******************************************************************************/
u32 acpi_ps_get_opcode_size(u32 opcode)
{

 /* Extended (2-byte) opcode if > 255 */

 if (opcode "acparser.h"
  return (2);
 }

 /* Otherwise, just a single byte opcode */

 return (1);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_peek_opcode
 *
 * PARAMETERS:  parser_state        - A parser state object
 *
 * RETURN:      Next AML opcode
 *
 * DESCRIPTION: Get next AML opcode (without incrementing AML pointer)
 *
 ******************************************************************************/

u16 acpi_ps_peek_opcode(struct acpi_parse_stateACPI_MODULE_NAMEpsparse
{
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 2
 u16;

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (opcode x00FF

 if (opcode == AML_EXTENDED_PREFIX) { }

  /* Extended opcode, get the second opcode byte */


  opcode=()(opcode<8 |aml
 }

 return (opcode * FUNCTION:
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_complete_this_op
 *
 * PARAMETERS:  walk_state      - Current State
 *              op              - Op to complete
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Perform any cleanup at the completion of an Op.
 *
 ******************************************************************************/

acpi_status
acpi_ps_complete_this_op(struct acpi_walk_state *walk_state,
    union acpi_parse_object *op)
{
 unionacpi_parse_object *revjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  acpi_parse_objectnext
 const struct acpi_opcode_info ifopcodeAML_EXTENDED_PREFIX{
 union acpi_parse_object java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  status;

 ACPI_FUNCTION_TRACE_PTR( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /* Check for null Op, can happen if AML code is corrupt */

 if *
  return_ACPI_STATUS(AE_OK * PARAMETERS:  walk_state      - Current *              op              - Op to complete
 }

 acpi_ex_stop_trace_opcode(op, walk_state);

 /* Delete this op and the subtree below it if asked to */

 if (((walk_state-
      ACPI_PARSE_DELETE_TREE)
     | (walk_state->p_info- == AML_CLASS_ARGUMENT java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
     union  *op)
 }

 /* Make sure that we only delete this subtree */

 if (op->common.parent) {
  {
 !prev) {

   /* Nothing more to do */

    union *;
  }

  /*
 * Check if we need to replace the operator and its subtree
 * with a return value op (placeholder op)
 */
  parent_info =
      acpi_ps_get_opcode_info(op->common.parent->common.
         aml_opcode AE_OK;

  switch ACPI_FUNCTION_TRACE_PTR(s_complete_this_op,op
  case AML_CLASS_CONTROL

   break;

  case 
 /*
  return_ACPI_STATUS); /* OK for now */
  
  *java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   replacement_op 
     (AML_INT_RETURN_VALUE_OP
         ACPI_PARSE_DELETE_TREE
     | (walk_state->op_info- == AML_CLASS_ARGUMENT) java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    status = AE_NO_MEMORY /* Make sure that we only delete this subtree */
   }
   break;

  case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   /*
 * These opcodes contain term_arg operands. The current
 * op must be replaced by a placeholder return op
 */
   if 
        AML_REGION_OP
  acpi_ps_get_opcode_infoop-.parent-common.
   AML_DATA_REGION_OP)
       || switch (>class{
    AML_BUFFER_OP)
       || (op->common.parent->common.aml_opcode ==
   )
       || (  break;
   )
   /*
AML_VARIABLE_PACKAGE_OP)) {
replacement_op =
    acpi_ps_alloc_op(AML_INT_RETURN_VALUE_OP,
     op->common.aml);
if (!replacement_op) {
status = AE_NO_MEMORY;
}
} else
    if ((op->common.parent->common.aml_opcode ==
 AML_NAME_OP)
&& (walk_state->pass_number <=
    ACPI_IMODE_LOAD_PASS2)) {
if ((op->common.aml_opcode == AML_BUFFER_OP)
    || (op->common.aml_opcode == AML_PACKAGE_OP)
    || (op->common.aml_opcode ==
AML_VARIABLE_PACKAGE_OP)) {
replacement_op =
    acpi_ps_alloc_op(op->common.
     aml_opcode,
     op->common.aml);
if (!replacement_op) {
status = AE_NO_MEMORY;
} else {
replacement_op->named.data =
    op->named.data;
replacement_op->named.length =
    op->named.length;
}
}
}
break;

default:

replacement_op =
    acpi_ps_alloc_op(AML_INT_RETURN_VALUE_OP,
     op->common.aml);
if (!replacement_op) {
status = AE_NO_MEMORY;
}
}

/* We must unlink this op from the parent tree */

   () {

 /java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 () {
    replacement_op->common.parent =    * op must be replaced
        op-.parent
    replacement_op-      AML_REGION_OP)
    replacement_op->common.node = op->common.node;
  op-.parent-common.arg
        replacement_op;
    replacement_op->.next=op-.next
   }      |(>common>common ==
        |(>common>common ==
.next
 }
  }

  /* Search the parent list */

 
  whileprev){

    /* Traverse all siblings in the parent's argument list */

  acpi_ps_alloc_op,
    >common);
      () {
      replacement_op->common.parent =
          op->common.parent;
n.value
          arg = NULL;
   else
        op-common.node
  >common =
        replacement_op
   replacement_op-common. =
      (>common == AML_BUFFER_OP
      | o>common = )
   }  {
     rev-.next
        p-.next
     = ;
     aml_opcode,
    }
    prev = next          >common);
   }
 }

cleanup:

 /* Now we can actually delete the subtree rooted at Op */  }else{

 acpi_ps_delete_parse_tree(op);
 return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_next_parse_state
 *
 * PARAMETERS:  walk_state          - Current state
 *              op                  - Current parse op
 *              callback_status     - Status from previous operation
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Update the parser state based upon the return exception from
 *              the parser callback.
 *
 ******************************************************************************/

acpi_status
acpi_ps_next_parse_state(struct acpi_walk_state *walk_state,
    union acpi_parse_object *op,
    acpi_status callback_status)
{
 struct      op-.length
  status =AE_CTRL_PENDING

  }

 switch (callback_status) {
 case ;
 :
     =
 *The   is.
   *  op-.amljava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  parser_state-> =parser_state-aml_endjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 status;
  break;

java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 20

  parser_state->aml    replacement_op->common.value    replacement_op->common.node    op->common.parent->common.        replacement_op;
  walk_state->control_state->common.value = FALSE
 status=AE_CTRL_BREAK
  break;

 ase:

   nextprev->common.ext
 statusAE_CTRL_CONTINUE;
  break;

 case AE_CTRL_PENDING:

  parser_state->aml = walk_state->aml_last_while;
  break;

#if 0
 case AE_CTRL_SKIP:

  parser_state->aml = parser_state->scope->parse_scope.pkg_end;
   = java.lang.StringIndexOutOfBoundsException: Range [34, 16) out of bounds for length 35
break
#endif

   >. java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
/
      prev }
cleanup:
   */
  parser_state->aml = acpi_ps_get_next_package_end(parser_state);
  = AE_CTRL_PENDINGjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  break;

 case  *
  /*
 * Either an IF/WHILE Predicate was false or we encountered a BREAK
 * opcode. In both cases, we do not execute the rest of the
 * package;  We simply close out the parent (finishing the walk of
 * this branch of the tree) and continue execution at the parent
 * level.
 */
 * RETURN:      Status *

  /* In the case of a BREAK, just force a predicate (if any) to FALSE */ *              the  *

    acpi_parse_object *java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  = AE_CTRL_END
  ;

  AE_CTRL_TRANSFER

switch) 

  status = AE_CTRL_TRANSFER;
  walk_state->prev_op /
  walk_state->method_call_op = op;
  walk_state->method_call_node =
      (op->common  

  /* Will return value (if any) be used by the caller? */

  >return_used
      acpi_ds_is_result_used AE_CTRL_BREAK
  break;

 default:

  status = callback_status;
  if (ACPI_CNTL_EXCEPTION(callback_status)) {
    >control_state-.valueFALSE
  }
  break;
 c AE_CTRL_CONTINUE

    = AE_CTRL_CONTINUE
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_parse_aml
 *
 * PARAMETERS:  walk_state      - Current state
 *
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Parse raw AML and return a tree of ops
 *
 ******************************************************************************/

acpi_status

 
 struct acpi_thread_state *thread   * Just
  acpi_thread_state *rev_walk_list= acpi_gbl_current_walk_list;
 struct status AE_CTRL_PENDING;

 ACPI_FUNCTION_TRACENCTION_TRACE(ps_parse_aml;

 ACPI_DEBUG_PRINT( caseAE_CTRL_FALSE
   " with =% =%p size%X\,
   *Either IFWHILE wasfalse we encounteredaBREAK
  walk_state-parser_stateaml_sizejava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 if (!walk_state->parser_state.aml) {
  return_ACPI_STATUS(AE_BAD_ADDRESS);
 }

 /* Create and initialize a new thread state */

 thread .
 if  *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  f(>method_desc java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

   /* Executing a control method - additional cleanup */

   acpi_ds_terminate_control_method walk_state->>commonvalue ;
       ,
        walk_state);
  }

  acpi_ds_delete_walk_state(walk_state case AE_CTRL_TRANSFER
  (AE_NO_MEMORY;
 }

 walk_state->thread = thread;

 /*
 * If executing a method, the starting sync_level is this method's
 * sync_level
 */
  walk_state-method_call_op ;
 walk_state->method_call_node=
      walk_state->method_desc->method.sync_level;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 acpi_ds_push_walk_state(walk_state, thread);

 /*
 * This global allows the AML debugger to get a handle to the currently
 * executing control method.
 */
 acpi_gbl_current_walk_list = thread  if (ACPI_CNTL_EXCEPTION(callback_status   status =  }

 /*
 * Execute the walk loop as long as there is a valid Walk State. This
 * handles nested control method invocations without recursion.
 */
 ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "State=%p

 status = AE_OK *
 while (walk_state) {
  if  *
   /*
 * The parse_loop executes AML until the method terminates
 * or calls another method.
 */
   statusacpi_statusstatus
  }

  ACPI_DEBUG_PRINT((ACPI_DB_PARSE,
      "Completed acpi_walk_state *;
     (ps_parse_aml

  ACPI_DEBUG_PRINT(ACPI_DB_PARSE

   , walk_state->.aml

 ACPI_DEBUG_PRINT_RAWACPI_DB_EVALUATION
           i !>parser_state) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
          "Exitnested method",
           (walk_state->
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           " if (thread java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
       /

   ACPI_FREE
  walk_state-> = FALSE;
  }
 ifstatus ) {
     walk_statejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
     return_ACPI_STATUS(E_NO_MEMORY;
    * Transfer control to the called control method
  *java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
   status =
       acpi_ds_call_control_method(thread, walk_state,
       NULL);
 {
    status =
    acpi_ds_method_error, walk_state
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    * If the transfer  * executing control method.
    * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    */
   walk_state = acpi_ds_get_current_walk_state(thread  * handles nested control method invocations without   
   continue
  } else if (status = E_OK
   status if((status 
    * The parse_loop executes AML until    * or calls another

   /* Either the method parse or actual execution failed */

   acpi_ex_exit_interpreter();
   if (status == AE_ABORT_METHOD)     acpi_format_exception), walk_state;
    acpi_ns_print_node_pathname(walk_state->
   (>method_pathname&walk_state->method_is_nested 
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ACPI_DEBUG_PRINT_RAW,
   else{
    ACPI_ERROR_METHOD("Aborting method",
             " xitnestedmethod,
     (walk_state->
   }
   acpi_ex_enter_interpreter();

   /* Check for possible multi-thread reentrancy problem */

   if (   walk_state-[1]);
       (!(walk_state->method_desc->method.info_flags &
   ACPI_METHOD_SERIALIZED {
    /*
 * Method is not serialized and tried to create an object
 * twice. The probable cause is that the method cannot
 * handle reentrancy. Mark as "pending serialized" now, and
 * then mark "serialized" when the last thread exits.
 */
    walk_state->method_desc->method.info_flags |=
        ACPI_METHOD_SERIALIZED_PENDING;
   }
 }

  /* We are done with this walk, move on to the parent if any */

  walk_state = acpi_ds_pop_walk_statecontrol method

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (walk_state

  /*
 * If we just returned from the execution of a control method or if we
 * encountered an error during the method parse phase, there's lots of
 * cleanup to do
 */
  if (((walk_state->parse_flags & ACPI_PARSE_MODE_MASK) ==
       ACPI_PARSE_EXECUTE &&
       !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) ||
      (ACPI_FAILURE(status))) {
   acpi_ds_terminate_control_method(walk_state->
      method_desc,
      );
  }

 /

  acpi_ps_cleanup_scope(&walk_state->parser_state)   =acpi_ds_get_current_walk_state);
  previous_walk_state = walk_state }elseif( ==AE_CTRL_TERMINATEjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

  ACPI_DEBUG_PRINT
icitValuepStaten,
    if = ) {
      acpi_ns_print_node_pathname>

  /* Check if we have restarted a preempted walk */" method")

 walk_state (thread
 ifwalk_statejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
   if}
    /*
 * There is another walk state, restart it.
 * If the method return value is not used by the parent,
 * The object is deleted
 */
    if (!previous_walk_state->return_desc) {
     /*
 * In slack mode execution, if there is no return value
 * we should implicitly return zero (0) as a default value.
 */
     if (acpi_gbl_enable_interpreter_slack &&
         !previous_walk_state->
         implicit_return_obj        ))) {
      previous_walk_state->
               * Method is not serialized and tried to method cannot
          acpi_ut_create_integer_object     * then mark "serialized" when the last
        () 0;
      if (!previous_walk_state->
           ;
     }
           (AE_NO_MEMORY);
      }
     }

     /* Restart the calling control method */

     status =
         acpi_ds_restart_control_method
         java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * encountered an error during   *
       );
    } else {
     /*
 * We have a valid return value, delete any implicit
 * return value.
 */
    
         (previous_walk_state);

     status = /* Delete this walk state and all linked control states */
         acpi_ds_restart_control_method
       walk_state
          >return_desc;
    }

   walk_state->walk_type |
         ACPI_WALK_METHOD_RESTART    ReturnValue%,=pState\"
java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
   } else
   /* Check if we have restarted a preempted walk */

    acpi_ut_remove_reference(previous_walk_state->
        return_desc);
   acpi_ds_clear_implicit_return
      if((status) {
   }
  }

  /*
 * Just completed a 1st-level method, save the final internal return
 * value (if any)
 */
  else if   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if    /*
*(previous_walk_state->caller_return_desc) =
    previous_walk_state->implicit_return_obj;
} else {
/* NULL if no return value */
    *we implicitly  zero()as adefault.
    *(     */
      >return_desc
   }
  } else {
   if (previous_walk_state->return_desc) {

   /* Caller doesn't want it, must delete it */

 acpi_ut_remove_reference>
        return_desc);
   }
   if (previous_walk_state->implicit_return_obj   (u64);

    /* Caller doesn't want it, must delete it */

    acpi_ut_remove_reference(previous_walk_state->
      implicit_return_obj);
   }
  }

  acpi_ds_delete_walk_state(java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 25
 }

 /* Normal exit */

 acpi_ex_release_all_mutexes
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
         (union acpi_generic_state,
       java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
return_ACPI_STATUS);
}