int main(void) {
SceneSize scene_size = { SCENE_WIDTH, SCENE_HEIGHT };
int scene[SCENE_WIDTH][SCENE_HEIGHT];
size_t step_count;
while (1) {
scanf("%zu", &step_count);
for (int i = 0; i < SCENE_WIDTH; i++) {
for (int j = 0; i < SCENE_HEIGHT; j++) {
scanf("%d", &scene[i][j]);
if (scene[i][j] == 0) {
for (int k = j+1; k < SCENE_HEIGHT; k++) {
scene[i][k] = 0;
}
break;
}
}
}
Action actions[MAX_STEP_NUM];
if (Solve(scene_size, scene, actions, 0, step_count)) {
print_actions(actions, step_count);
} else {
printf("Im sooooorry\n");
}
}
return 0;
}
static void final_print(t_options **options, t_lman **a, t_lman **retain)
{
if ((*options)->printoff != 1)
print_actions(retain, options);
if ((*options)->list == 1)
print_list(a);
if ((*options)->nbop == 1)
ft_printf("%ld operations to sort this list", (*retain)->stack_size);
}
static void print_state (int state)
{
if (state)
fprintf (verbose_file, "\n\n");
if (SRconflicts[state] || RRconflicts[state])
print_conflicts (state);
fprintf (verbose_file, "state %d\n", state);
print_core (state);
print_nulls (state);
print_actions (state);
}
void cpn_opts_usage(const struct cpn_opt *opts,
const char *executable, FILE *out)
{
fputs("USAGE: ", out);
print_header(opts, executable, NULL, out);
if (has_actions(opts) || has_options(opts))
fputc('\n', out);
print_arguments(opts, out, 1);
if (has_actions(opts) && has_options(opts))
fputc('\n', out);
print_actions(opts, out, 1);
}
void print_state(int state)
{
if (state)
BtYacc_puts("\n\n", verbose_file);
if (SRconflicts[state] || RRconflicts[state])
print_conflicts(state);
BtYacc_printf(verbose_file, "state %d\n", state);
print_core(state);
print_nulls(state);
print_actions(state);
}
/* debug function, prints main routing table */
void print_rl(void)
{
int j;
for(j=0; j<RT_NO; j++){
if (rlist[j]==0){
if (j==0) LM_DBG("WARNING: the main routing table is empty\n");
continue;
}
LM_DBG("routing table %d:\n",j);
print_actions(rlist[j]);
LM_DBG("\n");
}
for(j=0; j<ONREPLY_RT_NO; j++){
if (onreply_rlist[j]==0){
continue;
}
LM_DBG("onreply routing table %d:\n",j);
print_actions(onreply_rlist[j]);
LM_DBG("\n");
}
for(j=0; j<FAILURE_RT_NO; j++){
if (failure_rlist[j]==0){
continue;
}
LM_DBG("failure routing table %d:\n",j);
print_actions(failure_rlist[j]);
LM_DBG("\n");
}
for(j=0; j<BRANCH_RT_NO; j++){
if (branch_rlist[j]==0){
continue;
}
LM_DBG("T-branch routing table %d:\n",j);
print_actions(branch_rlist[j]);
LM_DBG("\n");
}
}
static void
print_state (FILE *out, state *s)
{
fputs ("\n\n", out);
fprintf (out, _("state %d"), s->number);
fputc ('\n', out);
print_core (out, s);
print_actions (out, s);
if ((report_flag & report_solved_conflicts) && s->solved_conflicts)
{
fputc ('\n', out);
fputs (s->solved_conflicts, out);
}
}
static void
print_state (FILE *out, int level, state *s)
{
fputc ('\n', out);
xml_printf (out, level, "<state number=\"%d\">", s->number);
print_core (out, level + 1, s);
print_actions (out, level + 1, s);
if (s->solved_conflicts_xml)
{
xml_puts (out, level + 1, "<solved-conflicts>");
fputs (s->solved_conflicts_xml, out);
xml_puts (out, level + 1, "</solved-conflicts>");
}
else
xml_puts (out, level + 1, "<solved-conflicts/>");
xml_puts (out, level, "</state>");
}
static void print_actions(const struct cpn_opt *opts, FILE *out, int indent)
{
const struct cpn_opt *it;
int i;
for (it = opts; it && it->type != CPN_OPTS_TYPE_END; it++) {
if (it->type != CPN_OPTS_TYPE_ACTION)
continue;
for (i = indent; i; i--)
fputc('\t', out);
print_header(it->value.action_opts, it->long_name, it->description, out);
print_arguments(it->value.action_opts, out, indent + 1);
if (has_actions(it) && has_options(it))
fputc('\n', out);
print_actions(it->value.action_opts, out, indent + 1);
}
}
static void
got_introspection (GUPnPServiceInfo *info,
GUPnPServiceIntrospection *introspection,
const GError *error,
G_GNUC_UNUSED gpointer user_data)
{
if (error) {
g_warning ("Failed to create introspection for '%s': %s",
gupnp_service_info_get_udn (info),
error->message);
return;
}
g_print ("service: %s\nlocation: %s\n",
gupnp_service_info_get_udn (info),
gupnp_service_info_get_location (info));
print_actions (introspection);
print_state_variables (introspection);
g_object_unref (introspection);
}
void print_action(struct action* t)
{
switch(t->type){
case FORWARD_T:
DBG("forward(");
break;
case FORWARD_TCP_T:
DBG("forward_tcp(");
break;
case FORWARD_UDP_T:
DBG("forward_udp(");
break;
case DROP_T:
DBG("drop(");
break;
case LOG_T:
DBG("log(");
break;
case ERROR_T:
DBG("error(");
break;
case ROUTE_T:
DBG("route(");
break;
case EXEC_T:
DBG("exec(");
break;
case REVERT_URI_T:
DBG("revert_uri(");
break;
case STRIP_T:
DBG("strip(");
break;
case APPEND_BRANCH_T:
DBG("append_branch(");
break;
case PREFIX_T:
DBG("prefix(");
break;
case LEN_GT_T:
DBG("len_gt(");
break;
case SETFLAG_T:
DBG("setflag(");
break;
case RESETFLAG_T:
DBG("resetflag(");
break;
case ISFLAGSET_T:
DBG("isflagset(");
break;
case AVPFLAG_OPER_T:
DBG("avpflagoper(");
break;
case SET_HOST_T:
DBG("sethost(");
break;
case SET_HOSTPORT_T:
DBG("sethostport(");
break;
case SET_HOSTPORTTRANS_T:
DBG("sethostporttrans(");
break;
case SET_USER_T:
DBG("setuser(");
break;
case SET_USERPASS_T:
DBG("setuserpass(");
break;
case SET_PORT_T:
DBG("setport(");
break;
case SET_URI_T:
DBG("seturi(");
break;
case IF_T:
DBG("if (");
break;
case MODULE0_T:
case MODULE1_T:
case MODULE2_T:
case MODULE3_T:
case MODULE4_T:
case MODULE5_T:
case MODULE6_T:
case MODULEX_T:
case MODULE1_RVE_T:
case MODULE2_RVE_T:
case MODULE3_RVE_T:
case MODULE4_RVE_T:
case MODULE5_RVE_T:
case MODULE6_RVE_T:
case MODULEX_RVE_T:
DBG(" external_module_call(");
break;
case FORCE_RPORT_T:
DBG("force_rport(");
break;
case SET_ADV_ADDR_T:
DBG("set_advertised_address(");
break;
case SET_ADV_PORT_T:
DBG("set_advertised_port(");
break;
case FORCE_TCP_ALIAS_T:
DBG("force_tcp_alias(");
break;
case LOAD_AVP_T:
DBG("load_avp(");
break;
case AVP_TO_URI_T:
DBG("avp_to_attr");
break;
case FORCE_SEND_SOCKET_T:
DBG("force_send_socket");
break;
case ASSIGN_T
: DBG("assign(");
break;
case ADD_T:
DBG("assign_add(");
break;
default:
DBG("UNKNOWN(");
}
switch(t->val[0].type){
case STRING_ST:
DBG("\"%s\"", ZSW(t->val[0].u.string));
break;
case NUMBER_ST:
DBG("%lu",t->val[0].u.number);
break;
case IP_ST:
print_ip("", (struct ip_addr*)t->val[0].u.data, "");
break;
case EXPR_ST:
print_expr((struct expr*)t->val[0].u.data);
break;
case ACTIONS_ST:
print_actions((struct action*)t->val[0].u.data);
break;
case MODEXP_ST:
DBG("f_ptr<%p>",t->val[0].u.data);
break;
case SOCKID_ST:
DBG("%d:%s:%d",
((struct socket_id*)t->val[0].u.data)->proto,
ZSW(((struct socket_id*)t->val[0].u.data)->addr_lst->name),
((struct socket_id*)t->val[0].u.data)->port
);
break;
case AVP_ST:
DBG("avp(%u,%.*s)", t->val[0].u.attr->type, t->val[0].u.attr->name.s.len, ZSW(t->val[0].u.attr->name.s.s));
break;
case SELECT_ST:
DBG("select");
break;
default:
DBG("type<%d>", t->val[0].type);
}
if (t->type==IF_T) DBG(") {");
switch(t->val[1].type){
case NOSUBTYPE:
break;
case STRING_ST:
DBG(", \"%s\"", ZSW(t->val[1].u.string));
break;
case NUMBER_ST:
DBG(", %lu",t->val[1].u.number);
break;
case EXPR_ST:
print_expr((struct expr*)t->val[1].u.data);
break;
case ACTION_ST:
case ACTIONS_ST:
print_actions((struct action*)t->val[1].u.data);
break;
case SOCKID_ST:
DBG("%d:%s:%d",
((struct socket_id*)t->val[0].u.data)->proto,
ZSW(((struct socket_id*)t->val[0].u.data)->addr_lst->name),
((struct socket_id*)t->val[0].u.data)->port
);
break;
case AVP_ST:
DBG(", avp(%u,%.*s)", t->val[1].u.attr->type, t->val[1].u.attr->name.s.len, ZSW(t->val[1].u.attr->name.s.s));
break;
case SELECT_ST:
DBG("select");
break;
default:
DBG(", type<%d>", t->val[1].type);
}
if (t->type==IF_T) DBG("} else {");
switch(t->val[2].type){
case NOSUBTYPE:
break;
case STRING_ST:
DBG(", \"%s\"", ZSW(t->val[2].u.string));
break;
case NUMBER_ST:
DBG(", %lu",t->val[2].u.number);
break;
case EXPR_ST:
print_expr((struct expr*)t->val[2].u.data);
break;
case ACTIONS_ST:
print_actions((struct action*)t->val[2].u.data);
break;
case SOCKID_ST:
DBG("%d:%s:%d",
((struct socket_id*)t->val[0].u.data)->proto,
ZSW(((struct socket_id*)t->val[0].u.data)->addr_lst->name),
((struct socket_id*)t->val[0].u.data)->port
);
break;
default:
DBG(", type<%d>", t->val[2].type);
}
if (t->type==IF_T) DBG("}; ");
else DBG("); ");
}
void print_expr(struct expr* exp)
{
if (exp==0){
LM_CRIT("null expression!\n");
return;
}
if (exp->type==ELEM_T){
switch(exp->l_type){
case METHOD_O:
DBG("method");
break;
case URI_O:
DBG("uri");
break;
case FROM_URI_O:
DBG("from_uri");
break;
case TO_URI_O:
DBG("to_uri");
break;
case SRCIP_O:
DBG("srcip");
break;
case SRCPORT_O:
DBG("srcport");
break;
case DSTIP_O:
DBG("dstip");
break;
case DSTPORT_O:
DBG("dstport");
break;
case PROTO_O:
DBG("proto");
break;
case AF_O:
DBG("af");
break;
case MSGLEN_O:
DBG("msglen");
break;
case ACTION_O:
break;
case NUMBER_O:
break;
case AVP_O:
DBG("avp");
break;
case SNDIP_O:
DBG("sndip");
break;
case SNDPORT_O:
DBG("sndport");
break;
case TOIP_O:
DBG("toip");
break;
case TOPORT_O:
DBG("toport");
break;
case SNDPROTO_O:
DBG("sndproto");
break;
case SNDAF_O:
DBG("sndaf");
break;
case RETCODE_O:
DBG("retcode");
break;
case SELECT_O:
DBG("select");
break;
case RVEXP_O:
DBG("rval");
break;
default:
DBG("UNKNOWN");
}
switch(exp->op){
case EQUAL_OP:
DBG("==");
break;
case MATCH_OP:
DBG("=~");
break;
case NO_OP:
break;
case GT_OP:
DBG(">");
break;
case GTE_OP:
DBG(">=");
break;
case LT_OP:
DBG("<");
break;
case LTE_OP:
DBG("<=");
break;
case DIFF_OP:
DBG("!=");
break;
default:
DBG("<UNKNOWN>");
}
switch(exp->r_type){
case NOSUBTYPE:
DBG("N/A");
break;
case STRING_ST:
DBG("\"%s\"", ZSW((char*)exp->r.param));
break;
case NET_ST:
print_net((struct net*)exp->r.param);
break;
case IP_ST:
print_ip("", (struct ip_addr*)exp->r.param, "");
break;
case ACTIONS_ST:
print_actions((struct action*)exp->r.param);
break;
case NUMBER_ST:
DBG("%ld",exp->r.numval);
break;
case MYSELF_ST:
DBG("_myself_");
break;
case AVP_ST:
DBG("attr");
break;
case SELECT_ST:
DBG("select");
break;
default:
DBG("type<%d>", exp->r_type);
}
}else if (exp->type==EXP_T){
switch(exp->op){
case LOGAND_OP:
DBG("AND( ");
print_expr(exp->l.expr);
DBG(", ");
print_expr(exp->r.expr);
DBG(" )");
break;
case LOGOR_OP:
DBG("OR( ");
print_expr(exp->l.expr);
DBG(", ");
print_expr(exp->r.expr);
DBG(" )");
break;
case NOT_OP:
DBG("NOT( ");
print_expr(exp->l.expr);
DBG(" )");
break;
default:
DBG("UNKNOWN_EXP ");
}
}else{
DBG("ERROR:print_expr: unknown type\n");
}
}
void print_action(struct action* t)
{
switch(t->type){
case FORWARD_T:
LM_DBG("forward(");
break;
case SEND_T:
LM_DBG("send(");
break;
case DROP_T:
LM_DBG("drop(");
break;
case LOG_T:
LM_DBG("log(");
break;
case ERROR_T:
LM_DBG("error(");
break;
case ROUTE_T:
LM_DBG("route(");
break;
case EXEC_T:
LM_DBG("exec(");
break;
case REVERT_URI_T:
LM_DBG("revert_uri(");
break;
case STRIP_T:
LM_DBG("strip(");
break;
case APPEND_BRANCH_T:
LM_DBG("append_branch(");
break;
case PREFIX_T:
LM_DBG("prefix(");
break;
case LEN_GT_T:
LM_DBG("len_gt(");
break;
case SET_DEBUG_T:
LM_DBG("setdebug(");
break;
case SETFLAG_T:
LM_DBG("setflag(");
break;
case RESETFLAG_T:
LM_DBG("resetflag(");
break;
case ISFLAGSET_T:
LM_DBG("isflagset(");
break;
case SETBFLAG_T:
LM_DBG("setbflag(");
break;
case RESETBFLAG_T:
LM_DBG("resetbflag(");
break;
case ISBFLAGSET_T:
LM_DBG("isbflagset(");
break;
case SETSFLAG_T:
LM_DBG("setsflag(");
break;
case RESETSFLAG_T:
LM_DBG("resetsflag(");
break;
case ISSFLAGSET_T:
LM_DBG("issflagset(");
break;
case SET_HOST_T:
LM_DBG("sethost(");
break;
case SET_HOSTPORT_T:
LM_DBG("sethostport(");
break;
case SET_USER_T:
LM_DBG("setuser(");
break;
case SET_USERPASS_T:
LM_DBG("setuserpass(");
break;
case SET_PORT_T:
LM_DBG("setport(");
break;
case SET_URI_T:
LM_DBG("seturi(");
break;
case IF_T:
LM_DBG("if (");
break;
case WHILE_T:
LM_DBG("while (");
break;
case MODULE_T:
LM_DBG(" external_module_call(");
break;
case FORCE_RPORT_T:
LM_DBG("force_rport(");
break;
case SET_ADV_ADDR_T:
LM_DBG("set_advertised_address(");
break;
case SET_ADV_PORT_T:
LM_DBG("set_advertised_port(");
break;
case FORCE_TCP_ALIAS_T:
LM_DBG("force_tcp_alias(");
break;
case FORCE_SEND_SOCKET_T:
LM_DBG("force_send_socket");
break;
case RETURN_T:
LM_DBG("return(");
break;
case EXIT_T:
LM_DBG("exit(");
break;
case SWITCH_T:
LM_DBG("switch(");
break;
case CASE_T:
LM_DBG("case(");
break;
case DEFAULT_T:
LM_DBG("default(");
break;
case SBREAK_T:
LM_DBG("sbreak(");
break;
case EQ_T:
LM_DBG("assign(");
break;
default:
LM_DBG("UNKNOWN(");
}
switch(t->elem[0].type){
case STRING_ST:
LM_DBG("\"%s\"", ZSW(t->elem[0].u.string));
break;
case NUMBER_ST:
LM_DBG("%lu",t->elem[0].u.number);
break;
case SCRIPTVAR_ST:
LM_DBG("scriptvar[%d]",t->elem[0].u.item->type);
break;
case IP_ST:
print_ip("", (struct ip_addr*)t->elem[0].u.data, "");
break;
case EXPR_ST:
print_expr((struct expr*)t->elem[0].u.data);
break;
case ACTIONS_ST:
print_actions((struct action*)t->elem[0].u.data);
break;
case CMD_ST:
LM_DBG("f<%s>",((cmd_export_t*)t->elem[0].u.data)->name);
break;
case SOCKID_ST:
LM_DBG("%d:%s:%d",
((struct socket_id*)t->elem[0].u.data)->proto,
ZSW(((struct socket_id*)t->elem[0].u.data)->name),
((struct socket_id*)t->elem[0].u.data)->port
);
break;
default:
LM_DBG("type<%d>", t->elem[0].type);
}
if (t->type==IF_T) LM_DBG(") {");
switch(t->elem[1].type){
case NOSUBTYPE:
break;
case STRING_ST:
LM_DBG(", \"%s\"", ZSW(t->elem[1].u.string));
break;
case NUMBER_ST:
LM_DBG(", %lu",t->elem[1].u.number);
break;
case EXPR_ST:
print_expr((struct expr*)t->elem[1].u.data);
break;
case ACTIONS_ST:
print_actions((struct action*)t->elem[1].u.data);
break;
case SOCKID_ST:
LM_DBG("%d:%s:%d",
((struct socket_id*)t->elem[1].u.data)->proto,
ZSW(((struct socket_id*)t->elem[1].u.data)->name),
((struct socket_id*)t->elem[1].u.data)->port
);
break;
default:
LM_DBG(", type<%d>", t->elem[1].type);
}
if (t->type==IF_T && t->elem[2].type!=NOSUBTYPE) LM_DBG(" } else { ");
switch(t->elem[2].type){
case NOSUBTYPE:
break;
case STRING_ST:
LM_DBG(", \"%s\"", ZSW(t->elem[2].u.string));
break;
case NUMBER_ST:
LM_DBG(", %lu",t->elem[2].u.number);
break;
case EXPR_ST:
print_expr((struct expr*)t->elem[2].u.data);
break;
case ACTIONS_ST:
print_actions((struct action*)t->elem[2].u.data);
break;
case SOCKID_ST:
LM_DBG("%d:%s:%d",
((struct socket_id*)t->elem[2].u.data)->proto,
ZSW(((struct socket_id*)t->elem[2].u.data)->name),
((struct socket_id*)t->elem[2].u.data)->port
);
break;
default:
LM_DBG(", type<%d>", t->elem[2].type);
}
if (t->type==IF_T) LM_DBG("}; ");
else LM_DBG("); ");
}
void print_expr(struct expr* exp)
{
if (exp==0){
LM_CRIT("null expression!\n");
return;
}
if (exp->type==ELEM_T){
switch(exp->left.type){
case METHOD_O:
LM_DBG("method");
break;
case URI_O:
LM_DBG("uri");
break;
case FROM_URI_O:
LM_DBG("from_uri");
break;
case TO_URI_O:
LM_DBG("to_uri");
break;
case SRCIP_O:
LM_DBG("srcip");
break;
case SRCPORT_O:
LM_DBG("srcport");
break;
case DSTIP_O:
LM_DBG("dstip");
break;
case DSTPORT_O:
LM_DBG("dstport");
break;
case SCRIPTVAR_O:
LM_DBG("scriptvar[%d]",
(exp->left.v.spec)?exp->left.v.spec->type:0);
break;
case NUMBER_O:
case NUMBERV_O:
LM_DBG("%d",exp->left.v.n);
break;
case STRINGV_O:
LM_DBG("\"%s\"", ZSW((char*)exp->left.v.data));
break;
case ACTION_O:
break;
case EXPR_O:
print_expr((struct expr*)exp->left.v.data);
break;
default:
LM_DBG("UNKNOWN[%d]", exp->left.type);
}
switch(exp->op){
case EQUAL_OP:
LM_DBG("==");
break;
case MATCHD_OP:
case MATCH_OP:
LM_DBG("=~");
break;
case NOTMATCHD_OP:
case NOTMATCH_OP:
LM_DBG("!~");
break;
case GT_OP:
LM_DBG(">");
break;
case GTE_OP:
LM_DBG(">=");
break;
case LT_OP:
LM_DBG("<");
break;
case LTE_OP:
LM_DBG("<=");
break;
case DIFF_OP:
LM_DBG("!=");
break;
case PLUS_OP:
LM_DBG("+");
break;
case MINUS_OP:
LM_DBG("-");
break;
case DIV_OP:
LM_DBG("/");
break;
case MULT_OP:
LM_DBG("*");
break;
case MODULO_OP:
LM_DBG(" mod ");
break;
case BAND_OP:
LM_DBG("&");
break;
case BOR_OP:
LM_DBG("|");
break;
case BXOR_OP:
LM_DBG("^");
break;
case BNOT_OP:
LM_DBG("~");
break;
case VALUE_OP:
case NO_OP:
break;
default:
LM_DBG("<UNKNOWN[%d]>", exp->op);
}
switch(exp->right.type){
case NOSUBTYPE:
/* LM_DBG("N/A"); */
break;
case STRING_ST:
LM_DBG("\"%s\"", ZSW((char*)exp->right.v.data));
break;
case NET_ST:
print_net((struct net*)exp->right.v.data);
break;
case IP_ST:
print_ip("", (struct ip_addr*)exp->right.v.data, "");
break;
case ACTIONS_ST:
print_actions((struct action*)exp->right.v.data);
break;
case NUMBER_ST:
LM_DBG("%d",exp->right.v.n);
break;
case MYSELF_ST:
LM_DBG("_myself_");
break;
case SCRIPTVAR_ST:
LM_DBG("scriptvar[%d]", exp->right.v.spec->type);
break;
case NULLV_ST:
LM_DBG("null");
break;
case EXPR_ST:
print_expr((struct expr*)exp->right.v.data);
break;
default:
LM_DBG("type<%d>", exp->right.type);
}
}else if (exp->type==EXP_T){
switch(exp->op){
case AND_OP:
LM_DBG("AND( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case OR_OP:
LM_DBG("OR( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case NOT_OP:
LM_DBG("NOT( ");
print_expr(exp->left.v.expr);
LM_DBG(" )");
break;
case EVAL_OP:
LM_DBG("EVAL( ");
print_expr(exp->left.v.expr);
LM_DBG(" )");
break;
case PLUS_OP:
LM_DBG("PLUS( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case MINUS_OP:
LM_DBG("MINUS( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case DIV_OP:
LM_DBG("DIV( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case MULT_OP:
LM_DBG("MULT( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case MODULO_OP:
LM_DBG("MODULO( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case BAND_OP:
LM_DBG("BAND( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case BOR_OP:
LM_DBG("BOR( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case BXOR_OP:
LM_DBG("BXOR( ");
print_expr(exp->left.v.expr);
LM_DBG(", ");
print_expr(exp->right.v.expr);
LM_DBG(" )");
break;
case BNOT_OP:
LM_DBG("BNOT( ");
print_expr(exp->left.v.expr);
LM_DBG(" )");
break;
default:
LM_DBG("UNKNOWN_EXP[%d] ", exp->op);
}
}else{
LM_ERR("unknown type\n");
}
}
static int
help (int argc, char **argv, Coord x, Coord y)
{
print_actions ();
return 0;
}
int
main (int argc, char *argv[])
{
int i;
/* init application:
* - make program name available for error handlers
* - evaluate special options
* - initialize toplevel shell and resources
* - create an empty PCB with default symbols
* - initialize all other widgets
* - update screen and get size of drawing area
* - evaluate command-line arguments
* - register 'call on exit()' function
*/
setbuf (stdout, 0);
InitPaths (argv[0]);
#ifdef LOCALEDIR
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
textdomain(GETTEXT_PACKAGE);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
setlocale(LC_ALL,"");
#endif
srand ( time(NULL) ); /* Set seed for rand() */
initialize_units();
polygon_init ();
hid_init ();
hid_load_settings ();
program_name = argv[0];
program_basename = strrchr (program_name, PCB_DIR_SEPARATOR_C);
if (program_basename)
{
program_directory = strdup (program_name);
*strrchr (program_directory, PCB_DIR_SEPARATOR_C) = 0;
program_basename++;
}
else
{
program_directory = ".";
program_basename = program_name;
}
Progname = program_basename;
/* Print usage or version if requested. Then exit. */
if (argc > 1 &&
(strcmp (argv[1], "-h") == 0 ||
strcmp (argv[1], "-?") == 0 ||
strcmp (argv[1], "--help") == 0))
usage ();
if (argc > 1 && strcmp (argv[1], "-V") == 0)
print_version ();
/* Export pcb from command line if requested. */
if (argc > 1 && strcmp (argv[1], "-p") == 0)
{
exporter = gui = hid_find_printer ();
argc--;
argv++;
}
else if (argc > 2 && strcmp (argv[1], "-x") == 0)
{
exporter = gui = hid_find_exporter (argv[2]);
argc -= 2;
argv += 2;
}
/* Otherwise start GUI. */
else if (argc > 2 && strcmp (argv[1], "--gui") == 0)
{
gui = hid_find_gui (argv[2]);
if (gui == NULL) {
Message("Can't find the gui requested.\n");
exit(1);
}
argc -= 2;
argv += 2;
}
else {
const char **g;
gui = NULL;
for(g = try_gui_hids; (*g != NULL) && (gui == NULL); g++) {
gui = hid_find_gui (*g);
}
/* try anything */
if (gui == NULL) {
Message("Warning: can't find any of the preferred GUIs, falling back to anything available...\n");
gui = hid_find_gui (NULL);
}
}
/* Exit with error if GUI failed to start. */
if (!gui)
exit (1);
/* Initialize actions only when the gui is already known so only the right
one is registered (there can be only one GUI). */
#include "action_list.h"
/* Set up layers. */
for (i = 0; i < MAX_LAYER; i++)
{
char buf[20];
sprintf (buf, "signal%d", i + 1);
Settings.DefaultLayerName[i] = strdup (buf);
Settings.LayerColor[i] = "#c49350";
Settings.LayerSelectedColor[i] = "#00ffff";
}
gui->parse_arguments (&argc, &argv);
if (show_help || (argc > 1 && argv[1][0] == '-'))
usage ();
if (show_version)
print_version ();
if (show_defaults)
print_defaults ();
if (show_copyright)
copyright ();
settings_post_process ();
if (show_actions)
{
print_actions ();
exit (0);
}
if (do_dump_actions)
{
extern void dump_actions (void);
dump_actions ();
exit (0);
}
set_fontfile();
/* Create a new PCB object in memory */
PCB = CreateNewPCB ();
if (PCB == NULL) {
Message("Can't load the default pcb (%s) for creating an empty layout\n", Settings.DefaultPcbFile);
exit(1);
}
/* Add silk layers to newly created PCB */
CreateNewPCBPost (PCB, 1);
if (argc > 1)
command_line_pcb = argv[1];
ResetStackAndVisibility ();
if (gui->gui)
InitCrosshair ();
InitHandler ();
InitBuffers ();
SetMode (ARROW_MODE);
if (command_line_pcb)
{
/* keep filename even if initial load command failed;
* file might not exist
*/
if (LoadPCB (command_line_pcb))
PCB->Filename = strdup (command_line_pcb);
}
if (Settings.InitialLayerStack
&& Settings.InitialLayerStack[0])
{
LayerStringToLayerStack (Settings.InitialLayerStack);
}
/* This must be called before any other atexit functions
* are registered, as it configures an atexit function to
* clean up and free various items of allocated memory,
* and must be the last last atexit function to run.
*/
leaky_init ();
/* Register a function to be called when the program terminates.
* This makes sure that data is saved even if LEX/YACC routines
* abort the program.
* If the OS doesn't have at least one of them,
* the critical sections will be handled by parse_l.l
*/
atexit (EmergencySave);
/* read the library file and display it if it's not empty
*/
if (!ReadLibraryContents () && Library.MenuN)
hid_action ("LibraryChanged");
#ifdef HAVE_LIBSTROKE
stroke_init ();
#endif
if (Settings.ScriptFilename)
{
Message (_("Executing startup script file %s\n"),
Settings.ScriptFilename);
hid_actionl ("ExecuteFile", Settings.ScriptFilename, NULL);
}
if (Settings.ActionString)
{
Message (_("Executing startup action %s\n"), Settings.ActionString);
hid_parse_actions (Settings.ActionString);
}
if (gui->printer || gui->exporter)
{
// Workaround to fix batch output for non-C locales
setlocale(LC_NUMERIC,"C");
gui->do_export (0);
exit (0);
}
#if HAVE_DBUS
pcb_dbus_setup();
#endif
EnableAutosave ();
#ifdef DEBUG
printf ("Settings.FontPath = \"%s\"\n",
Settings.FontPath);
printf ("Settings.ElementPath = \"%s\"\n",
Settings.ElementPath);
printf ("Settings.LibrarySearchPaths = \"%s\"\n",
Settings.LibrarySearchPaths);
printf ("Settings.LibraryShell = \"%s\"\n",
Settings.LibraryShell);
printf ("Settings.MakeProgram = \"%s\"\n",
UNKNOWN (Settings.MakeProgram));
printf ("Settings.GnetlistProgram = \"%s\"\n",
UNKNOWN (Settings.GnetlistProgram));
#endif
buildin_init();
gui->do_export (0);
#if HAVE_DBUS
pcb_dbus_finish();
#endif
return (0);
}
