summaryrefslogtreecommitdiffstats
path: root/src/usr/diag/prdf/framework/rule/prdrExpr.H
diff options
context:
space:
mode:
Diffstat (limited to 'src/usr/diag/prdf/framework/rule/prdrExpr.H')
-rwxr-xr-xsrc/usr/diag/prdf/framework/rule/prdrExpr.H1046
1 files changed, 1046 insertions, 0 deletions
diff --git a/src/usr/diag/prdf/framework/rule/prdrExpr.H b/src/usr/diag/prdf/framework/rule/prdrExpr.H
new file mode 100755
index 000000000..adb32fad9
--- /dev/null
+++ b/src/usr/diag/prdf/framework/rule/prdrExpr.H
@@ -0,0 +1,1046 @@
+/* IBM_PROLOG_BEGIN_TAG */
+/* This is an automatically generated prolog. */
+/* */
+/* $Source: src/usr/diag/prdf/framework/rule/prdrExpr.H $ */
+/* */
+/* IBM CONFIDENTIAL */
+/* */
+/* COPYRIGHT International Business Machines Corp. 2004,2012 */
+/* */
+/* p1 */
+/* */
+/* Object Code Only (OCO) source materials */
+/* Licensed Internal Code Source Materials */
+/* IBM HostBoot Licensed Internal Code */
+/* */
+/* The source code for this program is not published or otherwise */
+/* divested of its trade secrets, irrespective of what has been */
+/* deposited with the U.S. Copyright Office. */
+/* */
+/* Origin: 30 */
+/* */
+/* IBM_PROLOG_END_TAG */
+
+#ifndef __PRDREXPR_H
+#define __PRDREXPR_H
+
+#include <map>
+#include <list>
+#include <sstream>
+#include <stdint.h>
+#include <typeinfo> // for typeid
+
+#include <netinet/in.h>
+
+#include <prdrCommon.H> // for enums.
+
+// -- Forward defs //
+class PrdrExpr;
+uint16_t prdrGetRefId(std::string *);
+char prdrGetRefType(std::string *);
+void prdrCheckReferences();
+uint32_t prdrActionArgMap(const std::string &);
+uint32_t prdrCaptureGroupMap(const std::string &);
+uint32_t prdrCaptureTypeMap(const std::string &); // @jl04 Type for registers.
+std::list<std::string> prdrParseDoxygen(std::string & i_string);
+class PrdrChip;
+extern PrdrChip * g_currentChip;
+extern std::map<std::string, PrdrExpr *> g_rules;
+extern void yyerror(const char *);
+extern uint32_t g_nextAndBit;
+extern bool g_hadError;
+// -- end Forward defs //
+
+using Prdr::PrdrSignatureOp;
+
+class PrdrExpr
+{
+ public:
+
+ virtual int output(FILE *) = 0;
+
+ virtual void setComment(std::string & i_comment)
+ { cv_doxcomment = i_comment; };
+
+ virtual void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ { o_stream << "Using default."; };
+
+ virtual uint16_t getSignature()
+ {
+ std::cerr << "def sig: " << typeid(*this).name()
+ << std::endl;
+ return PrdrSignatureOp::DEFAULT_SIGNATURE;
+ };
+
+
+ PrdrExpr() : cv_doxcomment("") {};
+ virtual ~PrdrExpr() {};
+
+ protected:
+ std::string cv_doxcomment;
+};
+
+class PrdrExprRef : public PrdrExpr
+{
+ public:
+ std::string * cv_name;
+
+ PrdrExprRef(std::string * n) : cv_name(n) {};
+
+ int output(FILE * i_file)
+ {
+ char l_op = prdrGetRefType(cv_name);
+ uint16_t l_id = htons(prdrGetRefId(cv_name));
+
+ fwrite(&l_op, 1, 1, i_file);
+ fwrite(&l_id, sizeof(l_id), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "<A HREF=\"#" << *cv_name << "\">"
+ << *cv_name << "</A>";
+ }
+
+ virtual uint16_t getSignature()
+ {
+ if (Prdr::REF_REG == prdrGetRefType(cv_name))
+ {
+ return Util::hashString(cv_name->c_str());
+ }
+ else
+ {
+ PrdrExpr * tmp = g_rules[*cv_name];
+ if (NULL == tmp)
+ {
+ std::cerr << "NPE: " << *cv_name << std::endl;
+ }
+ return (NULL == tmp ?
+ PrdrSignatureOp::DEFAULT_SIGNATURE
+ : tmp->getSignature()
+ );
+ }
+ };
+
+};
+
+class PrdrExprInt : public PrdrExpr
+{
+ public:
+ uint32_t cv_value;
+ char cv_op;
+
+ PrdrExprInt() : cv_op(Prdr::INTEGER) {};
+ PrdrExprInt(uint32_t v, char o = Prdr::INTEGER) : cv_value(v),
+ cv_op(o) {};
+
+ int output(FILE * i_file)
+ {
+ char tmp = cv_op;
+ fwrite(&tmp, 1, 1, i_file);
+
+ if (Prdr::INTEGER != cv_op)
+ {
+ uint16_t temp = htons((uint16_t) cv_value);
+ fwrite(&temp, sizeof(temp), 1, i_file);
+ }
+ else
+ {
+ uint32_t temp = htonl(cv_value);
+ fwrite(&temp, sizeof(temp), 1, i_file);
+ }
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << cv_value;
+ o_errFile << std::setfill('0') << std::setw(2) << std::hex
+ << cv_value;
+ };
+
+ uint16_t getSignature() { return PrdrSignatureOp::DEFAULT_SIGNATURE; };
+};
+
+class PrdrExprTime : public PrdrExpr
+{
+ public:
+
+ uint32_t iv_units;
+ Prdr::PrdrTimeBaseFlags iv_base;
+
+ PrdrExprTime() :
+ iv_units(0xffffffff), iv_base(Prdr::PRDR_TIME_BASE_SEC)
+ {}
+
+ PrdrExprTime( uint32_t units, Prdr::PrdrTimeBaseFlags base ) :
+ iv_units(units), iv_base(base)
+ {}
+
+ int output( FILE * i_file )
+ {
+ uint32_t seconds = 0xffffffff;
+ if ( (seconds / iv_base) > iv_units )
+ seconds = iv_units * iv_base;
+
+ seconds = htonl( seconds );
+ fwrite( &seconds, sizeof(seconds), 1, i_file );
+
+ return 0;
+ }
+
+ void generateDoxygen( std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr )
+ {
+ uint32_t seconds = iv_units * iv_base;
+
+ o_stream << iv_units << " ";
+ switch ( iv_base )
+ {
+ case Prdr::PRDR_TIME_BASE_SEC: o_stream << "sec"; break;
+ case Prdr::PRDR_TIME_BASE_MIN: o_stream << "min"; break;
+ case Prdr::PRDR_TIME_BASE_HOUR: o_stream << "hour"; break;
+ case Prdr::PRDR_TIME_BASE_DAY: o_stream << "day"; break;
+ default: ;
+ }
+ }
+};
+
+class PrdrExprBitString : public PrdrExpr
+{
+ public:
+ std::string cv_value;
+ char cv_op;
+
+ PrdrExprBitString() : cv_value(), cv_op(Prdr::BIT_STR) {};
+ PrdrExprBitString(std::string v, char o = Prdr::BIT_STR) : cv_value(v),
+ cv_op(o) {};
+
+ int output(FILE * i_file)
+ {
+ char tmp = cv_op;
+ fwrite(&tmp, 1, 1, i_file);
+
+ // subtract 2 backticks.
+ uint8_t len = (cv_value.length() - 2) * 4;
+ fwrite(&len, sizeof(len), 1, i_file);
+
+ uint8_t tmp8 = 0;
+
+ len = len / 4;
+
+ // Output binary data from hex.
+ for (int i = 0; i < len; i++)
+ {
+ if (isdigit(cv_value[i+1]))
+ {
+ tmp8 |= cv_value[i+1] - '0';
+ }
+ else
+ {
+ tmp8 |= toupper(cv_value[i+1]) - 'A' + 0xa;
+ }
+
+ if (i == (len - 1))
+ {
+ while ((i % 2) != 1)
+ {
+ tmp8 <<= 4;
+ i++;
+ }
+ }
+ if (i % 2 == 1)
+ {
+ fwrite(&tmp8, sizeof(tmp8), 1, i_file);
+ tmp8 = 0;
+ }
+
+ tmp8 <<= 4;
+ }
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << cv_value;
+ o_errFile << cv_value;
+ };
+
+ uint16_t getSignature() { return PrdrSignatureOp::DEFAULT_SIGNATURE; };
+};
+
+
+class PrdrExprOp1 : public PrdrExpr
+{
+ public:
+ char cv_op;
+ PrdrExpr * cv_arg;
+
+ PrdrExprOp1(char o) : cv_op(o) {};
+ PrdrExprOp1(char o, PrdrExpr * a) : cv_op(o), cv_arg(a) {};
+
+ int output(FILE * i_file)
+ {
+ fwrite(&cv_op, 1, 1, i_file);
+ cv_arg->output(i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << cv_op << " ";
+ if (NULL != cv_arg)
+ cv_arg->generateDoxygen(o_stream, o_trailing, o_errFile);
+ };
+
+ uint16_t getSignature()
+ {
+ return (NULL == cv_arg ?
+ PrdrSignatureOp::DEFAULT_SIGNATURE
+ : cv_arg->getSignature()
+ );
+ }
+
+};
+
+class PrdrExprOp2 : public PrdrExpr
+{
+ public:
+ PrdrExpr * cv_arg[2];
+ char cv_op;
+
+ PrdrExprOp2(char o) : cv_op(o) {};
+ PrdrExprOp2(char o, PrdrExpr * a1, PrdrExpr * a2) : cv_op(o)
+ {
+ cv_arg[0] = a1; cv_arg[1] = a2;
+ };
+
+ int output(FILE * i_file)
+ {
+ fwrite(&cv_op, 1, 1, i_file);
+ cv_arg[0]->output(i_file);
+ cv_arg[1]->output(i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ if (NULL != cv_arg[0])
+ cv_arg[0]->generateDoxygen(o_stream, o_trailing, o_errFile);
+ o_stream << " " << cv_op << " ";
+
+ if (NULL != cv_arg[1])
+ cv_arg[1]->generateDoxygen(o_stream, o_trailing, o_errFile);
+ };
+
+ uint16_t getSignature()
+ {
+ return PrdrSignatureOp::combineSig(
+ (NULL == cv_arg[0] ?
+ PrdrSignatureOp::DEFAULT_SIGNATURE
+ : cv_arg[0]->getSignature()
+ ),
+ (NULL == cv_arg[1] ?
+ PrdrSignatureOp::DEFAULT_SIGNATURE
+ : cv_arg[1]->getSignature()
+ ));
+ };
+
+};
+
+class PrdrExprAttnLink : public PrdrExpr
+{
+ public:
+ static const int MAX_ATTNS = 4;
+ PrdrExpr * cv_arg[MAX_ATTNS];
+
+ PrdrExprAttnLink(std::string * attn1, PrdrExpr * exp1,
+ std::string * attn2, PrdrExpr * exp2,
+ std::string * attn3, PrdrExpr * exp3,
+ std::string * attn4, PrdrExpr * exp4)
+ {
+ for (int i = 0; i < MAX_ATTNS; i++)
+ cv_arg[i] = NULL;
+
+ cv_arg[decodeAttnType(attn1)] = exp1;
+ if (NULL != exp2)
+ cv_arg[decodeAttnType(attn2)] = exp2;
+ if (NULL != exp3)
+ cv_arg[decodeAttnType(attn3)] = exp3;
+ if (NULL != exp4)
+ cv_arg[decodeAttnType(attn4)] = exp4;
+ };
+
+ int output(FILE * i_file)
+ {
+ char cv_op = Prdr::ATTNLINK;
+ fwrite(&cv_op, 1, 1, i_file);
+
+ cv_op = 0;
+ for (int i = 0; i < MAX_ATTNS; i++)
+ if (NULL != cv_arg[i])
+ cv_op++;
+ fwrite(&cv_op, 1, 1, i_file);
+
+ for (int i = 0; i < MAX_ATTNS; i++)
+ if (NULL != cv_arg[i])
+ {
+ cv_op = i;
+ fwrite(&cv_op, 1, 1, i_file);
+ cv_arg[i]->output(i_file);
+ }
+
+ return 0;
+ }
+
+ uint16_t getSignature()
+ {
+ uint16_t l_val = PrdrSignatureOp::DEFAULT_SIGNATURE;
+ for (int i = 0; i < MAX_ATTNS; i++)
+ if (NULL != cv_arg[i])
+ l_val = PrdrSignatureOp::combineSig(l_val,
+ cv_arg[i]->getSignature());
+ else
+ l_val = PrdrSignatureOp::combineSig(l_val,
+ PrdrSignatureOp::DEFAULT_SIGNATURE);
+ return l_val;
+ };
+
+ protected:
+ int decodeAttnType(std::string * attn)
+ {
+ if (NULL == attn)
+ {
+ yyerror("ICE - NPE.");
+ }
+ else if ("CHECK_STOP" == *attn)
+ {
+ return 0;
+ }
+ else if ("RECOVERABLE" == *attn)
+ {
+ return 1;
+ }
+ else if ("SPECIAL" == *attn)
+ {
+ return 2;
+ }
+ else if ("PROC_CS" == *attn)
+ {
+ return 3;
+ }
+ else if ("UNIT_CS" == *attn) // @jl02 Add UNIT_CS check.
+ {
+ return 3; // @jl02
+ }
+ else
+ {
+ char error[256];
+ strcpy(error, "Invalid attention name: ");
+ strncat(error, attn->c_str(), 255);
+
+ yyerror(error);
+ }
+ return 0;
+ };
+};
+
+
+class PrdrExprRule : public PrdrExpr
+{
+ public:
+ std::string * cv_rulename;
+ PrdrExpr * cv_bits;
+ std::string * cv_actionname;
+
+ PrdrExprRule(std::string * r, PrdrExpr * b, std::string * a)
+ : cv_rulename(r), cv_bits(b), cv_actionname(a) {};
+
+ int output(FILE * i_file)
+ {
+ uint16_t l_ref;
+ char l_op;
+
+ l_op = Prdr::REF_RULE;
+ fwrite(&l_op, 1, 1, i_file);
+ l_ref = htons(prdrGetRefId(cv_rulename));
+ fwrite(&l_ref, sizeof(l_ref), 1, i_file);
+
+ cv_bits->output(i_file);
+
+ l_op = prdrGetRefType(cv_actionname);
+ fwrite(&l_op, 1, 1, i_file);
+ l_ref = htons(prdrGetRefId(cv_actionname));
+ fwrite(&l_ref, sizeof(l_ref), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ std::list<std::string> l_parsed = prdrParseDoxygen(cv_doxcomment);
+
+ std::string l_name("N/A"), l_short("N/A"), l_long("");
+ std::ostringstream l_errFront, l_errBits, l_errBack;
+
+ l_errFront << "\tPRDR_ERROR_SIGNATURE ( 0x"
+ << std::setfill('0') << std::setw(4)
+ << std::hex
+ << ( (PrdrExprRef(cv_rulename).getSignature()
+ + g_currentChip->cv_signatureOffset) & 0xffff )
+ << "00";
+
+ o_stream << "<TD align=\"center\">";
+ cv_bits->generateDoxygen(o_stream, o_trailing, l_errBits);
+
+ if (std::string() != l_parsed.front())
+ {
+ l_name = l_parsed.front();
+ }
+ l_parsed.pop_front();
+
+ if (std::string() != l_parsed.front())
+ {
+ l_short = l_parsed.front();
+ }
+ l_parsed.pop_front();
+
+ if (std::string() != l_parsed.front())
+ {
+ l_long = l_parsed.front();
+ }
+
+ o_stream << "<TD align=\"center\">";
+ if (std::string() != l_long)
+ {
+ o_stream << "<A HREF=\"#" << l_name << "\">";
+
+ o_trailing += "<B><A NAME='" + l_name + "'>" ;
+ o_trailing += l_name + ": </A></B>";
+
+ o_trailing += l_short + "<BR>";
+ o_trailing += l_long + "<BR><BR>\n";
+ }
+ o_stream << l_name;
+ if (std::string() != l_long)
+ {
+ o_stream << "</A>";
+ o_trailing += "</A>";
+ }
+
+ o_stream << "<TD>" << l_short;
+
+
+ o_stream << "<TD><A HREF=\"#" << *cv_actionname << "\">"
+ << *cv_actionname << "</A>";
+
+ l_errBack << ", \"" << l_name << "\", \"" << l_short << "\"";
+ l_errBack << " )" << std::endl;
+
+ for (size_t i = 0; i < (l_errBits.str().length()/2); i++)
+ {
+ o_errFile << l_errFront.str();
+
+ if (typeid(*cv_bits).name() == typeid(PrdrExprOp2).name())
+ {
+ if (static_cast<PrdrExprOp2 *>(cv_bits)->cv_op == Prdr::AND)
+ {
+ o_errFile << std::setfill('0') << std::setw(2)
+ << std::hex;
+ o_errFile << g_nextAndBit;
+ g_nextAndBit++;
+
+ i = 256;
+ }
+ else
+ {
+ o_errFile << l_errBits.str()[2*i]
+ << l_errBits.str()[2*i+1];
+ }
+ }
+ else
+ {
+ o_errFile << l_errBits.str()[2*i]
+ << l_errBits.str()[2*i+1];
+ }
+
+ o_errFile << l_errBack.str();
+ }
+ };
+};
+
+class PrdrExprAct_Try : public PrdrExpr
+{
+ public:
+ PrdrExpr * cv_left, * cv_right;
+
+ PrdrExprAct_Try(PrdrExpr * l, PrdrExpr * r) : cv_left(l),
+ cv_right(r) {};
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+
+ l_op = Prdr::ACT_TRY;
+ fwrite(&l_op, 1, 1, i_file);
+ cv_left->output(i_file);
+ cv_right->output(i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "try { ";
+ if (NULL != cv_left)
+ cv_left->generateDoxygen(o_stream, o_trailing, o_errFile);
+ o_stream << ", ";
+ if (NULL != cv_right)
+ cv_right->generateDoxygen(o_stream, o_trailing, o_errFile);
+ o_stream << " } ";
+ };
+
+};
+
+class PrdrExprAct_Thresh : public PrdrExpr
+{
+ public:
+ PrdrExpr* cv_thresholdTime[2];
+ //Maximum threshold value supported is 255
+ uint8_t cv_field;
+ uint8_t cv_mfg;
+ uint32_t cv_3;
+ std::string * cv_mfg_file_thr;
+
+ PrdrExprAct_Thresh( uint8_t i_field = 0, PrdrExpr * i_fieldTime = NULL,
+ uint8_t i_mfg = 0, PrdrExpr * i_mfgTime = NULL,
+ std::string * i_mfg_file = NULL ) :
+ cv_field(i_field), cv_mfg(i_mfg), cv_mfg_file_thr(i_mfg_file)
+ {
+ cv_thresholdTime[0] = i_fieldTime;
+ cv_thresholdTime[1] = i_mfgTime;
+ };
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+ l_op = Prdr::ACT_THRES;
+ fwrite(&l_op, 1, 1, i_file);
+
+ if (NULL == cv_thresholdTime[0])
+ l_op = 0;
+ else if ( (NULL == cv_thresholdTime[1]) &&
+ (NULL == cv_mfg_file_thr))
+ {
+ l_op = 1;
+ }
+ else
+ l_op = 2;
+
+ if (0 != cv_3)
+ l_op |= 0x40;
+
+ if (NULL != cv_mfg_file_thr)
+ l_op |= 0x20;
+
+ fwrite(&l_op, 1, 1, i_file);
+
+ if (NULL != cv_thresholdTime[0])
+ {
+ fwrite(&cv_field, sizeof(cv_field), 1, i_file);
+ cv_thresholdTime[0]->output(i_file);
+ if (NULL != cv_thresholdTime[1])
+ {
+ fwrite(&cv_mfg, sizeof(cv_mfg), 1, i_file);
+ cv_thresholdTime[1]->output(i_file);
+ }
+ else if (NULL != cv_mfg_file_thr)
+ {
+ uint32_t l_tmp32 = prdrActionArgMap(*cv_mfg_file_thr);
+ l_tmp32 = htonl(l_tmp32);
+ fwrite(&l_tmp32, sizeof(l_tmp32), 1, i_file);
+ }
+ }
+
+ if (0 != cv_3)
+ {
+ uint32_t l_tmp32 = htonl(cv_3);
+ fwrite(&l_tmp32, 4, 1, i_file);
+ }
+
+ return 0;
+ }
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "threshold(";
+ if (NULL != cv_thresholdTime[0])
+ {
+ uint32_t units = cv_field;
+ o_stream <<" field";
+ o_stream << "(";
+ o_stream << units;
+ o_stream << ",";
+ cv_thresholdTime[0]->generateDoxygen(o_stream, o_trailing, o_errFile);
+ o_stream << ")";
+ if (NULL != cv_thresholdTime[1])
+ {
+ units = cv_mfg;
+ o_stream << ", mfg";
+ o_stream << "(";
+ o_stream << units;
+ o_stream << ",";
+ cv_thresholdTime[1]->generateDoxygen(o_stream, o_trailing, o_errFile);
+ o_stream << ")";
+ }
+ else if (NULL != cv_mfg_file_thr)
+ {
+ o_stream << ", mfg_file";
+ o_stream << "(";
+ o_stream << *cv_mfg_file_thr;
+ o_stream << ")";
+ }
+ }
+ o_stream << ")";
+ if (0 != cv_3)
+ {
+ o_stream << " shared(" << cv_3 << ")";
+ }
+ };
+
+};
+
+
+class PrdrExprAct_Dump : public PrdrExpr //@ecdf
+{
+ public:
+ std::string * cv_1;
+
+ PrdrExprAct_Dump(std::string * i_1) : cv_1(i_1) {};
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+
+ l_op = Prdr::ACT_DUMP;
+ fwrite(&l_op, 1, 1, i_file);
+
+ uint32_t l_dType;
+
+ if (NULL == cv_1)
+ l_dType = prdrActionArgMap("DUMP_CONTENT_HW");
+ else
+ l_dType = prdrActionArgMap(*cv_1);
+ l_dType = htonl(l_dType);
+ fwrite(&l_dType, sizeof(l_dType), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "dump( " << *cv_1 << " ) ";
+ };
+
+};
+
+class PrdrExprAct_Gard : public PrdrExpr
+{
+ public:
+ std::string * cv_1;
+
+ PrdrExprAct_Gard(std::string * i_1) : cv_1(i_1) {};
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+
+ l_op = Prdr::ACT_GARD;
+ fwrite(&l_op, 1, 1, i_file);
+
+ uint32_t l_gType = htonl(prdrActionArgMap(*cv_1));
+ fwrite(&l_gType, sizeof(l_gType), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "gard( " << *cv_1 << " ) ";
+ };
+
+};
+
+class PrdrExprAct_Analyse : public PrdrExpr
+{
+ public:
+ std::string * cv_1;
+ uint32_t cv_2;
+
+ PrdrExprAct_Analyse( std::string * i_1, uint32_t i_2 = 0xffffffff ) :
+ cv_1(i_1), cv_2(i_2)
+ {}
+
+ int output(FILE * i_file)
+ {
+ char l_op = Prdr::ACT_ANALY;
+ fwrite(&l_op, 1, 1, i_file);
+
+ uint32_t l_chipType = htonl(prdrActionArgMap(*cv_1));
+ fwrite(&l_chipType, sizeof(l_chipType), 1, i_file);
+
+ uint32_t l_chipIndx = htonl(cv_2);
+ fwrite(&l_chipIndx, sizeof(l_chipIndx), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "analyze ( ";
+ o_stream << "connected ( " << *cv_1 ;
+ if ( 0xffffffff != cv_2 )
+ o_stream << ", " << cv_2;
+ o_stream << " ) ) ";
+ }
+
+};
+
+class PrdrExprAct_Callout : public PrdrExpr
+{
+ public:
+ std::string * cv_1, * cv_2;
+ uint32_t cv_3;
+
+ PrdrExpr * cv_alt;
+
+ enum Callout_type
+ {
+ CALLOUT_SELF = 's',
+ CALLOUT_CHIP = 'c',
+ CALLOUT_PROC = 'p',
+ };
+
+ Callout_type cv_type;
+
+ PrdrExprAct_Callout(std::string * i_1,
+ std::string * i_2 = NULL,
+ Callout_type i_t = CALLOUT_SELF,
+ uint32_t i_3 = 0xffffffff,
+ PrdrExpr * i_alt = NULL) :
+ cv_1(i_1), cv_2(i_2), cv_3(i_3), cv_alt(i_alt), cv_type(i_t)
+ {}
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+
+ l_op = Prdr::ACT_CALL;
+ fwrite(&l_op, 1, 1, i_file);
+
+ l_op = cv_type;
+ fwrite(&l_op, 1, 1, i_file);
+
+ uint32_t l_priority = htonl(prdrActionArgMap(*cv_1));
+ fwrite(&l_priority, sizeof(l_priority), 1, i_file);
+
+ if (CALLOUT_SELF != cv_type)
+ {
+ uint32_t l_arg = htonl(prdrActionArgMap(*cv_2));
+ fwrite(&l_arg, sizeof(l_arg), 1, i_file);
+
+ l_arg = htonl(cv_3);
+ fwrite(&l_arg, sizeof(l_arg), 1, i_file);
+ // Write bool for ALT resolution.
+ l_op = (NULL == cv_alt ? 0 : 1);
+ fwrite(&l_op, 1, 1, i_file);
+
+ // Write ALT resolution.
+ if (NULL != cv_alt)
+ cv_alt->output(i_file);
+ }
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "callout ( ";
+ if (CALLOUT_SELF == cv_type)
+ {
+ o_stream << "SELF, " << *cv_1 << " )";
+ }
+ else if (CALLOUT_PROC == cv_type)
+ {
+ o_stream << "procedure ( " << *cv_2 << " ), " << *cv_1 << " ) ";
+ }
+ else
+ {
+ o_stream << "connected ( " << *cv_2 ;
+ if ( 0xffffffff != cv_3 )
+ o_stream << ", " << cv_3;
+ o_stream << " ), " << *cv_1 << " ) ";
+ }
+ }
+
+};
+
+class PrdrExprAct_Funccall : public PrdrExpr
+{
+ public:
+ std::string * cv_1, * cv_2;
+
+ PrdrExprAct_Funccall(std::string * i_1, std::string * i_2 = NULL) :
+ cv_1(i_1), cv_2(i_2) {};
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+
+ l_op = Prdr::ACT_FUNC;
+ fwrite(&l_op, 1, 1, i_file);
+
+ if ('"' == (*cv_1)[0])
+ (*cv_1) = cv_1->substr(1, cv_1->size() - 2);
+ fwrite(cv_1->c_str(), cv_1->size() + 1, 1, i_file);
+
+ uint32_t l_chip;
+ if (NULL != cv_2)
+ l_chip = htonl(prdrActionArgMap(*cv_2));
+ else
+ l_chip = 0;
+ fwrite(&l_chip, sizeof(l_chip), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "funccall( " << *cv_1;
+ if (NULL != cv_2)
+ o_stream << ", " << *cv_2;
+ o_stream << " ) ";
+ };
+
+
+};
+
+class PrdrExprAct_Flag : public PrdrExpr
+{
+ public:
+ std::string * cv_1;
+
+ PrdrExprAct_Flag(std::string * i_1) : cv_1(i_1) {};
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+
+ l_op = Prdr::ACT_FLAG;
+ fwrite(&l_op, 1, 1, i_file);
+
+ uint32_t l_flag = htonl(prdrActionArgMap(*cv_1));
+ fwrite(&l_flag, sizeof(l_flag), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "flag( " << *cv_1 << " ) ";
+ };
+
+
+};
+
+class PrdrExprAct_Capture : public PrdrExpr
+{
+ public:
+ std::string * cv_1;
+
+ PrdrExprAct_Capture(std::string * i_1) : cv_1(i_1) {};
+
+ int output(FILE * i_file)
+ {
+ char l_op;
+
+ l_op = Prdr::ACT_CAPT;
+ fwrite(&l_op, 1, 1, i_file);
+
+ uint32_t l_group = htonl(prdrCaptureGroupMap(*cv_1));
+ fwrite(&l_group, sizeof(l_group), 1, i_file);
+
+ return 0;
+ };
+
+ void generateDoxygen(std::ostream & o_stream,
+ std::string & o_trailing,
+ std::ostream & o_errFile = std::cerr)
+ {
+ o_stream << "capture( " << *cv_1 << " ) ";
+ };
+
+
+};
+
+
+extern std::map<std::string, PrdrExpr *> g_rules;
+
+typedef std::pair<std::string, std::string> PrdrRefPair;
+extern std::list<PrdrRefPair> g_references;
+
+#endif
+
+// Change Log *********************************************************
+//
+// Flag Reason Vers Date Coder Description
+// ---- -------- ---- -------- -------- -------------------------------
+// F494911 f310 03/04/05 iawillia Initial File Creation
+// D515833 f300 09/19/05 iawillia Add capture support.
+// F526728 f300 10/25/05 iawillia Add >> and << registers.
+// F534311 f300 01/10/06 iawillia Add bit string expression.
+// F544848 f300 04/03/06 iawillia Add multi-bit support.
+// F549888 f300 05/01/06 iawillia Add Proc. CS attention.
+// ecdf F550548 f300 05/04/06 iawillia eClipz DUMP flags support.
+// D555348 f310 06/05/06 iawillia Update HTML generation.
+// jl02 F605874 f330 07/31/07 lukas Add functions to PRD framework/Galaxy
+// 2 code for unit CS.
+// @jl04 F630836 f330 09/17/07 lukas Add error log Cap. type.
+// End Change Log *****************************************************
OpenPOWER on IntegriCloud