explicit SAXEventHandler( ::CreateSpace * obj)
: state(-1)
, depth(0)
, handler_0(&obj->SpaceID)
{
reset_flags();
}
int w_drop_acc_2(struct sip_msg* msg, char* type_p, char* flags_p)
{
unsigned long long type=0;
/* if not set, we reset all flags for the type of accounting requested */
unsigned long long flags=ALL_ACC_FLAGS;
unsigned long long flag_mask;
acc_type_param_t* acc_param;
acc_ctx_t* acc_ctx=try_fetch_ctx();
str in;
if (acc_ctx == NULL) {
LM_ERR("do_accounting() not used! This function resets flags in "
"do_accounting()!\n");
return -1;
}
if (type_p != NULL) {
acc_param = (acc_type_param_t *)type_p;
if (acc_param->t == DO_ACC_PARAM_TYPE_VALUE) {
type = acc_param->u.ival;
} else {
if (pv_printf_s(msg, acc_param->u.pval, &in) < 0) {
LM_ERR("failed to fetch type value!\n");
return -1;
}
if ((type=do_acc_parse(&in, do_acc_type_parser)) == DO_ACC_ERR) {
LM_ERR("Invalid expression <%.*s> for acc type!\n", in.len, in.s);
return -1;
}
}
}
if (flags_p != NULL) {
flags= *(unsigned long long*)flags_p;
}
flag_mask = type * flags;
/* reset all flags */
if (flag_mask == 0) {
/*
* we use this flag in order make the difference between
* 0 value (do_accounting never called, callbacks never registered) and
* ACC_FLAGS_RESET (do_accounting called, callbacks registered, flag value
* changing during script execution)
*/
acc_ctx->flags = ACC_FLAGS_RESET;
} else {
reset_flags(acc_ctx->flags, flag_mask);
}
return 1;
}
void PrepareForReuse()
{
depth = 0;
state = -1;
the_error.reset();
reset_flags();
handler_0.PrepareForReuse();
}
static int bt_detect(struct si_sm_data *bt)
{
/* It's impossible for the BT status and interrupt registers to be
all 1's, (assuming a properly functioning, self-initialized BMC)
but that's what you get from reading a bogus address, so we
test that first. The calling routine uses negative logic. */
if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF)) return 1;
reset_flags(bt);
return 0;
}
int w_drop_acc_2(struct sip_msg* msg, char* type_p, char* flags_p)
{
unsigned long long type=0;
/* if not set, we reset all flags for the type of accounting requested */
unsigned long long flags=ALL_ACC_FLAGS;
unsigned long long flag_mask;
unsigned long long *context_flags_p=try_fetch_flags();
acc_type_param_t* acc_param;
str in;
if (context_flags_p == NULL) {
LM_ERR("do_accounting() not used! This function resets flags in "
"do_accounting()!\n");
return -1;
}
if (type_p != NULL) {
acc_param = (acc_type_param_t *)type_p;
if (acc_param->t == DO_ACC_PARAM_TYPE_VALUE) {
type = acc_param->u.ival;
} else {
if (pv_printf_s(msg, acc_param->u.pval, &in) < 0) {
LM_ERR("failed to fetch type value!\n");
return -1;
}
if ((type=do_acc_parse(&in, do_acc_type_parser)) < 0) {
LM_ERR("Invalid expression <%.*s> for acc type!\n", in.len, in.s);
return -1;
}
}
}
if (flags_p != NULL) {
flags= *(unsigned long long*)flags_p;
}
flag_mask = type * flags;
/* reset all flags */
if (flag_mask == 0) {
*context_flags_p = 0;
} else {
reset_flags(*context_flags_p, flag_mask);
}
return 1;
}
MultivariateFNormalSufficient::MultivariateFNormalSufficient(
const MatrixXd& FX, double JF, const VectorXd& FM,
const MatrixXd& Sigma, double factor)
{
//O(1)
reset_flags();
N_=FX.rows();
M_=FX.cols();
LOG( "MVN: direct init with N=" << N_
<< " and M=" << M_ << std::endl);
CHECK( N_ > 0,
"please provide at least one observation per dimension");
CHECK( M_ > 0,
"please provide at least one variable");
set_factor(factor);
set_FM(FM);
set_FX(FX);
set_jacobian(JF);
set_Sigma(Sigma);
}
MultivariateFNormalSufficient::MultivariateFNormalSufficient(
const VectorXd& Fbar, double JF, const VectorXd& FM, int Nobs,
const MatrixXd& W, const MatrixXd& Sigma, double factor)
{
reset_flags();
N_=Nobs;
M_=Fbar.rows();
LOG( "MVN: sufficient statistics init with N=" << N_
<< " and M=" << M_ << std::endl);
CHECK( N_ > 0,
"please provide at least one observation per dimension");
CHECK( M_ > 0,
"please provide at least one variable");
set_factor(factor);
set_FM(FM);
set_Fbar(Fbar);
set_W(W);
set_jacobian(JF);
set_Sigma(Sigma);
}
MultivariateFNormalSufficient::MultivariateFNormalSufficient(
const MatrixXd& FX, double JF, const VectorXd& FM,
const MatrixXd& Sigma, double factor) :
base::Object("Multivariate Normal distribution %1%")
{
//O(1)
reset_flags();
N_=FX.rows();
M_=FX.cols();
IMP_LOG_TERSE( "MVN: direct init with N=" << N_
<< " and M=" << M_ << std::endl);
IMP_USAGE_CHECK( N_ > 0,
"please provide at least one observation per dimension");
IMP_USAGE_CHECK( M_ > 0,
"please provide at least one variable");
set_factor(factor);
set_FM(FM);
set_FX(FX);
set_jacobian(JF);
set_Sigma(Sigma);
use_cg_=false;
}
MultivariateFNormalSufficient::MultivariateFNormalSufficient(
const VectorXd& Fbar, double JF, const VectorXd& FM, int Nobs,
const MatrixXd& W, const MatrixXd& Sigma, double factor)
: base::Object("Multivariate Normal distribution %1%")
{
reset_flags();
N_=Nobs;
M_=Fbar.rows();
IMP_LOG_TERSE( "MVN: sufficient statistics init with N=" << N_
<< " and M=" << M_ << std::endl);
IMP_USAGE_CHECK( N_ > 0,
"please provide at least one observation per dimension");
IMP_USAGE_CHECK( M_ > 0,
"please provide at least one variable");
set_factor(factor);
set_FM(FM);
set_Fbar(Fbar);
set_W(W);
set_jacobian(JF);
set_Sigma(Sigma);
use_cg_=false;
}
static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
{
unsigned char status;
char buf[40]; /* For getting status */
int i;
status = BT_STATUS;
bt->nonzero_status |= status;
if ((bt_debug & BT_DEBUG_STATES) && (bt->state != bt->last_state))
printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
STATE2TXT,
STATUS2TXT(buf),
bt->timeout,
time);
bt->last_state = bt->state;
if (bt->state == BT_STATE_HOSED) return SI_SM_HOSED;
if (bt->state != BT_STATE_IDLE) { /* do timeout test */
/* Certain states, on error conditions, can lock up a CPU
because they are effectively in an infinite loop with
CALL_WITHOUT_DELAY (right back here with time == 0).
Prevent infinite lockup by ALWAYS decrementing timeout. */
/* FIXME: bt_event is sometimes called with time > BT_NORMAL_TIMEOUT
(noticed in ipmi_smic_sm.c January 2004) */
if ((time <= 0) || (time >= BT_NORMAL_TIMEOUT)) time = 100;
bt->timeout -= time;
if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1)) {
error_recovery(bt, "timed out");
return SI_SM_CALL_WITHOUT_DELAY;
}
}
switch (bt->state) {
case BT_STATE_IDLE: /* check for asynchronous messages */
if (status & BT_SMS_ATN) {
BT_CONTROL(BT_SMS_ATN); /* clear it */
return SI_SM_ATTN;
}
return SI_SM_IDLE;
case BT_STATE_XACTION_START:
if (status & BT_H_BUSY) {
BT_CONTROL(BT_H_BUSY);
break;
}
if (status & BT_B2H_ATN) break;
bt->state = BT_STATE_WRITE_BYTES;
return SI_SM_CALL_WITHOUT_DELAY; /* for logging */
case BT_STATE_WRITE_BYTES:
if (status & (BT_B_BUSY | BT_H2B_ATN)) break;
BT_CONTROL(BT_CLR_WR_PTR);
write_all_bytes(bt);
BT_CONTROL(BT_H2B_ATN); /* clears too fast to catch? */
bt->state = BT_STATE_WRITE_CONSUME;
return SI_SM_CALL_WITHOUT_DELAY; /* it MIGHT sail through */
case BT_STATE_WRITE_CONSUME: /* BMCs usually blow right thru here */
if (status & (BT_H2B_ATN | BT_B_BUSY)) break;
bt->state = BT_STATE_B2H_WAIT;
/* fall through with status */
/* Stay in BT_STATE_B2H_WAIT until a packet matches. However, spinning
hard here, constantly reading status, seems to hold off the
generation of B2H_ATN so ALWAYS return CALL_WITH_DELAY. */
case BT_STATE_B2H_WAIT:
if (!(status & BT_B2H_ATN)) break;
/* Assume ordered, uncached writes: no need to wait */
if (!(status & BT_H_BUSY)) BT_CONTROL(BT_H_BUSY); /* set */
BT_CONTROL(BT_B2H_ATN); /* clear it, ACK to the BMC */
BT_CONTROL(BT_CLR_RD_PTR); /* reset the queue */
i = read_all_bytes(bt);
BT_CONTROL(BT_H_BUSY); /* clear */
if (!i) break; /* Try this state again */
bt->state = BT_STATE_READ_END;
return SI_SM_CALL_WITHOUT_DELAY; /* for logging */
case BT_STATE_READ_END:
/* I could wait on BT_H_BUSY to go clear for a truly clean
exit. However, this is already done in XACTION_START
and the (possible) extra loop/status/possible wait affects
performance. So, as long as it works, just ignore H_BUSY */
#ifdef MAKE_THIS_TRUE_IF_NECESSARY
if (status & BT_H_BUSY) break;
#endif
bt->seq++;
bt->state = BT_STATE_IDLE;
return SI_SM_TRANSACTION_COMPLETE;
case BT_STATE_RESET1:
reset_flags(bt);
bt->timeout = BT_RESET_DELAY;
bt->state = BT_STATE_RESET2;
break;
case BT_STATE_RESET2: /* Send a soft reset */
BT_CONTROL(BT_CLR_WR_PTR);
HOST2BMC(3); /* number of bytes following */
HOST2BMC(0x18); /* NetFn/LUN == Application, LUN 0 */
HOST2BMC(42); /* Sequence number */
HOST2BMC(3); /* Cmd == Soft reset */
BT_CONTROL(BT_H2B_ATN);
bt->state = BT_STATE_RESET3;
break;
case BT_STATE_RESET3:
if (bt->timeout > 0) return SI_SM_CALL_WITH_DELAY;
bt->state = BT_STATE_RESTART; /* printk in debug modes */
break;
case BT_STATE_RESTART: /* don't reset retries! */
bt->write_data[2] = ++bt->seq;
bt->read_count = 0;
bt->nonzero_status = 0;
bt->timeout = BT_NORMAL_TIMEOUT;
bt->state = BT_STATE_XACTION_START;
break;
default: /* HOSED is supposed to be caught much earlier */
error_recovery(bt, "internal logic error");
break;
}
return SI_SM_CALL_WITH_DELAY;
}
void check_route(enum e_route_type route_type, int num_switch,
t_ivec ** clb_opins_used_locally) {
/* This routine checks that a routing: (1) Describes a properly *
* connected path for each net, (2) this path connects all the *
* pins spanned by that net, and (3) that no routing resources are *
* oversubscribed (the occupancy of everything is recomputed from *
* scratch). */
int inet, ipin, max_pins, inode, prev_node;
boolean valid, connects;
boolean * connected_to_route; /* [0 .. num_rr_nodes-1] */
struct s_trace *tptr;
boolean * pin_done;
vpr_printf(TIO_MESSAGE_INFO, "\n");
vpr_printf(TIO_MESSAGE_INFO, "Checking to ensure routing is legal...\n");
/* Recompute the occupancy from scratch and check for overuse of routing *
* resources. This was already checked in order to determine that this *
* is a successful routing, but I want to double check it here. */
recompute_occupancy_from_scratch(clb_opins_used_locally);
valid = feasible_routing();
if (valid == FALSE) {
vpr_printf(TIO_MESSAGE_ERROR, "Error in check_route -- routing resources are overused.\n");
exit(1);
}
check_locally_used_clb_opins(clb_opins_used_locally, route_type);
connected_to_route = (boolean *) my_calloc(num_rr_nodes, sizeof(boolean));
max_pins = 0;
for (inet = 0; inet < num_nets; inet++)
max_pins = std::max(max_pins, (clb_net[inet].num_sinks + 1));
pin_done = (boolean *) my_malloc(max_pins * sizeof(boolean));
/* Now check that all nets are indeed connected. */
for (inet = 0; inet < num_nets; inet++) {
if (clb_net[inet].is_global || clb_net[inet].num_sinks == 0) /* Skip global nets. */
continue;
for (ipin = 0; ipin < (clb_net[inet].num_sinks + 1); ipin++)
pin_done[ipin] = FALSE;
/* Check the SOURCE of the net. */
tptr = trace_head[inet];
if (tptr == NULL) {
vpr_printf(TIO_MESSAGE_ERROR, "in check_route: net %d has no routing.\n", inet);
exit(1);
}
inode = tptr->index;
check_node_and_range(inode, route_type);
check_switch(tptr, num_switch);
connected_to_route[inode] = TRUE; /* Mark as in path. */
check_source(inode, inet);
pin_done[0] = TRUE;
prev_node = inode;
tptr = tptr->next;
/* Check the rest of the net */
while (tptr != NULL) {
inode = tptr->index;
check_node_and_range(inode, route_type);
check_switch(tptr, num_switch);
if (rr_node[prev_node].type == SINK) {
if (connected_to_route[inode] == FALSE) {
vpr_printf(TIO_MESSAGE_ERROR, "in check_route: node %d does not link into existing routing for net %d.\n", inode, inet);
exit(1);
}
}
else {
connects = check_adjacent(prev_node, inode);
if (!connects) {
vpr_printf(TIO_MESSAGE_ERROR, "in check_route: found non-adjacent segments in traceback while checking net %d.\n", inet);
exit(1);
}
if (connected_to_route[inode] && rr_node[inode].type != SINK) {
/* Note: Can get multiple connections to the same logically-equivalent *
* SINK in some logic blocks. */
vpr_printf(TIO_MESSAGE_ERROR, "in check_route: net %d routing is not a tree.\n", inet);
exit(1);
}
connected_to_route[inode] = TRUE; /* Mark as in path. */
if (rr_node[inode].type == SINK)
check_sink(inode, inet, pin_done);
} /* End of prev_node type != SINK */
prev_node = inode;
tptr = tptr->next;
} /* End while */
if (rr_node[prev_node].type != SINK) {
vpr_printf(TIO_MESSAGE_ERROR, "in check_route: net %d does not end with a SINK.\n", inet);
exit(1);
}
for (ipin = 0; ipin < (clb_net[inet].num_sinks + 1); ipin++) {
if (pin_done[ipin] == FALSE) {
vpr_printf(TIO_MESSAGE_ERROR, "in check_route: net %d does not connect to pin %d.\n", inet, ipin);
exit(1);
}
}
reset_flags(inet, connected_to_route);
} /* End for each net */
free(pin_done);
free(connected_to_route);
vpr_printf(TIO_MESSAGE_INFO, "Completed routing consistency check successfully.\n");
vpr_printf(TIO_MESSAGE_INFO, "\n");
}
void SaveDepth::create_depth(){
// cout << CameraMat_ << endl;
// cout << CameraExtrinsicMat_ << endl;
// cout << DistCoeff_ << endl;
// cout << points_.header << endl;
// stringstream ss;
// ss << width << " : " << height << endl;
// cout << ss.str() << endl;
// cout << points_.header << endl;
int width = ImageSize_.width;
int height = ImageSize_.height;
cv::Mat invR = CameraExtrinsicMat_(cv::Rect(0,0,3,3)).t();
cv::Mat invT = -invR*(CameraExtrinsicMat_(cv::Rect(3,0,1,3)));
cv::Mat invR_T = invR.t();
cv::Mat invT_T = invT.t();
// cv::Mat depth = cv::Mat::zeros(cv::Size(width, height), CV_8U);
cv::Mat depth = cv::Mat::zeros(cv::Size(width, height), CV_32F);
// cv::imwrite(save_path_ + "otameshi" +".jpg", depth);
// cout << "Height " << points_.height << " Width " << points_.height << endl;
// cout << "Image height " << ImageSize_.width << " Height " << ImageSize_.height << endl;
// cout << time_stamp_ << endl;
// cout << points_.row_step << endl;
// cout << points_.point_step << endl;
pcl::PointCloud<pcl::PointXYZI> data_;
pcl::fromROSMsg(points_, data_);
int count = 0;
for (pcl::PointCloud<pcl::PointXYZI>::const_iterator item = data_.begin(); item!=data_.end(); item++){
// cout << "x " << item->x << endl;
// cout << "y " << item->y << endl;
// cout << "z " << item->z << endl;
// cout << item->intensity << endl;
cv::Mat point(1, 3, CV_64F);
point.at<double>(0) = double(item->x);
point.at<double>(1) = double(item->y);
point.at<double>(2) = double(item->z);
point = point * invR_T + invT_T;
// if (point.at<double>(2) <= 2.5) {
// continue;
// }
double tmpx = point.at<double>(0) / point.at<double>(2);
double tmpy = point.at<double>(1)/point.at<double>(2);
double r2 = tmpx * tmpx + tmpy * tmpy;
double tmpdist = 1 + DistCoeff_.at<double>(0) * r2
+ DistCoeff_.at<double>(1) * r2 * r2
+ DistCoeff_.at<double>(4) * r2 * r2 * r2;
cv::Point2d imagepoint;
imagepoint.x = tmpx * tmpdist
+ 2 * DistCoeff_.at<double>(2) * tmpx * tmpy
+ DistCoeff_.at<double>(3) * (r2 + 2 * tmpx * tmpx);
imagepoint.y = tmpy * tmpdist
+ DistCoeff_.at<double>(2) * (r2 + 2 * tmpy * tmpy)
+ 2 * DistCoeff_.at<double>(3) * tmpx * tmpy;
imagepoint.x = CameraMat_.at<double>(0,0) * imagepoint.x + CameraMat_.at<double>(0,2);
imagepoint.y = CameraMat_.at<double>(1,1) * imagepoint.y + CameraMat_.at<double>(1,2);
int px = int(imagepoint.x + 0.5);
int py = int(imagepoint.y + 0.5);
// cout << "px " << px << endl;
// cout << "py " << py << endl;
if(0 <= px && px < width && 0 <= py && py < height){
count = count + 1;
if ((depth.at<double>(py, px) == 0) || (depth.at<double>(py, px) > point.at<double>(2))){
// point.at<double>(2) = point.at<double>(2) * 2;
depth.at<double>(py, px) = point.at<double>(2) / 255;
// depth.at<int>(py+1, px) = int(point.at<double>(2));
// depth.at<int>(py+2, px) = int(point.at<double>(2));
// depth.at<int>(py+1, px+1) = int(point.at<double>(2));
// depth.at<int>(py+2, px+1) = int(point.at<double>(2));
// depth.at<int>(py-1, px) = int(point.at<double>(2));
// depth.at<int>(py-1, px) = int(point.at<double>(2));
// depth.at<int>(py-2, px-1) = int(point.at<double>(2));
// depth.at<int>(py-2, px-1) = int(point.at<double>(2));
}
// double distance = point.at<double>(2);
// cout << "max " << depth.at<double>(py, px) << endl;
// depth.at<double>(50, 50) = 1;
// exit(EXIT_FAILURE);
}
// exit(EXIT_FAILURE);
}
// cout << "count " << count << endl;
double min, max;
// cout << "ok1" << endl;
cv::minMaxLoc(depth, &min, &max);
// cout << "ok2 " << max << endl;
for (int w; w<width; w++){
for (int h; h<height; h++){
if (depth.at<double>(h, w) != 0){
depth.at<double>(h, w) = depth.at<double>(h, w) / max;
}
}
}
cv::imwrite(save_path_ + "depth_" + time_stamp_ +".jpg", depth);
cv::imwrite(save_path_ + "rgb_" + time_stamp_ +".jpg", image_);
// exit(EXIT_FAILURE);
// cout << data_ << endl;
// cv::imwrite(save_path_ + "otameshi" +".jpg", depth);
// cout << "func finish\n";
reset_flags();
}
LogStream::LogStream(logs::LevelFlag lf): level_flag(lf),
file_output(false),
filename("scatter.log") {
reset_flags();
}
/* initiate a report if we previously enabled MC accounting for this t */
static inline void on_missed(struct cell *t, struct sip_msg *req,
struct sip_msg *reply, int code, unsigned long long *flags)
{
str new_uri_bk={0,0};
str dst_uri_bk={0,0};
unsigned long long flags_to_reset=0;
if (t->nr_of_outgoings) {
/* set as new_uri the last branch */
new_uri_bk = req->new_uri;
dst_uri_bk = req->dst_uri;
req->new_uri = t->uac[t->nr_of_outgoings-1].uri;
req->dst_uri = t->uac[t->nr_of_outgoings-1].duri;
req->parsed_uri_ok = 0;
}
/* set env variables */
env_set_to( get_rpl_to(t,reply) );
env_set_code_status( code, reply);
/* we report on missed calls when the first
* forwarding attempt fails; we do not wish to
* report on every attempt; so we clear the flags;
*/
if (is_evi_mc_on(*flags)) {
env_set_event(acc_missed_event);
acc_evi_request( req, reply, is_evi_cdr_on(*flags) );
flags_to_reset |= DO_ACC_EVI * DO_ACC_MISSED;
}
if (is_log_mc_on(*flags)) {
env_set_text( ACC_MISSED, ACC_MISSED_LEN);
acc_log_request( req, reply, is_log_cdr_on(*flags) );
flags_to_reset |= DO_ACC_LOG * DO_ACC_MISSED;
}
if (is_aaa_mc_on(*flags)) {
acc_aaa_request( req, reply, is_aaa_cdr_on(*flags) );
flags_to_reset |= DO_ACC_AAA * DO_ACC_MISSED;
}
if (is_db_mc_on(*flags)) {
env_set_text(db_table_mc.s, db_table_mc.len);
acc_db_request( req, reply,&mc_ins_list, is_db_cdr_on(*flags));
flags_to_reset |= DO_ACC_DB * DO_ACC_MISSED;
}
/* DIAMETER */
#ifdef DIAM_ACC
if (is_diam_mc_on(*flags)) {
acc_diam_request( req, reply );
flags_to_reset |= DO_ACC_DIAM * DO_ACC_MISSED;
}
#endif
/* Reset the accounting missed_flags
* These can't be reset in the blocks above, because
* it would skip accounting if the flags are identical
*/
if (new_uri_bk.s) {
req->new_uri = new_uri_bk;
req->dst_uri = dst_uri_bk;
req->parsed_uri_ok = 0;
}
reset_flags(*flags, flags_to_reset);
}
void CPU::reset() {
reset_flags();
reset_registers();
}
/*
* Portions Copyright 2011 VMware, Inc.
*/
static int bt_detect(struct si_sm_data *bt)
{
/*
* It's impossible for the BT status and interrupt registers to be
* all 1's, (assuming a properly functioning, self-initialized BMC)
* but that's what you get from reading a bogus address, so we
* test that first. The calling routine uses negative logic.
*/
unsigned char bt_status = BT_STATUS;
unsigned char bt_intmask = BT_INTMASK_R;
if ((bt_status == 0xFF) || (bt_intmask == 0xFF)) {
if (bt_debug) {
printk(KERN_WARNING "IPMI BT: BT__STATUS or BT_MASK is invalid: %d, %d\n",
bt_status, bt_intmask);
}
return 1;
}
/*
* Test the R/W bits on the BT interface to ascertain if the device is
* truly available. These bits the host to device clear read bit and clear write
* bit, bit 0 and 1 on the BT_CNTL register and bit 7 the h/w reset bit of the
* BT_INTMASK register. The R/W bits should return 0 when read
*/
if (bt_status & (BT_CLR_WR_PTR | BT_CLR_RD_PTR)) {
if (bt_debug) {
printk(KERN_WARNING "IPMI BT: BT_CLR_WR_PTR or BT_CLR_RD_PTR are not 0: %d, %d\n",
(bt_status & BT_CLR_WR_PTR), (bt_status & BT_CLR_WR_PTR));
}
return 1;
}
if(bt_intmask & BT_BMC_HWRST) {
if (bt_debug) {
printk(KERN_WARNING "IPMI BT: BT_BMC_HWRST is not 0: %d\n",
(bt_intmask & BT_BMC_HWRST));
}
return 1;
}
/*
* The H_BUSY (bit 6) of the BT_CNTL register works as a toggle bit, with
* the state of the bit toggling if a 1 is written. No change is seen if 0 is
* written. This bit is toggled to further verify the presence of the BT interface
*/
// Toggle bit
BT_CONTROL(BT_H_BUSY);
if (!((bt_status ^ BT_STATUS) & BT_H_BUSY)) {
if (bt_debug) {
printk(KERN_WARNING "IPMI BT: Unable to toggle BT_H_BUSY once\n");
}
return 1;
}
//Toggle again
BT_CONTROL(BT_H_BUSY);
if ((bt_status ^ BT_STATUS) & BT_H_BUSY) {
if (bt_debug) {
printk(KERN_WARNING "IPMI BT: Unable to toggle BT_H_BUSY twice\n");
}
return 1;
}
reset_flags(bt);
return 0;
}
static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
{
unsigned char status, BT_CAP[8];
static enum bt_states last_printed = BT_STATE_PRINTME;
int i;
status = BT_STATUS;
bt->nonzero_status |= status;
if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) {
printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
STATE2TXT,
STATUS2TXT,
bt->timeout,
time);
last_printed = bt->state;
}
/*
* Commands that time out may still (eventually) provide a response.
* This stale response will get in the way of a new response so remove
* it if possible (hopefully during IDLE). Even if it comes up later
* it will be rejected by its (now-forgotten) seq number.
*/
if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) {
drain_BMC2HOST(bt);
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
}
if ((bt->state != BT_STATE_IDLE) &&
(bt->state < BT_STATE_PRINTME)) {
/* check timeout */
bt->timeout -= time;
if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))
return error_recovery(bt,
status,
IPMI_TIMEOUT_ERR);
}
switch (bt->state) {
/*
* Idle state first checks for asynchronous messages from another
* channel, then does some opportunistic housekeeping.
*/
case BT_STATE_IDLE:
if (status & BT_SMS_ATN) {
BT_CONTROL(BT_SMS_ATN); /* clear it */
return SI_SM_ATTN;
}
if (status & BT_H_BUSY) /* clear a leftover H_BUSY */
BT_CONTROL(BT_H_BUSY);
/* Read BT capabilities if it hasn't been done yet */
if (!bt->BT_CAP_outreqs)
BT_STATE_CHANGE(BT_STATE_CAPABILITIES_BEGIN,
SI_SM_CALL_WITHOUT_DELAY);
bt->timeout = bt->BT_CAP_req2rsp;
BT_SI_SM_RETURN(SI_SM_IDLE);
case BT_STATE_XACTION_START:
if (status & (BT_B_BUSY | BT_H2B_ATN))
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
if (BT_STATUS & BT_H_BUSY)
BT_CONTROL(BT_H_BUSY); /* force clear */
BT_STATE_CHANGE(BT_STATE_WRITE_BYTES,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_WRITE_BYTES:
if (status & BT_H_BUSY)
BT_CONTROL(BT_H_BUSY); /* clear */
BT_CONTROL(BT_CLR_WR_PTR);
write_all_bytes(bt);
BT_CONTROL(BT_H2B_ATN); /* can clear too fast to catch */
BT_STATE_CHANGE(BT_STATE_WRITE_CONSUME,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_WRITE_CONSUME:
if (status & (BT_B_BUSY | BT_H2B_ATN))
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
BT_STATE_CHANGE(BT_STATE_READ_WAIT,
SI_SM_CALL_WITHOUT_DELAY);
/* Spinning hard can suppress B2H_ATN and force a timeout */
case BT_STATE_READ_WAIT:
if (!(status & BT_B2H_ATN))
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
BT_CONTROL(BT_H_BUSY); /* set */
/*
* Uncached, ordered writes should just proceeed serially but
* some BMCs don't clear B2H_ATN with one hit. Fast-path a
* workaround without too much penalty to the general case.
*/
BT_CONTROL(BT_B2H_ATN); /* clear it to ACK the BMC */
BT_STATE_CHANGE(BT_STATE_CLEAR_B2H,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_CLEAR_B2H:
if (status & BT_B2H_ATN) {
/* keep hitting it */
BT_CONTROL(BT_B2H_ATN);
BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
}
BT_STATE_CHANGE(BT_STATE_READ_BYTES,
SI_SM_CALL_WITHOUT_DELAY);
case BT_STATE_READ_BYTES:
if (!(status & BT_H_BUSY))
/* check in case of retry */
BT_CONTROL(BT_H_BUSY);
BT_CONTROL(BT_CLR_RD_PTR); /* start of BMC2HOST buffer */
i = read_all_bytes(bt); /* true == packet seq match */
BT_CONTROL(BT_H_BUSY); /* NOW clear */
if (!i) /* Not my message */
BT_STATE_CHANGE(BT_STATE_READ_WAIT,
SI_SM_CALL_WITHOUT_DELAY);
bt->state = bt->complete;
return bt->state == BT_STATE_IDLE ? /* where to next? */
SI_SM_TRANSACTION_COMPLETE : /* normal */
SI_SM_CALL_WITHOUT_DELAY; /* Startup magic */
case BT_STATE_LONG_BUSY: /* For example: after FW update */
if (!(status & BT_B_BUSY)) {
reset_flags(bt); /* next state is now IDLE */
bt_init_data(bt, bt->io);
}
return SI_SM_CALL_WITH_DELAY; /* No repeat printing */
case BT_STATE_RESET1:
reset_flags(bt);
drain_BMC2HOST(bt);
BT_STATE_CHANGE(BT_STATE_RESET2,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_RESET2: /* Send a soft reset */
BT_CONTROL(BT_CLR_WR_PTR);
HOST2BMC(3); /* number of bytes following */
HOST2BMC(0x18); /* NetFn/LUN == Application, LUN 0 */
HOST2BMC(42); /* Sequence number */
HOST2BMC(3); /* Cmd == Soft reset */
BT_CONTROL(BT_H2B_ATN);
bt->timeout = BT_RESET_DELAY * 1000000;
BT_STATE_CHANGE(BT_STATE_RESET3,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_RESET3: /* Hold off everything for a bit */
if (bt->timeout > 0)
return SI_SM_CALL_WITH_DELAY;
drain_BMC2HOST(bt);
BT_STATE_CHANGE(BT_STATE_RESTART,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_RESTART: /* don't reset retries or seq! */
bt->read_count = 0;
bt->nonzero_status = 0;
bt->timeout = bt->BT_CAP_req2rsp;
BT_STATE_CHANGE(BT_STATE_XACTION_START,
SI_SM_CALL_WITH_DELAY);
/*
* Get BT Capabilities, using timing of upper level state machine.
* Set outreqs to prevent infinite loop on timeout.
*/
case BT_STATE_CAPABILITIES_BEGIN:
bt->BT_CAP_outreqs = 1;
{
unsigned char GetBT_CAP[] = { 0x18, 0x36 };
bt->state = BT_STATE_IDLE;
bt_start_transaction(bt, GetBT_CAP, sizeof(GetBT_CAP));
}
bt->complete = BT_STATE_CAPABILITIES_END;
BT_STATE_CHANGE(BT_STATE_XACTION_START,
SI_SM_CALL_WITH_DELAY);
case BT_STATE_CAPABILITIES_END:
i = bt_get_result(bt, BT_CAP, sizeof(BT_CAP));
bt_init_data(bt, bt->io);
if ((i == 8) && !BT_CAP[2]) {
bt->BT_CAP_outreqs = BT_CAP[3];
bt->BT_CAP_req2rsp = BT_CAP[6] * 1000000;
bt->BT_CAP_retries = BT_CAP[7];
} else
printk(KERN_WARNING "IPMI BT: using default values\n");
if (!bt->BT_CAP_outreqs)
bt->BT_CAP_outreqs = 1;
printk(KERN_WARNING "IPMI BT: req2rsp=%ld secs retries=%d\n",
bt->BT_CAP_req2rsp / 1000000L, bt->BT_CAP_retries);
bt->timeout = bt->BT_CAP_req2rsp;
return SI_SM_CALL_WITHOUT_DELAY;
default: /* should never occur */
return error_recovery(bt,
status,
IPMI_ERR_UNSPECIFIED);
}
return SI_SM_CALL_WITH_DELAY;
}
Token malpar_next_token(Buffer * sc_buf)
{
Token t; /*token to be returned */
unsigned char c; /* input symbol */
Buffer *lex_buf; /* temporary buffer for holding lexemes */
int accept = NOAS; /* Not Accepting State */
int state = 0; /* Start state in the Transition Table */
int lexstart; /* current lexeme start offset */
static int forward; /* current input char offset */
/*
forward is the offset from the beginning of the char buffer of the
input buffer (sc_buf) to the current character, which is to be processed
by the scanner.
lexstart is the offset from the beginning of the char buffer of the
input buffer (sc_buf) to the first character of the current lexeme,
which is being processed by the scanner.
*/
/* DECLARE YOUR VARIABLES HERE IF NEEDED */
int VID_FLAG = 0; /*flag if start of VID reconised*/
int FPL_FLAG = 0; /*flag for if FPL*/
int DIL_FLAG = 0; /*flag for if DIL is reconised*/
int OIL_FLAG = 0; /*flag for if octal literal is reconised*/
int ZERO_FLAG = 0; /*flag for if first digit is a 0*/
int NUM_FLAG = 0; /*flag if number of unknown type is reconised*/
int i; /*generic counter for a for loop*/
lexstart = sc_buf->addc_offset;
forward = lexstart;
while (1)/*constant used for infinite loop*/
{
c = sc_buf->ca_head[forward++]; /*may need to be ++forward if getting wierd errors*/
if (isalnum(c)==0 || c=='"')
{
switch (c)
{
case '"':
{
ca_setmark(sc_buf,forward);
c = sc_buf->ca_head[forward++];
if (c != '"') /*checks to see if it is an empty string*/
{
while (c = sc_buf->ca_head[forward++])
{
if (c=='\n' || c=='\r') /*potential weird string error*/
{
t.code = ERR_T;
if ((forward - ca_getmark(sc_buf)) >= 20)
{
for (i=0;i<17;i++)
{
t.attribute.err_lex[i] = sc_buf->ca_head[ca_getmark(sc_buf)+1];
}
t.attribute.err_lex[17]='.';
t.attribute.err_lex[18]='.';
t.attribute.err_lex[19]='.';
t.attribute.err_lex[20]='\0';
}
else
{
for (i=0;i<20;i++)
{
t.attribute.err_lex[i]= sc_buf->ca_head[ca_getmark(sc_buf)+1];
}
t.attribute.err_lex[20]='\0';
}
}
if (c == '"')
{
t.attribute.str_offset = str_LTBL->addc_offset;
for (i=(ca_getmark(sc_buf)+1);i<forward;i++) /*forward may point to 1 past the quotation mark*/
{
ca_addc(str_LTBL,sc_buf->ca_head[i]);
}
ca_addc(str_LTBL,'\0'); /*end of string marker*/
t.code = STR_T;
}
}
}
else
{
t.code = ERR_T;
t.attribute.err_lex[0]='R';
t.attribute.err_lex[1]='U';
t.attribute.err_lex[2]='N';
t.attribute.err_lex[3]=' ';
t.attribute.err_lex[4]='T';
t.attribute.err_lex[5]='I';
t.attribute.err_lex[6]='M';
t.attribute.err_lex[7]='E';
t.attribute.err_lex[8]=' ';
t.attribute.err_lex[9]='E';
t.attribute.err_lex[10]='R';
t.attribute.err_lex[11]='R';
t.attribute.err_lex[12]='O';
t.attribute.err_lex[13]='R';
t.attribute.err_lex[14]=':';
t.attribute.err_lex[15]='\0';
}
break;
}
case '+':
{
t.code = ART_OP_T;
t.attribute.arr_op = PLUS;
break;
}
case '-':
{
t.code = ART_OP_T;
t.attribute.arr_op = MINUS;
break;
}
case '*':
{
t.code = ART_OP_T;
t.attribute.arr_op = MULT;
break;
}
case '/':
{
t.code = ART_OP_T;
t.attribute.arr_op = DIV;
break;
}
case '{':
{
t.code = LPR_T;
break;
}
case '}':
{
t.code = RPR_T;
break;
}
case '>':
{
t.code = REL_OP_T;
t.attribute.rel_op = GT;
break;
}
case '<':
{
t.code = REL_OP_T;
t.attribute.rel_op = LT;
break;
}
case '=':
{
if (sc_buf->ca_head[forward++] == '=')
{
t.code = REL_OP_T;
t.attribute.rel_op = EQ;
}
else
{
forward--;
t.code = ASS_OP_T;
}
break;
}
case ' ':
{
//c = sc_buf->ca_head[forward++];
break;
}
case '.':
{
c= sc_buf->ca_head[forward++];
if (c == 'A')
{
c= sc_buf->ca_head[forward++];
if (c == 'N')
{
c = sc_buf->ca_head[forward++];
if (c =='D')
{
t.code = LOG_OP_T;
t.attribute.log_op = AND;
}
else
{
t.code = ERR_T;
}
}
else
{
t.code = ERR_T;
}
}
if (c == 'O')
{
c = sc_buf->ca_head[forward++];
if (c == 'R')
{
t.code = LOG_OP_T;
t.attribute.log_op = OR;
}
else
{
t.code = ERR_T;
}
}
else
{
t.code = ERR_T;
}
break;
}
case '!':
{
c = sc_buf->ca_head[forward++];
if (c != '<')
{
t.code = ERR_T;
forward--;
}
if (c == '=')
{
t.code = REL_OP_T;
t.attribute.rel_op = NE;
}
else
{
while (sc_buf->ca_head[forward++] != '\n'){} //move through buffer untill comment is done
}
break;
}
case ';':
{
t.code = EOS_T;
break;
}
case '(':
{
t.code = LBR_T;
break;
}
case ')':
{
t.code = RBR_T;
break;
}
case EOF:
{
t.code=SEOF_T;
break;
}
default:/* may pick up others like string, so wierd errors could come from here*/
{
t.code = ERR_T;
t.attribute.err_lex[0] = c;
t.attribute.err_lex[1] = '/0'; /*store end of string inidicator to the string*/
break;
}
}
}
else /*character is a digit or letter*/
/*final state machine*/
{
ca_setmark(sc_buf,forward);
state = 0;
lexstart = ca_getmark(sc_buf);
state = get_next_state (state,c,&accept);
c = sc_buf->ca_head[forward++];
while (accept == NOAS)
{
state = get_next_state(state,c,&accept);
if (accept == NOAS) /*if statemet to check if sate has changed*/
{
c = sc_buf->ca_head[forward++];
}
}
lex_buf = b_create(sc_buf->capacity,sc_buf->inc_factor,sc_buf->mode);
if (state == (2||7||8||11))
{
forward = lexstart;
}
c = sc_buf->ca_head[lexstart];
while (1)
{
switch (c)/*character most recently added in*/
{
case 0: /*[a-zA-Z]*/
{
/*VID or SVID or Keyword may need to take this out check w/ leland*/
if (iskeyword(lex_buf->ca_head) != FALSE) /*keyword token found*/
{
if (lex_buf->addc_offset>0)
{
forward--; /*character not added to lex_buf move pointer back 1*/
}
t.code = KW_T;
t.attribute.kwt_idx = iskeyword(lex_buf->ca_head); /*set attribute*/
}
else
{
/*check to see if any of the identifier flags have been checked*/
if (FPL_FLAG!=0||DIL_FLAG!=0||OIL_FLAG!=0||NUM_FLAG!=0)
{
if (FPL_FLAG == 1)
{
if (lex_buf->addc_offset>0)
{
forward--; /*character not added to lex_buf move pointer back 1*/
}
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[8](lex_buf->ca_head);
}
if (DIL_FLAG == 1)
{
if (lex_buf->addc_offset>0)
{
forward--; /*character not added to lex_buf move pointer back 1*/
}
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[7](lex_buf->ca_head);
}
if (OIL_FLAG == 1)
{
if (lex_buf->addc_offset>0)
{
forward--; /*character not added to lex_buf move pointer back 1*/
}
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[12](lex_buf->ca_head);
}
if (ZERO_FLAG == 1)
{
if (lex_buf->addc_offset>0)
{
forward--; /*character not added to lex_buf move pointer back 1*/
}
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[7](lex_buf->ca_head);
}
if (NUM_FLAG==1&&ZERO_FLAG==0)
{
if (lex_buf->addc_offset>0)
{
forward--; /*character not added to lex_buf move pointer back 1*/
}
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[7](lex_buf->ca_head);
}
}
VID_FLAG = 1; /*set variable identifier flag*/
}
ca_addc(lex_buf,c);
break;
}
case 1: /*0*/
{
/*octal or DIL 0 or FPL 0*/
if (ZERO_FLAG==1)/*leading 0 and another digit*/
{
OIL_FLAG=1;
}
if (FPL_FLAG==0&&NUM_FLAG==0&&DIL_FLAG==0&&ZERO_FLAG==0)
{
ZERO_FLAG=1; /*identify as a numeric token starting with 0*/
}
if (NUM_FLAG==1&&ZERO_FLAG==0) /*number with no leading 0*/
{
/*could be FPL or DIL*/
}
if (VID_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
VID_FLAG=1;
}
/*if FPL_FLAG is set it is known to be an FPL*/
ca_addc(lex_buf,c);
break;
}
case 2: /*[8-9]*/
{
if (ZERO_FLAG==1&&FPL_FLAG==0&&OIL_FLAG==0&&DIL_FLAG==0)/*leading 0 and no decimal place*/
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
/*number is single 0*/
if (lex_buf->addc_offset > 0)
{
forward--;
}
t=aa_table[7](lex_buf->ca_head);
}
if (OIL_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG); /*reset the flags*/
if (lex_buf->addc_offset > 0)
{
forward--;
}
t=aa_table[12](lex_buf->ca_head);
}
if (NUM_FLAG==0&&DIL_FLAG==0&&FPL_FLAG==0) /*no preceeding digits*/
{
/*could be a DIL or FPL*/
NUM_FLAG=1;
}
if (VID_FLAG==1)/*is already known VID*/
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
VID_FLAG=1;
}
ca_addc(lex_buf,c);
break;
}
case 3: /*[1-7]*/
{
if (ZERO_FLAG==1&&OIL_FLAG==1) /*already known oil*/
{
/*still oil*/
}
if (ZERO_FLAG==1&&OIL_FLAG==0)/*leading 0 with no other digits*/
{
OIL_FLAG=1;
}
if (NUM_FLAG==0&&FPL_FLAG==0&&DIL_FLAG==0)/*no numeric flags set*/
{
NUM_FLAG=1;
}
if (VID_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
VID_FLAG=1;
}
ca_addc(lex_buf,c);
break;
}
case 4: /*.*/
{
if (NUM_FLAG==0&&ZERO_FLAG==0&&DIL_FLAG==0&&FPL_FLAG==0)/*if no numeric flags are set*/
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
ca_addc(lex_buf,c);
t=aa_table[9](lex_buf->ca_head);
}
if (OIL_FLAG==1) /*if known OIL*/
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
ca_addc(lex_buf,c);
t=aa_table[9](lex_buf->ca_head);
}
if (FPL_FLAG==1) /*if known FPL*/
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
ca_addc(lex_buf,c);
t=aa_table[9](lex_buf->ca_head);
}
if ((DIL_FLAG==1||NUM_FLAG==1)&&FPL_FLAG==0)/*if identified as a DIL or NUM already*/
{
FPL_FLAG=1;
}
if (VID_FLAG==1) /*if VID*/
{
if (lex_buf->addc_offset>0)
{
forward--; /*character not added to lex_buf move pointer back 1*/
}
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[3](lex_buf->ca_head);
}
ca_addc(lex_buf,c);
break;
}
case 5: /*#*/
{
if (VID_FLAG==0&&FPL_FLAG==0&&DIL_FLAG==0&&OIL_FLAG==0&&ZERO_FLAG==0)
{
ca_addc(lex_buf,c);
t=aa_table[9](lex_buf->ca_head);
}
if (FPL_FLAG==1)
{
if(lex_buf->addc_offset>0)
{
forward--;
}
t=aa_table[8](lex_buf->ca_head);
}
if (VID_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
ca_addc(lex_buf,c);
t=aa_table[2](lex_buf->ca_head);
}
break;
}
case 6: /*other*/
{
if (lex_buf->addc_offset!=0)
{
sc_buf->addc_offset--; /*character never written to lex_buf set pointer back 1*/
}
if ((c==';'||c ==' ')&&VID_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t = aa_table[2](lex_buf->ca_head);
}
if ((c==';'||c ==' ')&&FPL_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[8](lex_buf->ca_head);
}
if ((c==';'||c ==' ')&&DIL_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[7](lex_buf->ca_head);
}
if ((c==';'||c ==' ')&&OIL_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[11](lex_buf->ca_head);
}
if ((c==';'||c ==' ')&&NUM_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[11](lex_buf->ca_head);
}
if ((c==';'||c ==' ')&&ZERO_FLAG==1)
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
t=aa_table[7](lex_buf->ca_head);
}
else
{
reset_flags(&FPL_FLAG,&DIL_FLAG,&OIL_FLAG,&ZERO_FLAG,&VID_FLAG,&NUM_FLAG);
ca_addc(lex_buf,c);
t=aa_table[9](lex_buf->ca_head);
}
break;
}
}
c=(lex_buf,sc_buf->ca_head[forward++]);/*add next character to the buffer*/
}
}
b_destroy(lex_buf);
return t;
}//end while(1)
}
