示例#1
0
static int waitjob_cb (const char *jcbstr, void *arg, int errnum)
{
    JSON jcb = NULL;
    int64_t os = 0, ns = 0, j = 0;
    flux_t h = (flux_t)arg;
    wjctx_t *ctx = getctx (h);

    if (errnum > 0) {
        flux_log (ctx->h, LOG_ERR, "waitjob_cb: errnum passed in");
        return -1;
    }

    if (!(jcb = Jfromstr (jcbstr))) {
        flux_log (ctx->h, LOG_ERR, "waitjob_cb: error parsing JSON string");
        return -1;
    }
    get_jobid (jcb, &j);
    get_states (jcb, &os, &ns);
    Jput (jcb);
    if ((j == ctx->jobid) && (ns == J_COMPLETE)) {
        if (ctx->complete)
            touch_outfile (ctx->complete);
        flux_log (ctx->h, LOG_INFO, "waitjob_cb: completion notified");
        raise (SIGINT);
    }

    return 0;
}
示例#2
0
static int job_status_cb (const char *jcbstr, void *arg, int errnum)
{
    int64_t os = 0;
    int64_t ns = 0;
    int64_t j = 0;
    jstatctx_t *ctx = NULL;
    flux_t h = (flux_t)arg;
    JSON jcb = NULL;

    ctx = getctx (h);
    if (errnum > 0) {
        flux_log (ctx->h, LOG_ERR, "job_status_cb: errnum passed in");
        return -1;
    }

    if (!(jcb = Jfromstr (jcbstr))) {
        flux_log (ctx->h, LOG_ERR, "job_status_cb: error parsing JSON string");
        return -1;
    }
    get_jobid (jcb, &j);
    get_states (jcb, &os, &ns);
    Jput (jcb);

    fprintf (ctx->op, "%s->%s\n", 
    jsc_job_num2state ((job_state_t)os), 
    jsc_job_num2state ((job_state_t)ns));
    fflush (ctx->op);

    return 0;
}
示例#3
0
static void add_rules(StateMachinePtr sm, BindingsPtr bindings, NodePtr root) {
   if (root->get_op() == Op::sm_rules) {
      add_rules(sm, bindings, root->get_operand(0));
      root = root->get_operand(1);
   }
   assert(root->get_op() == Op::sm_rule);
   if (root->size() == 1) {
      // handler
      root = root->get_operand(0);
      assert(root->get_op() == Op::ON);
      assert(root->get_operand(0)->get_op() == Op::CLOSE);
      root = root->get_operand(1);
      assert(root->get_op() == Op::sm_handler);
      if (root->size() == 1) {
	 StateSet states;
	 sm->add_close_handler(states, root->get_operand(0));
      } else {
	 StateSet states(sm->get_nofstates());
	 get_states(sm, root->get_operand(0), states);
	 sm->add_close_handler(states, root->get_operand(1));
      }
   } else {
      // regular rule
      NodePtr smcond = root->get_operand(0);
      StateMachineRulePtr rule;
      NodePtr node_expr;
      if (smcond->size() == 2) {
	 NodePtr tree_expr = smcond->get_operand(0);
	 NodeTypeSet nodetypes(nof_node_types(bindings));
	 get_node_expression(bindings, smcond->get_operand(1),
	    nodetypes, node_expr);
	 rule = std::make_shared<StateMachineRule>(sm,
		  tree_expr, nodetypes, bindings->get_rules());
      } else {
	 if (smcond->get_operand(0)->get_op() == Op::cfg_node_expression) {
	    NodeTypeSet nodetypes(nof_node_types(bindings));
	    get_node_expression(bindings, smcond->get_operand(0),
	       nodetypes, node_expr);
	    rule = std::make_shared<StateMachineRule>(sm,
	       nodetypes, bindings->get_rules());
	 } else {
	    NodePtr tree_expr = smcond->get_operand(0);
	    rule = std::make_shared<StateMachineRule>(sm,
	       tree_expr, bindings->get_rules());
	 }
      }
      if (node_expr) {
	 rule->add_node_condition(node_expr);
      }
      if (root->get_operand(1)->get_op() == Op::sm_block) {
	 NodePtr smblock = root->get_operand(1);
	 rule->add_alternative(create_alternative(sm, smblock));
      } else {
	 add_alternatives(sm, rule, bindings, root->get_operand(1));
      }
      sm->add_rule(rule);
   }
}
int getQTIs(int highPin, int lowPin)           // Function - getQTIs
{
  int dt = (CLKFREQ / 1000000) * 230;          // Set up 230 us time increment
  set_outputs(highPin, lowPin, 0b1111);        // highPin...lowPin set high
  set_directions(highPin, lowPin, 0b1111);     // highPin...lowPin set to output
  waitcnt(dt + CNT);                           // Wait 230 us
  set_directions(highPin, lowPin, 0b0000);     // highPin...lowPin st to input
  waitcnt(dt + CNT);                           // Wait 230 us
  int qtis = get_states(highPin, lowPin);      // Get 4-bit pattern QTIs apply
  return qtis;                                 // Return val containing pattern
}
示例#5
0
文件: pfs.c 项目: ryo/netbsd-src
static int
dump_states_binary(int fd, int verbose, const char* filename)
{
    int wfd;
    struct pfioc_states ps;
    struct pfsync_state *p = NULL;
    int nb_states;
    int i;
    int error = 0;
    int errno_saved = 0;

    wfd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0600);
    if (wfd == -1)
        err(EXIT_FAILURE, "Cannot open %s", filename);

    nb_states = get_states(fd, verbose, &ps);
    if (nb_states <= 0) {
        close(wfd);
        return nb_states;
    }

    /*
     * In the file, write the number of states, then store the different states
     * When we will switch to text format, we probably don't care any more about the len
     */
    if (write(wfd, &nb_states, sizeof(nb_states)) != sizeof(nb_states)) {
        error = EXIT_FAILURE;
        errno_saved = errno;
        goto done;
    }

    p = ps.ps_states;
    for (i = 0; i < nb_states; i++) {
        if (write(wfd, &p[i], sizeof(*p)) != sizeof(*p)) {
            error = EXIT_FAILURE;
            errno_saved = errno;
            goto done;
        }
    }

done:
    free(p);
    close(wfd);
    // close can't modify errno
    if (error) {
        errno = errno_saved;
        err(error, NULL);
    }

    return 0;
}
示例#6
0
文件: pfs.c 项目: ryo/netbsd-src
static int
print_states(int fd, int verbose, FILE* f)
{
    struct pfioc_states ps;
    int nb_states;

    nb_states = get_states(fd, verbose, &ps);
    if (nb_states <= 0) {
        return nb_states;
    }

    display_states(&ps, verbose, f);

    free(ps.ps_states);
    return 0;
}
示例#7
0
文件: args.c 项目: blabos/Comp
int get_args(char* filename, args_t* args) {
    FILE* fp;

    int ret = 0;

    if ((fp = fopen(filename, "r")) != NULL) {
        ret =  get_mode(fp, args)
            && get_states(fp, args)
            && get_symbols(fp, args)
            && get_transitions(fp, args);
        
        fclose(fp);
    }

    return ret;
}
示例#8
0
static void get_states(StateMachinePtr sm, NodePtr root, StateSet& states) {
   assert(root->get_op() == Op::sm_state_condition);
   if (root->size() == 2) {
      get_states(sm, root->get_operand(0), states);
      root = root->get_operand(1);
   } else {
      root = root->get_operand(0);
   }
   std::string statename = root->get_token().get_text();
   int index = sm->get_state_by_name(statename);
   if (index < 0) {
      throw Exception(root->get_location(),
	 "unknown state: " + statename);
   }
   states.set(index);
}
示例#9
0
static void add_alternatives(StateMachinePtr sm, StateMachineRulePtr rule,
      BindingsPtr bindings, NodePtr root) {
   if (root->get_op() == Op::sm_alternatives) {
      add_alternatives(sm, rule, bindings, root->get_operand(0));
      root = root->get_operand(1);
   }
   assert(root->get_op() == Op::sm_alternative);
   NodePtr smblock = root->get_operand(root->size() - 1);
   StateMachineRuleAlternativePtr alternative = create_alternative(sm, smblock);
   std::size_t nextop = 0;
   if (root->get_operand(nextop)->get_op() == Op::cfg_edge_condition) {
      NodePtr edge_cond = root->get_operand(nextop++);
      LabelSet labels(nof_labels(bindings));
      get_labelset(bindings, edge_cond, labels);
      alternative->set_labels(labels);
   }
   if (nextop + 1 < root->size()) {
      NodePtr state_cond = root->get_operand(nextop++);
      StateSet states(sm->get_nofstates());
      get_states(sm, state_cond, states);
      alternative->set_states(states);
   }
   rule->add_alternative(alternative);
}
示例#10
0
void print_states() {
  read_states();
  matrix_t *state_matrix = get_states();
  print_matrix(state_matrix, info->state_bits);
}