Java example source code file (adlparse.hpp)

This example Java source code file (adlparse.hpp) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

adlparser, constraint, constructrule, expandrule, file, formatrule, formdict, grab, interface, matchrule, parse, predicate, rewriterule, share_vm_adlc_adlparse_hpp

The adlparse.hpp Java example source code

/*
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_VM_ADLC_ADLPARSE_HPP
#define SHARE_VM_ADLC_ADLPARSE_HPP

// ADLPARSE.HPP - Definitions for Architecture Description Language Parser
// Authors: Chris Vick and Mike Paleczny

// Class List
class Form;
// ***** Top Level, 1, classes  *****
class InstructForm;
class OperandForm;
class OpClassForm;
class AttributeForm;
class RegisterForm;
class PipelineForm;
class SourceForm;
class Peephole;
// ***** Level 2 classes *****
class Component;
class Predicate;
class MatchRule;
class Encode;
class Attribute;
class Effect;
class ExpandRule;
class RewriteRule;
class Constraint;
class ConstructRule;
// ***** Register Section *****
class RegDef;
class RegClass;
class AllocClass;
class ResourceForm;
// ***** Pipeline Section *****
class PipeDesc;
class PipeClass;
class RegList;
// ***** Peephole Section *****
class PeepMatch;
class PeepConstraint;
class PeepReplace;

// class ostream; // ostream is a typedef in some systems

extern char *toUpper(const char *str);

//---------------------------ADLParser-----------------------------------------
class ADLParser {
protected:
  char     *_curline;           // Start of current line
  char     *_ptr;               // Pointer into current location in File Buffer
  char      _curchar;           // Current character from buffer
  FormDict &_globalNames;       // Global names

  enum { _preproc_limit = 20 };
  int       _preproc_depth;                 // How deep are we into ifdefs?
  int       _preproc_not_taken;             // How deep in not-taken ifdefs?
  bool      _preproc_taken[_preproc_limit]; // Are we taking this ifdef level?
  bool      _preproc_else[_preproc_limit];  // Did this level have an else yet?

  // ***** Level 1 Parse functions *****
  void instr_parse(void);       // Parse instruction definitions
  void oper_parse(void);        // Parse operand definitions
  void opclass_parse(void);     // Parse operand class definitions
  void ins_attr_parse(void);    // Parse instruction attrubute definitions
  void op_attr_parse(void);     // Parse operand attrubute definitions
  void source_parse(void);      // Parse source section
  void source_hpp_parse(void);  // Parse source_hpp section
  void reg_parse(void);         // Parse register section
  void encode_parse(void);      // Parse encoding section
  void frame_parse(void);       // Parse frame section
  void pipe_parse(void);        // Parse pipeline section
  void definitions_parse(void); // Parse definitions section
  void peep_parse(void);        // Parse peephole rule definitions
  void preproc_line(void);      // Parse a #line statement
  void preproc_define(void);    // Parse a #define statement
  void preproc_undef(void);     // Parse an #undef statement

  // Helper functions for instr_parse().
  void adjust_set_rule(InstructForm *instr);
  void matchrule_clone_and_swap(MatchRule *rule, const char* instr_ident, int& match_rules_cnt);

  // ***** Level 2 Parse functions *****
  // Parse the components of the encode section
  void enc_class_parse(void);   // Parse encoding class definition
  void enc_class_parse_block(EncClass* encoding, char* ec_name);

  // Parse the components of the frame section
  void stack_dir_parse(FrameForm *frame);   // Parse the stack direction entry
  void sync_stack_slots_parse(FrameForm *frame);
  void frame_pointer_parse(FrameForm *frame, bool native);
  void interpreter_frame_pointer_parse(FrameForm *frame, bool native);
  void inline_cache_parse(FrameForm *frame, bool native);
  void interpreter_arg_ptr_parse(FrameForm *frame, bool native);
  void interpreter_method_oop_parse(FrameForm *frame, bool native);
  void cisc_spilling_operand_name_parse(FrameForm *frame, bool native);
  void stack_alignment_parse(FrameForm *frame);
  void return_addr_parse(FrameForm *frame, bool native);
  void preserve_stack_parse(FrameForm *frame);
  char *calling_convention_parse();
  char *return_value_parse();

  // Parse components of the register section
  void reg_def_parse(void);              // Parse register definition
  void reg_class_parse(void);            // Parse register class definition
  void alloc_class_parse(void);          // Parse allocation class definition

  // Parse components of the definition section
  void int_def_parse(void);              // Parse an integer definition

  // Parse components of a pipeline rule
  void resource_parse(PipelineForm &pipe);   // Parse resource definition
  void pipe_desc_parse(PipelineForm &pipe);  // Parse pipeline description definition
  void pipe_class_parse(PipelineForm &pipe); // Parse pipeline class definition

  // Parse components of a peephole rule
  void peep_match_parse(Peephole &peep);     // Parse the peephole match rule
  void peep_constraint_parse(Peephole &peep);// Parse the peephole constraints
  void peep_replace_parse(Peephole &peep);   // Parse peephole replacement rule

  // Parse the peep match rule tree
  InstructForm *peep_match_child_parse(PeepMatch &match, int parent, int &position, int input);

  // Parse components of an operand and/or instruction form
  Predicate     *pred_parse(void);       // Parse predicate rule
  // Parse match rule, and internal nodes
  MatchRule     *match_parse(FormDict &operands);
  MatchNode     *matchNode_parse(FormDict &operands, int &depth,
                                 int &numleaves, bool atroot);
  MatchNode     *matchChild_parse(FormDict &operands, int &depth,
                                  int &numleaves, bool atroot);

  Attribute     *attr_parse(char *ident);// Parse instr/operand attribute rule
  // Parse instruction encode rule
  void           ins_encode_parse(InstructForm &inst);
  void           ins_encode_parse_block(InstructForm &inst);
  void           ins_encode_parse_block_impl(InstructForm& inst, EncClass* encoding, char* ec_name);

  void           constant_parse(InstructForm& inst);
  void           constant_parse_expression(EncClass* encoding, char* ec_name);

  Opcode        *opcode_parse(InstructForm *insr); // Parse instruction opcode
  char          *size_parse(InstructForm *insr); // Parse instruction size
  Interface     *interface_parse();      // Parse operand interface rule
  Interface     *mem_interface_parse();  // Parse memory interface rule
  Interface     *cond_interface_parse(); // Parse conditional interface rule
  char          *interface_field_parse(const char** format = NULL);// Parse field contents

  FormatRule    *format_parse(void);     // Parse format rule
  FormatRule    *template_parse(void);     // Parse format rule
  void           effect_parse(InstructForm *instr); // Parse effect rule
  ExpandRule    *expand_parse(InstructForm *instr); // Parse expand rule
  RewriteRule   *rewrite_parse(void);    // Parse rewrite rule
  Constraint    *constraint_parse(void); // Parse constraint rule
  ConstructRule *construct_parse(void);  // Parse construct rule
  void           ins_pipe_parse(InstructForm &instr); // Parse ins_pipe rule

  // ***** Preprocessor functions *****
  void begin_if_def(bool taken) {
    assert(_preproc_depth < _preproc_limit, "#ifdef nesting limit");
    int ppn = _preproc_depth++;
    _preproc_taken[ppn] = taken;
    // Invariant:  _preproc_not_taken = SUM !_preproc_taken[0.._preproc_depth)
    if (!_preproc_taken[ppn])  _preproc_not_taken += 1;
    _preproc_else[ppn] = false;
  }
  void invert_if_def() {
    assert(_preproc_depth > 0, "#ifdef matching");
    int ppn = _preproc_depth - 1;
    assert(!_preproc_else[ppn], "multiple #else lines");
    _preproc_else[ppn] = true;
    if (!_preproc_taken[ppn])  _preproc_not_taken -= 1;
    _preproc_taken[ppn] = !_preproc_taken[ppn];
    if (!_preproc_taken[ppn])  _preproc_not_taken += 1;
  }
  void end_if_def() {
    assert(_preproc_depth > 0, "#ifdef matching");
    int ppn = --_preproc_depth;
    if (!_preproc_taken[ppn])  _preproc_not_taken -= 1;
  }
  bool preproc_taken() {
    // Return true only if there is no directive hiding this text position.
    return _preproc_not_taken == 0;
  }
  // Handle a '#' token.  Return true if it disappeared.
  bool handle_preproc_token();

  // ***** Utility Functions for ADL Parser ******

  // Parse one string argument inside parens:  '(' string ')' ';'
  char *parse_one_arg(const char *description);

  // Return the next identifier given a pointer into a line of the buffer.
  char *get_ident()            { return get_ident_common(true); }
  char *get_ident_no_preproc() { return get_ident_common(false); }
  char *get_ident_common(bool do_preproc);      // Grab it from the file buffer
  char *get_ident_dup(void);    // Grab a duplicate of the identifier
  char *get_ident_or_literal_constant(const char* description);
  // Grab unique identifier from file buffer
  char *get_unique_ident(FormDict &dict, const char *nameDescription);
  // Return the next replacement variable identifier
  char *get_rep_var_ident(void);
  // Skip first '$' and make a duplicate of the string
  char *get_rep_var_ident_dup(void);
  // Return the next token given as a signed integer.
  int   get_int(void);
  // Return the next token, a relational operator { ==, !=, <=, >= }
  char *get_relation_dup(void);

  void  get_oplist(NameList ¶meters, FormDict &operands);// Parse type-operand pairs
  void  get_effectlist(FormDict &effects, FormDict &operands, bool& has_call); // Parse effect-operand pairs
  // Return the contents of a parenthesized expression.
  // Requires initial '(' and consumes final ')', which is replaced by '\0'.
  char *get_paren_expr(const char *description, bool include_location = false);
  // Return expression up to next stop-char, which terminator replaces.
  // Does not require initial '('.  Does not consume final stop-char.
  // Final stop-char is left in _curchar, but is also is replaced by '\0'.
  char *get_expr(const char *description, const char *stop_chars);
  char *find_cpp_block(const char *description); // Parse a C++ code block
  // Issue parser error message & go to EOL
  void parse_err(int flag, const char *fmt, ...);
  // Create a location marker for this file and line.
  char *get_line_string(int linenum = 0);
  // Return a location marker which tells the C preprocessor to
  // forget the previous location marker.  (Requires awk postprocessing.)
  char *end_line_marker() { return (char*)"\n#line 999999\n"; }

  // Return pointer to current character
  inline char  cur_char(void);
  // Advance to next character, assign this to _curchar
  inline void  next_char(void);
  inline void  next_char_or_line(void);
  // Advance File Buffer to next line, updating _curline
  inline void  next_line(void);
  // Issue an error if we are not at the beginning of a line (exc. whitespace).
  void ensure_start_of_line(void);
  // Issue an error if we are not at the end of a line (exc. whitespace).
  void ensure_end_of_line(void);
  // Skip whitespace, leaving ptr pointing to first non-whitespace character
  // Also handle preprocessor constructs like "#ifdef".
  void skipws()                { skipws_common(true); }
  // Skip comments and spaces but not newlines or preprocessor constructs.
  void skipws_no_preproc()     { skipws_common(false); }
  void skipws_common(bool do_preproc);

  FileBuff &_buf;               // File buffer to be parsed
  ArchDesc &_AD;                // Architecture Description being built

public:

  ADLParser(FileBuff &buf, ArchDesc &archDesc); // Create new ADLParser object
  ~ADLParser();                 // Destroy ADLParser object

  void parse(void);             // Do the parsing & build forms lists

  int linenum() { return _buf.linenum(); }

  static bool is_literal_constant(const char *hex_string);
  static bool is_hex_digit(char digit);
  static bool is_int_token(const char* token, int& intval);
  static bool equivalent_expressions(const char* str1, const char* str2);
  static void trim(char* &token);  // trim leading & trailing spaces
};

#endif // SHARE_VM_ADLC_ADLPARSE_HPP