/* <angle> <matrix> rotate <matrix> */ static int zrotate(i_ctx_t *i_ctx_p) { os_ptr op = osp; int code; double ang; if ((code = real_param(op, &ang)) >= 0) { code = gs_rotate(igs, ang); if (code < 0) return code; } else { /* matrix operand */ gs_matrix mat; /* The num_params failure might be a stack underflow. */ check_op(1); if ((code = num_params(op - 1, 1, &ang)) < 0 || (code = gs_make_rotation(ang, &mat)) < 0 || (code = write_matrix(op, &mat)) < 0 ) { /* Might be a stack underflow. */ check_op(2); return code; } op[-1] = *op; } pop(1); return code; }
/* <sx> <sy> <matrix> scale <matrix> */ static int zscale(i_ctx_t *i_ctx_p) { os_ptr op = osp; int code; double scale[2]; if ((code = num_params(op, 2, scale)) >= 0) { code = gs_scale(igs, scale[0], scale[1]); if (code < 0) return code; } else { /* matrix operand */ gs_matrix mat; /* The num_params failure might be a stack underflow. */ check_op(2); if ((code = num_params(op - 1, 2, scale)) < 0 || (code = gs_make_scaling(scale[0], scale[1], &mat)) < 0 || (code = write_matrix(op, &mat)) < 0 ) { /* Might be a stack underflow. */ check_op(3); return code; } op[-2] = *op; } pop(2); return code; }
static int zrunandhide(i_ctx_t *i_ctx_p) { os_ptr op = osp; es_ptr ep; check_op(2); if (!r_is_array(op - 1)) return_op_typecheck(op); if (!r_has_attr(op, a_executable)) return 0; /* literal object just gets pushed back */ check_estack(5); ep = esp += 5; make_mark_estack(ep - 4, es_other, err_end_runandhide); /* error case */ make_op_estack(ep - 1, end_runandhide); /* normal case */ ref_assign(ep, op); /* Store the object we are hiding and it's current tas.type_attrs */ /* on the exec stack then change to 'noaccess' */ make_int(ep - 3, (int)op[-1].tas.type_attrs); ref_assign(ep - 2, op - 1); r_clear_attrs(ep - 2, a_all); /* replace the array with a special kind of mark that has a_read access */ esfile_check_cache(); pop(2); return o_push_estack; }
/* <result> <mask> .stop - */ static int zzstop(i_ctx_t *i_ctx_p) { os_ptr op = osp; uint count; check_type(*op, t_integer); count = count_to_stopped(i_ctx_p, op->value.intval); if (count) { /* * If there are any t_oparrays on the e-stack, they will pop * any new items from the o-stack. Wait to push the result * until we have run all the unwind procedures. */ ref save_result; check_op(2); save_result = op[-1]; pop(2); pop_estack(i_ctx_p, count); op = osp; push(1); *op = save_result; return o_pop_estack; } /* No mark, quit. (per Adobe documentation) */ return unmatched_exit(op, zzstop); }
int main(int ac, char **av) { bool help = false; bool verbose = check_op(ac, av, help); if (!help) { if (!(optind < ac)) readIn(verbose); else { for (; optind < ac; optind += 1) { std::cout << "--- --- --- ---" << std::endl << " Debut du fichier " << av[optind] << ": " << std::endl << "--- --- --- ---" << std::endl; readOut(av[optind], verbose); std::cout << "--- --- --- ---" << std::endl << " Fin du fichier " << av[optind] << "." << std::endl << "--- --- --- ---" << std::endl; } } } return (0); }
/* <obj> <typenames> .type <name> */ static int ztype(i_ctx_t *i_ctx_p) { os_ptr op = osp; ref tnref; int code = array_get(imemory, op, (long)r_btype(op - 1), &tnref); if (code < 0) return code; if (!r_has_type(&tnref, t_name)) { /* Must be either a stack underflow or a t_[a]struct. */ check_op(2); { /* Get the type name from the structure. */ const char *sname = gs_struct_type_name_string(gs_object_type(imemory, op[-1].value.pstruct)); int code = name_ref(imemory, (const byte *)sname, strlen(sname), (ref *) (op - 1), 0); if (code < 0) return code; } r_set_attrs(op - 1, a_executable); } else { ref_assign(op - 1, &tnref); } pop(1); return 0; }
/* <key> where false */ int zwhere(i_ctx_t *i_ctx_p) { os_ptr op = osp; ref_stack_enum_t rsenum; check_op(1); ref_stack_enum_begin(&rsenum, &d_stack); do { const ref *const bot = rsenum.ptr; const ref *pdref = bot + rsenum.size; ref *pvalue; int code; while (pdref-- > bot) { check_dict_read(*pdref); code = dict_find(pdref, op, &pvalue); if (code < 0 && code != e_dictfull) return code; if (code > 0) { push(1); ref_assign(op - 1, pdref); make_true(op); return 0; } } } while (ref_stack_enum_next(&rsenum)); make_false(op); return 0; }
/* <obj1> ... <objn> <n> .execn - */ static int zexecn(i_ctx_t *i_ctx_p) { os_ptr op = osp; uint n, i; es_ptr esp_orig; check_int_leu(*op, max_uint - 1); n = (uint) op->value.intval; check_op(n + 1); check_estack(n); esp_orig = esp; for (i = 0; i < n; ++i) { const ref *rp = ref_stack_index(&o_stack, (long)(i + 1)); /* Make sure this object is legal to execute. */ if (ref_type_uses_access(r_type(rp))) { if (!r_has_attr(rp, a_execute) && r_has_attr(rp, a_executable) ) { esp = esp_orig; return_error(e_invalidaccess); } } /* Executable nulls have a special meaning on the e-stack, */ /* so since they are no-ops, don't push them. */ if (!r_has_type_attrs(rp, t_null, a_executable)) { ++esp; ref_assign(esp, rp); } } esfile_check_cache(); pop(n + 1); return o_push_estack; }
static bool check_ipa_store (gimple stmt ATTRIBUTE_UNUSED, tree op, void *data) { if (DECL_P (op)) check_decl ((funct_state)data, op, true, true); else check_op ((funct_state)data, op, true); return false; }
static bool check_ipa_load (gimple, tree op, tree, void *data) { if (DECL_P (op)) check_decl ((funct_state)data, op, false, true); else check_op ((funct_state)data, op, false); return false; }
/* <obj> xcheck <bool> */ static int zxcheck(i_ctx_t *i_ctx_p) { os_ptr op = osp; check_op(1); make_bool(op, (r_has_attr(ACCESS_REF(op), a_executable) ? 1 : 0)); return 0; }
/* <obj> <int> .quit - */ static int zquit(i_ctx_t *i_ctx_p) { os_ptr op = osp; check_op(2); check_type(*op, t_integer); return_error(e_Quit); /* Interpreter will do the exit */ }
/* <obj:array|packedarray|file|string> executeonly <obj> */ static int zexecuteonly(i_ctx_t *i_ctx_p) { os_ptr op = osp; check_op(1); if (r_has_type(op, t_dictionary)) return_error(e_typecheck); return access_check(i_ctx_p, a_execute, true); }
/* <obj1> <obj2> eq <bool> */ int zeq(i_ctx_t *i_ctx_p) { os_ptr op = osp; EQ_CHECK_READ(op - 1, check_op(2)); EQ_CHECK_READ(op, DO_NOTHING); make_bool(op - 1, (obj_eq(imemory, op - 1, op) ? 1 : 0)); pop(1); return 0; }
/* Common logic for [i][d]transform */ static int common_transform(i_ctx_t *i_ctx_p, int (*ptproc)(gs_state *, double, double, gs_point *), int (*matproc)(double, double, const gs_matrix *, gs_point *)) { os_ptr op = osp; double opxy[2]; gs_point pt; int code; /* Optimize for the non-matrix case */ switch (r_type(op)) { case t_real: opxy[1] = op->value.realval; break; case t_integer: opxy[1] = (double)op->value.intval; break; case t_array: /* might be a matrix */ case t_shortarray: case t_mixedarray: { gs_matrix mat; gs_matrix *pmat = &mat; if ((code = read_matrix(imemory, op, pmat)) < 0 || (code = num_params(op - 1, 2, opxy)) < 0 || (code = (*matproc) (opxy[0], opxy[1], pmat, &pt)) < 0 ) { /* Might be a stack underflow. */ check_op(3); return code; } op--; pop(1); goto out; } default: return_op_typecheck(op); } switch (r_type(op - 1)) { case t_real: opxy[0] = (op - 1)->value.realval; break; case t_integer: opxy[0] = (double)(op - 1)->value.intval; break; default: return_op_typecheck(op - 1); } if ((code = (*ptproc) (igs, opxy[0], opxy[1], &pt)) < 0) return code; out: make_real(op - 1, pt.x); make_real(op, pt.y); return 0; }
/* <obj> cvlit <obj> */ static int zcvlit(i_ctx_t *i_ctx_p) { os_ptr op = osp; ref *aop; check_op(1); aop = ACCESS_REF(op); r_clear_attrs(aop, a_executable); return 0; }
/* <any> <string> cvs <substring> */ static int zcvs(i_ctx_t *i_ctx_p) { os_ptr op = osp; int code; check_write_type(*op, t_string); check_op(2); code = convert_to_string(imemory, op - 1, op); if (code >= 0) pop(1); return code; }
/* * Continuation for procedure data source. We use the topmost aliasing slot * to remember whether we've just called the procedure (1) or whether we're * returning from a RemapColor callout (0). */ static int image_proc_continue(i_ctx_t *i_ctx_p) { os_ptr op = osp; gs_image_enum *penum = r_ptr(esp, gs_image_enum); int px = ETOP_PLANE_INDEX(esp)->value.intval; int num_sources = ETOP_NUM_SOURCES(esp)->value.intval; uint size, used[gs_image_max_planes]; gs_const_string plane_data[gs_image_max_planes]; const byte *wanted; int i, code; if (!r_has_type_attrs(op, t_string, a_read)) { check_op(1); /* Procedure didn't return a (readable) string. Quit. */ esp = zimage_pop_estack(esp); image_cleanup(i_ctx_p); return_error(!r_has_type(op, t_string) ? e_typecheck : e_invalidaccess); } size = r_size(op); if (size == 0 && ETOP_SOURCE(esp, 0)[1].value.intval == 0) code = 1; else { for (i = 0; i < num_sources; i++) plane_data[i].size = 0; plane_data[px].data = op->value.bytes; plane_data[px].size = size; code = gs_image_next_planes(penum, plane_data, used); if (code == e_RemapColor) { op->value.bytes += used[px]; /* skip used data */ r_dec_size(op, used[px]); ETOP_SOURCE(esp, 0)[1].value.intval = 0; /* RemapColor callout */ return code; } } if (code) { /* Stop now. */ esp = zimage_pop_estack(esp); pop(1); image_cleanup(i_ctx_p); return (code < 0 ? code : o_pop_estack); } pop(1); wanted = gs_image_planes_wanted(penum); do { if (++px == num_sources) px = 0; } while (!wanted[px]); ETOP_PLANE_INDEX(esp)->value.intval = px; return image_proc_process(i_ctx_p); }
/* <obj> <result> <mask> .stopped <result> */ static int zzstopped(i_ctx_t *i_ctx_p) { os_ptr op = osp; check_type(*op, t_integer); check_op(3); /* Mark the execution stack, and push the default result */ /* in case control returns normally. */ check_estack(5); push_mark_estack(es_stopped, no_cleanup); *++esp = op[-1]; /* save the result */ *++esp = *op; /* save the signal mask */ push_op_estack(stopped_push); push_op_estack(zexec); /* execute the operand */ pop(2); return o_push_estack; }
/* the stacks would get restored in case of an error. */ static int zstopped(i_ctx_t *i_ctx_p) { os_ptr op = osp; check_op(1); /* Mark the execution stack, and push the default result */ /* in case control returns normally. */ check_estack(5); push_mark_estack(es_stopped, no_cleanup); ++esp; make_false(esp); /* save the result */ ++esp; make_int(esp, 1); /* save the signal mask */ push_op_estack(stopped_push); push_op_estack(zexec); /* execute the operand */ return o_push_estack; }
/* v [ws wd bs bd] proc -> -mark- ws wd bs bd v proc + exec */ static int cie_exec_tpqr(i_ctx_t *i_ctx_p) { os_ptr op = osp; const ref *ppt = op[-1].value.const_refs; uint space = r_space(op - 1); int i; check_op(3); push(4); *op = op[-4]; /* proc */ op[-1] = op[-6]; /* v */ for (i = 0; i < 4; i++) make_const_array(op - 5 + i, a_readonly | space, 6, ppt + i * 6); make_mark(op - 6); return zexec(i_ctx_p); }
/* but not for dictionaries (see zcopy_dict in zdict.c). */ int zcopy(i_ctx_t *i_ctx_p) { os_ptr op = osp; int type = r_type(op); if (type == t_integer) return zcopy_integer(i_ctx_p); check_op(2); switch (type) { case t_array: case t_string: return zcopy_interval(i_ctx_p); case t_dictionary: return zcopy_dict(i_ctx_p); default: return_op_typecheck(op); } }
static int zsuperexec(i_ctx_t *i_ctx_p) { os_ptr op = osp; es_ptr ep; check_op(1); if (!r_has_attr(op, a_executable)) return 0; /* literal object just gets pushed back */ check_estack(2); ep = esp += 3; make_mark_estack(ep - 2, es_other, end_superexec); /* error case */ make_op_estack(ep - 1, end_superexec); /* normal case */ ref_assign(ep, op); esfile_check_cache(); pop(1); i_ctx_p->in_superexec++; return o_push_estack; }
static inline jl_value_t *jl_intrinsic_cvt(jl_value_t *ty, jl_value_t *a, const char *name, intrinsic_cvt_t op, intrinsic_cvt_check_t check_op) { jl_value_t *aty = jl_typeof(a); if (!jl_is_bitstype(aty)) jl_errorf("%s: value is not a bitstype", name); if (!jl_is_bitstype(ty)) jl_errorf("%s: type is not a bitstype", name); void *pa = jl_data_ptr(a); unsigned isize = jl_datatype_size(aty); unsigned osize = jl_datatype_size(ty); if (check_op && check_op(isize, osize, pa)) jl_throw(jl_inexact_exception); jl_value_t *newv = newstruct((jl_datatype_t*)ty); op(aty == (jl_value_t*)jl_bool_type ? 1 : isize * host_char_bit, pa, osize * host_char_bit, jl_data_ptr(newv)); if (ty == (jl_value_t*)jl_bool_type) return *(uint8_t*)jl_data_ptr(newv) & 1 ? jl_true : jl_false; return newv; }
/* <obj> exec - */ int zexec(i_ctx_t *i_ctx_p) { os_ptr op = osp; int code; check_op(1); code = check_for_exec(op); if (code < 0) { return code; } if (!r_has_attr(op, a_executable)) { return 0; /* shortcut, literal object just gets pushed back */ } check_estack(1); ++esp; ref_assign(esp, op); esfile_check_cache(); pop(1); return o_push_estack; }
/* <obj> cvx <obj> */ int zcvx(i_ctx_t *i_ctx_p) { os_ptr op = osp; ref *aop; uint opidx; check_op(1); /* * If the object is an internal operator, we can't allow it to * exist in executable form anywhere outside the e-stack. */ if (r_has_type(op, t_operator) && ((opidx = op_index(op)) == 0 || op_def_is_internal(op_index_def(opidx))) ) return_error(e_rangecheck); aop = ACCESS_REF(op); r_set_attrs(aop, a_executable); return 0; }
static int search_epur(int s, char *ret, char *line, t_sh *term) { t_epur e; e.i = -1; e.f = 0; e.j = 0; while (line[++e.i]) { if (line[e.i] != ' ' && line[e.i] != '\t' && line[e.i] != '\n') fsretj(&e, &ret, &s, line[e.i]); else if (line[e.i + 1] && line[e.i + 1] != ' ' && line[e.i + 1] != '\t' && line[e.i + 1] != '\n') { if (e.i && !check_op(term->ope, line[e.i + 1]) && !rev_srch(term->ope, line, e.i)) fsretj(&e, &ret, &s, ' '); } } if (ret) ret[e.j] = '\0'; return (s); }
void cmd_user(t_message *msg, t_client *client) { if (msg == NULL || client == NULL) return; if (get_nb_params(msg->params) != 4) { dprintf(client->client, ERR_NEEDMOREPARAMS, S_NAME, S_ADDR, \ client->nick, "USER"); return; } if (client->isAuth >= 3 || client->isAuth == 1) { dprintf(client->client, ERR_ALREADYREGISTRED, S_NAME, S_ADDR, \ client->nick); return; } strcpy(client->user, msg->params[0]); strcpy(client->rname, msg->params[3]); if (client->isAuth == 0) client->isAuth = 1; else if (client->isAuth == 2) auth_client(client); check_op(client); }
/* <obj:array|packedarray|dict|file|string> noaccess <obj> */ static int znoaccess(i_ctx_t *i_ctx_p) { os_ptr op = osp; check_op(1); if (r_has_type(op, t_dictionary)) { ref *aop = dict_access_ref(op); /* CPSI throws invalidaccess when seting noaccess to a readonly dictionary (CET 13-13-6) : */ if (!r_has_attrs(aop, a_write)) { if (!r_has_attrs(aop, a_read) && !r_has_attrs(aop, a_execute)) { /* Already noaccess - do nothing (CET 24-09-1). */ return 0; } return_error(e_invalidaccess); } /* Don't allow removing read access to permanent dictionaries. */ if (dict_is_permanent_on_dstack(op)) return_error(e_invalidaccess); } return access_check(i_ctx_p, 0, true); }
int main( int argc, char **argv) { int c; int errflg = 0; char *errmsg; #define MAX_OPTARG_LEN 256 #define MAX_RESOURCE_NAME_LEN 256 char optargout[MAX_OPTARG_LEN+1]; char resource_name[MAX_RESOURCE_NAME_LEN+1]; enum batch_op op; enum batch_op *pop = &op; struct attropl *select_list = 0; static char destination[PBS_MAXROUTEDEST+1] = ""; char server_out[MAXSERVERNAME] = ""; char *queue_name_out; char *server_name_out; int connect; char **selectjob_list; char *res_pos; char *pc; int u_cnt, o_cnt, s_cnt, n_cnt; time_t after; char a_value[80]; int exec_only = 0; if (getenv("PBS_QSTAT_EXECONLY") != NULL) exec_only = 1; #define GETOPT_ARGS "a:A:ec:h:l:N:p:q:r:s:u:" while ((c = getopt(argc, argv, GETOPT_ARGS)) != EOF) switch (c) { case 'a': check_op(optarg, pop, optargout); if ((after = cvtdate(optargout)) < 0) { fprintf(stderr, "qselect: illegal -a value\n"); errflg++; break; } sprintf(a_value, "%ld", (long)after); set_attrop(&select_list, ATTR_a, NULL, a_value, op); break; case 'e': exec_only = 1; break; case 'c': check_op(optarg, pop, optargout); pc = optargout; while (isspace((int)*pc)) pc++; if (strlen(pc) == 0) { fprintf(stderr, "qselect: illegal -c value\n"); errflg++; break; } if (strcmp(pc, "u") == 0) { if ((op != EQ) && (op != NE)) { fprintf(stderr, "qselect: illegal -c value\n"); errflg++; break; } } else if ((strcmp(pc, "n") != 0) && (strcmp(pc, "s") != 0) && (strcmp(pc, "c") != 0)) { if (strncmp(pc, "c=", 2) != 0) { fprintf(stderr, "qselect: illegal -c value\n"); errflg++; break; } pc += 2; if (strlen(pc) == 0) { fprintf(stderr, "qselect: illegal -c value\n"); errflg++; break; } while (*pc != '\0') { if (!isdigit((int)*pc)) { fprintf(stderr, "qselect: illegal -c value\n"); errflg++; break; } pc++; } } set_attrop(&select_list, ATTR_c, NULL, optargout, op); break; case 'h': check_op(optarg, pop, optargout); pc = optargout; while (isspace((int)*pc)) pc++; if (strlen(pc) == 0) { fprintf(stderr, "qselect: illegal -h value\n"); errflg++; break; } u_cnt = o_cnt = s_cnt = n_cnt = 0; while (*pc) { if (*pc == 'u') u_cnt++; else if (*pc == 'o') o_cnt++; else if (*pc == 's') s_cnt++; else if (*pc == 'n') n_cnt++; else { fprintf(stderr, "qselect: illegal -h value\n"); errflg++; break; } pc++; } if (n_cnt && (u_cnt + o_cnt + s_cnt)) { fprintf(stderr, "qselect: illegal -h value\n"); errflg++; break; } set_attrop(&select_list, ATTR_h, NULL, optargout, op); break; case 'l': res_pos = optarg; while (*res_pos != '\0') { if (check_res_op(res_pos, resource_name, pop, optargout, &res_pos) != 0) { errflg++; break; } set_attrop(&select_list, ATTR_l, resource_name, optargout, op); } break; case 'p': check_op(optarg, pop, optargout); set_attrop(&select_list, ATTR_p, NULL, optargout, op); break; case 'q': strncpy(destination, optarg, PBS_MAXROUTEDEST); check_op(optarg, pop, optargout); set_attrop(&select_list, ATTR_q, NULL, optargout, op); break; case 'r': op = EQ; pc = optarg; while (isspace((int)(*pc))) pc++; if (strlen(pc) != 1) { fprintf(stderr, "qsub: illegal -r value\n"); errflg++; break; } if (*pc != 'y' && *pc != 'n') { fprintf(stderr, "qsub: illegal -r value\n"); errflg++; break; } set_attrop(&select_list, ATTR_r, NULL, pc, op); break; case 's': check_op(optarg, pop, optargout); pc = optargout; while (isspace((int)(*pc))) pc++; if (strlen(optarg) == 0) { fprintf(stderr, "qselect: illegal -s value\n"); errflg++; break; } while (*pc) { if (*pc != 'C' && *pc != 'E' && *pc != 'H' && *pc != 'Q' && *pc != 'R' && *pc != 'T' && *pc != 'W') { fprintf(stderr, "qselect: illegal -s value\n"); errflg++; break; } pc++; } set_attrop(&select_list, ATTR_state, NULL, optargout, op); break; case 'u': op = EQ; if (parse_at_list(optarg, FALSE, FALSE)) { fprintf(stderr, "qselect: illegal -u value\n"); errflg++; break; } set_attrop(&select_list, ATTR_u, NULL, optarg, op); break; case 'A': op = EQ; set_attrop(&select_list, ATTR_A, NULL, optarg, op); break; case 'N': op = EQ; set_attrop(&select_list, ATTR_N, NULL, optarg, op); break; default : errflg++; } if (errflg || (optind < argc)) { static char usage[] = "usage: qselect \ [-a [op]date_time] [-A account_string] [-e] [-c [op]interval] \n\ [-h hold_list] [-l resource_list] [-N name] [-p [op]priority] \n\ [-q destination] [-r y|n] [-s states] [-u user_name]\n"; fprintf(stderr,"%s", usage); exit(2); } if (notNULL(destination)) { if (parse_destination_id(destination, &queue_name_out, &server_name_out)) { fprintf(stderr, "qselect: illegally formed destination: %s\n", destination); exit(2); } else { if (notNULL(server_name_out)) { strcpy(server_out, server_name_out); } } } connect = cnt2server(server_out); if (connect <= 0) { fprintf(stderr, "qselect: cannot connect to server %s (errno=%d) %s\n", pbs_server, pbs_errno, pbs_strerror(pbs_errno)); exit(pbs_errno); } selectjob_list = pbs_selectjob(connect, select_list, exec_only ? EXECQUEONLY : NULL); if (selectjob_list == NULL) { if (pbs_errno != PBSE_NONE) { errmsg = pbs_geterrmsg(connect); if (errmsg != NULL) { fprintf(stderr, "qselect: %s\n", errmsg); } else { fprintf(stderr, "qselect: Error (%d - %s) selecting jobs\n", pbs_errno, pbs_strerror(pbs_errno)); } exit(pbs_errno); } } else /* got some jobs ids */ { int i = 0; while (selectjob_list[i] != NULL) { printf("%s\n", selectjob_list[i++]); } free(selectjob_list); } pbs_disconnect(connect); exit(0); }