jdk8-mips64-public/hotspot: src/share/vm/adlc/adlparse.cpp@98cb887364d3 (annotated)

src/share/vm/adlc/adlparse.cpp@98cb887364d3 (annotated)

src/share/vm/adlc/adlparse.cpp

Fri, 27 Feb 2009 13:27:09 -0800

author: twisti
date: Fri, 27 Feb 2009 13:27:09 -0800
changeset 1040: 98cb887364d3
parent 1038: dbbe28fc66b5
child 1063: 7bb995fbd3c0
permissions: -rw-r--r--

6810672: Comment typos
Summary: I have collected some typos I have found while looking at the code.
Reviewed-by: kvn, never

 /*
  * Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  *
  */
 // ADLPARSE.CPP - Architecture Description Language Parser
 // Authors: Chris Vick and Mike Paleczny
 #include "adlc.hpp"
 //----------------------------ADLParser----------------------------------------
 // Create a new ADL parser
 ADLParser::ADLParser(FileBuff& buffer, ArchDesc& archDesc)
   : _buf(buffer), _AD(archDesc),
     _globalNames(archDesc.globalNames()) {
   _AD._syntax_errs = _AD._semantic_errs = 0; // No errors so far this file
   _AD._warnings    = 0;                      // No warnings either
   _curline         = _ptr = NULL;            // No pointers into buffer yet
   _preproc_depth = 0;
   _preproc_not_taken = 0;
   // Delimit command-line definitions from in-file definitions:
   _AD._preproc_list.add_signal();
 }
 //------------------------------~ADLParser-------------------------------------
 // Delete an ADL parser.
 ADLParser::~ADLParser() {
   if (!_AD._quiet_mode)
     fprintf(stderr,"---------------------------- Errors and Warnings ----------------------------\n");
 #ifndef ASSERT
   fprintf(stderr, "**************************************************************\n");
   fprintf(stderr, "***** WARNING: ASSERT is undefined, assertions disabled. *****\n");
   fprintf(stderr, "**************************************************************\n");
 #endif
   if( _AD._syntax_errs + _AD._semantic_errs + _AD._warnings == 0 ) {
     if (!_AD._quiet_mode)
       fprintf(stderr,"No errors or warnings to report from phase-1 parse.\n" );
   }
   else {
     if( _AD._syntax_errs ) {      // Any syntax errors?
       fprintf(stderr,"%s:  Found %d syntax error", _buf._fp->_name, _AD._syntax_errs);
       if( _AD._syntax_errs > 1 ) fprintf(stderr,"s.\n\n");
       else fprintf(stderr,".\n\n");
     }
     if( _AD._semantic_errs ) {    // Any semantic errors?
       fprintf(stderr,"%s:  Found %d semantic error", _buf._fp->_name, _AD._semantic_errs);
       if( _AD._semantic_errs > 1 ) fprintf(stderr,"s.\n\n");
       else fprintf(stderr,".\n\n");
     }
     if( _AD._warnings ) {         // Any warnings?
       fprintf(stderr,"%s:  Found %d warning", _buf._fp->_name, _AD._warnings);
       if( _AD._warnings > 1 ) fprintf(stderr,"s.\n\n");
       else fprintf(stderr,".\n\n");
     }
   }
   if (!_AD._quiet_mode)
     fprintf(stderr,"-----------------------------------------------------------------------------\n");
   _AD._TotalLines += linenum()-1;     // -1 for overshoot in "nextline" routine
   // Write out information we have stored
   // // UNIXism == fsync(stderr);
 }
 //------------------------------parse------------------------------------------
 // Each top-level keyword should appear as the first non-whitespace on a line.
 //
 void ADLParser::parse() {
   char *ident;
   // Iterate over the lines in the file buffer parsing Level 1 objects
   for( next_line(); _curline != NULL; next_line()) {
     _ptr = _curline;             // Reset ptr to start of new line
     skipws();                    // Skip any leading whitespace
     ident = get_ident();         // Get first token
     if (ident == NULL) {         // Empty line
       continue;                  // Get the next line
     }
     if (!strcmp(ident, "instruct"))        instr_parse();
     else if (!strcmp(ident, "operand"))    oper_parse();
     else if (!strcmp(ident, "opclass"))    opclass_parse();
     else if (!strcmp(ident, "ins_attrib")) ins_attr_parse();
     else if (!strcmp(ident, "op_attrib"))  op_attr_parse();
     else if (!strcmp(ident, "source"))     source_parse();
     else if (!strcmp(ident, "source_hpp")) source_hpp_parse();
     else if (!strcmp(ident, "register"))   reg_parse();
     else if (!strcmp(ident, "frame"))      frame_parse();
     else if (!strcmp(ident, "encode"))     encode_parse();
     else if (!strcmp(ident, "pipeline"))   pipe_parse();
     else if (!strcmp(ident, "definitions")) definitions_parse();
     else if (!strcmp(ident, "peephole"))   peep_parse();
     else if (!strcmp(ident, "#line"))      preproc_line();
     else if (!strcmp(ident, "#define"))    preproc_define();
     else if (!strcmp(ident, "#undef"))     preproc_undef();
     else {
       parse_err(SYNERR, "expected one of - instruct, operand, ins_attrib, op_attrib, source, register, pipeline, encode\n     Found %s",ident);
     }
   }
   // Done with parsing, check consistency.
   if (_preproc_depth != 0) {
     parse_err(SYNERR, "End of file inside #ifdef");
   }
   // AttributeForms ins_cost and op_cost must be defined for default behaviour
   if (_globalNames[AttributeForm::_ins_cost] == NULL) {
     parse_err(SEMERR, "Did not declare 'ins_cost' attribute");
   }
   if (_globalNames[AttributeForm::_ins_pc_relative] == NULL) {
     parse_err(SEMERR, "Did not declare 'ins_pc_relative' attribute");
   }
   if (_globalNames[AttributeForm::_op_cost] == NULL) {
     parse_err(SEMERR, "Did not declare 'op_cost' attribute");
   }
 }
 // ******************** Private Level 1 Parse Functions ********************
 //------------------------------instr_parse------------------------------------
 // Parse the contents of an instruction definition, build the InstructForm to
 // represent that instruction, and add it to the InstructForm list.
 void ADLParser::instr_parse(void) {
   char          *ident;
   InstructForm  *instr;
   MatchRule     *rule;
   int            match_rules_cnt = 0;
   // First get the name of the instruction
   if( (ident = get_unique_ident(_globalNames,"instruction")) == NULL )
     return;
   instr = new InstructForm(ident); // Create new instruction form
   instr->_linenum = linenum();
   _globalNames.Insert(ident, instr); // Add name to the name table
   // Debugging Stuff
   if (_AD._adl_debug > 1)
     fprintf(stderr,"Parsing Instruction Form %s\n", ident);
   // Then get the operands
   skipws();
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' in instruct definition\n");
   }
   // Parse the operand list
   else get_oplist(instr->_parameters, instr->_localNames);
   skipws();                        // Skip leading whitespace
   // Check for block delimiter
   if ( (_curchar != '%')
        || ( next_char(),  (_curchar != '{')) ) {
     parse_err(SYNERR, "missing '%{' in instruction definition\n");
     return;
   }
   next_char();                     // Maintain the invariant
   do {
     ident = get_ident();           // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar);
       continue;
     }
     if      (!strcmp(ident, "predicate")) instr->_predicate = pred_parse();
     else if      (!strcmp(ident, "match")) {
       // Allow one instruction have several match rules.
       rule = instr->_matrule;
       if (rule == NULL) {
         // This is first match rule encountered
         rule = match_parse(instr->_localNames);
         if (rule) {
           instr->_matrule = rule;
           // Special case the treatment of Control instructions.
           if( instr->is_ideal_control() ) {
             // Control instructions return a special result, 'Universe'
             rule->_result = "Universe";
           }
           // Check for commutative operations with tree operands.
           matchrule_clone_and_swap(rule, instr->_ident, match_rules_cnt);
         }
       } else {
         // Find the end of the match rule list
         while (rule->_next != NULL)
           rule = rule->_next;
         // Add the new match rule to the list
         rule->_next = match_parse(instr->_localNames);
         if (rule->_next) {
           rule = rule->_next;
           if( instr->is_ideal_control() ) {
             parse_err(SYNERR, "unique match rule expected for %s\n", rule->_name);
             return;
           }
           assert(match_rules_cnt < 100," too many match rule clones");
           char* buf = (char*) malloc(strlen(instr->_ident) + 4);
           sprintf(buf, "%s_%d", instr->_ident, match_rules_cnt++);
           rule->_result = buf;
           // Check for commutative operations with tree operands.
           matchrule_clone_and_swap(rule, instr->_ident, match_rules_cnt);
         }
       }
     }
     else if (!strcmp(ident, "encode"))  {
       parse_err(SYNERR, "Instructions specify ins_encode, not encode\n");
     }
     else if (!strcmp(ident, "ins_encode"))
       instr->_insencode = ins_encode_parse(*instr);
     else if (!strcmp(ident, "opcode"))  instr->_opcode = opcode_parse(instr);
     else if (!strcmp(ident, "size"))    instr->_size = size_parse(instr);
     else if (!strcmp(ident, "effect"))  effect_parse(instr);
     else if (!strcmp(ident, "expand"))  instr->_exprule = expand_parse(instr);
     else if (!strcmp(ident, "rewrite")) instr->_rewrule = rewrite_parse();
     else if (!strcmp(ident, "constraint")) {
       parse_err(SYNERR, "Instructions do not specify a constraint\n");
     }
     else if (!strcmp(ident, "construct")) {
       parse_err(SYNERR, "Instructions do not specify a construct\n");
     }
     else if (!strcmp(ident, "format"))  instr->_format  = format_parse();
     else if (!strcmp(ident, "interface")) {
       parse_err(SYNERR, "Instructions do not specify an interface\n");
     }
     else if (!strcmp(ident, "ins_pipe")) ins_pipe_parse(*instr);
     else {  // Done with staticly defined parts of instruction definition
       // Check identifier to see if it is the name of an attribute
       const Form    *form = _globalNames[ident];
       AttributeForm *attr = form ? form->is_attribute() : NULL;
       if( attr && (attr->_atype == INS_ATTR) ) {
         // Insert the new attribute into the linked list.
         Attribute *temp = attr_parse(ident);
         temp->_next = instr->_attribs;
         instr->_attribs = temp;
       } else {
         parse_err(SYNERR, "expected one of:\n predicate, match, encode, or the name of an instruction attribute at %s\n", ident);
       }
     }
     skipws();
   } while(_curchar != '%');
   next_char();
   if (_curchar != '}') {
     parse_err(SYNERR, "missing '%}' in instruction definition\n");
     return;
   }
   // Check for "Set" form of chain rule
   adjust_set_rule(instr);
   if (_AD._pipeline ) {
     if( instr->expands() ) {
       if( instr->_ins_pipe )
         parse_err(WARN, "ins_pipe and expand rule both specified for instruction \"%s\"; ins_pipe will be unused\n", instr->_ident);
     } else {
       if( !instr->_ins_pipe )
         parse_err(WARN, "No ins_pipe specified for instruction \"%s\"\n", instr->_ident);
     }
   }
   // Add instruction to tail of instruction list
   _AD.addForm(instr);
   // Create instruction form for each additional match rule
   rule = instr->_matrule;
   if (rule != NULL) {
     rule = rule->_next;
     while (rule != NULL) {
       ident = (char*)rule->_result;
       InstructForm *clone = new InstructForm(ident, instr, rule); // Create new instruction form
       _globalNames.Insert(ident, clone); // Add name to the name table
       // Debugging Stuff
       if (_AD._adl_debug > 1)
         fprintf(stderr,"Parsing Instruction Form %s\n", ident);
       // Check for "Set" form of chain rule
       adjust_set_rule(clone);
       // Add instruction to tail of instruction list
       _AD.addForm(clone);
       rule = rule->_next;
       clone->_matrule->_next = NULL; // One match rule per clone
     }
   }
 }
 //------------------------------matchrule_clone_and_swap-----------------------
 // Check for commutative operations with subtree operands,
 // create clones and swap operands.
 void ADLParser::matchrule_clone_and_swap(MatchRule* rule, const char* instr_ident, int& match_rules_cnt) {
   // Check for commutative operations with tree operands.
   int count = 0;
   rule->count_commutative_op(count);
   if (count > 0) {
     // Clone match rule and swap commutative operation's operands.
     rule->matchrule_swap_commutative_op(instr_ident, count, match_rules_cnt);
   }
 }
 //------------------------------adjust_set_rule--------------------------------
 // Check for "Set" form of chain rule
 void ADLParser::adjust_set_rule(InstructForm *instr) {
   if (instr->_matrule == NULL || instr->_matrule->_rChild == NULL) return;
   const char *rch = instr->_matrule->_rChild->_opType;
   const Form *frm = _globalNames[rch];
   if( (! strcmp(instr->_matrule->_opType,"Set")) &&
       frm && frm->is_operand() && (! frm->ideal_only()) ) {
     // Previous implementation, which missed leaP*, but worked for loadCon*
     unsigned    position = 0;
     const char *result   = NULL;
     const char *name     = NULL;
     const char *optype   = NULL;
     MatchNode  *right    = instr->_matrule->_rChild;
     if (right->base_operand(position, _globalNames, result, name, optype)) {
       position = 1;
       const char *result2  = NULL;
       const char *name2    = NULL;
       const char *optype2  = NULL;
       // Can not have additional base operands in right side of match!
       if ( ! right->base_operand( position, _globalNames, result2, name2, optype2) ) {
         assert( instr->_predicate == NULL, "ADLC does not support instruction chain rules with predicates");
         // Chain from input  _ideal_operand_type_,
         // Needed for shared roots of match-trees
         ChainList *lst = (ChainList *)_AD._chainRules[optype];
         if (lst == NULL) {
           lst = new ChainList();
           _AD._chainRules.Insert(optype, lst);
         }
         if (!lst->search(instr->_matrule->_lChild->_opType)) {
           const char *cost = instr->cost();
           if (cost == NULL) {
             cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef;
           }
           // The ADLC does not support chaining from the ideal operand type
           // of a predicated user-defined operand
           if( frm->is_operand() == NULL || frm->is_operand()->_predicate == NULL ) {
             lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident);
           }
         }
         // Chain from input  _user_defined_operand_type_,
         lst = (ChainList *)_AD._chainRules[result];
         if (lst == NULL) {
           lst = new ChainList();
           _AD._chainRules.Insert(result, lst);
         }
         if (!lst->search(instr->_matrule->_lChild->_opType)) {
           const char *cost = instr->cost();
           if (cost == NULL) {
             cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef;
           }
           // It is safe to chain from the top-level user-defined operand even
           // if it has a predicate, since the predicate is checked before
           // the user-defined type is available.
           lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident);
         }
       } else {
         // May have instruction chain rule if root of right-tree is an ideal
         OperandForm *rightOp = _globalNames[right->_opType]->is_operand();
         if( rightOp ) {
           const Form *rightRoot = _globalNames[rightOp->_matrule->_opType];
           if( rightRoot && rightRoot->ideal_only() ) {
             const char *chain_op = NULL;
             if( rightRoot->is_instruction() )
               chain_op = rightOp->_ident;
             if( chain_op ) {
               // Look-up the operation in chain rule table
               ChainList *lst = (ChainList *)_AD._chainRules[chain_op];
               if (lst == NULL) {
                 lst = new ChainList();
                 _AD._chainRules.Insert(chain_op, lst);
               }
               // if (!lst->search(instr->_matrule->_lChild->_opType)) {
               const char *cost = instr->cost();
               if (cost == NULL) {
                 cost = ((AttributeForm*)_globalNames[AttributeForm::_ins_cost])->_attrdef;
               }
               // This chains from a top-level operand whose predicate, if any,
               // has been checked.
               lst->insert(instr->_matrule->_lChild->_opType,cost,instr->_ident);
               // }
             }
           }
         }
       } // end chain rule from right-tree's ideal root
     }
   }
 }
 //------------------------------oper_parse-------------------------------------
 void ADLParser::oper_parse(void) {
   char          *ident;
   OperandForm   *oper;
   AttributeForm *attr;
   MatchRule     *rule;
   // First get the name of the operand
   skipws();
   if( (ident = get_unique_ident(_globalNames,"operand")) == NULL )
     return;
   oper = new OperandForm(ident);        // Create new operand form
   oper->_linenum = linenum();
   _globalNames.Insert(ident, oper); // Add name to the name table
   // Debugging Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Operand Form %s\n", ident);
   // Get the component operands
   skipws();
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' in operand definition\n");
     return;
   }
   else get_oplist(oper->_parameters, oper->_localNames); // Parse the component operand list
   skipws();
   // Check for block delimiter
   if ((_curchar != '%') || (*(_ptr+1) != '{')) { // If not open block
     parse_err(SYNERR, "missing '%c{' in operand definition\n","%");
     return;
   }
   next_char(); next_char();        // Skip over "%{" symbol
   do {
     ident = get_ident();           // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar);
       continue;
     }
     if      (!strcmp(ident, "predicate")) oper->_predicate = pred_parse();
     else if (!strcmp(ident, "match"))     {
       // Find the end of the match rule list
       rule = oper->_matrule;
       if (rule) {
         while (rule->_next) rule = rule->_next;
         // Add the new match rule to the list
         rule->_next = match_parse(oper->_localNames);
         if (rule->_next) {
           rule->_next->_result = oper->_ident;
         }
       }
       else {
         // This is first match rule encountered
         oper->_matrule = match_parse(oper->_localNames);
         if (oper->_matrule) {
           oper->_matrule->_result = oper->_ident;
         }
       }
     }
     else if (!strcmp(ident, "encode"))    oper->_interface = interface_parse();
     else if (!strcmp(ident, "ins_encode")) {
       parse_err(SYNERR, "Operands specify 'encode', not 'ins_encode'\n");
     }
     else if (!strcmp(ident, "opcode"))    {
       parse_err(SYNERR, "Operands do not specify an opcode\n");
     }
     else if (!strcmp(ident, "effect"))    {
       parse_err(SYNERR, "Operands do not specify an effect\n");
     }
     else if (!strcmp(ident, "expand"))    {
       parse_err(SYNERR, "Operands do not specify an expand\n");
     }
     else if (!strcmp(ident, "rewrite"))   {
       parse_err(SYNERR, "Operands do not specify a rewrite\n");
     }
     else if (!strcmp(ident, "constraint"))oper->_constraint= constraint_parse();
     else if (!strcmp(ident, "construct")) oper->_construct = construct_parse();
     else if (!strcmp(ident, "format"))    oper->_format    = format_parse();
     else if (!strcmp(ident, "interface")) oper->_interface = interface_parse();
     // Check identifier to see if it is the name of an attribute
     else if (((attr = _globalNames[ident]->is_attribute()) != NULL) &&
              (attr->_atype == OP_ATTR))   oper->_attribs   = attr_parse(ident);
     else {
       parse_err(SYNERR, "expected one of - constraint, predicate, match, encode, format, construct, or the name of a defined operand attribute at %s\n", ident);
     }
     skipws();
   } while(_curchar != '%');
   next_char();
   if (_curchar != '}') {
     parse_err(SYNERR, "missing '%}' in operand definition\n");
     return;
   }
   // Add operand to tail of operand list
   _AD.addForm(oper);
 }
 //------------------------------opclass_parse----------------------------------
 // Operand Classes are a block with a comma delimited list of operand names
 void ADLParser::opclass_parse(void) {
   char          *ident;
   OpClassForm   *opc;
   OperandForm   *opForm;
   // First get the name of the operand class
   skipws();
   if( (ident = get_unique_ident(_globalNames,"opclass")) == NULL )
     return;
   opc = new OpClassForm(ident);             // Create new operand class form
   _globalNames.Insert(ident, opc);  // Add name to the name table
   // Debugging Stuff
   if (_AD._adl_debug > 1)
     fprintf(stderr,"Parsing Operand Class Form %s\n", ident);
   // Get the list of operands
   skipws();
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' in operand definition\n");
     return;
   }
   do {
     next_char();                            // Skip past open paren or comma
     ident = get_ident();                    // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar);
       continue;
     }
     // Check identifier to see if it is the name of an operand
     const Form *form = _globalNames[ident];
     opForm     = form ? form->is_operand() : NULL;
     if ( opForm ) {
       opc->_oplst.addName(ident);           // Add operand to opclass list
       opForm->_classes.addName(opc->_ident);// Add opclass to operand list
     }
     else {
       parse_err(SYNERR, "expected name of a defined operand at %s\n", ident);
     }
     skipws();                               // skip trailing whitespace
   } while (_curchar == ',');                // Check for the comma
   // Check for closing ')'
   if (_curchar != ')') {
     parse_err(SYNERR, "missing ')' or ',' in opclass definition\n");
     return;
   }
   next_char();                              // Consume the ')'
   skipws();
   // Check for closing ';'
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in opclass definition\n");
     return;
   }
   next_char();                             // Consume the ';'
   // Add operand to tail of operand list
   _AD.addForm(opc);
 }
 //------------------------------ins_attr_parse---------------------------------
 void ADLParser::ins_attr_parse(void) {
   char          *ident;
   char          *aexpr;
   AttributeForm *attrib;
   // get name for the instruction attribute
   skipws();                      // Skip leading whitespace
   if( (ident = get_unique_ident(_globalNames,"inst_attrib")) == NULL )
     return;
   // Debugging Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Ins_Attribute Form %s\n", ident);
   // Get default value of the instruction attribute
   skipws();                      // Skip whitespace
   if ((aexpr = get_paren_expr("attribute default expression string")) == NULL) {
     parse_err(SYNERR, "missing '(' in ins_attrib definition\n");
     return;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Attribute Expression: %s\n", aexpr);
   // Check for terminator
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in ins_attrib definition\n");
     return;
   }
   next_char();                    // Advance past the ';'
   // Construct the attribute, record global name, and store in ArchDesc
   attrib = new AttributeForm(ident, INS_ATTR, aexpr);
   _globalNames.Insert(ident, attrib);  // Add name to the name table
   _AD.addForm(attrib);
 }
 //------------------------------op_attr_parse----------------------------------
 void ADLParser::op_attr_parse(void) {
   char          *ident;
   char          *aexpr;
   AttributeForm *attrib;
   // get name for the operand attribute
   skipws();                      // Skip leading whitespace
   if( (ident = get_unique_ident(_globalNames,"op_attrib")) == NULL )
     return;
   // Debugging Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Parsing Op_Attribute Form %s\n", ident);
   // Get default value of the instruction attribute
   skipws();                      // Skip whitespace
   if ((aexpr = get_paren_expr("attribute default expression string")) == NULL) {
     parse_err(SYNERR, "missing '(' in op_attrib definition\n");
     return;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Attribute Expression: %s\n", aexpr);
   // Check for terminator
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in op_attrib definition\n");
     return;
   }
   next_char();                    // Advance past the ';'
   // Construct the attribute, record global name, and store in ArchDesc
   attrib = new AttributeForm(ident, OP_ATTR, aexpr);
   _globalNames.Insert(ident, attrib);
   _AD.addForm(attrib);
 }
 //------------------------------definitions_parse-----------------------------------
 void ADLParser::definitions_parse(void) {
   skipws();                       // Skip leading whitespace
   if (_curchar == '%' && *(_ptr+1) == '{') {
     next_char(); next_char();     // Skip "%{"
     skipws();
     while (_curchar != '%' && *(_ptr+1) != '}') {
       // Process each definition until finding closing string "%}"
       char *token = get_ident();
       if (token == NULL) {
         parse_err(SYNERR, "missing identifier inside definitions block.\n");
         return;
       }
       if (strcmp(token,"int_def")==0)     { int_def_parse(); }
       // if (strcmp(token,"str_def")==0)   { str_def_parse(); }
       skipws();
     }
   }
   else {
     parse_err(SYNERR, "Missing %%{ ... %%} block after definitions keyword.\n");
     return;
   }
 }
 //------------------------------int_def_parse----------------------------------
 // Parse Example:
 // int_def    MEMORY_REF_COST      (         200,  DEFAULT_COST * 2);
 // <keyword>  <name>               ( <int_value>,   <description>  );
 //
 void ADLParser::int_def_parse(void) {
   char *name        = NULL;         // Name of definition
   char *value       = NULL;         // its value,
   int   int_value   = -1;           // positive values only
   char *description = NULL;         // textual description
   // Get definition name
   skipws();                      // Skip whitespace
   name = get_ident();
   if (name == NULL) {
     parse_err(SYNERR, "missing definition name after int_def\n");
     return;
   }
   // Check for value of int_def dname( integer_value [, string_expression ] )
   skipws();
   if (_curchar == '(') {
     // Parse the integer value.
     next_char();
     value = get_ident();
     if (value == NULL) {
       parse_err(SYNERR, "missing value in int_def\n");
       return;
     }
     if( !is_int_token(value, int_value) ) {
       parse_err(SYNERR, "value in int_def is not recognized as integer\n");
       return;
     }
     skipws();
     // Check for description
     if (_curchar == ',') {
       next_char();   // skip ','
       description = get_expr("int_def description", ")");
       if (description == NULL) {
         parse_err(SYNERR, "invalid or missing description in int_def\n");
         return;
       }
       trim(description);
     }
     if (_curchar != ')') {
       parse_err(SYNERR, "missing ')' in register definition statement\n");
       return;
     }
     next_char();
   }
   // Check for closing ';'
   skipws();
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' after int_def\n");
     return;
   }
   next_char();                   // move past ';'
   // Debug Stuff
   if (_AD._adl_debug > 1) {
     fprintf(stderr,"int_def: %s ( %s, %s )\n", name,
             (value), (description ? description : ""));
   }
   // Record new definition.
   Expr *expr     = new Expr(name, description, int_value, int_value);
   const Expr *old_expr = _AD.globalDefs().define(name, expr);
   if (old_expr != NULL) {
     parse_err(SYNERR, "Duplicate definition\n");
     return;
   }
   return;
 }
 //------------------------------source_parse-----------------------------------
 void ADLParser::source_parse(void) {
   SourceForm *source;             // Encode class for instruction/operand
   char   *rule = NULL;            // String representation of encode rule
   skipws();                       // Skip leading whitespace
   if ( (rule = find_cpp_block("source block")) == NULL ) {
     parse_err(SYNERR, "incorrect or missing block for 'source'.\n");
     return;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Source Form: %s\n", rule);
   source = new SourceForm(rule);    // Build new Source object
   _AD.addForm(source);
   // skipws();
 }
 //------------------------------source_hpp_parse-------------------------------
 // Parse a source_hpp %{ ... %} block.
 // The code gets stuck into the ad_<arch>.hpp file.
 // If the source_hpp block appears before the register block in the AD
 // file, it goes up at the very top of the ad_<arch>.hpp file, so that
 // it can be used by register encodings, etc.  Otherwise, it goes towards
 // the bottom, where it's useful as a global definition to *.cpp files.
 void ADLParser::source_hpp_parse(void) {
   char   *rule = NULL;            // String representation of encode rule
   skipws();                       // Skip leading whitespace
   if ( (rule = find_cpp_block("source_hpp block")) == NULL ) {
     parse_err(SYNERR, "incorrect or missing block for 'source_hpp'.\n");
     return;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Header Form: %s\n", rule);
   if (_AD.get_registers() == NULL) {
     // Very early in the file, before reg_defs, we collect pre-headers.
     PreHeaderForm* pre_header = new PreHeaderForm(rule);
     _AD.addForm(pre_header);
   } else {
     // Normally, we collect header info, placed at the bottom of the hpp file.
     HeaderForm* header = new HeaderForm(rule);
     _AD.addForm(header);
   }
 }
 //------------------------------reg_parse--------------------------------------
 void ADLParser::reg_parse(void) {
   // Create the RegisterForm for the architecture description.
   RegisterForm *regBlock = new RegisterForm();    // Build new Source object
   regBlock->_linenum = linenum();
   _AD.addForm(regBlock);
   skipws();                       // Skip leading whitespace
   if (_curchar == '%' && *(_ptr+1) == '{') {
     next_char(); next_char();     // Skip "%{"
     skipws();
     while (_curchar != '%' && *(_ptr+1) != '}') {
       char *token = get_ident();
       if (token == NULL) {
         parse_err(SYNERR, "missing identifier inside register block.\n");
         return;
       }
       if (strcmp(token,"reg_def")==0)          { reg_def_parse(); }
       else if (strcmp(token,"reg_class")==0)   { reg_class_parse(); }
       else if (strcmp(token,"alloc_class")==0) { alloc_class_parse(); }
       else if (strcmp(token,"#define")==0)     { preproc_define(); }
       else { parse_err(SYNERR, "bad token %s inside register block.\n", token); break; }
       skipws();
     }
   }
   else {
     parse_err(SYNERR, "Missing %c{ ... %c} block after register keyword.\n",'%','%');
     return;
   }
   // Add reg_class spill_regs
   regBlock->addSpillRegClass();
 }
 //------------------------------encode_parse-----------------------------------
 void ADLParser::encode_parse(void) {
   EncodeForm *encBlock;         // Information about instruction/operand encoding
   char       *desc = NULL;      // String representation of encode rule
   _AD.getForm(&encBlock);
   if ( encBlock == NULL) {
     // Create the EncodeForm for the architecture description.
     encBlock = new EncodeForm();    // Build new Source object
     _AD.addForm(encBlock);
   }
   skipws();                       // Skip leading whitespace
   if (_curchar == '%' && *(_ptr+1) == '{') {
     next_char(); next_char();     // Skip "%{"
     skipws();
     while (_curchar != '%' && *(_ptr+1) != '}') {
       char *token = get_ident();
       if (token == NULL) {
             parse_err(SYNERR, "missing identifier inside encoding block.\n");
             return;
       }
       if (strcmp(token,"enc_class")==0)   { enc_class_parse(); }
       skipws();
     }
   }
   else {
     parse_err(SYNERR, "Missing %c{ ... %c} block after encode keyword.\n",'%','%');
     return;
   }
 }
 //------------------------------enc_class_parse--------------------------------
 void ADLParser::enc_class_parse(void) {
   char       *ec_name;           // Name of encoding class being defined
   // Get encoding class name
   skipws();                      // Skip whitespace
   ec_name = get_ident();
   if (ec_name == NULL) {
     parse_err(SYNERR, "missing encoding class name after encode.\n");
     return;
   }
   EncClass  *encoding = _AD._encode->add_EncClass(ec_name);
   encoding->_linenum = linenum();
   skipws();                      // Skip leading whitespace
   // Check for optional parameter list
   if (_curchar == '(') {
     do {
       char *pType = NULL;        // parameter type
       char *pName = NULL;        // parameter name
       next_char();               // skip open paren & comma characters
       skipws();
       if (_curchar == ')') break;
       // Get parameter type
       pType = get_ident();
       if (pType == NULL) {
         parse_err(SYNERR, "parameter type expected at %c\n", _curchar);
         return;
       }
       skipws();
       // Get parameter name
       pName = get_ident();
       if (pName == NULL) {
         parse_err(SYNERR, "parameter name expected at %c\n", _curchar);
         return;
       }
       // Record parameter type and name
       encoding->add_parameter( pType, pName );
       skipws();
     } while(_curchar == ',');
     if (_curchar != ')') parse_err(SYNERR, "missing ')'\n");
     else {
       next_char();                  // Skip ')'
     }
   } // Done with parameter list
   skipws();
   // Check for block starting delimiters
   if ((_curchar != '%') || (*(_ptr+1) != '{')) { // If not open block
     parse_err(SYNERR, "missing '%c{' in enc_class definition\n", '%');
     return;
   }
   next_char();                      // Skip '%'
   next_char();                      // Skip '{'
   enc_class_parse_block(encoding, ec_name);
 }
 void ADLParser::enc_class_parse_block(EncClass* encoding, char* ec_name) {
   skipws_no_preproc();              // Skip leading whitespace
   // Prepend location descriptor, for debugging; cf. ADLParser::find_cpp_block
   if (_AD._adlocation_debug) {
     encoding->add_code(get_line_string());
   }
   // Collect the parts of the encode description
   // (1) strings that are passed through to output
   // (2) replacement/substitution variable, preceeded by a '$'
   while ( (_curchar != '%') && (*(_ptr+1) != '}') ) {
     // (1)
     // Check if there is a string to pass through to output
     char *start = _ptr;       // Record start of the next string
     while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) {
       // If at the start of a comment, skip past it
       if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) {
         skipws_no_preproc();
       } else {
         // ELSE advance to the next character, or start of the next line
         next_char_or_line();
       }
     }
     // If a string was found, terminate it and record in EncClass
     if ( start != _ptr ) {
       *_ptr  = '\0';          // Terminate the string
       encoding->add_code(start);
     }
     // (2)
     // If we are at a replacement variable,
     // copy it and record in EncClass
     if ( _curchar == '$' ) {
       // Found replacement Variable
       char *rep_var = get_rep_var_ident_dup();
       // Add flag to _strings list indicating we should check _rep_vars
       encoding->add_rep_var(rep_var);
     }
   } // end while part of format description
   next_char();                      // Skip '%'
   next_char();                      // Skip '}'
   skipws();
   if (_AD._adlocation_debug) {
     encoding->add_code(end_line_marker());
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"EncodingClass Form: %s\n", ec_name);
 }
 //------------------------------frame_parse-----------------------------------
 void ADLParser::frame_parse(void) {
   FrameForm  *frame;              // Information about stack-frame layout
   char       *desc = NULL;        // String representation of frame
   skipws();                       // Skip leading whitespace
   frame = new FrameForm();        // Build new Frame object
   // Check for open block sequence
   skipws();                       // Skip leading whitespace
   if (_curchar == '%' && *(_ptr+1) == '{') {
     next_char(); next_char();     // Skip "%{"
     skipws();
     while (_curchar != '%' && *(_ptr+1) != '}') {
       char *token = get_ident();
       if (token == NULL) {
             parse_err(SYNERR, "missing identifier inside frame block.\n");
             return;
       }
       if (strcmp(token,"stack_direction")==0) {
         stack_dir_parse(frame);
       }
       if (strcmp(token,"sync_stack_slots")==0) {
         sync_stack_slots_parse(frame);
       }
       if (strcmp(token,"frame_pointer")==0) {
         frame_pointer_parse(frame, false);
       }
       if (strcmp(token,"interpreter_frame_pointer")==0) {
         interpreter_frame_pointer_parse(frame, false);
         // Add  reg_class interpreter_frame_pointer_reg
         if( _AD._register != NULL ) {
           RegClass *reg_class = _AD._register->addRegClass("interpreter_frame_pointer_reg");
           char *interpreter_frame_pointer_reg = frame->_interpreter_frame_pointer_reg;
           if( interpreter_frame_pointer_reg != NULL ) {
             RegDef *regDef = _AD._register->getRegDef(interpreter_frame_pointer_reg);
             reg_class->addReg(regDef);     // add regDef to regClass
           }
         }
       }
       if (strcmp(token,"inline_cache_reg")==0) {
         inline_cache_parse(frame, false);
         // Add  reg_class inline_cache_reg
         if( _AD._register != NULL ) {
           RegClass *reg_class = _AD._register->addRegClass("inline_cache_reg");
           char *inline_cache_reg = frame->_inline_cache_reg;
           if( inline_cache_reg != NULL ) {
             RegDef *regDef = _AD._register->getRegDef(inline_cache_reg);
             reg_class->addReg(regDef);     // add regDef to regClass
           }
         }
       }
       if (strcmp(token,"compiler_method_oop_reg")==0) {
         parse_err(WARN, "Using obsolete Token, compiler_method_oop_reg");
         skipws();
       }
       if (strcmp(token,"interpreter_method_oop_reg")==0) {
         interpreter_method_oop_parse(frame, false);
         // Add  reg_class interpreter_method_oop_reg
         if( _AD._register != NULL ) {
           RegClass *reg_class = _AD._register->addRegClass("interpreter_method_oop_reg");
           char *method_oop_reg = frame->_interpreter_method_oop_reg;
           if( method_oop_reg != NULL ) {
             RegDef *regDef = _AD._register->getRegDef(method_oop_reg);
             reg_class->addReg(regDef);     // add regDef to regClass
           }
         }
       }
       if (strcmp(token,"cisc_spilling_operand_name")==0) {
         cisc_spilling_operand_name_parse(frame, false);
       }
       if (strcmp(token,"stack_alignment")==0) {
         stack_alignment_parse(frame);
       }
       if (strcmp(token,"return_addr")==0) {
         return_addr_parse(frame, false);
       }
       if (strcmp(token,"in_preserve_stack_slots")==0) {
         preserve_stack_parse(frame);
       }
       if (strcmp(token,"out_preserve_stack_slots")==0) {
         parse_err(WARN, "Using obsolete token, out_preserve_stack_slots");
         skipws();
       }
       if (strcmp(token,"varargs_C_out_slots_killed")==0) {
         frame->_varargs_C_out_slots_killed = parse_one_arg("varargs C out slots killed");
       }
       if (strcmp(token,"calling_convention")==0) {
         frame->_calling_convention = calling_convention_parse();
       }
       if (strcmp(token,"return_value")==0) {
         frame->_return_value = return_value_parse();
       }
       if (strcmp(token,"c_frame_pointer")==0) {
         frame_pointer_parse(frame, true);
       }
       if (strcmp(token,"c_return_addr")==0) {
         return_addr_parse(frame, true);
       }
       if (strcmp(token,"c_calling_convention")==0) {
         frame->_c_calling_convention = calling_convention_parse();
       }
       if (strcmp(token,"c_return_value")==0) {
         frame->_c_return_value = return_value_parse();
       }
       skipws();
     }
   }
   else {
     parse_err(SYNERR, "Missing %c{ ... %c} block after encode keyword.\n",'%','%');
     return;
   }
   // All Java versions are required, native versions are optional
   if(frame->_frame_pointer == NULL) {
     parse_err(SYNERR, "missing frame pointer definition in frame section.\n");
     return;
   }
   // !!!!! !!!!!
   // if(frame->_interpreter_frame_ptr_reg == NULL) {
   //   parse_err(SYNERR, "missing interpreter frame pointer definition in frame section.\n");
   //   return;
   // }
   if(frame->_alignment == NULL) {
     parse_err(SYNERR, "missing alignment definition in frame section.\n");
     return;
   }
   if(frame->_return_addr == NULL) {
     parse_err(SYNERR, "missing return address location in frame section.\n");
     return;
   }
   if(frame->_in_preserve_slots == NULL) {
     parse_err(SYNERR, "missing stack slot preservation definition in frame section.\n");
     return;
   }
   if(frame->_varargs_C_out_slots_killed == NULL) {
     parse_err(SYNERR, "missing varargs C out slots killed definition in frame section.\n");
     return;
   }
   if(frame->_calling_convention == NULL) {
     parse_err(SYNERR, "missing calling convention definition in frame section.\n");
     return;
   }
   if(frame->_return_value == NULL) {
     parse_err(SYNERR, "missing return value definition in frame section.\n");
     return;
   }
   // Fill natives in identically with the Java versions if not present.
   if(frame->_c_frame_pointer == NULL) {
     frame->_c_frame_pointer = frame->_frame_pointer;
   }
   if(frame->_c_return_addr == NULL) {
     frame->_c_return_addr = frame->_return_addr;
     frame->_c_return_addr_loc = frame->_return_addr_loc;
   }
   if(frame->_c_calling_convention == NULL) {
     frame->_c_calling_convention = frame->_calling_convention;
   }
   if(frame->_c_return_value == NULL) {
     frame->_c_return_value = frame->_return_value;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Frame Form: %s\n", desc);
   // Create the EncodeForm for the architecture description.
   _AD.addForm(frame);
   // skipws();
 }
 //------------------------------stack_dir_parse--------------------------------
 void ADLParser::stack_dir_parse(FrameForm *frame) {
   char *direction = parse_one_arg("stack direction entry");
   if (strcmp(direction, "TOWARDS_LOW") == 0) {
     frame->_direction = false;
   }
   else if (strcmp(direction, "TOWARDS_HIGH") == 0) {
     frame->_direction = true;
   }
   else {
     parse_err(SYNERR, "invalid value inside stack direction entry.\n");
     return;
   }
 }
 //------------------------------sync_stack_slots_parse-------------------------
 void ADLParser::sync_stack_slots_parse(FrameForm *frame) {
     // Assign value into frame form
     frame->_sync_stack_slots = parse_one_arg("sync stack slots entry");
 }
 //------------------------------frame_pointer_parse----------------------------
 void ADLParser::frame_pointer_parse(FrameForm *frame, bool native) {
   char *frame_pointer = parse_one_arg("frame pointer entry");
   // Assign value into frame form
   if (native) { frame->_c_frame_pointer = frame_pointer; }
   else        { frame->_frame_pointer   = frame_pointer; }
 }
 //------------------------------interpreter_frame_pointer_parse----------------------------
 void ADLParser::interpreter_frame_pointer_parse(FrameForm *frame, bool native) {
   frame->_interpreter_frame_pointer_reg = parse_one_arg("interpreter frame pointer entry");
 }
 //------------------------------inline_cache_parse-----------------------------
 void ADLParser::inline_cache_parse(FrameForm *frame, bool native) {
   frame->_inline_cache_reg = parse_one_arg("inline cache reg entry");
 }
 //------------------------------interpreter_method_oop_parse------------------
 void ADLParser::interpreter_method_oop_parse(FrameForm *frame, bool native) {
   frame->_interpreter_method_oop_reg = parse_one_arg("method oop reg entry");
 }
 //------------------------------cisc_spilling_operand_parse---------------------
 void ADLParser::cisc_spilling_operand_name_parse(FrameForm *frame, bool native) {
   frame->_cisc_spilling_operand_name = parse_one_arg("cisc spilling operand name");
 }
 //------------------------------stack_alignment_parse--------------------------
 void ADLParser::stack_alignment_parse(FrameForm *frame) {
   char *alignment = parse_one_arg("stack alignment entry");
   // Assign value into frame
   frame->_alignment   = alignment;
 }
 //------------------------------parse_one_arg-------------------------------
 char *ADLParser::parse_one_arg(const char *description) {
   char *token = NULL;
   if(_curchar == '(') {
     next_char();
     skipws();
     token = get_expr(description, ")");
     if (token == NULL) {
       parse_err(SYNERR, "missing value inside %s.\n", description);
       return NULL;
     }
     next_char();           // skip the close paren
     if(_curchar != ';') {  // check for semi-colon
       parse_err(SYNERR, "missing %c in.\n", ';', description);
       return NULL;
     }
     next_char();           // skip the semi-colon
   }
   else {
     parse_err(SYNERR, "Missing %c in.\n", '(', description);
     return NULL;
   }
   trim(token);
   return token;
 }
 //------------------------------return_addr_parse------------------------------
 void ADLParser::return_addr_parse(FrameForm *frame, bool native) {
   bool in_register  = true;
   if(_curchar == '(') {
     next_char();
     skipws();
     char *token = get_ident();
     if (token == NULL) {
       parse_err(SYNERR, "missing value inside return address entry.\n");
       return;
     }
     // check for valid values for stack/register
     if (strcmp(token, "REG") == 0) {
       in_register = true;
     }
     else if (strcmp(token, "STACK") == 0) {
       in_register = false;
     }
     else {
       parse_err(SYNERR, "invalid value inside return_address entry.\n");
       return;
     }
     if (native) { frame->_c_return_addr_loc = in_register; }
     else        { frame->_return_addr_loc   = in_register; }
     // Parse expression that specifies register or stack position
     skipws();
     char *token2 = get_expr("return address entry", ")");
     if (token2 == NULL) {
       parse_err(SYNERR, "missing value inside return address entry.\n");
       return;
     }
     next_char();           // skip the close paren
     if (native) { frame->_c_return_addr = token2; }
     else        { frame->_return_addr   = token2; }
     if(_curchar != ';') {  // check for semi-colon
       parse_err(SYNERR, "missing %c in return address entry.\n", ';');
       return;
     }
     next_char();           // skip the semi-colon
   }
   else {
     parse_err(SYNERR, "Missing %c in return_address entry.\n", '(');
   }
 }
 //------------------------------preserve_stack_parse---------------------------
 void ADLParser::preserve_stack_parse(FrameForm *frame) {
   if(_curchar == '(') {
     char *token = get_paren_expr("preserve_stack_slots");
     frame->_in_preserve_slots   = token;
     if(_curchar != ';') {  // check for semi-colon
       parse_err(SYNERR, "missing %c in preserve stack slot entry.\n", ';');
       return;
     }
     next_char();           // skip the semi-colon
   }
   else {
     parse_err(SYNERR, "Missing %c in preserve stack slot entry.\n", '(');
   }
 }
 //------------------------------calling_convention_parse-----------------------
 char *ADLParser::calling_convention_parse() {
   char   *desc = NULL;          // String representation of calling_convention
   skipws();                     // Skip leading whitespace
   if ( (desc = find_cpp_block("calling convention block")) == NULL ) {
     parse_err(SYNERR, "incorrect or missing block for 'calling_convention'.\n");
   }
   return desc;
 }
 //------------------------------return_value_parse-----------------------------
 char *ADLParser::return_value_parse() {
   char   *desc = NULL;          // String representation of calling_convention
   skipws();                     // Skip leading whitespace
   if ( (desc = find_cpp_block("return value block")) == NULL ) {
     parse_err(SYNERR, "incorrect or missing block for 'return_value'.\n");
   }
   return desc;
 }
 //------------------------------ins_pipe_parse---------------------------------
 void ADLParser::ins_pipe_parse(InstructForm &instr) {
   char * ident;
   skipws();
   if ( _curchar != '(' ) {       // Check for delimiter
     parse_err(SYNERR, "missing \"(\" in ins_pipe definition\n");
     return;
   }
   next_char();
   ident = get_ident();           // Grab next identifier
   if (ident == NULL) {
     parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar);
     return;
   }
   skipws();
   if ( _curchar != ')' ) {       // Check for delimiter
     parse_err(SYNERR, "missing \")\" in ins_pipe definition\n");
     return;
   }
   next_char();                   // skip the close paren
   if(_curchar != ';') {          // check for semi-colon
     parse_err(SYNERR, "missing %c in return value entry.\n", ';');
     return;
   }
   next_char();                   // skip the semi-colon
   // Check ident for validity
   if (_AD._pipeline && !_AD._pipeline->_classlist.search(ident)) {
     parse_err(SYNERR, "\"%s\" is not a valid pipeline class\n", ident);
     return;
   }
   // Add this instruction to the list in the pipeline class
   _AD._pipeline->_classdict[ident]->is_pipeclass()->_instructs.addName(instr._ident);
   // Set the name of the pipeline class in the instruction
   instr._ins_pipe = ident;
   return;
 }
 //------------------------------pipe_parse-------------------------------------
 void ADLParser::pipe_parse(void) {
   PipelineForm *pipeline;         // Encode class for instruction/operand
   char * ident;
   pipeline = new PipelineForm();  // Build new Source object
   _AD.addForm(pipeline);
   skipws();                       // Skip leading whitespace
   // Check for block delimiter
   if ( (_curchar != '%')
        || ( next_char(),  (_curchar != '{')) ) {
     parse_err(SYNERR, "missing '%{' in pipeline definition\n");
     return;
   }
   next_char();                     // Maintain the invariant
   do {
     ident = get_ident();           // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "keyword identifier expected at %c\n", _curchar);
       continue;
     }
     if      (!strcmp(ident, "resources" )) resource_parse(*pipeline);
     else if (!strcmp(ident, "pipe_desc" )) pipe_desc_parse(*pipeline);
     else if (!strcmp(ident, "pipe_class")) pipe_class_parse(*pipeline);
     else if (!strcmp(ident, "define")) {
       skipws();
       if ( (_curchar != '%')
            || ( next_char(),  (_curchar != '{')) ) {
         parse_err(SYNERR, "expected '%{'\n");
         return;
       }
       next_char(); skipws();
       char *node_class = get_ident();
       if (node_class == NULL) {
         parse_err(SYNERR, "expected identifier, found \"%c\"\n", _curchar);
         return;
       }
       skipws();
       if (_curchar != ',' && _curchar != '=') {
         parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar);
         break;
       }
       next_char(); skipws();
       char *pipe_class = get_ident();
       if (pipe_class == NULL) {
         parse_err(SYNERR, "expected identifier, found \"%c\"\n", _curchar);
         return;
       }
       if (_curchar != ';' ) {
         parse_err(SYNERR, "expected `;`, found '%c'\n", _curchar);
         break;
       }
       next_char();              // Skip over semi-colon
       skipws();
       if ( (_curchar != '%')
            || ( next_char(),  (_curchar != '}')) ) {
         parse_err(SYNERR, "expected '%%}', found \"%c\"\n", _curchar);
       }
       next_char();
       // Check ident for validity
       if (_AD._pipeline && !_AD._pipeline->_classlist.search(pipe_class)) {
         parse_err(SYNERR, "\"%s\" is not a valid pipeline class\n", pipe_class);
         return;
       }
       // Add this machine node to the list in the pipeline class
       _AD._pipeline->_classdict[pipe_class]->is_pipeclass()->_instructs.addName(node_class);
       MachNodeForm *machnode = new MachNodeForm(node_class); // Create new machnode form
       machnode->_machnode_pipe = pipe_class;
       _AD.addForm(machnode);
     }
     else if (!strcmp(ident, "attributes")) {
       bool vsi_seen = false, bhds_seen = false;
       skipws();
       if ( (_curchar != '%')
            || ( next_char(),  (_curchar != '{')) ) {
         parse_err(SYNERR, "expected '%{'\n");
         return;
       }
       next_char(); skipws();
       while (_curchar != '%') {
         ident = get_ident();
         if (ident == NULL)
           break;
         if (!strcmp(ident, "variable_size_instructions")) {
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           pipeline->_variableSizeInstrs = true;
           vsi_seen = true;
           continue;
         }
         if (!strcmp(ident, "fixed_size_instructions")) {
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           pipeline->_variableSizeInstrs = false;
           vsi_seen = true;
           continue;
         }
         if (!strcmp(ident, "branch_has_delay_slot")) {
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           pipeline->_branchHasDelaySlot = true;
           bhds_seen = true;
           continue;
         }
         if (!strcmp(ident, "max_instructions_per_bundle")) {
           skipws();
           if (_curchar != '=') {
             parse_err(SYNERR, "expected `=`\n");
             break;
             }
           next_char(); skipws();
           pipeline->_maxInstrsPerBundle = get_int();
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           continue;
         }
         if (!strcmp(ident, "max_bundles_per_cycle")) {
           skipws();
           if (_curchar != '=') {
             parse_err(SYNERR, "expected `=`\n");
             break;
             }
           next_char(); skipws();
           pipeline->_maxBundlesPerCycle = get_int();
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           continue;
         }
         if (!strcmp(ident, "instruction_unit_size")) {
           skipws();
           if (_curchar != '=') {
             parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar);
             break;
             }
           next_char(); skipws();
           pipeline->_instrUnitSize = get_int();
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           continue;
         }
         if (!strcmp(ident, "bundle_unit_size")) {
           skipws();
           if (_curchar != '=') {
             parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar);
             break;
             }
           next_char(); skipws();
           pipeline->_bundleUnitSize = get_int();
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           continue;
         }
         if (!strcmp(ident, "instruction_fetch_unit_size")) {
           skipws();
           if (_curchar != '=') {
             parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar);
             break;
             }
           next_char(); skipws();
           pipeline->_instrFetchUnitSize = get_int();
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           continue;
         }
         if (!strcmp(ident, "instruction_fetch_units")) {
           skipws();
           if (_curchar != '=') {
             parse_err(SYNERR, "expected `=`, found '%c'\n", _curchar);
             break;
             }
           next_char(); skipws();
           pipeline->_instrFetchUnits = get_int();
           skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           continue;
         }
         if (!strcmp(ident, "nops")) {
           skipws();
           if (_curchar != '(') {
             parse_err(SYNERR, "expected `(`, found '%c'\n", _curchar);
             break;
             }
           next_char(); skipws();
           while (_curchar != ')') {
             ident = get_ident();
             if (ident == NULL) {
               parse_err(SYNERR, "expected identifier for nop instruction, found '%c'\n", _curchar);
               break;
             }
             pipeline->_noplist.addName(ident);
             pipeline->_nopcnt++;
             skipws();
             if (_curchar == ',') {
               next_char(); skipws();
             }
           }
           next_char(); skipws();
           if (_curchar == ';') {
             next_char(); skipws();
           }
           continue;
         }
         parse_err(SYNERR, "unknown specifier \"%s\"\n", ident);
       }
       if ( (_curchar != '%')
            || ( next_char(),  (_curchar != '}')) ) {
         parse_err(SYNERR, "expected '%}', found \"%c\"\n", _curchar);
       }
       next_char(); skipws();
       if (pipeline->_maxInstrsPerBundle == 0)
         parse_err(SYNERR, "\"max_instructions_per_bundle\" unspecified\n");
       if (pipeline->_instrUnitSize == 0 && pipeline->_bundleUnitSize == 0)
         parse_err(SYNERR, "\"instruction_unit_size\" and \"bundle_unit_size\" unspecified\n");
       if (pipeline->_instrFetchUnitSize == 0)
         parse_err(SYNERR, "\"instruction_fetch_unit_size\" unspecified\n");
       if (pipeline->_instrFetchUnits == 0)
         parse_err(SYNERR, "\"instruction_fetch_units\" unspecified\n");
       if (!vsi_seen)
         parse_err(SYNERR, "\"variable_size_instruction\" or \"fixed_size_instruction\" unspecified\n");
     }
     else {  // Done with staticly defined parts of instruction definition
       parse_err(SYNERR, "expected one of \"resources\", \"pipe_desc\", \"pipe_class\", found \"%s\"\n", ident);
       return;
     }
     skipws();
     if (_curchar == ';')
       skipws();
   } while(_curchar != '%');
   next_char();
   if (_curchar != '}') {
     parse_err(SYNERR, "missing \"%}\" in pipeline definition\n");
     return;
   }
   next_char();
 }
 //------------------------------resource_parse----------------------------
 void ADLParser::resource_parse(PipelineForm &pipeline) {
   ResourceForm *resource;
   char * ident;
   char * expr;
   unsigned mask;
   pipeline._rescount = 0;
   skipws();                       // Skip leading whitespace
   if (_curchar != '(') {
     parse_err(SYNERR, "missing \"(\" in resource definition\n");
     return;
   }
   do {
     next_char();                   // Skip "(" or ","
     ident = get_ident();           // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar);
       return;
     }
     skipws();
     if (_curchar != '=') {
       mask = (1 << pipeline._rescount++);
     }
     else {
       next_char(); skipws();
       expr = get_ident();          // Grab next identifier
       if (expr == NULL) {
         parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar);
         return;
       }
       resource = (ResourceForm *) pipeline._resdict[expr];
       if (resource == NULL) {
         parse_err(SYNERR, "resource \"%s\" is not defined\n", expr);
         return;
       }
       mask = resource->mask();
       skipws();
       while (_curchar == '|') {
         next_char(); skipws();
         expr = get_ident();          // Grab next identifier
         if (expr == NULL) {
           parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar);
           return;
         }
         resource = (ResourceForm *) pipeline._resdict[expr];   // Look up the value
         if (resource == NULL) {
           parse_err(SYNERR, "resource \"%s\" is not defined\n", expr);
           return;
         }
         mask |= resource->mask();
         skipws();
       }
     }
     resource = new ResourceForm(mask);
     pipeline._resdict.Insert(ident, resource);
     pipeline._reslist.addName(ident);
   } while (_curchar == ',');
   if (_curchar != ')') {
       parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar);
       return;
   }
   next_char();                 // Skip ")"
   if (_curchar == ';')
     next_char();               // Skip ";"
 }
 //------------------------------resource_parse----------------------------
 void ADLParser::pipe_desc_parse(PipelineForm &pipeline) {
   char * ident;
   skipws();                       // Skip leading whitespace
   if (_curchar != '(') {
     parse_err(SYNERR, "missing \"(\" in pipe_desc definition\n");
     return;
   }
   do {
     next_char();                   // Skip "(" or ","
     ident = get_ident();           // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar);
       return;
     }
     // Add the name to the list
     pipeline._stages.addName(ident);
     pipeline._stagecnt++;
     skipws();
   } while (_curchar == ',');
   if (_curchar != ')') {
       parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar);
       return;
   }
   next_char();                     // Skip ")"
   if (_curchar == ';')
     next_char();                   // Skip ";"
 }
 //------------------------------pipe_class_parse--------------------------
 void ADLParser::pipe_class_parse(PipelineForm &pipeline) {
   PipeClassForm *pipe_class;
   char * ident;
   char * stage;
   char * read_or_write;
   int is_write;
   int is_read;
   OperandForm  *oper;
   skipws();                       // Skip leading whitespace
   ident = get_ident();            // Grab next identifier
   if (ident == NULL) {
     parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar);
     return;
   }
   // Create a record for the pipe_class
   pipe_class = new PipeClassForm(ident, ++pipeline._classcnt);
   pipeline._classdict.Insert(ident, pipe_class);
   pipeline._classlist.addName(ident);
   // Then get the operands
   skipws();
   if (_curchar != '(') {
     parse_err(SYNERR, "missing \"(\" in pipe_class definition\n");
   }
   // Parse the operand list
   else get_oplist(pipe_class->_parameters, pipe_class->_localNames);
   skipws();                        // Skip leading whitespace
   // Check for block delimiter
   if ( (_curchar != '%')
        || ( next_char(),  (_curchar != '{')) ) {
     parse_err(SYNERR, "missing \"%{\" in pipe_class definition\n");
     return;
   }
   next_char();
   do {
     ident = get_ident();           // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "keyword identifier expected at \"%c\"\n", _curchar);
       continue;
     }
     skipws();
     if (!strcmp(ident, "fixed_latency")) {
       skipws();
       if (_curchar != '(') {
         parse_err(SYNERR, "missing \"(\" in latency definition\n");
         return;
       }
       next_char(); skipws();
       if( !isdigit(_curchar) ) {
         parse_err(SYNERR, "number expected for \"%c\" in latency definition\n", _curchar);
         return;
       }
       int fixed_latency = get_int();
       skipws();
       if (_curchar != ')') {
         parse_err(SYNERR, "missing \")\" in latency definition\n");
         return;
       }
       next_char(); skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" in latency definition\n");
         return;
       }
       pipe_class->setFixedLatency(fixed_latency);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "zero_instructions") ||
         !strcmp(ident, "no_instructions")) {
       skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" in latency definition\n");
         return;
       }
       pipe_class->setInstructionCount(0);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "one_instruction_with_delay_slot") ||
         !strcmp(ident, "single_instruction_with_delay_slot")) {
       skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" in latency definition\n");
         return;
       }
       pipe_class->setInstructionCount(1);
       pipe_class->setBranchDelay(true);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "one_instruction") ||
         !strcmp(ident, "single_instruction")) {
       skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" in latency definition\n");
         return;
       }
       pipe_class->setInstructionCount(1);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "instructions_in_first_bundle") ||
         !strcmp(ident, "instruction_count")) {
       skipws();
       int number_of_instructions = 1;
       if (_curchar != '(') {
         parse_err(SYNERR, "\"(\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char(); skipws();
       number_of_instructions = get_int();
       skipws();
       if (_curchar != ')') {
         parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char(); skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" in latency definition\n");
         return;
       }
       pipe_class->setInstructionCount(number_of_instructions);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "multiple_bundles")) {
       skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" after multiple bundles\n");
         return;
       }
       pipe_class->setMultipleBundles(true);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "has_delay_slot")) {
       skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" after \"has_delay_slot\"\n");
         return;
       }
       pipe_class->setBranchDelay(true);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "force_serialization")) {
       skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" after \"force_serialization\"\n");
         return;
       }
       pipe_class->setForceSerialization(true);
       next_char(); skipws();
       continue;
     }
     if (!strcmp(ident, "may_have_no_code")) {
       skipws();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing \";\" after \"may_have_no_code\"\n");
         return;
       }
       pipe_class->setMayHaveNoCode(true);
       next_char(); skipws();
       continue;
     }
     const Form *parm = pipe_class->_localNames[ident];
     if (parm != NULL) {
       oper = parm->is_operand();
       if (oper == NULL && !parm->is_opclass()) {
         parse_err(SYNERR, "operand name expected at %s\n", ident);
         continue;
       }
       if (_curchar != ':') {
         parse_err(SYNERR, "\":\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char(); skipws();
       stage = get_ident();
       if (stage == NULL) {
         parse_err(SYNERR, "pipeline stage identifier expected at \"%c\"\n", _curchar);
         continue;
       }
       skipws();
       if (_curchar != '(') {
         parse_err(SYNERR, "\"(\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char();
       read_or_write = get_ident();
       if (read_or_write == NULL) {
         parse_err(SYNERR, "\"read\" or \"write\" expected at \"%c\"\n", _curchar);
         continue;
       }
       is_read  = strcmp(read_or_write, "read")   == 0;
       is_write = strcmp(read_or_write, "write")  == 0;
       if (!is_read && !is_write) {
         parse_err(SYNERR, "\"read\" or \"write\" expected at \"%c\"\n", _curchar);
         continue;
       }
       skipws();
       if (_curchar != ')') {
         parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char(); skipws();
       int more_instrs = 0;
       if (_curchar == '+') {
           next_char(); skipws();
           if (_curchar < '0' || _curchar > '9') {
             parse_err(SYNERR, "<number> expected at \"%c\"\n", _curchar);
             continue;
           }
           while (_curchar >= '0' && _curchar <= '9') {
             more_instrs *= 10;
             more_instrs += _curchar - '0';
             next_char();
           }
           skipws();
       }
       PipeClassOperandForm *pipe_operand = new PipeClassOperandForm(stage, is_write, more_instrs);
       pipe_class->_localUsage.Insert(ident, pipe_operand);
       if (_curchar == '%')
           continue;
       if (_curchar != ';') {
         parse_err(SYNERR, "\";\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char(); skipws();
       continue;
     }
     // Scan for Resource Specifier
     const Form *res = pipeline._resdict[ident];
     if (res != NULL) {
       int cyclecnt = 1;
       if (_curchar != ':') {
         parse_err(SYNERR, "\":\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char(); skipws();
       stage = get_ident();
       if (stage == NULL) {
         parse_err(SYNERR, "pipeline stage identifier expected at \"%c\"\n", _curchar);
         continue;
       }
       skipws();
       if (_curchar == '(') {
         next_char();
         cyclecnt = get_int();
         skipws();
         if (_curchar != ')') {
           parse_err(SYNERR, "\")\" expected at \"%c\"\n", _curchar);
           continue;
         }
         next_char(); skipws();
       }
       PipeClassResourceForm *resource = new PipeClassResourceForm(ident, stage, cyclecnt);
       int stagenum = pipeline._stages.index(stage);
       if (pipeline._maxcycleused < (stagenum+cyclecnt))
         pipeline._maxcycleused = (stagenum+cyclecnt);
       pipe_class->_resUsage.addForm(resource);
       if (_curchar == '%')
           continue;
       if (_curchar != ';') {
         parse_err(SYNERR, "\";\" expected at \"%c\"\n", _curchar);
         continue;
       }
       next_char(); skipws();
       continue;
     }
     parse_err(SYNERR, "resource expected at \"%s\"\n", ident);
     return;
   } while(_curchar != '%');
   next_char();
   if (_curchar != '}') {
     parse_err(SYNERR, "missing \"%}\" in pipe_class definition\n");
     return;
   }
   next_char();
 }
 //------------------------------peep_parse-------------------------------------
 void ADLParser::peep_parse(void) {
   Peephole  *peep;                // Pointer to current peephole rule form
   char      *desc = NULL;         // String representation of rule
   skipws();                       // Skip leading whitespace
   peep = new Peephole();          // Build new Peephole object
   // Check for open block sequence
   skipws();                       // Skip leading whitespace
   if (_curchar == '%' && *(_ptr+1) == '{') {
     next_char(); next_char();     // Skip "%{"
     skipws();
     while (_curchar != '%' && *(_ptr+1) != '}') {
       char *token = get_ident();
       if (token == NULL) {
         parse_err(SYNERR, "missing identifier inside peephole rule.\n");
         return;
       }
       // check for legal subsections of peephole rule
       if (strcmp(token,"peepmatch")==0) {
         peep_match_parse(*peep); }
       else if (strcmp(token,"peepconstraint")==0) {
         peep_constraint_parse(*peep); }
       else if (strcmp(token,"peepreplace")==0) {
         peep_replace_parse(*peep); }
       else {
         parse_err(SYNERR, "expected peepmatch, peepconstraint, or peepreplace for identifier %s.\n", token);
       }
       skipws();
     }
   }
   else {
     parse_err(SYNERR, "Missing %%{ ... %%} block after peephole keyword.\n");
     return;
   }
   next_char();                    // Skip past '%'
   next_char();                    // Skip past '}'
 }
 // ******************** Private Level 2 Parse Functions ********************
 //------------------------------constraint_parse------------------------------
 Constraint *ADLParser::constraint_parse(void) {
   char *func;
   char *arg;
   // Check for constraint expression
   skipws();
   if (_curchar != '(') {
     parse_err(SYNERR, "missing constraint expression, (...)\n");
     return NULL;
   }
   next_char();                    // Skip past '('
   // Get constraint function
   skipws();
   func = get_ident();
   if (func == NULL) {
     parse_err(SYNERR, "missing function in constraint expression.\n");
     return NULL;
   }
   if (strcmp(func,"ALLOC_IN_RC")==0
       || strcmp(func,"IS_R_CLASS")==0) {
     // Check for '(' before argument
     skipws();
     if (_curchar != '(') {
       parse_err(SYNERR, "missing '(' for constraint function's argument.\n");
       return NULL;
     }
     next_char();
     // Get it's argument
     skipws();
     arg = get_ident();
     if (arg == NULL) {
       parse_err(SYNERR, "missing argument for constraint function %s\n",func);
       return NULL;
     }
     // Check for ')' after argument
     skipws();
     if (_curchar != ')') {
       parse_err(SYNERR, "missing ')' after constraint function argument %s\n",arg);
       return NULL;
     }
     next_char();
   } else {
     parse_err(SYNERR, "Invalid constraint function %s\n",func);
     return NULL;
   }
   // Check for closing paren and ';'
   skipws();
   if (_curchar != ')') {
     parse_err(SYNERR, "Missing ')' for constraint function %s\n",func);
     return NULL;
   }
   next_char();
   skipws();
   if (_curchar != ';') {
     parse_err(SYNERR, "Missing ';' after constraint.\n");
     return NULL;
   }
   next_char();
   // Create new "Constraint"
   Constraint *constraint = new Constraint(func,arg);
   return constraint;
 }
 //------------------------------constr_parse-----------------------------------
 ConstructRule *ADLParser::construct_parse(void) {
   return NULL;
 }
 //------------------------------reg_def_parse----------------------------------
 void ADLParser::reg_def_parse(void) {
   char *rname;                   // Name of register being defined
   // Get register name
   skipws();                      // Skip whitespace
   rname = get_ident();
   if (rname == NULL) {
     parse_err(SYNERR, "missing register name after reg_def\n");
     return;
   }
   // Check for definition of register calling convention (save on call, ...),
   // register save type, and register encoding value.
   skipws();
   char *callconv  = NULL;
   char *c_conv    = NULL;
   char *idealtype = NULL;
   char *encoding  = NULL;
   char *concrete = NULL;
   if (_curchar == '(') {
     next_char();
     callconv = get_ident();
     // Parse the internal calling convention, must be NS, SOC, SOE, or AS.
     if (callconv == NULL) {
       parse_err(SYNERR, "missing register calling convention value\n");
       return;
     }
     if(strcmp(callconv, "SOC") && strcmp(callconv,"SOE") &&
        strcmp(callconv, "NS") && strcmp(callconv, "AS")) {
       parse_err(SYNERR, "invalid value for register calling convention\n");
     }
     skipws();
     if (_curchar != ',') {
       parse_err(SYNERR, "missing comma in register definition statement\n");
       return;
     }
     next_char();
     // Parse the native calling convention, must be NS, SOC, SOE, AS
     c_conv = get_ident();
     if (c_conv == NULL) {
       parse_err(SYNERR, "missing register native calling convention value\n");
       return;
     }
     if(strcmp(c_conv, "SOC") && strcmp(c_conv,"SOE") &&
        strcmp(c_conv, "NS") && strcmp(c_conv, "AS")) {
       parse_err(SYNERR, "invalid value for register calling convention\n");
     }
     skipws();
     if (_curchar != ',') {
       parse_err(SYNERR, "missing comma in register definition statement\n");
       return;
     }
     next_char();
     skipws();
     // Parse the ideal save type
     idealtype = get_ident();
     if (idealtype == NULL) {
       parse_err(SYNERR, "missing register save type value\n");
       return;
     }
     skipws();
     if (_curchar != ',') {
       parse_err(SYNERR, "missing comma in register definition statement\n");
       return;
     }
     next_char();
     skipws();
     // Parse the encoding value
     encoding = get_expr("encoding", ",");
     if (encoding == NULL) {
       parse_err(SYNERR, "missing register encoding value\n");
       return;
     }
     trim(encoding);
     if (_curchar != ',') {
       parse_err(SYNERR, "missing comma in register definition statement\n");
       return;
     }
     next_char();
     skipws();
     // Parse the concrete name type
     // concrete = get_ident();
     concrete = get_expr("concrete", ")");
     if (concrete == NULL) {
       parse_err(SYNERR, "missing vm register name value\n");
       return;
     }
     if (_curchar != ')') {
       parse_err(SYNERR, "missing ')' in register definition statement\n");
       return;
     }
     next_char();
   }
   // Check for closing ';'
   skipws();
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' after reg_def\n");
     return;
   }
   next_char();                   // move past ';'
   // Debug Stuff
   if (_AD._adl_debug > 1) {
     fprintf(stderr,"Register Definition: %s ( %s, %s %s )\n", rname,
             (callconv ? callconv : ""), (c_conv ? c_conv : ""), concrete);
   }
   // Record new register definition.
   _AD._register->addRegDef(rname, callconv, c_conv, idealtype, encoding, concrete);
   return;
 }
 //------------------------------reg_class_parse--------------------------------
 void ADLParser::reg_class_parse(void) {
   char *cname;                    // Name of register class being defined
   // Get register class name
   skipws();                       // Skip leading whitespace
   cname = get_ident();
   if (cname == NULL) {
     parse_err(SYNERR, "missing register class name after 'reg_class'\n");
     return;
   }
   // Debug Stuff
   if (_AD._adl_debug >1) fprintf(stderr,"Register Class: %s\n", cname);
   RegClass *reg_class = _AD._register->addRegClass(cname);
   // Collect registers in class
   skipws();
   if (_curchar == '(') {
     next_char();                  // Skip '('
     skipws();
     while (_curchar != ')') {
       char *rname = get_ident();
       if (rname==NULL) {
         parse_err(SYNERR, "missing identifier inside reg_class list.\n");
         return;
       }
       RegDef *regDef = _AD._register->getRegDef(rname);
       if (!regDef) {
         parse_err(SEMERR, "unknown identifier %s inside reg_class list.\n", rname);
       } else {
         reg_class->addReg(regDef); // add regDef to regClass
       }
       // Check for ',' and position to next token.
       skipws();
       if (_curchar == ',') {
         next_char();              // Skip trailing ','
         skipws();
       }
     }
     next_char();                  // Skip closing ')'
   }
   // Check for terminating ';'
   skipws();
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' at end of reg_class definition.\n");
     return;
   }
   next_char();                    // Skip trailing ';'
   // Check RegClass size, must be <= 32 registers in class.
   return;
 }
 //------------------------------alloc_class_parse------------------------------
 void ADLParser::alloc_class_parse(void) {
   char *name;                     // Name of allocation class being defined
   // Get allocation class name
   skipws();                       // Skip leading whitespace
   name = get_ident();
   if (name == NULL) {
     parse_err(SYNERR, "missing allocation class name after 'reg_class'\n");
     return;
   }
   // Debug Stuff
   if (_AD._adl_debug >1) fprintf(stderr,"Allocation Class: %s\n", name);
   AllocClass *alloc_class = _AD._register->addAllocClass(name);
   // Collect registers in class
   skipws();
   if (_curchar == '(') {
     next_char();                  // Skip '('
     skipws();
     while (_curchar != ')') {
       char *rname = get_ident();
       if (rname==NULL) {
         parse_err(SYNERR, "missing identifier inside reg_class list.\n");
         return;
       }
       // Check if name is a RegDef
       RegDef *regDef = _AD._register->getRegDef(rname);
       if (regDef) {
         alloc_class->addReg(regDef);   // add regDef to allocClass
       } else {
         // name must be a RegDef or a RegClass
         parse_err(SYNERR, "name %s should be a previously defined reg_def.\n", rname);
         return;
       }
       // Check for ',' and position to next token.
       skipws();
       if (_curchar == ',') {
         next_char();              // Skip trailing ','
         skipws();
       }
     }
     next_char();                  // Skip closing ')'
   }
   // Check for terminating ';'
   skipws();
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' at end of reg_class definition.\n");
     return;
   }
   next_char();                    // Skip trailing ';'
   return;
 }
 //------------------------------peep_match_child_parse-------------------------
 InstructForm *ADLParser::peep_match_child_parse(PeepMatch &match, int parent, int &position, int input){
   char      *token  = NULL;
   int        lparen = 0;          // keep track of parenthesis nesting depth
   int        rparen = 0;          // position of instruction at this depth
   InstructForm *inst_seen  = NULL;
   InstructForm *child_seen = NULL;
   // Walk the match tree,
   // Record <parent, position, instruction name, input position>
   while ( lparen >= rparen ) {
     skipws();
     // Left paren signals start of an input, collect with recursive call
     if (_curchar == '(') {
       ++lparen;
       next_char();
       child_seen = peep_match_child_parse(match, parent, position, rparen);
     }
     // Right paren signals end of an input, may be more
     else if (_curchar == ')') {
       ++rparen;
       if( rparen == lparen ) { // IF rparen matches an lparen I've seen
         next_char();           //    move past ')'
       } else {                 // ELSE leave ')' for parent
         assert( rparen == lparen + 1, "Should only see one extra ')'");
         // if an instruction was not specified for this paren-pair
         if( ! inst_seen ) {   // record signal entry
           match.add_instruction( parent, position, NameList::_signal, input );
           ++position;
         }
         // ++input;   // TEMPORARY
         return inst_seen;
       }
     }
     // if no parens, then check for instruction name
     // This instruction is the parent of a sub-tree
     else if ((token = get_ident_dup()) != NULL) {
       const Form *form = _AD._globalNames[token];
       if (form) {
         InstructForm *inst = form->is_instruction();
         // Record the first instruction at this level
         if( inst_seen == NULL ) {
           inst_seen = inst;
         }
         if (inst) {
           match.add_instruction( parent, position, token, input );
           parent = position;
           ++position;
         } else {
           parse_err(SYNERR, "instruction name expected at identifier %s.\n",
                     token);
           return inst_seen;
         }
       }
       else {
         parse_err(SYNERR, "missing identifier in peepmatch rule.\n");
         return NULL;
       }
     }
     else {
       parse_err(SYNERR, "missing identifier in peepmatch rule.\n");
       return NULL;
     }
   } // end while
   assert( false, "ShouldNotReachHere();");
   return NULL;
 }
 //------------------------------peep_match_parse-------------------------------
 // Syntax for a peepmatch rule
 //
 // peepmatch ( root_instr_name [(instruction subtree)] [,(instruction subtree)]* );
 //
 void ADLParser::peep_match_parse(Peephole &peep) {
   skipws();
   // Check the structure of the rule
   // Check for open paren
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' at start of peepmatch rule.\n");
     return;
   }
   next_char();   // skip '('
   // Construct PeepMatch and parse the peepmatch rule.
   PeepMatch *match = new PeepMatch(_ptr);
   int  parent   = -1;                   // parent of root
   int  position = 0;                    // zero-based positions
   int  input    = 0;                    // input position in parent's operands
   InstructForm *root= peep_match_child_parse( *match, parent, position, input);
   if( root == NULL ) {
     parse_err(SYNERR, "missing instruction-name at start of peepmatch.\n");
     return;
   }
   if( _curchar != ')' ) {
     parse_err(SYNERR, "missing ')' at end of peepmatch.\n");
     return;
   }
   next_char();   // skip ')'
   // Check for closing semicolon
   skipws();
   if( _curchar != ';' ) {
     parse_err(SYNERR, "missing ';' at end of peepmatch.\n");
     return;
   }
   next_char();   // skip ';'
   // Store match into peep, and store peep into instruction
   peep.add_match(match);
   root->append_peephole(&peep);
 }
 //------------------------------peep_constraint_parse--------------------------
 // Syntax for a peepconstraint rule
 // A parenthesized list of relations between operands in peepmatch subtree
 //
 // peepconstraint %{
 // (instruction_number.operand_name
 //     relational_op
 //  instruction_number.operand_name OR register_name
 //  [, ...] );
 //
 // // instruction numbers are zero-based using topological order in peepmatch
 //
 void ADLParser::peep_constraint_parse(Peephole &peep) {
   skipws();
   // Check the structure of the rule
   // Check for open paren
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' at start of peepconstraint rule.\n");
     return;
   }
   else {
     next_char();                  // Skip '('
   }
   // Check for a constraint
   skipws();
   while( _curchar != ')' ) {
     // Get information on the left instruction and its operand
     // left-instructions's number
     int left_inst = get_int();
     // Left-instruction's operand
     skipws();
     if( _curchar != '.' ) {
       parse_err(SYNERR, "missing '.' in peepconstraint after instruction number.\n");
       return;
     }
     next_char();                  // Skip '.'
     char *left_op = get_ident_dup();
     skipws();
     // Collect relational operator
     char *relation = get_relation_dup();
     skipws();
     // Get information on the right instruction and its operand
     int right_inst;        // Right-instructions's number
     if( isdigit(_curchar) ) {
       right_inst = get_int();
       // Right-instruction's operand
       skipws();
       if( _curchar != '.' ) {
         parse_err(SYNERR, "missing '.' in peepconstraint after instruction number.\n");
         return;
       }
       next_char();              // Skip '.'
     } else {
       right_inst = -1;          // Flag as being a register constraint
     }
     char *right_op = get_ident_dup();
     // Construct the next PeepConstraint
     PeepConstraint *constraint = new PeepConstraint( left_inst, left_op,
                                                      relation,
                                                      right_inst, right_op );
     // And append it to the list for this peephole rule
     peep.append_constraint( constraint );
     // Check for another constraint, or end of rule
     skipws();
     if( _curchar == ',' ) {
       next_char();                // Skip ','
       skipws();
     }
     else if( _curchar != ')' ) {
       parse_err(SYNERR, "expected ',' or ')' after peephole constraint.\n");
       return;
     }
   } // end while( processing constraints )
   next_char();                    // Skip ')'
   // Check for terminating ';'
   skipws();
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' at end of peepconstraint.\n");
     return;
   }
   next_char();                    // Skip trailing ';'
 }
 //------------------------------peep_replace_parse-----------------------------
 // Syntax for a peepreplace rule
 // root instruction name followed by a
 // parenthesized list of whitespace separated instruction.operand specifiers
 //
 // peepreplace ( instr_name  ( [instruction_number.operand_name]* ) );
 //
 //
 void ADLParser::peep_replace_parse(Peephole &peep) {
   int          lparen = 0;        // keep track of parenthesis nesting depth
   int          rparen = 0;        // keep track of parenthesis nesting depth
   int          icount = 0;        // count of instructions in rule for naming
   char        *str    = NULL;
   char        *token  = NULL;
   skipws();
   // Check for open paren
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' at start of peepreplace rule.\n");
     return;
   }
   else {
     lparen++;
     next_char();
   }
   // Check for root instruction
   char       *inst = get_ident_dup();
   const Form *form = _AD._globalNames[inst];
   if( form == NULL || form->is_instruction() == NULL ) {
     parse_err(SYNERR, "Instruction name expected at start of peepreplace.\n");
     return;
   }
   // Store string representation of rule into replace
   PeepReplace *replace = new PeepReplace(str);
   replace->add_instruction( inst );
   skipws();
   // Start of root's operand-list
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' at peepreplace root's operand-list.\n");
     return;
   }
   else {
     lparen++;
     next_char();
   }
   skipws();
   // Get the list of operands
   while( _curchar != ')' ) {
     // Get information on an instruction and its operand
     // instructions's number
     int   inst_num = get_int();
     // Left-instruction's operand
     skipws();
     if( _curchar != '.' ) {
       parse_err(SYNERR, "missing '.' in peepreplace after instruction number.\n");
       return;
     }
     next_char();                  // Skip '.'
     char *inst_op = get_ident_dup();
     if( inst_op == NULL ) {
       parse_err(SYNERR, "missing operand identifier in peepreplace.\n");
       return;
     }
     // Record this operand's position in peepmatch
     replace->add_operand( inst_num, inst_op );
     skipws();
   }
   // Check for the end of operands list
   skipws();
   assert( _curchar == ')', "While loop should have advanced to ')'.");
   next_char();  // Skip ')'
   skipws();
   // Check for end of peepreplace
   if( _curchar != ')' ) {
     parse_err(SYNERR, "missing ')' at end of peepmatch.\n");
     parse_err(SYNERR, "Support one replacement instruction.\n");
     return;
   }
   next_char(); // Skip ')'
   // Check for closing semicolon
   skipws();
   if( _curchar != ';' ) {
     parse_err(SYNERR, "missing ';' at end of peepreplace.\n");
     return;
   }
   next_char();   // skip ';'
   // Store replace into peep
   peep.add_replace( replace );
 }
 //------------------------------pred_parse-------------------------------------
 Predicate *ADLParser::pred_parse(void) {
   Predicate *predicate;           // Predicate class for operand
   char      *rule = NULL;         // String representation of predicate
   skipws();                       // Skip leading whitespace
   int line = linenum();
   if ( (rule = get_paren_expr("pred expression", true)) == NULL ) {
     parse_err(SYNERR, "incorrect or missing expression for 'predicate'\n");
     return NULL;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Predicate: %s\n", rule);
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in predicate definition\n");
     return NULL;
   }
   next_char();                     // Point after the terminator
   predicate = new Predicate(rule); // Build new predicate object
   skipws();
   return predicate;
 }
 //------------------------------ins_encode_parse_block-------------------------
 // Parse the block form of ins_encode.  See ins_encode_parse for more details
 InsEncode *ADLParser::ins_encode_parse_block(InstructForm &inst) {
   // Create a new encoding name based on the name of the instruction
   // definition, which should be unique.
   const char * prefix = "__enc_";
   char* ec_name = (char*)malloc(strlen(inst._ident) + strlen(prefix) + 1);
   sprintf(ec_name, "%s%s", prefix, inst._ident);
   assert(_AD._encode->encClass(ec_name) == NULL, "shouldn't already exist");
   EncClass  *encoding = _AD._encode->add_EncClass(ec_name);
   encoding->_linenum = linenum();
   // synthesize the arguments list for the enc_class from the
   // arguments to the instruct definition.
   const char * param = NULL;
   inst._parameters.reset();
   while ((param = inst._parameters.iter()) != NULL) {
     OperandForm *opForm = (OperandForm*)inst._localNames[param];
     encoding->add_parameter(opForm->_ident, param);
   }
   // Add the prologue to create the MacroAssembler
   encoding->add_code("\n"
   "    // Define a MacroAssembler instance for use by the encoding.  The\n"
   "    // name is chosen to match the __ idiom used for assembly in other\n"
   "    // parts of hotspot and assumes the existence of the standard\n"
   "    // #define __ _masm.\n"
   "    MacroAssembler _masm(&cbuf);\n");
   // Parse the following %{ }% block
   enc_class_parse_block(encoding, ec_name);
   // Build an encoding rule which invokes the encoding rule we just
   // created, passing all arguments that we received.
   InsEncode *encrule  = new InsEncode(); // Encode class for instruction
   NameAndList *params = encrule->add_encode(ec_name);
   inst._parameters.reset();
   while ((param = inst._parameters.iter()) != NULL) {
     params->add_entry(param);
   }
   return encrule;
 }
 //------------------------------ins_encode_parse-------------------------------
 // Encode rules have the form
 //   ins_encode( encode_class_name(parameter_list), ... );
 //
 // The "encode_class_name" must be defined in the encode section
 // The parameter list contains $names that are locals.
 //
 // Alternatively it can be written like this:
 //
 //   ins_encode %{
 //      ... // body
 //   %}
 //
 // which synthesizes a new encoding class taking the same arguments as
 // the InstructForm, and automatically prefixes the definition with:
 //
 //    MacroAssembler masm(&cbuf);\n");
 //
 //  making it more compact to take advantage of the MacroAssembler and
 //  placing the assembly closer to it's use by instructions.
 InsEncode *ADLParser::ins_encode_parse(InstructForm &inst) {
   // Parse encode class name
   skipws();                        // Skip whitespace
   if (_curchar != '(') {
     // Check for ins_encode %{ form
     if ((_curchar == '%') && (*(_ptr+1) == '{')) {
       next_char();                      // Skip '%'
       next_char();                      // Skip '{'
       // Parse the block form of ins_encode
       return ins_encode_parse_block(inst);
     }
     parse_err(SYNERR, "missing '%%{' or '(' in ins_encode definition\n");
     return NULL;
   }
   next_char();                     // move past '('
   skipws();
   InsEncode *encrule  = new InsEncode(); // Encode class for instruction
   encrule->_linenum = linenum();
   char      *ec_name  = NULL;      // String representation of encode rule
   // identifier is optional.
   while (_curchar != ')') {
     ec_name = get_ident();
     if (ec_name == NULL) {
       parse_err(SYNERR, "Invalid encode class name after 'ins_encode('.\n");
       return NULL;
     }
     // Check that encoding is defined in the encode section
     EncClass *encode_class = _AD._encode->encClass(ec_name);
     if (encode_class == NULL) {
       // Like to defer checking these till later...
       // parse_err(WARN, "Using an undefined encode class '%s' in 'ins_encode'.\n", ec_name);
     }
     // Get list for encode method's parameters
     NameAndList *params = encrule->add_encode(ec_name);
     // Parse the parameters to this encode method.
     skipws();
     if ( _curchar == '(' ) {
       next_char();                 // move past '(' for parameters
       // Parse the encode method's parameters
       while (_curchar != ')') {
         char *param = get_ident_or_literal_constant("encoding operand");
         if ( param != NULL ) {
           // Found a parameter:
           // Check it is a local name, add it to the list, then check for more
           // New: allow hex constants as parameters to an encode method.
           // New: allow parenthesized expressions as parameters.
           // New: allow "primary", "secondary", "tertiary" as parameters.
           // New: allow user-defined register name as parameter
           if ( (inst._localNames[param] == NULL) &&
                !ADLParser::is_literal_constant(param) &&
                (Opcode::as_opcode_type(param) == Opcode::NOT_AN_OPCODE) &&
                ((_AD._register == NULL ) || (_AD._register->getRegDef(param) == NULL)) ) {
             parse_err(SYNERR, "Using non-locally defined parameter %s for encoding %s.\n", param, ec_name);
             return NULL;
           }
           params->add_entry(param);
           skipws();
           if (_curchar == ',' ) {
             // More parameters to come
             next_char();           // move past ',' between parameters
             skipws();              // Skip to next parameter
           }
           else if (_curchar == ')') {
             // Done with parameter list
           }
           else {
             // Only ',' or ')' are valid after a parameter name
             parse_err(SYNERR, "expected ',' or ')' after parameter %s.\n",
                       ec_name);
             return NULL;
           }
         } else {
           skipws();
           // Did not find a parameter
           if (_curchar == ',') {
             parse_err(SYNERR, "Expected encode parameter before ',' in encoding %s.\n", ec_name);
             return NULL;
           }
           if (_curchar != ')') {
             parse_err(SYNERR, "Expected ')' after encode parameters.\n");
             return NULL;
           }
         }
       } // WHILE loop collecting parameters
       next_char();                   // move past ')' at end of parameters
     } // done with parameter list for encoding
     // Check for ',' or ')' after encoding
     skipws();                      // move to character after parameters
     if ( _curchar == ',' ) {
       // Found a ','
       next_char();                 // move past ',' between encode methods
       skipws();
     }
     else if ( _curchar != ')' ) {
       // If not a ',' then only a ')' is allowed
       parse_err(SYNERR, "Expected ')' after encoding %s.\n", ec_name);
       return NULL;
     }
     // Check for ',' separating parameters
     // if ( _curchar != ',' && _curchar != ')' ) {
     //   parse_err(SYNERR, "expected ',' or ')' after encode method inside ins_encode.\n");
     //   return NULL;
     // }
   } // done parsing ins_encode methods and their parameters
   if (_curchar != ')') {
     parse_err(SYNERR, "Missing ')' at end of ins_encode description.\n");
     return NULL;
   }
   next_char();                     // move past ')'
   skipws();                        // Skip leading whitespace
   if ( _curchar != ';' ) {
     parse_err(SYNERR, "Missing ';' at end of ins_encode.\n");
     return NULL;
   }
   next_char();                     // move past ';'
   skipws();                        // be friendly to oper_parse()
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Instruction Encode: %s\n", ec_name);
   return encrule;
 }
 //------------------------------size_parse-----------------------------------
 char* ADLParser::size_parse(InstructForm *instr) {
   char* sizeOfInstr = NULL;
   // Get value of the instruction's size
   skipws();
   // Parse size
   sizeOfInstr = get_paren_expr("size expression");
   if (sizeOfInstr == NULL) {
      parse_err(SYNERR, "size of opcode expected at %c\n", _curchar);
      return NULL;
   }
   skipws();
   // Check for terminator
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in ins_attrib definition\n");
     return NULL;
   }
   next_char();                     // Advance past the ';'
   skipws();                        // necessary for instr_parse()
   // Debug Stuff
   if (_AD._adl_debug > 1) {
     if (sizeOfInstr != NULL) {
       fprintf(stderr,"size of opcode: %s\n", sizeOfInstr);
     }
   }
   return sizeOfInstr;
 }
 //------------------------------opcode_parse-----------------------------------
 Opcode * ADLParser::opcode_parse(InstructForm *instr) {
   char *primary   = NULL;
   char *secondary = NULL;
   char *tertiary  = NULL;
   char   *val    = NULL;
   Opcode *opcode = NULL;
   // Get value of the instruction's opcode
   skipws();
   if (_curchar != '(') {         // Check for parenthesized operand list
     parse_err(SYNERR, "missing '(' in expand instruction declaration\n");
     return NULL;
   }
   next_char();                   // skip open paren
   skipws();
   if (_curchar != ')') {
     // Parse primary, secondary, and tertiary opcodes, if provided.
     if ( ((primary = get_ident_or_literal_constant("primary opcode")) == NULL) ) {
         parse_err(SYNERR, "primary hex opcode expected at %c\n", _curchar);
         return NULL;
     }
     skipws();
     if (_curchar == ',') {
       next_char();
       skipws();
       // Parse secondary opcode
       if ( ((secondary = get_ident_or_literal_constant("secondary opcode")) == NULL) ) {
         parse_err(SYNERR, "secondary hex opcode expected at %c\n", _curchar);
         return NULL;
       }
       skipws();
       if (_curchar == ',') {
         next_char();
         skipws();
         // Parse tertiary opcode
         if ( ((tertiary = get_ident_or_literal_constant("tertiary opcode")) == NULL) ) {
           parse_err(SYNERR,"tertiary hex opcode expected at %c\n", _curchar);
           return NULL;
         }
         skipws();
       }
     }
     skipws();
     if (_curchar != ')') {
       parse_err(SYNERR, "Missing ')' in opcode description\n");
       return NULL;
     }
   }
   next_char();                     // Skip ')'
   skipws();
   // Check for terminator
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in ins_attrib definition\n");
     return NULL;
   }
   next_char();                     // Advance past the ';'
   skipws();                        // necessary for instr_parse()
   // Debug Stuff
   if (_AD._adl_debug > 1) {
     if (primary   != NULL) fprintf(stderr,"primary   opcode: %s\n", primary);
     if (secondary != NULL) fprintf(stderr,"secondary opcode: %s\n", secondary);
     if (tertiary  != NULL) fprintf(stderr,"tertiary  opcode: %s\n", tertiary);
   }
   // Generate new object and return
   opcode = new Opcode(primary, secondary, tertiary);
   return opcode;
 }
 //------------------------------interface_parse--------------------------------
 Interface *ADLParser::interface_parse(void) {
   char *iface_name  = NULL;      // Name of interface class being used
   char *iface_code  = NULL;      // Describe components of this class
   // Get interface class name
   skipws();                       // Skip whitespace
   if (_curchar != '(') {
     parse_err(SYNERR, "Missing '(' at start of interface description.\n");
     return NULL;
   }
   next_char();                    // move past '('
   skipws();
   iface_name = get_ident();
   if (iface_name == NULL) {
     parse_err(SYNERR, "missing interface name after 'interface'.\n");
     return NULL;
   }
   skipws();
   if (_curchar != ')') {
     parse_err(SYNERR, "Missing ')' after name of interface.\n");
     return NULL;
   }
   next_char();                    // move past ')'
   // Get details of the interface,
   // for the type of interface indicated by iface_name.
   Interface *inter = NULL;
   skipws();
   if ( _curchar != ';' ) {
     if ( strcmp(iface_name,"MEMORY_INTER") == 0 ) {
       inter = mem_interface_parse();
     }
     else if ( strcmp(iface_name,"COND_INTER") == 0 ) {
       inter = cond_interface_parse();
     }
     // The parse routines consume the "%}"
     // Check for probable extra ';' after defining block.
     if ( _curchar == ';' ) {
       parse_err(SYNERR, "Extra ';' after defining interface block.\n");
       next_char();                // Skip ';'
       return NULL;
     }
   } else {
     next_char();                  // move past ';'
     // Create appropriate interface object
     if ( strcmp(iface_name,"REG_INTER") == 0 ) {
       inter = new RegInterface();
     }
     else if ( strcmp(iface_name,"CONST_INTER") == 0 ) {
       inter = new ConstInterface();
     }
   }
   skipws();                       // be friendly to oper_parse()
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Interface Form: %s\n", iface_name);
   // Create appropriate interface object and return.
   return inter;
 }
 //------------------------------mem_interface_parse----------------------------
 Interface *ADLParser::mem_interface_parse(void) {
   // Fields for MemInterface
   char *base        = NULL;
   char *index       = NULL;
   char *scale       = NULL;
   char *disp        = NULL;
   if (_curchar != '%') {
     parse_err(SYNERR, "Missing '%{' for 'interface' block.\n");
     return NULL;
   }
   next_char();                  // Skip '%'
   if (_curchar != '{') {
     parse_err(SYNERR, "Missing '%{' for 'interface' block.\n");
     return NULL;
   }
   next_char();                  // Skip '{'
   skipws();
   do {
     char *field = get_ident();
     if (field == NULL) {
       parse_err(SYNERR, "Expected keyword, base|index|scale|disp,  or '%}' ending interface.\n");
       return NULL;
     }
     if ( strcmp(field,"base") == 0 ) {
       base  = interface_field_parse();
     }
     else if ( strcmp(field,"index") == 0 ) {
       index = interface_field_parse();
     }
     else if ( strcmp(field,"scale") == 0 ) {
       scale = interface_field_parse();
     }
     else if ( strcmp(field,"disp") == 0 ) {
       disp  = interface_field_parse();
     }
     else {
       parse_err(SYNERR, "Expected keyword, base|index|scale|disp,  or '%}' ending interface.\n");
       return NULL;
     }
   } while( _curchar != '%' );
   next_char();                  // Skip '%'
   if ( _curchar != '}' ) {
     parse_err(SYNERR, "Missing '%}' for 'interface' block.\n");
     return NULL;
   }
   next_char();                  // Skip '}'
   // Construct desired object and return
   Interface *inter = new MemInterface(base, index, scale, disp);
   return inter;
 }
 //------------------------------cond_interface_parse---------------------------
 Interface *ADLParser::cond_interface_parse(void) {
   char *equal;
   char *not_equal;
   char *less;
   char *greater_equal;
   char *less_equal;
   char *greater;
   const char *equal_format = "eq";
   const char *not_equal_format = "ne";
   const char *less_format = "lt";
   const char *greater_equal_format = "ge";
   const char *less_equal_format = "le";
   const char *greater_format = "gt";
   if (_curchar != '%') {
     parse_err(SYNERR, "Missing '%{' for 'cond_interface' block.\n");
     return NULL;
   }
   next_char();                  // Skip '%'
   if (_curchar != '{') {
     parse_err(SYNERR, "Missing '%{' for 'cond_interface' block.\n");
     return NULL;
   }
   next_char();                  // Skip '{'
   skipws();
   do {
     char *field = get_ident();
     if (field == NULL) {
       parse_err(SYNERR, "Expected keyword, base|index|scale|disp,  or '%}' ending interface.\n");
       return NULL;
     }
     if ( strcmp(field,"equal") == 0 ) {
       equal  = interface_field_parse(&equal_format);
     }
     else if ( strcmp(field,"not_equal") == 0 ) {
       not_equal = interface_field_parse(&not_equal_format);
     }
     else if ( strcmp(field,"less") == 0 ) {
       less = interface_field_parse(&less_format);
     }
     else if ( strcmp(field,"greater_equal") == 0 ) {
       greater_equal  = interface_field_parse(&greater_equal_format);
     }
     else if ( strcmp(field,"less_equal") == 0 ) {
       less_equal = interface_field_parse(&less_equal_format);
     }
     else if ( strcmp(field,"greater") == 0 ) {
       greater = interface_field_parse(&greater_format);
     }
     else {
       parse_err(SYNERR, "Expected keyword, base|index|scale|disp,  or '%}' ending interface.\n");
       return NULL;
     }
   } while( _curchar != '%' );
   next_char();                  // Skip '%'
   if ( _curchar != '}' ) {
     parse_err(SYNERR, "Missing '%}' for 'interface' block.\n");
     return NULL;
   }
   next_char();                  // Skip '}'
   // Construct desired object and return
   Interface *inter = new CondInterface(equal,         equal_format,
                                        not_equal,     not_equal_format,
                                        less,          less_format,
                                        greater_equal, greater_equal_format,
                                        less_equal,    less_equal_format,
                                        greater,       greater_format);
   return inter;
 }
 //------------------------------interface_field_parse--------------------------
 char *ADLParser::interface_field_parse(const char ** format) {
   char *iface_field = NULL;
   // Get interface field
   skipws();                      // Skip whitespace
   if (_curchar != '(') {
     parse_err(SYNERR, "Missing '(' at start of interface field.\n");
     return NULL;
   }
   next_char();                   // move past '('
   skipws();
   if ( _curchar != '0' && _curchar != '$' ) {
     parse_err(SYNERR, "missing or invalid interface field contents.\n");
     return NULL;
   }
   iface_field = get_rep_var_ident();
   if (iface_field == NULL) {
     parse_err(SYNERR, "missing or invalid interface field contents.\n");
     return NULL;
   }
   skipws();
   if (format != NULL && _curchar == ',') {
     next_char();
     skipws();
     if (_curchar != '"') {
       parse_err(SYNERR, "Missing '\"' in field format .\n");
       return NULL;
     }
     next_char();
     char *start = _ptr;       // Record start of the next string
     while ((_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) {
       if (_curchar == '\\')  next_char();  // superquote
       if (_curchar == '\n')  parse_err(SYNERR, "newline in string");  // unimplemented!
       next_char();
     }
     if (_curchar != '"') {
       parse_err(SYNERR, "Missing '\"' at end of field format .\n");
       return NULL;
     }
     // If a string was found, terminate it and record in FormatRule
     if ( start != _ptr ) {
       *_ptr  = '\0';          // Terminate the string
       *format = start;
     }
     next_char();
     skipws();
   }
   if (_curchar != ')') {
     parse_err(SYNERR, "Missing ')' after interface field.\n");
     return NULL;
   }
   next_char();                   // move past ')'
   skipws();
   if ( _curchar != ';' ) {
     parse_err(SYNERR, "Missing ';' at end of interface field.\n");
     return NULL;
   }
   next_char();                    // move past ';'
   skipws();                       // be friendly to interface_parse()
   return iface_field;
 }
 //------------------------------match_parse------------------------------------
 MatchRule *ADLParser::match_parse(FormDict &operands) {
   MatchRule *match;               // Match Rule class for instruction/operand
   char      *cnstr = NULL;        // Code for constructor
   int        depth = 0;           // Counter for matching parentheses
   int        numleaves = 0;       // Counter for number of leaves in rule
   // Parse the match rule tree
   MatchNode *mnode = matchNode_parse(operands, depth, numleaves, true);
   // Either there is a block with a constructor, or a ';' here
   skipws();                       // Skip whitespace
   if ( _curchar == ';' ) {        // Semicolon is valid terminator
     cnstr = NULL;                 // no constructor for this form
     next_char();                  // Move past the ';', replaced with '\0'
   }
   else if ((cnstr = find_cpp_block("match constructor")) == NULL ) {
     parse_err(SYNERR, "invalid construction of match rule\n"
               "Missing ';' or invalid '%{' and '%}' constructor\n");
     return NULL;                  // No MatchRule to return
   }
   if (_AD._adl_debug > 1)
     if (cnstr) fprintf(stderr,"Match Constructor: %s\n", cnstr);
   // Build new MatchRule object
   match = new MatchRule(_AD, mnode, depth, cnstr, numleaves);
   skipws();                       // Skip any trailing whitespace
   return match;                   // Return MatchRule object
 }
 //------------------------------format_parse-----------------------------------
 FormatRule* ADLParser::format_parse(void) {
   char       *desc   = NULL;
   FormatRule *format = (new FormatRule(desc));
   // Without expression form, MUST have a code block;
   skipws();                       // Skip whitespace
   if ( _curchar == ';' ) {        // Semicolon is valid terminator
     desc  = NULL;                 // no constructor for this form
     next_char();                  // Move past the ';', replaced with '\0'
   }
   else if ( _curchar == '%' && *(_ptr+1) == '{') {
     next_char();                  // Move past the '%'
     next_char();                  // Move past the '{'
     skipws();
     if (_curchar == '$') {
       char* ident = get_rep_var_ident();
       if (strcmp(ident, "$$template") == 0) return template_parse();
       parse_err(SYNERR, "Unknown \"%s\" directive in format", ident);
       return NULL;
     }
     // Check for the opening '"' inside the format description
     if ( _curchar == '"' ) {
       next_char();              // Move past the initial '"'
       if( _curchar == '"' ) {   // Handle empty format string case
         *_ptr = '\0';           // Terminate empty string
         format->_strings.addName(_ptr);
       }
       // Collect the parts of the format description
       // (1) strings that are passed through to tty->print
       // (2) replacement/substitution variable, preceeded by a '$'
       // (3) multi-token ANSIY C style strings
       while ( true ) {
         if ( _curchar == '%' || _curchar == '\n' ) {
           if ( _curchar != '"' ) {
             parse_err(SYNERR, "missing '\"' at end of format block");
             return NULL;
           }
         }
         // (1)
         // Check if there is a string to pass through to output
         char *start = _ptr;       // Record start of the next string
         while ((_curchar != '$') && (_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) {
           if (_curchar == '\\') {
             next_char();  // superquote
             if ((_curchar == '$') || (_curchar == '%'))
               // hack to avoid % escapes and warnings about undefined \ escapes
               *(_ptr-1) = _curchar;
           }
           if (_curchar == '\n')  parse_err(SYNERR, "newline in string");  // unimplemented!
           next_char();
         }
         // If a string was found, terminate it and record in FormatRule
         if ( start != _ptr ) {
           *_ptr  = '\0';          // Terminate the string
           format->_strings.addName(start);
         }
         // (2)
         // If we are at a replacement variable,
         // copy it and record in FormatRule
         if ( _curchar == '$' ) {
           next_char();          // Move past the '$'
           char* rep_var = get_ident(); // Nil terminate the variable name
           rep_var = strdup(rep_var);// Copy the string
           *_ptr   = _curchar;     // and replace Nil with original character
           format->_rep_vars.addName(rep_var);
           // Add flag to _strings list indicating we should check _rep_vars
           format->_strings.addName(NameList::_signal);
         }
         // (3)
         // Allow very long strings to be broken up,
         // using the ANSI C syntax "foo\n" <newline> "bar"
         if ( _curchar == '"') {
           next_char();           // Move past the '"'
           skipws();              // Skip white space before next string token
           if ( _curchar != '"') {
             break;
           } else {
             // Found one.  Skip both " and the whitespace in between.
             next_char();
           }
         }
       } // end while part of format description
       // Check for closing '"' and '%}' in format description
       skipws();                   // Move to closing '%}'
       if ( _curchar != '%' ) {
         parse_err(SYNERR, "non-blank characters between closing '\"' and '%' in format");
         return NULL;
       }
     } // Done with format description inside
     skipws();
     // Past format description, at '%'
     if ( _curchar != '%' || *(_ptr+1) != '}' ) {
       parse_err(SYNERR, "missing '%}' at end of format block");
       return NULL;
     }
     next_char();                  // Move past the '%'
     next_char();                  // Move past the '}'
   }
   else {  // parameter list alone must terminate with a ';'
     parse_err(SYNERR, "missing ';' after Format expression");
     return NULL;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Format Rule: %s\n", desc);
   skipws();
   return format;
 }
 //------------------------------template_parse-----------------------------------
 FormatRule* ADLParser::template_parse(void) {
   char       *desc   = NULL;
   FormatRule *format = (new FormatRule(desc));
   skipws();
   while ( (_curchar != '%') && (*(_ptr+1) != '}') ) {
     // (1)
     // Check if there is a string to pass through to output
     {
       char *start = _ptr;       // Record start of the next string
       while ((_curchar != '$') && ((_curchar != '%') || (*(_ptr+1) != '}')) ) {
         // If at the start of a comment, skip past it
         if( (_curchar == '/') && ((*(_ptr+1) == '/') || (*(_ptr+1) == '*')) ) {
           skipws_no_preproc();
         } else {
           // ELSE advance to the next character, or start of the next line
           next_char_or_line();
         }
       }
       // If a string was found, terminate it and record in EncClass
       if ( start != _ptr ) {
         *_ptr  = '\0';          // Terminate the string
         // Add flag to _strings list indicating we should check _rep_vars
         format->_strings.addName(NameList::_signal2);
         format->_strings.addName(start);
       }
     }
     // (2)
     // If we are at a replacement variable,
     // copy it and record in EncClass
     if ( _curchar == '$' ) {
       // Found replacement Variable
       char *rep_var = get_rep_var_ident_dup();
       if (strcmp(rep_var, "$emit") == 0) {
         // switch to normal format parsing
         next_char();
         next_char();
         skipws();
         // Check for the opening '"' inside the format description
         if ( _curchar == '"' ) {
           next_char();              // Move past the initial '"'
           if( _curchar == '"' ) {   // Handle empty format string case
             *_ptr = '\0';           // Terminate empty string
             format->_strings.addName(_ptr);
           }
           // Collect the parts of the format description
           // (1) strings that are passed through to tty->print
           // (2) replacement/substitution variable, preceeded by a '$'
           // (3) multi-token ANSIY C style strings
           while ( true ) {
             if ( _curchar == '%' || _curchar == '\n' ) {
               parse_err(SYNERR, "missing '\"' at end of format block");
               return NULL;
             }
             // (1)
             // Check if there is a string to pass through to output
             char *start = _ptr;       // Record start of the next string
             while ((_curchar != '$') && (_curchar != '"') && (_curchar != '%') && (_curchar != '\n')) {
               if (_curchar == '\\')  next_char();  // superquote
               if (_curchar == '\n')  parse_err(SYNERR, "newline in string");  // unimplemented!
               next_char();
             }
             // If a string was found, terminate it and record in FormatRule
             if ( start != _ptr ) {
               *_ptr  = '\0';          // Terminate the string
               format->_strings.addName(start);
             }
             // (2)
             // If we are at a replacement variable,
             // copy it and record in FormatRule
             if ( _curchar == '$' ) {
               next_char();          // Move past the '$'
               char* next_rep_var = get_ident(); // Nil terminate the variable name
               next_rep_var = strdup(next_rep_var);// Copy the string
               *_ptr   = _curchar;     // and replace Nil with original character
               format->_rep_vars.addName(next_rep_var);
               // Add flag to _strings list indicating we should check _rep_vars
               format->_strings.addName(NameList::_signal);
             }
             // (3)
             // Allow very long strings to be broken up,
             // using the ANSI C syntax "foo\n" <newline> "bar"
             if ( _curchar == '"') {
               next_char();           // Move past the '"'
               skipws();              // Skip white space before next string token
               if ( _curchar != '"') {
                 break;
               } else {
                 // Found one.  Skip both " and the whitespace in between.
                 next_char();
               }
             }
           } // end while part of format description
         }
       } else {
         // Add flag to _strings list indicating we should check _rep_vars
         format->_rep_vars.addName(rep_var);
         // Add flag to _strings list indicating we should check _rep_vars
         format->_strings.addName(NameList::_signal3);
       }
     } // end while part of format description
   }
   skipws();
   // Past format description, at '%'
   if ( _curchar != '%' || *(_ptr+1) != '}' ) {
     parse_err(SYNERR, "missing '%}' at end of format block");
     return NULL;
   }
   next_char();                  // Move past the '%'
   next_char();                  // Move past the '}'
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Format Rule: %s\n", desc);
   skipws();
   return format;
 }
 //------------------------------effect_parse-----------------------------------
 void ADLParser::effect_parse(InstructForm *instr) {
   char* desc   = NULL;
   skipws();                      // Skip whitespace
   if (_curchar != '(') {
     parse_err(SYNERR, "missing '(' in effect definition\n");
     return;
   }
   // Get list of effect-operand pairs and insert into dictionary
   else get_effectlist(instr->_effects, instr->_localNames);
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Effect description: %s\n", desc);
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in Effect definition\n");
   }
   next_char();                  // Skip ';'
 }
 //------------------------------expand_parse-----------------------------------
 ExpandRule* ADLParser::expand_parse(InstructForm *instr) {
   char         *ident, *ident2;
   OperandForm  *oper;
   InstructForm *ins;
   NameAndList  *instr_and_operands = NULL;
   ExpandRule   *exp = new ExpandRule();
   // Expand is a block containing an ordered list of instructions, each of
   // which has an ordered list of operands.
   // Check for block delimiter
   skipws();                        // Skip leading whitespace
   if ((_curchar != '%')
       || (next_char(), (_curchar != '{')) ) { // If not open block
     parse_err(SYNERR, "missing '%{' in expand definition\n");
     return(NULL);
   }
   next_char();                     // Maintain the invariant
   do {
     ident = get_ident();           // Grab next identifier
     if (ident == NULL) {
       parse_err(SYNERR, "identifier expected at %c\n", _curchar);
       continue;
     }                              // Check that you have a valid instruction
     const Form *form = _globalNames[ident];
     ins = form ? form->is_instruction() : NULL;
     if (ins == NULL) {
       // This is a new operand
       oper = form ? form->is_operand() : NULL;
       if (oper == NULL) {
         parse_err(SYNERR, "instruction/operand name expected at %s\n", ident);
         continue;
       }
       // Throw the operand on the _newopers list
       skipws();
       ident = get_unique_ident(instr->_localNames,"Operand");
       if (ident == NULL) {
         parse_err(SYNERR, "identifier expected at %c\n", _curchar);
         continue;
       }
       exp->_newopers.addName(ident);
       // Add new operand to LocalNames
       instr->_localNames.Insert(ident, oper);
       // Grab any constructor code and save as a string
       char *c = NULL;
       skipws();
       if (_curchar == '%') { // Need a constructor for the operand
         c = find_cpp_block("Operand Constructor");
         if (c == NULL) {
           parse_err(SYNERR, "Invalid code block for operand constructor\n", _curchar);
           continue;
         }
         // Add constructor to _newopconst Dict
         exp->_newopconst.Insert(ident, c);
       }
       else if (_curchar != ';') { // If no constructor, need a ;
         parse_err(SYNERR, "Missing ; in expand rule operand declaration\n");
         continue;
       }
       else next_char(); // Skip the ;
       skipws();
     }
     else {
       // Add instruction to list
       instr_and_operands = new NameAndList(ident);
       // Grab operands, build nameList of them, and then put into dictionary
       skipws();
       if (_curchar != '(') {         // Check for parenthesized operand list
         parse_err(SYNERR, "missing '(' in expand instruction declaration\n");
         continue;
       }
       do {
         next_char();                 // skip open paren & comma characters
         skipws();
         if (_curchar == ')') break;
         ident2 = get_ident();
         skipws();
         if (ident2 == NULL) {
           parse_err(SYNERR, "identifier expected at %c\n", _curchar);
           continue;
         }                            // Check that you have a valid operand
         const Form *form2 = instr->_localNames[ident2];
         if (!form2) {
           parse_err(SYNERR, "operand name expected at %s\n", ident2);
           continue;
         }
         oper = form2->is_operand();
         if (oper == NULL && !form2->is_opclass()) {
           parse_err(SYNERR, "operand name expected at %s\n", ident2);
           continue;
         }                            // Add operand to list
         instr_and_operands->add_entry(ident2);
       } while(_curchar == ',');
       if (_curchar != ')') {
         parse_err(SYNERR, "missing ')'in expand instruction declaration\n");
         continue;
       }
       next_char();
       if (_curchar != ';') {
         parse_err(SYNERR, "missing ';'in expand instruction declaration\n");
         continue;
       }
       next_char();
       // Record both instruction name and its operand list
       exp->add_instruction(instr_and_operands);
       skipws();
     }
   } while(_curchar != '%');
   next_char();
   if (_curchar != '}') {
     parse_err(SYNERR, "missing '%}' in expand rule definition\n");
     return(NULL);
   }
   next_char();
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Expand Rule:\n");
   skipws();
   return (exp);
 }
 //------------------------------rewrite_parse----------------------------------
 RewriteRule* ADLParser::rewrite_parse(void) {
   char* params = NULL;
   char* desc   = NULL;
   // This feature targeted for second generation description language.
   skipws();                      // Skip whitespace
   // Get parameters for rewrite
   if ((params = get_paren_expr("rewrite parameters")) == NULL) {
     parse_err(SYNERR, "missing '(' in rewrite rule\n");
     return NULL;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Rewrite parameters: %s\n", params);
   // For now, grab entire block;
   skipws();
   if ( (desc = find_cpp_block("rewrite block")) == NULL ) {
     parse_err(SYNERR, "incorrect or missing block for 'rewrite'.\n");
     return NULL;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Rewrite Rule: %s\n", desc);
   skipws();
   return (new RewriteRule(params,desc));
 }
 //------------------------------attr_parse-------------------------------------
 Attribute *ADLParser::attr_parse(char* ident) {
   Attribute *attrib;              // Attribute class
   char      *cost = NULL;         // String representation of cost attribute
   skipws();                       // Skip leading whitespace
   if ( (cost = get_paren_expr("attribute")) == NULL ) {
     parse_err(SYNERR, "incorrect or missing expression for 'attribute'\n");
     return NULL;
   }
   // Debug Stuff
   if (_AD._adl_debug > 1) fprintf(stderr,"Attribute: %s\n", cost);
   if (_curchar != ';') {
     parse_err(SYNERR, "missing ';' in attribute definition\n");
     return NULL;
   }
   next_char();                   // Point after the terminator
   skipws();
   attrib = new Attribute(ident,cost,INS_ATTR); // Build new predicate object
   return attrib;
 }
 //------------------------------matchNode_parse--------------------------------
 MatchNode *ADLParser::matchNode_parse(FormDict &operands, int &depth, int &numleaves, bool atroot) {
   // Count depth of parenthesis nesting for both left and right children
   int   lParens = depth;
   int   rParens = depth;
   // MatchNode objects for left, right, and root of subtree.
   MatchNode *lChild = NULL;
   MatchNode *rChild = NULL;
   char      *token;               // Identifier which may be opcode or operand
   // Match expression starts with a '('
   if (cur_char() != '(')
     return NULL;
   next_char();                    // advance past '('
   // Parse the opcode
   token = get_ident();            // Get identifier, opcode
   if (token == NULL) {
     parse_err(SYNERR, "missing opcode in match expression\n");
     return NULL;
   }
   // Take note if we see one of a few special operations - those that are
   // treated differently on different architectures in the sense that on
   // one architecture there is a match rule and on another there isn't (so
   // a call will eventually be generated).
   for (int i = _last_machine_leaf + 1; i < _last_opcode; i++) {
     if (strcmp(token, NodeClassNames[i]) == 0) {
       _AD.has_match_rule(i, true);
     }
   }
   // Lookup the root value in the operands dict to perform substitution
   const char  *result    = NULL;  // Result type will be filled in later
   const char  *name      = token; // local name associated with this node
   const char  *operation = token; // remember valid operation for later
   const Form  *form      = operands[token];
   OpClassForm *opcForm = form ? form->is_opclass() : NULL;
   if (opcForm != NULL) {
     // If this token is an entry in the local names table, record its type
     if (!opcForm->ideal_only()) {
       operation = opcForm->_ident;
       result = operation;         // Operands result in their own type
     }
     // Otherwise it is an ideal type, and so, has no local name
     else                        name = NULL;
   }
   // Parse the operands
   skipws();
   if (cur_char() != ')') {
     // Parse the left child
     if (strcmp(operation,"Set"))
       lChild = matchChild_parse(operands, lParens, numleaves, false);
     else
       lChild = matchChild_parse(operands, lParens, numleaves, true);
     skipws();
     if (cur_char() != ')' ) {
       if(strcmp(operation, "Set"))
         rChild = matchChild_parse(operands,rParens,numleaves,false);
       else
         rChild = matchChild_parse(operands,rParens,numleaves,true);
     }
   }
   // Check for required ')'
   skipws();
   if (cur_char() != ')') {
     parse_err(SYNERR, "missing ')' in match expression\n");
     return NULL;
   }
   next_char();                    // skip the ')'
   MatchNode* mroot = new MatchNode(_AD,result,name,operation,lChild,rChild);
   // If not the root, reduce this subtree to an internal operand
   if (!atroot) {
     mroot->build_internalop();
   }
   // depth is greater of left and right paths.
   depth = (lParens > rParens) ? lParens : rParens;
   return mroot;
 }
 //------------------------------matchChild_parse-------------------------------
 MatchNode *ADLParser::matchChild_parse(FormDict &operands, int &parens, int &numleaves, bool atroot) {
   MatchNode  *child  = NULL;
   const char *result = NULL;
   const char *token  = NULL;
   const char *opType = NULL;
   if (cur_char() == '(') {         // child is an operation
     ++parens;
     child = matchNode_parse(operands, parens, numleaves, atroot);
   }
   else {                           // child is an operand
     token = get_ident();
     const Form  *form    = operands[token];
     OpClassForm *opcForm = form ? form->is_opclass() : NULL;
     if (opcForm != NULL) {
       opType = opcForm->_ident;
       result = opcForm->_ident;    // an operand's result matches its type
     } else {
       parse_err(SYNERR, "undefined operand %s in match rule\n", token);
       return NULL;
     }
     if (opType == NULL) {
       parse_err(SYNERR, "missing type for argument '%s'\n", token);
     }
     child = new MatchNode(_AD, result, token, opType);
     ++numleaves;
   }
   return child;
 }
 // ******************** Private Utility Functions *************************
 char* ADLParser::find_cpp_block(const char* description) {
   char *next;                     // Pointer for finding block delimiters
   char* cppBlock = NULL;          // Beginning of C++ code block
   if (_curchar == '%') {          // Encoding is a C++ expression
     next_char();
     if (_curchar != '{') {
       parse_err(SYNERR, "missing '{' in %s \n", description);
       return NULL;
     }
     next_char();                  // Skip block delimiter
     skipws_no_preproc();          // Skip leading whitespace
     cppBlock = _ptr;              // Point to start of expression
     int line = linenum();
     next = _ptr + 1;
     while(((_curchar != '%') || (*next != '}')) && (_curchar != '\0')) {
       next_char_or_line();
       next = _ptr+1;              // Maintain the next pointer
     }                             // Grab string
     if (_curchar == '\0') {
       parse_err(SYNERR, "invalid termination of %s \n", description);
       return NULL;
     }
     *_ptr = '\0';                 // Terminate string
     _ptr += 2;                    // Skip block delimiter
     _curchar = *_ptr;             // Maintain invariant
     // Prepend location descriptor, for debugging.
     if (_AD._adlocation_debug) {
       char* location = get_line_string(line);
       char* end_loc  = end_line_marker();
       char* result = (char *)malloc(strlen(location) + strlen(cppBlock) + strlen(end_loc) + 1);
       strcpy(result, location);
       strcat(result, cppBlock);
       strcat(result, end_loc);
       cppBlock = result;
       free(location);
     }
   }
   return cppBlock;
 }
 // Move to the closing token of the expression we are currently at,
 // as defined by stop_chars.  Match parens and quotes.
 char* ADLParser::get_expr(const char *desc, const char *stop_chars) {
   char* expr = NULL;
   int   paren = 0;
   expr = _ptr;
   while (paren > 0 || !strchr(stop_chars, _curchar)) {
     if (_curchar == '(') {        // Down level of nesting
       paren++;                    // Bump the parenthesis counter
       next_char();                // maintain the invariant
     }
     else if (_curchar == ')') {   // Up one level of nesting
       if (paren == 0) {
         // Paren underflow:  We didn't encounter the required stop-char.
         parse_err(SYNERR, "too many )'s, did not find %s after %s\n",
                   stop_chars, desc);
         return NULL;
       }
       paren--;                    // Drop the parenthesis counter
       next_char();                // Maintain the invariant
     }
     else if (_curchar == '"' || _curchar == '\'') {
       int qchar = _curchar;
       while (true) {
         next_char();
         if (_curchar == qchar) { next_char(); break; }
         if (_curchar == '\\')  next_char();  // superquote
         if (_curchar == '\n' || _curchar == '\0') {
           parse_err(SYNERR, "newline in string in %s\n", desc);
           return NULL;
         }
       }
     }
     else if (_curchar == '%' && (_ptr[1] == '{' || _ptr[1] == '}')) {
       // Make sure we do not stray into the next ADLC-level form.
       parse_err(SYNERR, "unexpected %%%c in %s\n", _ptr[1], desc);
       return NULL;
     }
     else if (_curchar == '\0') {
       parse_err(SYNERR, "unexpected EOF in %s\n", desc);
       return NULL;
     }
     else {
       // Always walk over whitespace, comments, preprocessor directives, etc.
       char* pre_skip_ptr = _ptr;
       skipws();
       // If the parser declined to make progress on whitespace,
       // skip the next character, which is therefore NOT whitespace.
       if (pre_skip_ptr == _ptr) {
         next_char();
       } else if (pre_skip_ptr+strlen(pre_skip_ptr) != _ptr+strlen(_ptr)) {
         parse_err(SYNERR, "unimplemented: preprocessor must not elide subexpression in %s", desc);
       }
     }
   }
   assert(strchr(stop_chars, _curchar), "non-null return must be at stop-char");
   *_ptr = '\0';               // Replace ')' or other stop-char with '\0'
   return expr;
 }
 // Helper function around get_expr
 // Sets _curchar to '(' so that get_paren_expr will search for a matching ')'
 char *ADLParser::get_paren_expr(const char *description, bool include_location) {
   int line = linenum();
   if (_curchar != '(')            // Escape if not valid starting position
     return NULL;
   next_char();                    // Skip the required initial paren.
   char *token2 = get_expr(description, ")");
   if (_curchar == ')')
     next_char();                  // Skip required final paren.
   int junk = 0;
   if (include_location && _AD._adlocation_debug && !is_int_token(token2, junk)) {
     // Prepend location descriptor, for debugging.
     char* location = get_line_string(line);
     char* end_loc  = end_line_marker();
     char* result = (char *)malloc(strlen(location) + strlen(token2) + strlen(end_loc) + 1);
     strcpy(result, location);
     strcat(result, token2);
     strcat(result, end_loc);
     token2 = result;
     free(location);
   }
   return token2;
 }
 //------------------------------get_ident_common-------------------------------
 // Looks for an identifier in the buffer, and turns it into a null terminated
 // string(still inside the file buffer).  Returns a pointer to the string or
 // NULL if some other token is found instead.
 char *ADLParser::get_ident_common(bool do_preproc) {
   register char c;
   char *start;                    // Pointer to start of token
   char *end;                      // Pointer to end of token
   if( _curline == NULL )          // Return NULL at EOF.
     return NULL;
   skipws_common(do_preproc);      // Skip whitespace before identifier
   start = end = _ptr;             // Start points at first character
   end--;                          // unwind end by one to prepare for loop
   do {
     end++;                        // Increment end pointer
     c = *end;                     // Grab character to test
   } while ( ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))
             || ((c >= '0') && (c <= '9'))
             || ((c == '_')) || ((c == ':')) || ((c == '#')) );
   if (start == end) {             // We popped out on the first try
     parse_err(SYNERR, "identifier expected at %c\n", c);
     start = NULL;
   }
   else {
     _curchar = c;                 // Save the first character of next token
     *end = '\0';                  // NULL terminate the string in place
   }
   _ptr = end;                     // Reset _ptr to point to next char after token
   // Make sure we do not try to use #defined identifiers.  If start is
   // NULL an error was already reported.
   if (do_preproc && start != NULL) {
     const char* def = _AD.get_preproc_def(start);
     if (def != NULL && strcmp(def, start)) {
       const char* def1 = def;
       const char* def2 = _AD.get_preproc_def(def1);
       // implement up to 2 levels of #define
       if (def2 != NULL && strcmp(def2, def1)) {
         def = def2;
         const char* def3 = _AD.get_preproc_def(def2);
         if (def3 != NULL && strcmp(def3, def2) && strcmp(def3, def1)) {
           parse_err(SYNERR, "unimplemented: using %s defined as %s => %s => %s",
                     start, def1, def2, def3);
         }
       }
       start = strdup(def);
     }
   }
   return start;                   // Pointer to token in filebuf
 }
 //------------------------------get_ident_dup----------------------------------
 // Looks for an identifier in the buffer, and returns a duplicate
 // or NULL if some other token is found instead.
 char *ADLParser::get_ident_dup(void) {
   char *ident = get_ident();
   // Duplicate an identifier before returning and restore string.
   if( ident != NULL ) {
     ident = strdup(ident);  // Copy the string
     *_ptr   = _curchar;         // and replace Nil with original character
   }
   return ident;
 }
 //----------------------get_ident_or_literal_constant--------------------------
 // Looks for an identifier in the buffer, or a parenthesized expression.
 char *ADLParser::get_ident_or_literal_constant(const char* description) {
   char* param = NULL;
   skipws();
   if (_curchar == '(') {
     // Grab a constant expression.
     param = get_paren_expr(description);
     if (param[0] != '(') {
       char* buf = (char*) malloc(strlen(param) + 3);
       sprintf(buf, "(%s)", param);
       param = buf;
     }
     assert(is_literal_constant(param),
            "expr must be recognizable as a constant");
   } else {
     param = get_ident();
   }
   return param;
 }
 //------------------------------get_rep_var_ident-----------------------------
 // Do NOT duplicate,
 // Leave nil terminator in buffer
 // Preserve initial '$'(s) in string
 char *ADLParser::get_rep_var_ident(void) {
   // Remember starting point
   char *rep_var = _ptr;
   // Check for replacement variable indicator '$' and pass if present
   if ( _curchar == '$' ) {
     next_char();
   }
   // Check for a subfield indicator, a second '$', and pass if present
   if ( _curchar == '$' ) {
     next_char();
   }
   // Check for a control indicator, a third '$':
   if ( _curchar == '$' ) {
     next_char();
   }
   // Check for more than three '$'s in sequence, SYNERR
   if( _curchar == '$' ) {
     parse_err(SYNERR, "Replacement variables and field specifiers can not start with '$$$$'");
     next_char();
     return NULL;
   }
   // Nil terminate the variable name following the '$'
   char *rep_var_name = get_ident();
   assert( rep_var_name != NULL,
           "Missing identifier after replacement variable indicator '$'");
   return rep_var;
 }
 //------------------------------get_rep_var_ident_dup-------------------------
 // Return the next replacement variable identifier, skipping first '$'
 // given a pointer into a line of the buffer.
 // Null terminates string, still inside the file buffer,
 // Returns a pointer to a copy of the string, or NULL on failure
 char *ADLParser::get_rep_var_ident_dup(void) {
   if( _curchar != '$' ) return NULL;
   next_char();                // Move past the '$'
   char *rep_var = _ptr;       // Remember starting point
   // Check for a subfield indicator, a second '$':
   if ( _curchar == '$' ) {
     next_char();
   }
   // Check for a control indicator, a third '$':
   if ( _curchar == '$' ) {
     next_char();
   }
   // Check for more than three '$'s in sequence, SYNERR
   if( _curchar == '$' ) {
     parse_err(SYNERR, "Replacement variables and field specifiers can not start with '$$$$'");
     next_char();
     return NULL;
   }
   // Nil terminate the variable name following the '$'
   char *rep_var_name = get_ident();
   assert( rep_var_name != NULL,
           "Missing identifier after replacement variable indicator '$'");
   rep_var = strdup(rep_var);  // Copy the string
   *_ptr   = _curchar;         // and replace Nil with original character
   return rep_var;
 }
 //------------------------------get_unique_ident------------------------------
 // Looks for an identifier in the buffer, terminates it with a NULL,
 // and checks that it is unique
 char *ADLParser::get_unique_ident(FormDict& dict, const char* nameDescription){
   char* ident = get_ident();
   if (ident == NULL) {
     parse_err(SYNERR, "missing %s identifier at %c\n", nameDescription, _curchar);
   }
   else {
     if (dict[ident] != NULL) {
       parse_err(SYNERR, "duplicate name %s for %s\n", ident, nameDescription);
       ident = NULL;
     }
   }
   return ident;
 }
 //------------------------------get_int----------------------------------------
 // Looks for a character string integer in the buffer, and turns it into an int
 // invokes a parse_err if the next token is not an integer.
 // This routine does not leave the integer null-terminated.
 int ADLParser::get_int(void) {
   register char c;
   char         *start;            // Pointer to start of token
   char         *end;              // Pointer to end of token
   int           result;           // Storage for integer result
   if( _curline == NULL )          // Return NULL at EOF.
     return 0;
   skipws();                       // Skip whitespace before identifier
   start = end = _ptr;             // Start points at first character
   c = *end;                       // Grab character to test
   while ((c >= '0') && (c <= '9')
          || ((c == '-') && (end == start))) {
     end++;                        // Increment end pointer
     c = *end;                     // Grab character to test
   }
   if (start == end) {             // We popped out on the first try
     parse_err(SYNERR, "integer expected at %c\n", c);
     result = 0;
   }
   else {
     _curchar = c;                 // Save the first character of next token
     *end = '\0';                  // NULL terminate the string in place
     result = atoi(start);         // Convert the string to an integer
     *end = _curchar;              // Restore buffer to original condition
   }
   // Reset _ptr to next char after token
   _ptr = end;
   return result;                   // integer
 }
 //------------------------------get_relation_dup------------------------------
 // Looks for a relational operator in the buffer
 // invokes a parse_err if the next token is not a relation
 // This routine creates a duplicate of the string in the buffer.
 char *ADLParser::get_relation_dup(void) {
   char         *result = NULL;    // relational operator being returned
   if( _curline == NULL )          // Return NULL at EOF.
     return  NULL;
   skipws();                       // Skip whitespace before relation
   char *start = _ptr;             // Store start of relational operator
   char first  = *_ptr;            // the first character
   if( (first == '=') || (first == '!') || (first == '<') || (first == '>') ) {
     next_char();
     char second = *_ptr;          // the second character
     if( (second == '=') ) {
       next_char();
       char tmp  = *_ptr;
       *_ptr = '\0';               // NULL terminate
       result = strdup(start);     // Duplicate the string
       *_ptr = tmp;                // restore buffer
     } else {
       parse_err(SYNERR, "relational operator expected at %s\n", _ptr);
     }
   } else {
     parse_err(SYNERR, "relational operator expected at %s\n", _ptr);
   }
   return result;
 }
 //------------------------------get_oplist-------------------------------------
 // Looks for identifier pairs where first must be the name of an operand, and
 // second must be a name unique in the scope of this instruction.  Stores the
 // names with a pointer to the OpClassForm of their type in a local name table.
 void ADLParser::get_oplist(NameList &parameters, FormDict &operands) {
   OpClassForm *opclass = NULL;
   char        *ident   = NULL;
   do {
     next_char();             // skip open paren & comma characters
     skipws();
     if (_curchar == ')') break;
     // Get operand type, and check it against global name table
     ident = get_ident();
     if (ident == NULL) {
       parse_err(SYNERR, "optype identifier expected at %c\n", _curchar);
       return;
     }
     else {
       const Form  *form = _globalNames[ident];
       if( form == NULL ) {
         parse_err(SYNERR, "undefined operand type %s\n", ident);
         return;
       }
       // Check for valid operand type
       OpClassForm *opc  = form->is_opclass();
       OperandForm *oper = form->is_operand();
       if((oper == NULL) && (opc == NULL)) {
         parse_err(SYNERR, "identifier %s not operand type\n", ident);
         return;
       }
       opclass = opc;
     }
     // Debugging Stuff
     if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Type: %s\t", ident);
     // Get name of operand and add it to local name table
     if( (ident = get_unique_ident(operands, "operand")) == NULL) {
       return;
     }
     // Parameter names must not be global names.
     if( _globalNames[ident] != NULL ) {
          parse_err(SYNERR, "Reuse of global name %s as operand.\n",ident);
          return;
     }
     operands.Insert(ident, opclass);
     parameters.addName(ident);
     // Debugging Stuff
     if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Name: %s\n", ident);
     skipws();
   } while(_curchar == ',');
   if (_curchar != ')') parse_err(SYNERR, "missing ')'\n");
   else {
     next_char();  // set current character position past the close paren
   }
 }
 //------------------------------get_effectlist---------------------------------
 // Looks for identifier pairs where first must be the name of a pre-defined,
 // effect, and the second must be the name of an operand defined in the
 // operand list of this instruction.  Stores the names with a pointer to the
 // effect form in a local effects table.
 void ADLParser::get_effectlist(FormDict &effects, FormDict &operands) {
   OperandForm *opForm;
   Effect      *eForm;
   char        *ident;
   do {
     next_char();             // skip open paren & comma characters
     skipws();
     if (_curchar == ')') break;
     // Get effect type, and check it against global name table
     ident = get_ident();
     if (ident == NULL) {
       parse_err(SYNERR, "effect type identifier expected at %c\n", _curchar);
       return;
     }
     else {
       // Check for valid effect type
       const Form *form = _globalNames[ident];
       if( form == NULL ) {
         parse_err(SYNERR, "undefined effect type %s\n", ident);
         return;
       }
       else {
         if( (eForm = form->is_effect()) == NULL) {
           parse_err(SYNERR, "identifier %s not effect type\n", ident);
           return;
         }
       }
     }
       // Debugging Stuff
     if (_AD._adl_debug > 1) fprintf(stderr, "\tEffect Type: %s\t", ident);
     skipws();
     // Get name of operand and check that it is in the local name table
     if( (ident = get_unique_ident(effects, "effect")) == NULL) {
       parse_err(SYNERR, "missing operand identifier in effect list\n");
       return;
     }
     const Form *form = operands[ident];
     opForm = form ? form->is_operand() : NULL;
     if( opForm == NULL ) {
       if( form && form->is_opclass() ) {
         const char* cname = form->is_opclass()->_ident;
         parse_err(SYNERR, "operand classes are illegal in effect lists (found %s %s)\n", cname, ident);
       } else {
         parse_err(SYNERR, "undefined operand %s in effect list\n", ident);
       }
       return;
     }
     // Add the pair to the effects table
     effects.Insert(ident, eForm);
     // Debugging Stuff
     if (_AD._adl_debug > 1) fprintf(stderr, "\tOperand Name: %s\n", ident);
     skipws();
   } while(_curchar == ',');
   if (_curchar != ')') parse_err(SYNERR, "missing ')'\n");
   else {
     next_char();  // set current character position past the close paren
   }
 }
 //-------------------------------preproc_line----------------------------------
 // A "#line" keyword has been seen, so parse the rest of the line.
 void ADLParser::preproc_line(void) {
   int line = get_int();
   skipws_no_preproc();
   const char* file = NULL;
   if (_curchar == '"') {
     next_char();              // Move past the initial '"'
     file = _ptr;
     while (true) {
       if (_curchar == '\n') {
         parse_err(SYNERR, "missing '\"' at end of #line directive");
         return;
       }
       if (_curchar == '"') {
         *_ptr  = '\0';          // Terminate the string
         next_char();
         skipws_no_preproc();
         break;
       }
       next_char();
     }
   }
   ensure_end_of_line();
   if (file != NULL)
     _AD._ADL_file._name = file;
   _buf.set_linenum(line);
 }
 //------------------------------preproc_define---------------------------------
 // A "#define" keyword has been seen, so parse the rest of the line.
 void ADLParser::preproc_define(void) {
   char* flag = get_ident_no_preproc();
   skipws_no_preproc();
   // only #define x y is supported for now
   char* def = get_ident_no_preproc();
   _AD.set_preproc_def(flag, def);
   skipws_no_preproc();
   if (_curchar != '\n') {
     parse_err(SYNERR, "non-identifier in preprocessor definition\n");
   }
 }
 //------------------------------preproc_undef----------------------------------
 // An "#undef" keyword has been seen, so parse the rest of the line.
 void ADLParser::preproc_undef(void) {
   char* flag = get_ident_no_preproc();
   skipws_no_preproc();
   ensure_end_of_line();
   _AD.set_preproc_def(flag, NULL);
 }
 //------------------------------parse_err--------------------------------------
 // Issue a parser error message, and skip to the end of the current line
 void ADLParser::parse_err(int flag, const char *fmt, ...) {
   va_list args;
   va_start(args, fmt);
   if (flag == 1)
     _AD._syntax_errs += _AD.emit_msg(0, flag, linenum(), fmt, args);
   else if (flag == 2)
     _AD._semantic_errs += _AD.emit_msg(0, flag, linenum(), fmt, args);
   else
     _AD._warnings += _AD.emit_msg(0, flag, linenum(), fmt, args);
   int error_char = _curchar;
   char* error_ptr = _ptr+1;
   for(;*_ptr != '\n'; _ptr++) ; // Skip to the end of the current line
   _curchar = '\n';
   va_end(args);
   _AD._no_output = 1;
   if (flag == 1) {
     char* error_tail = strchr(error_ptr, '\n');
     char tem = *error_ptr;
     error_ptr[-1] = '\0';
     char* error_head = error_ptr-1;
     while (error_head > _curline && *error_head)  --error_head;
     if (error_tail)  *error_tail = '\0';
     fprintf(stderr, "Error Context:  %s>>>%c<<<%s\n",
             error_head, error_char, error_ptr);
     if (error_tail)  *error_tail = '\n';
     error_ptr[-1] = tem;
   }
 }
 //---------------------------ensure_start_of_line------------------------------
 // A preprocessor directive has been encountered.  Be sure it has fallen at
 // the beginning of a line, or else report an error.
 void ADLParser::ensure_start_of_line(void) {
   if (_curchar == '\n') { next_line(); return; }
   assert( _ptr >= _curline && _ptr < _curline+strlen(_curline),
           "Must be able to find which line we are in" );
   for (char *s = _curline; s < _ptr; s++) {
     if (*s > ' ') {
       parse_err(SYNERR, "'%c' must be at beginning of line\n", _curchar);
       break;
     }
   }
 }
 //---------------------------ensure_end_of_line--------------------------------
 // A preprocessor directive has been parsed.  Be sure there is no trailing
 // garbage at the end of this line.  Set the scan point to the beginning of
 // the next line.
 void ADLParser::ensure_end_of_line(void) {
   skipws_no_preproc();
   if (_curchar != '\n' && _curchar != '\0') {
     parse_err(SYNERR, "garbage char '%c' at end of line\n", _curchar);
   } else {
     next_char_or_line();
   }
 }
 //---------------------------handle_preproc------------------------------------
 // The '#' character introducing a preprocessor directive has been found.
 // Parse the whole directive name (e.g., #define, #endif) and take appropriate
 // action.  If we are in an "untaken" span of text, simply keep track of
 // #ifdef nesting structure, so we can find out when to start taking text
 // again.  (In this state, we "sort of support" C's #if directives, enough
 // to disregard their associated #else and #endif lines.)  If we are in a
 // "taken" span of text, there are two cases:  "#define" and "#undef"
 // directives are preserved and passed up to the caller, which eventually
 // passes control to the top-level parser loop, which handles #define and
 // #undef directly.  (This prevents these directives from occurring in
 // arbitrary positions in the AD file--we require better structure than C.)
 // In the other case, and #ifdef, #ifndef, #else, or #endif is silently
 // processed as whitespace, with the "taken" state of the text correctly
 // updated.  This routine returns "false" exactly in the case of a "taken"
 // #define or #undef, which tells the caller that a preprocessor token
 // has appeared which must be handled explicitly by the parse loop.
 bool ADLParser::handle_preproc_token() {
   assert(*_ptr == '#', "must be at start of preproc");
   ensure_start_of_line();
   next_char();
   skipws_no_preproc();
   char* start_ident = _ptr;
   char* ident = (_curchar == '\n') ? NULL : get_ident_no_preproc();
   if (ident == NULL) {
     parse_err(SYNERR, "expected preprocessor command, got end of line\n");
   } else if (!strcmp(ident, "ifdef") ||
              !strcmp(ident, "ifndef")) {
     char* flag = get_ident_no_preproc();
     ensure_end_of_line();
     // Test the identifier only if we are already in taken code:
     bool flag_def  = preproc_taken() && (_AD.get_preproc_def(flag) != NULL);
     bool now_taken = !strcmp(ident, "ifdef") ? flag_def : !flag_def;
     begin_if_def(now_taken);
   } else if (!strcmp(ident, "if")) {
     if (preproc_taken())
       parse_err(SYNERR, "unimplemented: #%s %s", ident, _ptr+1);
     next_line();
     // Intelligently skip this nested C preprocessor directive:
     begin_if_def(true);
   } else if (!strcmp(ident, "else")) {
     ensure_end_of_line();
     invert_if_def();
   } else if (!strcmp(ident, "endif")) {
     ensure_end_of_line();
     end_if_def();
   } else if (preproc_taken()) {
     // pass this token up to the main parser as "#define" or "#undef"
     _ptr = start_ident;
     _curchar = *--_ptr;
     if( _curchar != '#' ) {
       parse_err(SYNERR, "no space allowed after # in #define or #undef");
       assert(_curchar == '#', "no space allowed after # in #define or #undef");
     }
     return false;
   }
   return true;
 }
 //---------------------------skipws_common-------------------------------------
 // Skip whitespace, including comments and newlines, while keeping an accurate
 // line count.
 // Maybe handle certain preprocessor constructs: #ifdef, #ifndef, #else, #endif
 void ADLParser::skipws_common(bool do_preproc) {
   char *start = _ptr;
   char *next = _ptr + 1;
   if (*_ptr == '\0') {
     // Check for string terminator
     if (_curchar > ' ')  return;
     if (_curchar == '\n') {
       if (!do_preproc)  return;            // let caller handle the newline
       next_line();
       _ptr = _curline; next = _ptr + 1;
     }
     else if (_curchar == '#' ||
         (_curchar == '/' && (*next == '/' || *next == '*'))) {
       parse_err(SYNERR, "unimplemented: comment token in a funny place");
     }
   }
   while(_curline != NULL) {                // Check for end of file
     if (*_ptr == '\n') {                   // keep proper track of new lines
       if (!do_preproc)  break;             // let caller handle the newline
       next_line();
       _ptr = _curline; next = _ptr + 1;
     }
     else if ((*_ptr == '/') && (*next == '/'))      // C++ comment
       do { _ptr++; next++; } while(*_ptr != '\n');  // So go to end of line
     else if ((*_ptr == '/') && (*next == '*')) {    // C comment
       _ptr++; next++;
       do {
         _ptr++; next++;
         if (*_ptr == '\n') {               // keep proper track of new lines
           next_line();                     // skip newlines within comments
           if (_curline == NULL) {          // check for end of file
             parse_err(SYNERR, "end-of-file detected inside comment\n");
             break;
           }
           _ptr = _curline; next = _ptr + 1;
         }
       } while(!((*_ptr == '*') && (*next == '/'))); // Go to end of comment
       _ptr = ++next; next++;               // increment _ptr past comment end
     }
     else if (do_preproc && *_ptr == '#') {
       // Note that this calls skipws_common(false) recursively!
       bool preproc_handled = handle_preproc_token();
       if (!preproc_handled) {
         if (preproc_taken()) {
           return;  // short circuit
         }
         ++_ptr;    // skip the preprocessor character
       }
       next = _ptr+1;
     } else if(*_ptr > ' ' && !(do_preproc && !preproc_taken())) {
       break;
     }
     else if (*_ptr == '"' || *_ptr == '\'') {
       assert(do_preproc, "only skip strings if doing preproc");
       // skip untaken quoted string
       int qchar = *_ptr;
       while (true) {
         ++_ptr;
         if (*_ptr == qchar) { ++_ptr; break; }
         if (*_ptr == '\\')  ++_ptr;
         if (*_ptr == '\n' || *_ptr == '\0') {
           parse_err(SYNERR, "newline in string");
           break;
         }
       }
       next = _ptr + 1;
     }
     else { ++_ptr; ++next; }
   }
   if( _curline != NULL )            // at end of file _curchar isn't valid
     _curchar = *_ptr;               // reset _curchar to maintain invariant
 }
 //---------------------------cur_char-----------------------------------------
 char ADLParser::cur_char() {
   return (_curchar);
 }
 //---------------------------next_char-----------------------------------------
 void ADLParser::next_char() {
   if (_curchar == '\n')  parse_err(WARN, "must call next_line!");
   _curchar = *++_ptr;
   // if ( _curchar == '\n' ) {
   //   next_line();
   // }
 }
 //---------------------------next_char_or_line---------------------------------
 void ADLParser::next_char_or_line() {
   if ( _curchar != '\n' ) {
     _curchar = *++_ptr;
   } else {
     next_line();
     _ptr = _curline;
     _curchar = *_ptr;  // maintain invariant
   }
 }
 //---------------------------next_line-----------------------------------------
 void ADLParser::next_line() {
   _curline = _buf.get_line();
   _curchar = ' ';
 }
 //------------------------get_line_string--------------------------------------
 // Prepended location descriptor, for debugging.
 // Must return a malloced string (that can be freed if desired).
 char* ADLParser::get_line_string(int linenum) {
   const char* file = _AD._ADL_file._name;
   int         line = linenum ? linenum : this->linenum();
   char* location = (char *)malloc(strlen(file) + 100);
   sprintf(location, "\n#line %d \"%s\"\n", line, file);
   return location;
 }
 //-------------------------is_literal_constant---------------------------------
 bool ADLParser::is_literal_constant(const char *param) {
   if (param[0] == 0)     return false;  // null string
   if (param[0] == '(')   return true;   // parenthesized expression
   if (param[0] == '0' && (param[1] == 'x' || param[1] == 'X')) {
     // Make sure it's a hex constant.
     int i = 2;
     do {
       if( !ADLParser::is_hex_digit(*(param+i)) )  return false;
       ++i;
     } while( *(param+i) != 0 );
     return true;
   }
   return false;
 }
 //---------------------------is_hex_digit--------------------------------------
 bool ADLParser::is_hex_digit(char digit) {
   return ((digit >= '0') && (digit <= '9'))
        ||((digit >= 'a') && (digit <= 'f'))
        ||((digit >= 'A') && (digit <= 'F'));
 }
 //---------------------------is_int_token--------------------------------------
 bool ADLParser::is_int_token(const char* token, int& intval) {
   const char* cp = token;
   while (*cp != '\0' && *cp <= ' ')  cp++;
   if (*cp == '-')  cp++;
   int ndigit = 0;
   while (*cp >= '0' && *cp <= '9')  { cp++; ndigit++; }
   while (*cp != '\0' && *cp <= ' ')  cp++;
   if (ndigit == 0 || *cp != '\0') {
     return false;
   }
   intval = atoi(token);
   return true;
 }
 static const char* skip_expr_ws(const char* str) {
   const char * cp = str;
   while (cp[0]) {
     if (cp[0] <= ' ') {
       ++cp;
     } else if (cp[0] == '#') {
       ++cp;
       while (cp[0] == ' ')  ++cp;
       assert(0 == strncmp(cp, "line", 4), "must be a #line directive");
       const char* eol = strchr(cp, '\n');
       assert(eol != NULL, "must find end of line");
       if (eol == NULL)  eol = cp + strlen(cp);
       cp = eol;
     } else {
       break;
     }
   }
   return cp;
 }
 //-----------------------equivalent_expressions--------------------------------
 bool ADLParser::equivalent_expressions(const char* str1, const char* str2) {
   if (str1 == str2)
     return true;
   else if (str1 == NULL || str2 == NULL)
     return false;
   const char* cp1 = str1;
   const char* cp2 = str2;
   char in_quote = '\0';
   while (cp1[0] && cp2[0]) {
     if (!in_quote) {
       // skip spaces and/or cpp directives
       const char* cp1a = skip_expr_ws(cp1);
       const char* cp2a = skip_expr_ws(cp2);
       if (cp1a > cp1 && cp2a > cp2) {
         cp1 = cp1a; cp2 = cp2a;
         continue;
       }
       if (cp1a > cp1 || cp2a > cp2)  break; // fail
     }
     // match one non-space char
     if (cp1[0] != cp2[0])  break; // fail
     char ch = cp1[0];
     cp1++; cp2++;
     // watch for quotes
     if (in_quote && ch == '\\') {
       if (cp1[0] != cp2[0])  break; // fail
       if (!cp1[0])  break;
       cp1++; cp2++;
     }
     if (in_quote && ch == in_quote) {
       in_quote = '\0';
     } else if (!in_quote && (ch == '"' || ch == '\'')) {
       in_quote = ch;
     }
   }
   return (!cp1[0] && !cp2[0]);
 }
 //-------------------------------trim------------------------------------------
 void ADLParser::trim(char* &token) {
   while (*token <= ' ')  token++;
   char* end = token + strlen(token);
   while (end > token && *(end-1) <= ' ')  --end;
   *end = '\0';
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/adlc/adlparse.cpp@98cb887364d3 (annotated)

src/share/vm/adlc/adlparse.cpp