/* Get scan parameters */
SANE_Status
sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
{
struct scanner *s = (struct scanner *) handle;
SANE_Parameters *p = &s->params;
if (!s->scanning)
{
unsigned w, h, res = s->val[RESOLUTION].w;
unsigned i = str_index (paper_list,
s->val[PAPER_SIZE].s);
if (i)
{
if (s->val[LANDSCAPE].b)
{
w = paper_sizes[i].height;
h = paper_sizes[i].width;
}
else
{
w = paper_sizes[i].width;
h = paper_sizes[i].height;
}
}
else
{
w = s->val[BR_X].w - s->val[TL_X].w;
h = s->val[BR_Y].w - s->val[TL_Y].w;
}
p->pixels_per_line = w * res / 25.4 + .5;
p->lines = h * res / 25.4 + .5;
}
p->format = !strcmp (s->val[MODE].s,
SANE_VALUE_SCAN_MODE_COLOR) ? SANE_FRAME_RGB :
SANE_FRAME_GRAY;
p->last_frame = SANE_TRUE;
p->depth = bps_val[str_index (mode_list, s->val[MODE].s)];
p->bytes_per_line = p->depth * p->pixels_per_line / 8;
if (p->depth > 8)
p->depth = 8;
if (params)
memcpy (params, p, sizeof (SANE_Parameters));
s->side_size = p->bytes_per_line * p->lines;
return SANE_STATUS_GOOD;
}
inline
arr_and_str_indices<Ndims>
arr_index_data<Ndims>::operator()(
int first,
int last) const
{
return arr_and_str_indices<Ndims>(*this, str_index(first, last));
}
static mrb_value
mrb_str_index_m(mrb_state *mrb, mrb_value str)
{
mrb_value *argv;
mrb_int argc;
mrb_value sub;
mrb_int pos;
mrb_get_args(mrb, "*", &argv, &argc);
if (argc == 2) {
pos = mrb_fixnum(argv[1]);
sub = argv[0];
}
else {
pos = 0;
if (argc > 0)
sub = argv[0];
else
sub = mrb_nil_value();
}
regexp_check(mrb, sub);
if (pos < 0) {
pos += RSTRING_LEN(str);
if (pos < 0) {
return mrb_nil_value();
}
}
if (mrb_type(sub) == MRB_TT_FIXNUM) {
sub = mrb_fixnum_chr(mrb, sub);
}
switch (mrb_type(sub)) {
default: {
mrb_value tmp;
tmp = mrb_check_string_type(mrb, sub);
if (mrb_nil_p(tmp)) {
mrb_raisef(mrb, E_TYPE_ERROR, "type mismatch: %S given", sub);
}
sub = tmp;
}
/* fall through */
case MRB_TT_STRING:
pos = str_index(mrb, str, sub, pos);
break;
}
if (pos == -1) return mrb_nil_value();
return mrb_fixnum_value(mrb_utf8_strlen(str, pos));
}
int main(int argc, char **args)
{
char *str = (char *) malloc(100);
str_copy(str, "Hello World!");
printf("%s\n", str);
int cmp0 = str_compare("abcde", "abcde");
int cmp1 = str_compare("abcde", "abcdf");
int cmp2 = str_compare("abcdf", "abcde");
int cmp3 = str_compare("abcde", "abcdef");
int cmp4 = str_compare("abcdef", "abcde");
printf("%d %d %d %d %d\n", cmp0, cmp1, cmp2, cmp3, cmp4);
str_concat(str, "Hello ", "World!");
printf("%s\n", str);
str_sub(str, "Hello World!", 7, 2);
printf("%s\n", str);
int ind0 = str_index("Hello World!", "o", 0);
int ind1 = str_index("Hello World!", "o", 5);
printf("%d %d\n", ind0, ind1);
str_copy(str, "Hello World!");
str_insert(str, "My Beautiful ", 6);
printf("%s\n", str);
str_delete(str, 6, 3);
printf("%s\n", str);
str_delete(str, 6, 10);
printf("%s\n", str);
free(str);
return 0;
}
static mrb_value
mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx)
{
mrb_int idx;
regexp_check(mrb, indx);
switch (mrb_type(indx)) {
case MRB_TT_FIXNUM:
idx = mrb_fixnum(indx);
num_index:
str = str_substr(mrb, str, idx, 1);
if (!mrb_nil_p(str) && RSTRING_LEN(str) == 0) return mrb_nil_value();
return str;
case MRB_TT_STRING:
if (str_index(mrb, str, indx, 0) != -1)
return mrb_str_dup(mrb, indx);
return mrb_nil_value();
case MRB_TT_RANGE:
/* check if indx is Range */
{
mrb_int beg, len;
mrb_value tmp;
len = RSTRING_LEN_UTF8(str);
if (mrb_range_beg_len(mrb, indx, &beg, &len, len)) {
tmp = str_subseq(mrb, str, beg, len);
return tmp;
}
else {
return mrb_nil_value();
}
}
default:
idx = mrb_fixnum(indx);
goto num_index;
}
return mrb_nil_value(); /* not reached */
}
/*
* NAME: optimize->expr()
* DESCRIPTION: optimize an expression
*/
static Uint opt_expr(node **m, bool pop)
{
Uint d1, d2, i;
node *n;
node **oldside, *side;
Uint olddepth;
n = *m;
switch (n->type) {
case N_FLOAT:
case N_GLOBAL:
case N_INT:
case N_LOCAL:
case N_STR:
case N_NIL:
return !pop;
case N_TOINT:
case N_CAST:
return opt_expr(&n->l.left, FALSE);
case N_NEG:
case N_UMIN:
return max2(opt_expr(&n->l.left, FALSE), 2);
case N_CATCH:
oldside = side_start(&side, &olddepth);
d1 = opt_expr(&n->l.left, TRUE);
if (d1 == 0) {
n->l.left = (node *) NULL;
}
d1 = max2(d1, side_end(&n->l.left, side, oldside, olddepth));
if (d1 == 0) {
*m = node_nil();
(*m)->line = n->line;
return !pop;
}
return d1;
case N_TOFLOAT:
if (n->l.left->mod != T_INT) {
return opt_expr(&n->l.left, FALSE);
}
/* fall through */
case N_NOT:
case N_TST:
if (pop) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
return opt_expr(&n->l.left, FALSE);
case N_TOSTRING:
if (pop && (n->l.left->mod == T_INT || n->l.left->mod == T_FLOAT)) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
return opt_expr(&n->l.left, FALSE);
case N_LVALUE:
return opt_lvalue(n->l.left);
case N_ADD_EQ_1:
case N_ADD_EQ_1_INT:
case N_ADD_EQ_1_FLOAT:
case N_SUB_EQ_1:
case N_SUB_EQ_1_INT:
case N_SUB_EQ_1_FLOAT:
return opt_lvalue(n->l.left) + 1;
case N_MIN_MIN:
if (pop) {
n->type = N_SUB_EQ_1;
}
return opt_lvalue(n->l.left) + 1;
case N_MIN_MIN_INT:
if (pop) {
n->type = N_SUB_EQ_1_INT;
}
return opt_lvalue(n->l.left) + 1;
case N_MIN_MIN_FLOAT:
if (pop) {
n->type = N_SUB_EQ_1_FLOAT;
}
return opt_lvalue(n->l.left) + 1;
case N_PLUS_PLUS:
if (pop) {
n->type = N_ADD_EQ_1;
}
return opt_lvalue(n->l.left) + 1;
case N_PLUS_PLUS_INT:
if (pop) {
n->type = N_ADD_EQ_1_INT;
}
return opt_lvalue(n->l.left) + 1;
case N_PLUS_PLUS_FLOAT:
if (pop) {
n->type = N_ADD_EQ_1_FLOAT;
}
return opt_lvalue(n->l.left) + 1;
case N_FUNC:
m = &n->l.left->r.right;
n = *m;
if (n == (node *) NULL) {
return 1;
}
d1 = 0;
for (i = 0; n->type == N_PAIR; ) {
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left, FALSE);
d1 = max3(d1, i + d2,
i + side_end(&n->l.left, side, oldside, olddepth));
m = &n->r.right;
n = n->l.left;
i += (n->type == N_LVALUE ||
(n->type == N_COMMA && n->r.right->type == N_LVALUE)) ? 6 : 1;
n = *m;
}
if (n->type == N_SPREAD) {
m = &n->l.left;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(m, FALSE);
d1 = max3(d1, i + d2, i + side_end(m, side, oldside, olddepth));
n = *m;
if (n->type == N_LVALUE ||
(n->type == N_COMMA && n->r.right->type == N_LVALUE)) {
d1 += 2;
}
return d1;
case N_INSTANCEOF:
return opt_expr(&n->l.left, FALSE) + 1;
case N_GE:
case N_GT:
case N_LE:
case N_LT:
if (n->l.left->mod != n->r.right->mod) {
return max2(opt_expr(&n->l.left, FALSE),
opt_expr(&n->r.right, FALSE) + 1);
}
/* fall through */
case N_EQ:
case N_NE:
if (pop) {
d1 = opt_expr(&n->l.left, TRUE);
if (d1 == 0) {
*m = n->r.right;
return opt_expr(m, TRUE);
}
d2 = opt_expr(&n->r.right, TRUE);
if (d2 == 0) {
*m = n->l.left;
return d1;
}
n->type = N_COMMA;
side_add(m, d1);
return d2;
}
return opt_binop(m);
case N_DIV_INT:
case N_MOD_INT:
if (n->r.right->type == N_INT && n->r.right->l.number == 0) {
d1 = opt_binop(m);
return (d1 == 1) ? !pop : d1;
}
/* fall through */
case N_ADD_INT:
case N_ADD_FLOAT:
case N_AND_INT:
case N_DIV_FLOAT:
case N_EQ_INT:
case N_EQ_FLOAT:
case N_GE_INT:
case N_GE_FLOAT:
case N_GT_INT:
case N_GT_FLOAT:
case N_LE_INT:
case N_LE_FLOAT:
case N_LSHIFT_INT:
case N_LT_INT:
case N_LT_FLOAT:
case N_MULT_INT:
case N_MULT_FLOAT:
case N_NE_INT:
case N_NE_FLOAT:
case N_OR_INT:
case N_RSHIFT_INT:
case N_SUB_INT:
case N_SUB_FLOAT:
case N_XOR_INT:
if (pop) {
d1 = opt_expr(&n->l.left, TRUE);
if (d1 == 0) {
*m = n->r.right;
return opt_expr(m, TRUE);
}
d2 = opt_expr(&n->r.right, TRUE);
if (d2 == 0) {
*m = n->l.left;
return d1;
}
n->type = N_COMMA;
side_add(m, d1);
return d2;
}
/* fall through */
case N_ADD:
case N_AND:
case N_DIV:
case N_LSHIFT:
case N_MOD:
case N_MULT:
case N_OR:
case N_RSHIFT:
case N_SUB:
case N_SUM:
case N_XOR:
d1 = opt_binop(m);
return (d1 == 1) ? !pop : d1;
case N_INDEX:
if (n->l.left->type == N_STR && n->r.right->type == N_INT) {
if (n->r.right->l.number < 0 ||
n->r.right->l.number >= (long) n->l.left->l.string->len) {
return 2;
}
node_toint(n, (Int) str_index(n->l.left->l.string,
(long) n->r.right->l.number));
return !pop;
}
if (n->l.left->type == N_FUNC && n->r.right->mod == T_INT) {
if (n->l.left->r.number == kd_status) {
n->type = N_FUNC;
if (n->l.left->l.left->r.right != (node *) NULL) {
/* status(obj)[i] */
n = n->l.left;
n->type = N_STR;
n->r.right = n->l.left;
n->l.string = n->l.left->l.string;
n = n->r.right;
n->type = N_PAIR;
n->l.left = n->r.right;
n->r.right = (*m)->r.right;
(*m)->r.number = ((long) KFCALL << 24) | KF_STATUSO_IDX;
} else {
/* status()[i] */
n->l.left = n->l.left->l.left;
n->l.left->r.right = n->r.right;
n->r.number = ((long) KFCALL << 24) | KF_STATUS_IDX;
}
return opt_expr(m, pop);
}
if (n->l.left->r.number == kd_call_trace) {
/* call_trace()[i] */
n->type = N_FUNC;
n->l.left = n->l.left->l.left;
n->l.left->r.right = n->r.right;
n->r.number = ((long) KFCALL << 24) | KF_CALLTR_IDX;
return opt_expr(m, pop);
}
}
return max3(opt_expr(&n->l.left, FALSE),
opt_expr(&n->r.right, FALSE) + 1, 3);
case N_ADD_EQ:
case N_ADD_EQ_INT:
case N_ADD_EQ_FLOAT:
case N_AND_EQ:
case N_AND_EQ_INT:
case N_DIV_EQ:
case N_DIV_EQ_INT:
case N_DIV_EQ_FLOAT:
case N_LSHIFT_EQ:
case N_LSHIFT_EQ_INT:
case N_MOD_EQ:
case N_MOD_EQ_INT:
case N_MULT_EQ:
case N_MULT_EQ_INT:
case N_MULT_EQ_FLOAT:
case N_OR_EQ:
case N_OR_EQ_INT:
case N_RSHIFT_EQ:
case N_RSHIFT_EQ_INT:
case N_SUB_EQ:
case N_SUB_EQ_INT:
case N_SUB_EQ_FLOAT:
case N_SUM_EQ:
case N_XOR_EQ:
case N_XOR_EQ_INT:
return opt_asgnexp(m, pop);
case N_ASSIGN:
if (n->l.left->type == N_AGGR) {
d2 = 0;
for (n = n->l.left->l.left; n->type == N_PAIR; n = n->r.right) {
d1 = opt_lvalue(n->l.left);
d2 += 2 + ((d1 < 4) ? d1 : 4);
}
d1 = opt_lvalue(n);
d2 += 2 + ((d1 < 4) ? d1 : 4);
return d2 + max2(2, opt_expr(&(*m)->r.right, FALSE));
} else {
d1 = opt_lvalue(n->l.left);
return max2(d1, ((d1 < 4) ? d1 : 4) + opt_expr(&n->r.right, FALSE));
}
case N_COMMA:
side_add(m, opt_expr(&n->l.left, TRUE));
return opt_expr(m, pop);
case N_LAND:
d1 = opt_cond(&n->l.left, FALSE);
if (n->l.left->flags & F_CONST) {
if (!opt_ctest(n->l.left)) {
/* false && x */
*m = n->l.left;
return !pop;
}
/* true && x */
n->type = N_TST;
n->l.left = n->r.right;
return opt_expr(m, pop);
}
oldside = side_start(&side, &olddepth);
d2 = opt_cond(&n->r.right, pop);
if (d2 == 0) {
n->r.right = (node *) NULL;
}
d2 = max2(d2, side_end(&n->r.right, side, oldside, olddepth));
if (d2 == 0) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (n->r.right->flags & F_CONST) {
if (pop) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (!opt_ctest(n->r.right)) {
/* x && false */
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
/* x && true */
n->type = N_TST;
return d1;
}
if (n->r.right->type == N_COMMA) {
n = n->r.right;
if ((n->r.right->flags & F_CONST) && !opt_ctest(n->r.right)) {
/* x && (y, false) --> (x && y, false) */
(*m)->r.right = n->l.left;
n->l.left = *m;
*m = n;
return opt_expr(m, pop);
}
}
return max2(d1, d2);
case N_LOR:
d1 = opt_cond(&n->l.left, FALSE);
if (n->l.left->flags & F_CONST) {
if (opt_ctest(n->l.left)) {
/* true || x */
*m = n->l.left;
return !pop;
}
/* false || x */
n->type = N_TST;
n->l.left = n->r.right;
return opt_expr(m, pop);
}
oldside = side_start(&side, &olddepth);
d2 = opt_cond(&n->r.right, pop);
if (d2 == 0) {
n->r.right = (node *) NULL;
}
d2 = max2(d2, side_end(&n->r.right, side, oldside, olddepth));
if (d2 == 0) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (n->r.right->flags & F_CONST) {
if (pop) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (opt_ctest(n->r.right)) {
/* x || true */
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
/* x || false */
n->type = N_TST;
return d1;
}
if (n->r.right->type == N_COMMA) {
n = n->r.right;
if ((n->r.right->flags & F_CONST) && opt_ctest(n->r.right)) {
/* x || (y, true) --> (x || y, true) */
(*m)->r.right = n->l.left;
n->l.left = *m;
*m = n;
return opt_expr(m, pop);
}
}
return max2(d1, d2);
case N_QUEST:
i = opt_cond(&n->l.left, FALSE);
if (n->l.left->flags & F_CONST) {
if (opt_ctest(n->l.left)) {
*m = n->r.right->l.left;
} else {
*m = n->r.right->r.right;
}
return opt_expr(m, pop);
}
if (n->l.left->type == N_COMMA && (n->l.left->r.right->flags & F_CONST))
{
side_add(&n->l.left, i);
if (opt_ctest(n->l.left)) {
*m = n->r.right->l.left;
} else {
*m = n->r.right->r.right;
}
return opt_expr(m, pop);
}
n = n->r.right;
oldside = side_start(&side, &olddepth);
d1 = opt_expr(&n->l.left, pop);
if (d1 == 0) {
n->l.left = (node *) NULL;
}
d1 = max2(d1, side_end(&n->l.left, side, oldside, olddepth));
if (d1 == 0) {
n->l.left = (node *) NULL;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->r.right, pop);
if (d2 == 0) {
n->r.right = (node *) NULL;
}
d2 = max2(d2, side_end(&n->r.right, side, oldside, olddepth));
if (d2 == 0) {
n->r.right = (node *) NULL;
}
return max3(i, d1, d2);
case N_RANGE:
d1 = opt_expr(&n->l.left, FALSE);
d2 = 1;
if (n->r.right->l.left != (node *) NULL) {
d2 = opt_expr(&n->r.right->l.left, FALSE);
if ((n->l.left->mod == T_STRING || (n->l.left->mod & T_REF) != 0) &&
n->r.right->l.left->type == N_INT &&
n->r.right->l.left->l.number == 0) {
/*
* str[0 .. x] or arr[0 .. x]
*/
n->r.right->l.left = (node *) NULL;
d2 = 1;
} else {
d1 = max2(d1, d2 + 1);
d2 = 2;
}
}
if (n->r.right->r.right != (node *) NULL) {
d1 = max2(d1, d2 + opt_expr(&n->r.right->r.right, FALSE));
}
if (n->l.left->type == N_STR) {
long from, to;
if (n->r.right->l.left == (node *) NULL) {
from = 0;
} else {
if (n->r.right->l.left->type != N_INT) {
return d1;
}
from = n->r.right->l.left->l.number;
}
if (n->r.right->r.right == (node *) NULL) {
to = n->l.left->l.string->len - 1;
} else {
if (n->r.right->r.right->type != N_INT) {
return d1;
}
to = n->r.right->r.right->l.number;
}
if (from >= 0 && from <= to + 1 &&
to < (long) n->l.left->l.string->len) {
node_tostr(n, str_range(n->l.left->l.string, from, to));
return !pop;
}
return d1;
}
return max2(d1, 3);
case N_AGGR:
if (n->mod == T_MAPPING) {
n = n->l.left;
if (n == (node *) NULL) {
return 1;
}
d1 = 0;
for (i = 0; n->type == N_PAIR; i += 2) {
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left->l.left, FALSE);
d1 = max3(d1, i + d2, i + side_end(&n->l.left->l.left,
side, oldside, olddepth));
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left->r.right, FALSE);
d1 = max3(d1, i + 1 + d2,
i + 1 + side_end(&n->l.left->r.right, side, oldside,
olddepth));
n = n->r.right;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left, FALSE);
d1 = max3(d1, i + d2,
i + side_end(&n->l.left, side, oldside, olddepth));
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->r.right, FALSE);
return max3(d1, i + 1 + d2,
i + 1 + side_end(&n->r.right, side, oldside, olddepth));
} else {
m = &n->l.left;
n = *m;
if (n == (node *) NULL) {
return 1;
}
d1 = 0;
for (i = 0; n->type == N_PAIR; i++) {
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left, FALSE);
d1 = max3(d1, i + d2,
i + side_end(&n->l.left, side, oldside, olddepth));
m = &n->r.right;
n = *m;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(m, FALSE);
return max3(d1, i + d2, i + side_end(m, side, oldside, olddepth));
}
}
# ifdef DEBUG
fatal("unknown expression type %d", n->type);
# endif
return 0;
}
/* Control option */
SANE_Status
sane_control_option (SANE_Handle handle, SANE_Int option,
SANE_Action action, void *val, SANE_Int * info)
{
int i;
SANE_Status status;
SANE_Word cap;
struct scanner *s = (struct scanner *) handle;
if (info)
*info = 0;
if (option < 0 || option >= NUM_OPTIONS)
return SANE_STATUS_UNSUPPORTED;
cap = s->opt[option].cap;
if (!SANE_OPTION_IS_ACTIVE (cap))
return SANE_STATUS_UNSUPPORTED;
if (action == SANE_ACTION_GET_VALUE)
{
if (s->opt[option].type == SANE_TYPE_STRING)
{
DBG (DBG_INFO,
"sane_control_option: reading opt[%d] = %s\n",
option, s->val[option].s);
strcpy (val, s->val[option].s);
}
else
{
*(SANE_Word *) val = s->val[option].w;
DBG (DBG_INFO,
"sane_control_option: reading opt[%d] = %d\n",
option, s->val[option].w);
}
return SANE_STATUS_GOOD;
}
else if (action == SANE_ACTION_SET_VALUE)
{
if (!SANE_OPTION_IS_SETTABLE (cap))
return SANE_STATUS_INVAL;
status = sanei_constrain_value (s->opt + option, val, info);
if (status != SANE_STATUS_GOOD)
return status;
if (s->opt[option].type == SANE_TYPE_STRING)
{
if (!strcmp (val, s->val[option].s))
return SANE_STATUS_GOOD;
DBG (DBG_INFO,
"sane_control_option: writing opt[%d] = %s\n",
option, (SANE_String_Const) val);
}
else
{
if (*(SANE_Word *) val == s->val[option].w)
return SANE_STATUS_GOOD;
DBG (DBG_INFO,
"sane_control_option: writing opt[%d] = %d\n",
option, *(SANE_Word *) val);
}
switch (option)
{
/* Side-effect options */
case RESOLUTION:
s->val[option].w = *(SANE_Word *) val;
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
case TL_Y:
if ((*(SANE_Word *) val) + MIN_LENGTH <=
s->val[BR_Y].w &&
!check_area (s, s->val[TL_X].w, *(SANE_Word *) val,
s->val[BR_X].w, s->val[BR_Y].w))
{
s->val[option].w = *(SANE_Word *) val;
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
}
else if (info)
*info |= SANE_INFO_INEXACT |
SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
case BR_Y:
if ((*(SANE_Word *) val) >=
s->val[TL_Y].w + MIN_LENGTH
&& !check_area (s, s->val[TL_X].w, s->val[TL_Y].w,
s->val[BR_X].w, *(SANE_Word *) val))
{
s->val[option].w = *(SANE_Word *) val;
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
}
else if (info)
*info |= SANE_INFO_INEXACT |
SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
case TL_X:
if ((*(SANE_Word *) val) + MIN_WIDTH <=
s->val[BR_X].w &&
!check_area (s, *(SANE_Word *) val, s->val[TL_Y].w,
s->val[BR_X].w, s->val[BR_Y].w))
{
s->val[option].w = *(SANE_Word *) val;
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
}
else if (info)
*info |= SANE_INFO_INEXACT |
SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
case BR_X:
if (*(SANE_Word *) val >=
s->val[TL_X].w + MIN_WIDTH
&& !check_area (s, s->val[TL_X].w, s->val[TL_Y].w,
*(SANE_Word *) val, s->val[BR_Y].w))
{
s->val[option].w = *(SANE_Word *) val;
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
}
else if (info)
*info |= SANE_INFO_INEXACT |
SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
case LANDSCAPE:
s->val[option].w = *(SANE_Word *) val;
if (info)
*info |= SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
/* Side-effect free options */
case CONTRAST:
case BRIGHTNESS:
case DUPLEX:
case LENGTHCTL:
case LONG_PAPER:
case FIT_TO_PAGE:
case THRESHOLD:
case INVERSE:
case COMPRESSION_PAR:
case DFSTOP:
case DFEED_L:
case DFEED_C:
case DFEED_R:
case STOP_SKEW:
case DESKEW:
case MIRROR:
case CROP:
case TOPPOS:
case BTMPOS:
case RED_CHROMA:
case BLUE_CHROMA:
s->val[option].w = *(SANE_Word *) val;
return SANE_STATUS_GOOD;
case FEED_TIMEOUT:
s->val[option].w = *(SANE_Word *) val;
return kvs40xx_set_timeout (s, s->val[option].w);
/* String mode */
case IMAGE_EMPHASIS:
case GAMMA_CORRECTION:
case LAMP:
case HALFTONE_PATTERN:
case DFEED_SENCE:
case AUTOMATIC_THRESHOLD:
case WHITE_LEVEL:
case NOISE_REDUCTION:
strcpy (s->val[option].s, val);
return SANE_STATUS_GOOD;
case SOURCE:
strcpy (s->val[option].s, val);
if (strcmp (s->val[option].s, SANE_I18N ("adf")))
{
strcpy (s->val[FEEDER_MODE].s, feeder_mode_list[0]);
strcpy (s->val[MANUALFEED].s, manual_feed_list[0]);
s->val[DUPLEX].w = SANE_FALSE;
s->val[DBLFEED].w = SANE_FALSE;
s->val[BTMPOS].w = SANE_FALSE;
s->val[TOPPOS].w = SANE_FALSE;
s->val[STOP_SKEW].w = SANE_FALSE;
s->val[LENGTHCTL].w = SANE_FALSE;
s->val[LONG_PAPER].w = SANE_FALSE;
s->opt[FEEDER_MODE].cap |= SANE_CAP_INACTIVE;
s->opt[MANUALFEED].cap |= SANE_CAP_INACTIVE;
s->opt[DUPLEX].cap |= SANE_CAP_INACTIVE;
s->opt[DBLFEED].cap |= SANE_CAP_INACTIVE;
s->opt[BTMPOS].cap |= SANE_CAP_INACTIVE;
s->opt[TOPPOS].cap |= SANE_CAP_INACTIVE;
s->opt[STOP_SKEW].cap |= SANE_CAP_INACTIVE;
s->opt[LENGTHCTL].cap |= SANE_CAP_INACTIVE;
s->opt[LONG_PAPER].cap |= SANE_CAP_INACTIVE;
}
else
{
s->opt[FEEDER_MODE].cap &= ~SANE_CAP_INACTIVE;
s->opt[MANUALFEED].cap &= ~SANE_CAP_INACTIVE;
s->opt[DUPLEX].cap &= ~SANE_CAP_INACTIVE;
s->opt[DBLFEED].cap &= ~SANE_CAP_INACTIVE;
s->opt[BTMPOS].cap &= ~SANE_CAP_INACTIVE;
s->opt[TOPPOS].cap &= ~SANE_CAP_INACTIVE;
s->opt[STOP_SKEW].cap &= ~SANE_CAP_INACTIVE;
s->opt[LENGTHCTL].cap &= ~SANE_CAP_INACTIVE;
s->opt[LONG_PAPER].cap &= ~SANE_CAP_INACTIVE;
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
case FEEDER_MODE:
strcpy (s->val[option].s, val);
if (strcmp (s->val[option].s, SANE_I18N ("continuous")))
{
s->opt[LONG_PAPER].cap |= SANE_CAP_INACTIVE;
}
else
{
s->opt[LONG_PAPER].cap &= ~SANE_CAP_INACTIVE;
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
case MODE:
strcpy (s->val[option].s, val);
if (!strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_LINEART))
{
s->opt[GAMMA_CORRECTION].cap |= SANE_CAP_INACTIVE;
s->opt[COMPRESSION].cap |= SANE_CAP_INACTIVE;
s->opt[COMPRESSION_PAR].cap |= SANE_CAP_INACTIVE;
s->opt[THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
s->opt[HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
s->opt[AUTOMATIC_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
s->opt[WHITE_LEVEL].cap &= ~SANE_CAP_INACTIVE;
s->opt[NOISE_REDUCTION].cap &= ~SANE_CAP_INACTIVE;
s->opt[INVERSE].cap &= ~SANE_CAP_INACTIVE;
s->opt[RED_CHROMA].cap |= SANE_CAP_INACTIVE;
s->opt[BLUE_CHROMA].cap |= SANE_CAP_INACTIVE;
}
else
{
s->opt[COMPRESSION].cap &= ~SANE_CAP_INACTIVE;
s->opt[COMPRESSION_PAR].cap &= ~SANE_CAP_INACTIVE;
s->opt[THRESHOLD].cap |= SANE_CAP_INACTIVE;
s->opt[INVERSE].cap |= SANE_CAP_INACTIVE;
s->opt[HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
s->opt[AUTOMATIC_THRESHOLD].cap |= SANE_CAP_INACTIVE;
s->opt[WHITE_LEVEL].cap |= SANE_CAP_INACTIVE;
s->opt[NOISE_REDUCTION].cap |= SANE_CAP_INACTIVE;
s->opt[RED_CHROMA].cap &= ~SANE_CAP_INACTIVE;
s->opt[BLUE_CHROMA].cap &= ~SANE_CAP_INACTIVE;
}
if (!strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_GRAY))
{
s->opt[INVERSE].cap &= ~SANE_CAP_INACTIVE;
s->opt[GAMMA_CORRECTION].cap &= ~SANE_CAP_INACTIVE;
}
else
{
s->opt[GAMMA_CORRECTION].cap |= SANE_CAP_INACTIVE;
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
case MANUALFEED:
strcpy (s->val[option].s, val);
if (strcmp (s->val[option].s, manual_feed_list[0]) == 0) /* off */
s->opt[FEED_TIMEOUT].cap |= SANE_CAP_INACTIVE;
else
s->opt[FEED_TIMEOUT].cap &= ~SANE_CAP_INACTIVE;
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
case STAPELED_DOC:
strcpy (s->val[option].s, val);
if (strcmp (s->val[option].s, stapeled_list[0]) == 0)
{
s->opt[DBLFEED].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFSTOP].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_L].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_C].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_C].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_R].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_SENCE].cap &= ~SANE_CAP_INACTIVE;
}
else
{
s->opt[DBLFEED].cap |= SANE_CAP_INACTIVE;
s->opt[DFSTOP].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_L].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_C].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_R].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_SENCE].cap |= SANE_CAP_INACTIVE;
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
case DBLFEED:
s->val[option].w = *(SANE_Word *) val;
if (!s->val[option].b)
{
s->opt[DFSTOP].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_L].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_C].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_R].cap |= SANE_CAP_INACTIVE;
s->opt[DFEED_SENCE].cap |= SANE_CAP_INACTIVE;
}
else
{
s->opt[DFSTOP].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_L].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_C].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_C].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_R].cap &= ~SANE_CAP_INACTIVE;
s->opt[DFEED_SENCE].cap &= ~SANE_CAP_INACTIVE;
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
case PAPER_SIZE:
strcpy (s->val[option].s, val);
i = str_index (paper_list, s->val[option].s);
if (i == 0)
{ /*user def */
s->opt[TL_X].cap &=
s->opt[TL_Y].cap &=
s->opt[BR_X].cap &= s->opt[BR_Y].cap &= ~SANE_CAP_INACTIVE;
s->opt[LANDSCAPE].cap |= SANE_CAP_INACTIVE;
s->val[LANDSCAPE].w = 0;
}
else
{
s->opt[TL_X].cap |=
s->opt[TL_Y].cap |=
s->opt[BR_X].cap |= s->opt[BR_Y].cap |= SANE_CAP_INACTIVE;
if ( /*i == 4 || */ i == 5 || i == 6 /*XXX*/
|| i == 10 || i == 11)
{ /*A4, A5, A6, B5, B6 */
if ((s->id == KV_S4085CL || s->id == KV_S4065CL)
&& i == 4 && i == 10)
{ /*A4, B5 */
s->opt[LANDSCAPE].cap |= SANE_CAP_INACTIVE;
s->val[LANDSCAPE].w = 0;
}
else
s->opt[LANDSCAPE].cap &= ~SANE_CAP_INACTIVE;
}
else
{
s->opt[LANDSCAPE].cap |= SANE_CAP_INACTIVE;
s->val[LANDSCAPE].w = 0;
}
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
return SANE_STATUS_GOOD;
case COMPRESSION:
s->val[option].w = *(SANE_Word *) val;
if (!s->val[option].b)
{
s->opt[COMPRESSION_PAR].cap |= SANE_CAP_INACTIVE;
}
else
{
s->opt[COMPRESSION_PAR].cap &= ~SANE_CAP_INACTIVE;
}
if (info)
*info |= SANE_INFO_RELOAD_OPTIONS;
return SANE_STATUS_GOOD;
}
}
return SANE_STATUS_UNSUPPORTED;
}
void
kvs40xx_init_window (struct scanner *s, struct window *wnd, int wnd_id)
{
int paper = str_index (paper_list, s->val[PAPER_SIZE].s), i;
memset (wnd, 0, sizeof (struct window));
copy16 (wnd->window_descriptor_block_length, cpu2be16 (66));
wnd->window_identifier = wnd_id;
copy16 (wnd->x_resolution, cpu2be16 (s->val[RESOLUTION].w));
copy16 (wnd->y_resolution, cpu2be16 (s->val[RESOLUTION].w));
if (!paper)
{
copy32 (wnd->upper_left_x,
cpu2be32 (mm2scanner_units (s->val[TL_X].w)));
copy32 (wnd->upper_left_y,
cpu2be32 (mm2scanner_units (s->val[TL_Y].w)));
copy32 (wnd->document_width,
cpu2be32 (mm2scanner_units (s->val[BR_X].w)));
copy32 (wnd->width,
cpu2be32 (mm2scanner_units (s->val[BR_X].w - s->val[TL_X].w)));
copy32 (wnd->document_length, cpu2be32 (mm2scanner_units
(s->val[BR_Y].w)));
copy32 (wnd->length,
cpu2be32 (mm2scanner_units (s->val[BR_Y].w - s->val[TL_Y].w)));
}
else
{
u32 w = cpu2be32 (mm2scanner_units (paper_sizes[paper].width));
u32 h = cpu2be32 (mm2scanner_units (paper_sizes[paper].height));
copy32 (wnd->upper_left_x, cpu2be32 (mm2scanner_units (0)));
copy32 (wnd->upper_left_y, cpu2be32 (mm2scanner_units (0)));
if (!s->val[LANDSCAPE].b)
{
copy32 (wnd->width, w);
copy32 (wnd->length, h);
copy32 (wnd->document_width, w);
copy32 (wnd->document_length, h);
}
else
{
copy32 (wnd->width, h);
copy32 (wnd->length, w);
copy32 (wnd->document_width, h);
copy32 (wnd->document_length, w);
}
}
wnd->brightness = s->val[BRIGHTNESS].w;
wnd->threshold = s->val[THRESHOLD].w;
wnd->contrast = s->val[CONTRAST].w;
wnd->image_composition = mode_val[str_index (mode_list, s->val[MODE].s)];
wnd->bit_per_pixel = bps_val[str_index (mode_list, s->val[MODE].s)];
copy16 (wnd->halftone_pattern,
cpu2be16 (str_index (halftone_pattern, s->val[HALFTONE_PATTERN].s)));
wnd->rif_padding = s->val[INVERSE].b << 7;
copy16 (wnd->bit_ordering, cpu2be16 (BIT_ORDERING));
wnd->compression_type = s->val[COMPRESSION].b ? 0x81 : 0;
wnd->compression_argument = s->val[COMPRESSION_PAR].w;
wnd->vendor_unique_identifier = 0;
wnd->nobuf_fstspeed_dfstop = str_index (source_list,
s->val[SOURCE].s) << 7 |
str_index (stapeled_list,
s->val[STAPELED_DOC].s) << 5 |
s->val[STOP_SKEW].b << 4 | s->val[CROP].b << 3 | s->val[DFSTOP].b << 0;
wnd->mirror_image = s->val[MIRROR].b << 7 |
s->val[DFEED_L].b << 2 | s->val[DFEED_C].b << 1 | s->val[DFEED_R].b << 0;
wnd->image_emphasis = str_index (image_emphasis_list,
s->val[IMAGE_EMPHASIS].s);
wnd->gamma_correction = gamma_val[str_index (gamma_list,
s->val[GAMMA_CORRECTION].s)];
wnd->mcd_lamp_dfeed_sens =
str_index (lamp_list, s->val[LAMP].s) << 4 |
str_index (dfeed_sence_list, s->val[DFEED_SENCE].s);
wnd->document_size = (paper != 0) << 7
| s->val[LENGTHCTL].b << 6
| s->val[LONG_PAPER].b << 5 | s->val[LANDSCAPE].b << 4 | paper_val[paper];
wnd->ahead_deskew_dfeed_scan_area_fspeed_rshad =
(s->val[DESKEW].b || s->val[CROP].b ? 2 : 0) << 5 | /*XXX*/
s->val[DBLFEED].b << 4 | s->val[FIT_TO_PAGE].b << 2;
wnd->continuous_scanning_pages =
str_index (feeder_mode_list, s->val[FEEDER_MODE].s) ? 0xff : 0;
wnd->automatic_threshold_mode = automatic_threshold_val
[str_index (automatic_threshold_list, s->val[AUTOMATIC_THRESHOLD].s)];
wnd->automatic_separation_mode = 0; /*Does not supported */
wnd->standard_white_level_mode =
white_level_val[str_index (white_level_list, s->val[WHITE_LEVEL].s)];
wnd->b_wnr_noise_reduction =
str_index (noise_reduction_list, s->val[NOISE_REDUCTION].s);
i = str_index (manual_feed_list, s->val[MANUALFEED].s);
wnd->mfeed_toppos_btmpos_dsepa_hsepa_dcont_rstkr = i << 6 |
s->val[TOPPOS].b << 5 | s->val[BTMPOS].b << 4;
wnd->stop_mode = 1;
wnd->red_chroma = s->val[RED_CHROMA].w;
wnd->blue_chroma = s->val[BLUE_CHROMA].w;
}
int is_o(char *filename)
{
if(str_index(filename, ".o") != -1)
return(1);
return(0);
}
int print_output(char **output, int i, char **argv, int argc)
{
//stat files
struct stat buf;
int exists;
int x;
for(x = 0; x < i; x++)
{
exists = stat(output[x], &buf);
if (exists < 0)
{
fprintf(stderr, "%s not found\n", output[x]);
}
else
{
////////////get the argument
int arge = find_arg_element(argv, argc);
char* ls_arg;
ls_arg = (char*)malloc(MAX_BUFFER_SIZE);
if(arge != -1)
ls_arg = strdup(argv[arge]);
else
ls_arg = "";
/////////////filter arguments
// l option
char *l_opt;
l_opt = (char*)malloc(MAX_BUFFER_SIZE);
if(str_index(ls_arg, "l") != -1)
{
//convert stat's date
time_t rawtime = buf.st_mtime;
char *date = ctime(&rawtime);
//get rid of end newline
date[strlen(date) - 1] = '\0';
int read, write, execute;
read = buf.st_mode & S_IEXEC;
read = (int)read;
//read = sqrt(read) - 1;
sprintf(l_opt, "%4d %d %d %4d %5d %s",
buf.st_mode, buf.st_nlink, buf.st_uid,
buf.st_gid, buf.st_size, date);
}
else
{l_opt = "";}
// t option
char *t_opt;
t_opt = (char*)malloc(MAX_BUFFER_SIZE);
if(str_index(ls_arg, "t") != -1)
{
//convert stat's date
time_t rawtime = buf.st_mtime;
char *date = ctime(&rawtime);
//get rid of end newline
date[strlen(date) - 1] = '\0';
sprintf(t_opt, "%s", date);
}
else
{t_opt = "";}
// f option
char *f_opt;
f_opt = (char*)malloc(MAX_BUFFER_SIZE);
if(str_index(ls_arg, "f") != -1)
{
//open file and see what its first bits look like
FILE *fp;
fp = fopen(output[x], "r");
char line [MAX_BUFFER_SIZE];
if(fp != NULL)
{
if(fgets(line, sizeof(line), fp ) != NULL)
{
//fputs ( line, stdout );
//print_ts_str(line);
if(is_o(output[x]) == 1)
f_opt = " - Relocatable .o file";
else if(is_elf(line) == 1)
f_opt = " - ELF File";
else if(is_dos(fp) == 1)
f_opt = " - ASCII File";
else if(is_ascii(fp) == 1)
f_opt = " - ASCII File";
else
f_opt = " - file unknow";
}
else
f_opt = " - directory";
}
fclose(fp);
}
else
{f_opt = "";}
//print formatted text
printf("%s %s %10s %s\n", t_opt, l_opt, output[x], f_opt);
}
}
return(0);
}