#ifdef _ACPI_ASL_COMPILER 
#ifdef ACPI_ASL_COMPILER 
acpi_ds_load2_begin_op (	struct acpi_walk_state          *walk_state,	union acpi_parse_object         **out_op){	union acpi_parse_object         *op;	struct acpi_namespace_node      *node;	acpi_status                     status;	acpi_object_type                object_type;	char                            *buffer_ptr;	ACPI_FUNCTION_TRACE ("ds_load2_begin_op");	op = walk_state->op;	ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));	if (op) {		if ((walk_state->control_state) &&			(walk_state->control_state->common.state ==				ACPI_CONTROL_CONDITIONAL_EXECUTING)) {			/* We are executing a while loop outside of a method */			status = acpi_ds_exec_begin_op (walk_state, out_op);			return_ACPI_STATUS (status);		}		/* We only care about Namespace opcodes here */		if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&			  (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||			(!(walk_state->op_info->flags & AML_NAMED))) {			if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||				(walk_state->op_info->class == AML_CLASS_CONTROL)) {				ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,					"Begin/EXEC: %s (fl %8.8X)\n", walk_state->op_info->name,					walk_state->op_info->flags));				/* Executing a type1 or type2 opcode outside of a method */				status = acpi_ds_exec_begin_op (walk_state, out_op);				return_ACPI_STATUS (status);			}			return_ACPI_STATUS (AE_OK);		}		/* Get the name we are going to enter or lookup in the namespace */		if (walk_state->opcode == AML_INT_NAMEPATH_OP) {			/* For Namepath op, get the path string */			buffer_ptr = op->common.value.string;			if (!buffer_ptr) {				/* No name, just exit */				return_ACPI_STATUS (AE_OK);			}		}		else {			/* Get name from the op */			buffer_ptr = (char *) &op->named.name;		}	}	else {		/* Get the namestring from the raw AML */		buffer_ptr = acpi_ps_get_next_namestring (&walk_state->parser_state);	}	/* Map the opcode into an internal object type */	object_type = walk_state->op_info->object_type;	ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,		"State=%p Op=%p Type=%X\n", walk_state, op, object_type));	switch (walk_state->opcode) {	case AML_FIELD_OP:	case AML_BANK_FIELD_OP:	case AML_INDEX_FIELD_OP:		node = NULL;		status = AE_OK;		break;	case AML_INT_NAMEPATH_OP:		/*		 * The name_path is an object reference to an existing object.		 * Don't enter the name into the namespace, but look it up		 * for use later.		 */		status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,				  ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,				  walk_state, &(node));		break;	case AML_SCOPE_OP:		/*		 * The Path is an object reference to an existing object.		 * Don't enter the name into the namespace, but look it up		 * for use later.		 */		status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,				  ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,				  walk_state, &(node));		if (ACPI_FAILURE (status)) {#ifdef _ACPI_ASL_COMPILER			if (status == AE_NOT_FOUND) {				status = AE_OK;			}			else {				ACPI_REPORT_NSERROR (buffer_ptr, status);			}#else			ACPI_REPORT_NSERROR (buffer_ptr, status);#endif			return_ACPI_STATUS (status);		}		/*		 * We must check to make sure that the target is		 * one of the opcodes that actually opens a scope		 */		switch (node->type) {		case ACPI_TYPE_LOCAL_SCOPE:         /* Scope */		case ACPI_TYPE_DEVICE:		case ACPI_TYPE_POWER:		case ACPI_TYPE_PROCESSOR:		case ACPI_TYPE_THERMAL:			/* These are acceptable types */			break;		case ACPI_TYPE_INTEGER:		case ACPI_TYPE_STRING:		case ACPI_TYPE_BUFFER:			/*			 * These types we will allow, but we will change the type.  This			 * enables some existing code of the form:			 *			 *  Name (DEB, 0)			 *  Scope (DEB) { ... }			 */			ACPI_REPORT_WARNING ((				"Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",				buffer_ptr, acpi_ut_get_type_name (node->type)));			node->type = ACPI_TYPE_ANY;			walk_state->scope_info->common.value = ACPI_TYPE_ANY;			break;		default:			/* All other types are an error */			ACPI_REPORT_ERROR ((				"Invalid type (%s) for target of Scope operator [%4.4s]\n",				acpi_ut_get_type_name (node->type), buffer_ptr));			return (AE_AML_OPERAND_TYPE);		}		break;	default:		/* All other opcodes */		if (op && op->common.node) {			/* This op/node was previously entered into the namespace */			node = op->common.node;			if (acpi_ns_opens_scope (object_type)) {				status = acpi_ds_scope_stack_push (node, object_type, walk_state);				if (ACPI_FAILURE (status)) {					return_ACPI_STATUS (status);				}			}			return_ACPI_STATUS (AE_OK);		}		/*		 * Enter the named type into the internal namespace.  We enter the name		 * as we go downward in the parse tree.  Any necessary subobjects that		 * involve arguments to the opcode must be created as we go back up the		 * parse tree later.		 *		 * Note: Name may already exist if we are executing a deferred opcode.		 */		if (walk_state->deferred_node) {			/* This name is already in the namespace, get the node */			node = walk_state->deferred_node;			status = AE_OK;			break;		}		/* Add new entry into namespace */		status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,				  ACPI_IMODE_LOAD_PASS2, ACPI_NS_NO_UPSEARCH,				  walk_state, &(node));		break;	}	if (ACPI_FAILURE (status)) {		ACPI_REPORT_NSERROR (buffer_ptr, status);		return_ACPI_STATUS (status);	}	if (!op) {		/* Create a new op */		op = acpi_ps_alloc_op (walk_state->opcode);		if (!op) {			return_ACPI_STATUS (AE_NO_MEMORY);		}		/* Initialize the new op */		if (node) {			op->named.name = node->name.integer;		}		*out_op = op;	}	/*	 * Put the Node in the "op" object that the parser uses, so we	 * can get it again quickly when this scope is closed	 */	op->common.node = node;	return_ACPI_STATUS (status);}
10457	/local/tlutelli/issta_data/temp/c/2005_temp/2005/10457/73459f73e5d1602c59ebec114fc45185521353c1/dswload.c/buggy/drivers/acpi/dispatcher/dswload.c