1 files changed, 20 insertions, 20 deletions

diff --git a/source/compiler/aslfold.c b/source/compiler/aslfold.c
index 27090a229756..511db575bc6f 100644
--- a/source/compiler/aslfold.c
+++ b/source/compiler/aslfold.c
@@ -232,8 +232,8 @@ OpcAmlConstantWalk (
      * Only interested in subtrees that could possibly contain
      * expressions that can be evaluated at this time
      */
-    if ((!(Op->Asl.CompileFlags & NODE_COMPILE_TIME_CONST)) ||
-          (Op->Asl.CompileFlags & NODE_IS_TARGET))
+    if ((!(Op->Asl.CompileFlags & OP_COMPILE_TIME_CONST)) ||
+          (Op->Asl.CompileFlags & OP_IS_TARGET))
     {
         return (AE_OK);
     }
@@ -412,7 +412,7 @@ OpcAmlCheckForConstant (
         {
             /* Error if there is a target operand */
 
-            if (Op->Asl.CompileFlags & NODE_IS_TARGET)
+            if (Op->Asl.CompileFlags & OP_IS_TARGET)
             {
                 AslError (ASL_ERROR, ASL_MSG_INVALID_TARGET, Op, NULL);
                 Status = AE_TYPE;
@@ -420,11 +420,11 @@ OpcAmlCheckForConstant (
 
             /* Error if expression cannot be reduced (folded) */
 
-            if (!(NextOp->Asl.CompileFlags & NODE_COULD_NOT_REDUCE))
+            if (!(NextOp->Asl.CompileFlags & OP_COULD_NOT_REDUCE))
             {
                 /* Ensure only one error message per statement */
 
-                NextOp->Asl.CompileFlags |= NODE_COULD_NOT_REDUCE;
+                NextOp->Asl.CompileFlags |= OP_COULD_NOT_REDUCE;
                 DbgPrint (ASL_PARSE_OUTPUT,
                     "**** Could not reduce operands for NAME opcode ****\n");
 
@@ -441,7 +441,7 @@ OpcAmlCheckForConstant (
 
         /* This is not a 3/4/5 opcode, but maybe can convert to STORE */
 
-        if (Op->Asl.CompileFlags & NODE_IS_TARGET)
+        if (Op->Asl.CompileFlags & OP_IS_TARGET)
         {
             DbgPrint (ASL_PARSE_OUTPUT,
                 "**** Valid Target, transform to Store ****\n");
@@ -484,7 +484,7 @@ OpcAmlCheckForConstant (
 
     DbgPrint (ASL_PARSE_OUTPUT, "TYPE_345");
 
-    if (Op->Asl.CompileFlags & NODE_IS_TARGET)
+    if (Op->Asl.CompileFlags & OP_IS_TARGET)
     {
         if (Op->Asl.ParseOpcode == PARSEOP_ZERO)
         {
@@ -496,7 +496,7 @@ OpcAmlCheckForConstant (
         }
     }
 
-    if (Op->Asl.CompileFlags & NODE_IS_TERM_ARG)
+    if (Op->Asl.CompileFlags & OP_IS_TERM_ARG)
     {
         DbgPrint (ASL_PARSE_OUTPUT, "%-16s", " TERMARG");
     }
@@ -505,7 +505,7 @@ CleanupAndExit:
 
     /* Dump the node compile flags also */
 
-    TrPrintNodeCompileFlags (Op->Asl.CompileFlags);
+    TrPrintOpFlags (Op->Asl.CompileFlags, ASL_PARSE_OUTPUT);
     DbgPrint (ASL_PARSE_OUTPUT, "\n");
     return (Status);
 }
@@ -543,7 +543,7 @@ TrSimpleConstantReduction (
 
     /* Allocate a new temporary root for this subtree */
 
-    RootOp = TrAllocateNode (PARSEOP_INTEGER);
+    RootOp = TrAllocateOp (PARSEOP_INTEGER);
     if (!RootOp)
     {
         return (AE_NO_MEMORY);
@@ -654,7 +654,7 @@ TrTransformToStoreOp (
      * Create a NULL (zero) target so that we can use the
      * interpreter to evaluate the expression.
      */
-    NewTarget = TrCreateNullTarget ();
+    NewTarget = TrCreateNullTargetOp ();
     NewTarget->Common.AmlOpcode = AML_INT_NAMEPATH_OP;
 
     /* Handle one-operand cases (NOT, TOBCD, etc.) */
@@ -670,7 +670,7 @@ TrTransformToStoreOp (
     Child2->Asl.Next = NewTarget;
     NewTarget->Asl.Parent = OriginalTarget->Asl.Parent;
 
-    NewParent = TrAllocateNode (PARSEOP_INTEGER);
+    NewParent = TrAllocateOp (PARSEOP_INTEGER);
     NewParent->Common.AmlOpcode = AML_INT_EVAL_SUBTREE_OP;
 
     OriginalParent = Op->Common.Parent;
@@ -799,12 +799,12 @@ TrInstallReducedConstant (
          */
         Op->Asl.ParseOpcode = PARSEOP_BUFFER;
         Op->Common.AmlOpcode = AML_BUFFER_OP;
-        Op->Asl.CompileFlags = NODE_AML_PACKAGE;
+        Op->Asl.CompileFlags = OP_AML_PACKAGE;
         UtSetParseOpName (Op);
 
         /* Child node is the buffer length */
 
-        LengthOp = TrAllocateNode (PARSEOP_INTEGER);
+        LengthOp = TrAllocateOp (PARSEOP_INTEGER);
 
         LengthOp->Asl.AmlOpcode = AML_DWORD_OP;
         LengthOp->Asl.Value.Integer = ObjDesc->Buffer.Length;
@@ -815,7 +815,7 @@ TrInstallReducedConstant (
 
         /* Next child is the raw buffer data */
 
-        DataOp = TrAllocateNode (PARSEOP_RAW_DATA);
+        DataOp = TrAllocateOp (PARSEOP_RAW_DATA);
         DataOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
         DataOp->Asl.AmlLength = ObjDesc->Buffer.Length;
         DataOp->Asl.Value.String = (char *) ObjDesc->Buffer.Pointer;
@@ -863,25 +863,25 @@ OpcUpdateIntegerNode (
     {
     case 1:
 
-        TrUpdateNode (PARSEOP_BYTECONST, Op);
+        TrSetOpIntegerValue (PARSEOP_BYTECONST, Op);
         Op->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
         break;
 
     case 2:
 
-        TrUpdateNode (PARSEOP_WORDCONST, Op);
+        TrSetOpIntegerValue (PARSEOP_WORDCONST, Op);
         Op->Asl.AmlOpcode = AML_RAW_DATA_WORD;
         break;
 
     case 4:
 
-        TrUpdateNode (PARSEOP_DWORDCONST, Op);
+        TrSetOpIntegerValue (PARSEOP_DWORDCONST, Op);
         Op->Asl.AmlOpcode = AML_RAW_DATA_DWORD;
         break;
 
     case 8:
 
-        TrUpdateNode (PARSEOP_QWORDCONST, Op);
+        TrSetOpIntegerValue (PARSEOP_QWORDCONST, Op);
         Op->Asl.AmlOpcode = AML_RAW_DATA_QWORD;
         break;
 
@@ -889,7 +889,7 @@ OpcUpdateIntegerNode (
     default:
 
         OpcSetOptimalIntegerSize (Op);
-        TrUpdateNode (PARSEOP_INTEGER, Op);
+        TrSetOpIntegerValue (PARSEOP_INTEGER, Op);
         break;
     }