void
KeyAxisEventHandler::send(int value, int min, int max)
{
int old_zone = get_zone(to_float(m_old_value, min, max));
int zone = get_zone(to_float(value, min, max));
if (old_zone != zone)
{
// release the keys of the zone we leave
if (old_zone == -1)
{
m_up_codes.send(false);
}
else if (old_zone == +1)
{
m_down_codes.send(false);
}
// press the keys of the zone we enter
if (zone == +1)
{
m_down_codes.send(true);
}
else if (zone == -1)
{
m_up_codes.send(true);
}
}
m_old_value = value;
}
void
KeyAxisEventHandler::send(int value)
{
int old_zone = get_zone(m_old_value);
int zone = get_zone(value);
if (old_zone != zone)
{
// release the keys of the zone we leave
if (old_zone == -1)
{
send_up(false);
}
else if (old_zone == +1)
{
send_down(false);
}
// press the keys of the zone we enter
if (zone == +1)
{
send_down(true);
}
else if (zone == -1)
{
send_up(true);
}
}
m_old_value = value;
}
static int cmd_zone_show(int argc, char *argv[])
{
if (argc != 1) {
error("Name of one zone has to be specified.");
return 1;
}
char *zone_name = argv[0];
_cleanup_kasp_ dnssec_kasp_t *kasp = get_kasp();
if (!kasp) {
return 1;
}
_cleanup_zone_ dnssec_kasp_zone_t *zone = get_zone(kasp, zone_name);
if (!zone) {
return 1;
}
printf("zone: %s\n", zone_name);
const char *policy = dnssec_kasp_zone_get_policy(zone);
printf("policy: %s\n", policy ? policy : "(not set)");
printf("keys: %zu\n", dnssec_list_size(dnssec_kasp_zone_get_keys(zone)));
return 0;
}
void free(void* ptr) {
chunk_header_t* chunk;
chunk_header_t* next_chunk;
chunk_header_t* prev_chunk;
chunk_header_t* current_chunk;
chunk_header_t** chunk_header;
if (ptr) {
chunk = (void*) ptr - 8;
next_chunk = get_next_chunk(chunk);
prev_chunk = get_prev_chunk(chunk);
gHeapRemaining += chunk->size * 8;
if (chunk == next_chunk || chunk == prev_chunk
|| get_prev_chunk(next_chunk) != chunk
|| get_next_chunk(prev_chunk) != chunk
|| chunk->prev_size & 1) {
puts("Heap Error\n");
}
chunk->prev_size |= 1;
if ((chunk->prev_size << 30) < 0) {
*prev_chunk->head = prev_chunk->next;
if(prev_chunk->next) {
prev_chunk->next->head = prev_chunk->head;
}
prev_chunk->size += chunk->size;
chunk->size = 0;
chunk->prev_size &= 3u;
chunk = prev_chunk;
}
if ((next_chunk->prev_size << 31) < 0) {
*next_chunk->head = next_chunk->next;
if(next_chunk->next) {
next_chunk->next->head = next_chunk->head;
}
chunk->size += next_chunk->size;
next_chunk->size = 0;
next_chunk->prev_size &= 3u;
}
next_chunk->prev_size |= 2;
next_chunk->prev_size = (next_chunk->prev_size & 3) | (4 * chunk->size);
chunk_header = &gHeapHeader[get_zone(chunk->size * 8)];
current_chunk = *chunk_header;
chunk->head = chunk_header;
chunk->next = current_chunk;
if(current_chunk) {
current_chunk->head = &chunk;
}
*chunk_header = chunk;
}
}
inline void wamp_publish_message::set_arguments(const msgpack::object& arguments)
{
if (arguments.type == msgpack::type::NIL || arguments.type == msgpack::type::ARRAY) {
m_arguments = msgpack::object(arguments, get_zone());
} else {
throw std::invalid_argument("invalid arguments");
}
}
inline void wamp_event_message::set_details(const msgpack::object& details)
{
if (details.type == msgpack::type::MAP) {
m_details = msgpack::object(details, get_zone());
} else {
throw std::invalid_argument("invalid details");
}
}
inline void wamp_publish_message::set_options(const msgpack::object& options)
{
if (options.type == msgpack::type::MAP) {
m_options = msgpack::object(options, get_zone());
} else {
throw std::invalid_argument("invalid options");
}
}
inline void wamp_publish_message::set_arguments_kw(const msgpack::object& arguments_kw)
{
if (arguments_kw.type == msgpack::type::NIL || arguments_kw.type == msgpack::type::MAP) {
m_arguments_kw = msgpack::object(arguments_kw, get_zone());
} else {
throw std::invalid_argument("invalid arguments_kw");
}
}
/*
* Function: func_v13
* --------------------
* Вычисляет сумму квадратов отрицательных чисел, на заданном участке матрицы
*
* arr: Матрица
* n: Порядок матрицы
* zone: Участок для подсчета в виде битовой маски
*
* returns: сумму квадратов отрицательных чисел
*/
UINT64 func_v13(int* arr, size_t n, UINT16 zone)
{
UINT64 sum = 0;
size_t i, j;
for (i = 0; i < n; ++i)
{
for (j = 0; j < n; ++j)
{
if (zone & get_zone(i, j, n))
{
if (*(arr + i * MAX_SIZE + j) < 0)
sum += (UINT64)pow(*(arr + i * MAX_SIZE + j), 2);
}
}
}
return sum;
}
/*
* Function: print_array
* --------------------
* Печатает все элементы матрицы и подсвечивает элементы на заданном участке
*
* arr: Матрица
* n: Порядок матрицы
* zone: Участок для подсветки в виде битовой маски
* width: Ширина ячеек
*/
void print_array(int* arr, size_t n, UINT16 zone, UINT8 width)
{
size_t i, j;
for (i = 0; i < n; ++i)
{
for (j = 0; j < n; ++j)
{
if (get_zone(i, j, n) & zone)
{
SetConsoleTextAttribute(hConsole, HIGHLIGHT_COLOR);
printf("%*d", width, *(arr + i * MAX_SIZE + j));
SetConsoleTextAttribute(hConsole, currentConsoleAttr);
}
else
printf("%*d", width, *(arr + i * MAX_SIZE + j));
}
printf("\n");
}
}
void ft_free_all(void)
{
int i;
t_pr_alloc *zone;
i = 0;
while (i < SIZE_RANGE)
{
zone = get_zone(INDEX, i);
while (zone->data != NULL)
{
if (zone->size_ptr == LARGE_SIZE)
{
wipe_large_ptr(zone->data);
}
destroy_data_field(zone->data, zone);
}
i++;
}
}
void ft_free(void *ptr)
{
t_info_ptr mllc_ptr;
if (ptr == NULL)
print_log("ERROR : NULL pointer\n");
mllc_ptr = search_in_all_zones(ptr);
if (mllc_ptr.addr != NULL)
{
liberation(mllc_ptr);
if (mllc_ptr.data->count == 0 && mllc_ptr.data->prec != NULL)
{
destroy_data_field(mllc_ptr.data,
get_zone(GET, mllc_ptr.size_ptr));
}
}
else
{
dprintf(2, "ERROR : pointer was already free or not allocated\n");
}
}
static void
PyInit_timezone(PyObject *m) {
/* This code moved from PyInit_time wholesale to allow calling it from
time_tzset. In the future, some parts of it can be moved back
(for platforms that don't HAVE_WORKING_TZSET, when we know what they
are), and the extraneous calls to tzset(3) should be removed.
I haven't done this yet, as I don't want to change this code as
little as possible when introducing the time.tzset and time.tzsetwall
methods. This should simply be a method of doing the following once,
at the top of this function and removing the call to tzset() from
time_tzset():
#ifdef HAVE_TZSET
tzset()
#endif
And I'm lazy and hate C so nyer.
*/
#if defined(HAVE_TZNAME) && !defined(__GLIBC__) && !defined(__CYGWIN__)
PyObject *otz0, *otz1;
tzset();
PyModule_AddIntConstant(m, "timezone", timezone);
#ifdef HAVE_ALTZONE
PyModule_AddIntConstant(m, "altzone", altzone);
#else
PyModule_AddIntConstant(m, "altzone", timezone-3600);
#endif
PyModule_AddIntConstant(m, "daylight", daylight);
otz0 = PyUnicode_DecodeLocale(tzname[0], "surrogateescape");
otz1 = PyUnicode_DecodeLocale(tzname[1], "surrogateescape");
PyModule_AddObject(m, "tzname", Py_BuildValue("(NN)", otz0, otz1));
#else /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
{
#define YEAR ((time_t)((365 * 24 + 6) * 3600))
time_t t;
struct tm p;
long janzone, julyzone;
char janname[10], julyname[10];
t = (time((time_t *)0) / YEAR) * YEAR;
_PyTime_localtime(t, &p);
get_zone(janname, 9, &p);
janzone = -get_gmtoff(t, &p);
janname[9] = '\0';
t += YEAR/2;
_PyTime_localtime(t, &p);
get_zone(julyname, 9, &p);
julyzone = -get_gmtoff(t, &p);
julyname[9] = '\0';
if( janzone < julyzone ) {
/* DST is reversed in the southern hemisphere */
PyModule_AddIntConstant(m, "timezone", julyzone);
PyModule_AddIntConstant(m, "altzone", janzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
julyname, janname));
} else {
PyModule_AddIntConstant(m, "timezone", janzone);
PyModule_AddIntConstant(m, "altzone", julyzone);
PyModule_AddIntConstant(m, "daylight",
janzone != julyzone);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)",
janname, julyname));
}
}
#ifdef __CYGWIN__
tzset();
PyModule_AddIntConstant(m, "timezone", _timezone);
PyModule_AddIntConstant(m, "altzone", _timezone-3600);
PyModule_AddIntConstant(m, "daylight", _daylight);
PyModule_AddObject(m, "tzname",
Py_BuildValue("(zz)", _tzname[0], _tzname[1]));
#endif /* __CYGWIN__ */
#endif /* !HAVE_TZNAME || __GLIBC__ || __CYGWIN__*/
}
int main(int argc, char *argv[])
{
struct GModule *module;
int Out_proj;
int out_stat;
int old_zone, old_proj;
int i;
int stat;
char cmnd2[500];
char proj_out[20], proj_name[50], set_name[20];
char path[1024], buffa[1024], buffb[1024], answer[200], answer1[200];
char answer2[200], buff[1024];
char tmp_buff[20], *buf;
struct Key_Value *old_proj_keys, *out_proj_keys, *in_unit_keys;
double aa, e2;
double f;
FILE *FPROJ;
int exist = 0;
char spheroid[100];
int j, k, sph_check;
struct Cell_head cellhd;
char datum[100], dat_ellps[100], dat_params[100];
struct proj_parm *proj_parms;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("projection"));
module->description =
_("Interactively reset the location's projection settings.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (strcmp(G_mapset(), "PERMANENT") != 0)
G_fatal_error(_("You must be in the PERMANENT mapset to run g.setproj"));
/***
* no longer necessary, table is a static struct
* init_unit_table();
***/
sprintf(set_name, "PERMANENT");
G_file_name(path, "", PROJECTION_FILE, set_name);
/* get the output projection parameters, if existing */
/* Check for ownership here */
stat = G__mapset_permissions(set_name);
if (stat == 0) {
G_fatal_error(_("PERMANENT: permission denied"));
}
G_get_default_window(&cellhd);
if (-1 == G_set_window(&cellhd))
G_fatal_error(_("Current region cannot be set"));
if (G_get_set_window(&cellhd) == -1)
G_fatal_error(_("Retrieving and setting region failed"));
Out_proj = cellhd.proj;
old_zone = cellhd.zone;
old_proj = cellhd.proj;
if (access(path, 0) == 0) {
exist = 1;
FPROJ = fopen(path, "r");
old_proj_keys = G_fread_key_value(FPROJ);
fclose(FPROJ);
buf = G_find_key_value("name", old_proj_keys);
fprintf(stderr,
"\nWARNING: A projection file already exists for this location\n(Filename '%s')\n",
path);
fprintf(stderr,
"\nThis file contains all the parameters for the location's projection:\n %s\n",
buf);
fprintf(stderr,
"\n Overriding this information implies that the old projection parameters\n"
" were incorrect. If you change the parameters, all existing data will\n"
" be interpreted differently by the projection software.\n%c%c%c",
7, 7, 7);
fprintf(stderr,
" GRASS will not re-project your data automatically.\n\n");
if (!G_yes
(_("Would you still like to change some of the parameters?"),
0)) {
G_message(_("The projection information will not be updated"));
leave(SP_NOCHANGE);
}
}
out_proj_keys = G_create_key_value();
if (exist) {
buf = G_find_key_value("zone", old_proj_keys);
if (buf != NULL)
sscanf(buf, "%d", &zone);
if (zone != old_zone) {
G_warning(_("Zone in default geographic region definition: %d\n"
" is different from zone in PROJ_INFO file: %d"),
old_zone, zone);
old_zone = zone;
}
}
switch (Out_proj) {
case 0: /* No projection/units */
if (!exist) {
/* leap frog over code, and just make sure we remove the file */
G_warning(_("XY-location cannot be projected"));
goto write_file;
break;
}
case PROJECTION_UTM:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_UTM));
sprintf(proj_out, "utm");
break;
}
case PROJECTION_SP:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_SP));
sprintf(proj_out, "stp");
break;
}
case PROJECTION_LL:
if (!exist) {
sprintf(proj_name, "%s", G__projection_name(PROJECTION_LL));
sprintf(proj_out, "ll");
break;
}
case PROJECTION_OTHER:
if (G_ask_proj_name(proj_out, proj_name) < 0)
leave(SP_NOCHANGE);
if (G_strcasecmp(proj_out, "LL") == 0)
Out_proj = PROJECTION_LL;
else if (G_strcasecmp(proj_out, "UTM") == 0)
Out_proj = PROJECTION_UTM;
else if (G_strcasecmp(proj_out, "STP") == 0)
Out_proj = PROJECTION_SP;
break;
default:
G_fatal_error(_("Unknown projection"));
}
cellhd.proj = Out_proj;
proj_parms = get_proj_parms(proj_out);
if (!proj_parms)
G_fatal_error(_("Projection %s is not specified in the file 'proj-parms.table'"),
proj_out);
G_set_key_value("name", proj_name, out_proj_keys);
sph_check = 0;
if (G_yes
(_("Do you wish to specify a geodetic datum for this location?"),
1)) {
char lbuf[100], lbufa[100];
if (exist &&
(G_get_datumparams_from_projinfo(old_proj_keys, lbuf, lbufa) ==
2)) {
G_strip(lbuf);
if ((i = G_get_datum_by_name(lbuf)) > 0) {
G_message(_("The current datum is %s (%s)"),
G_datum_name(i), G_datum_description(i));
if (G_yes
(_("Do you wish to change the datum (or datum transformation parameters)?"),
0))
sph_check = ask_datum(datum, dat_ellps, dat_params);
else {
sprintf(datum, lbuf);
sprintf(dat_params, lbufa);
sprintf(dat_ellps, G_datum_ellipsoid(i));
sph_check = 1;
G_message(_("The datum information has not been changed"));
}
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
else
sph_check = ask_datum(datum, dat_ellps, dat_params);
}
if (sph_check > 0) {
char *paramkey, *paramvalue;
/* write out key/value pairs to out_proj_keys */
if (G_strcasecmp(datum, "custom") != 0)
G_set_key_value("datum", datum, out_proj_keys);
/* G_set_key_value("datumparams", dat_params, out_proj_keys); */
paramkey = strtok(dat_params, "=");
paramvalue = dat_params + strlen(paramkey) + 1;
G_set_key_value(paramkey, paramvalue, out_proj_keys);
sprintf(spheroid, "%s", dat_ellps);
}
else {
/***************** GET spheroid **************************/
if (Out_proj != PROJECTION_SP) { /* some projections have
* fixed spheroids */
if (G_strcasecmp(proj_out, "ALSK") == 0 ||
G_strcasecmp(proj_out, "GS48") == 0 ||
G_strcasecmp(proj_out, "GS50") == 0) {
sprintf(spheroid, "%s", "clark66");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "LABRD") == 0 ||
G_strcasecmp(proj_out, "NZMG") == 0) {
sprintf(spheroid, "%s", "international");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "SOMERC") == 0) {
sprintf(spheroid, "%s", "bessel");
G_set_key_value("ellps", spheroid, out_proj_keys);
sph_check = 1;
}
else if (G_strcasecmp(proj_out, "OB_TRAN") == 0) {
/* Hard coded to use "Equidistant Cylincrical"
* until g.setproj has been changed to run
* recurively, to allow input of options for
* a second projection, MHu991010 */
G_set_key_value("o_proj", "eqc", out_proj_keys);
sph_check = 2;
}
else {
if (exist &&
(buf =
G_find_key_value("ellps", old_proj_keys)) != NULL) {
strcpy(spheroid, buf);
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f)) {
/* if legal ellips. exist, ask wether or not to change it */
G_message(_("The current ellipsoid is %s"), spheroid);
if (G_yes
(_("Do you want to change ellipsoid parameter?"),
0))
sph_check = G_ask_ellipse_name(spheroid);
else {
G_message(_("The ellipse information has not been changed"));
sph_check = 1;
}
} /* the val is legal */
else
sph_check = G_ask_ellipse_name(spheroid);
}
else
sph_check = G_ask_ellipse_name(spheroid);
}
}
if (sph_check > 0) {
if (sph_check == 2) { /* ask radius */
if (exist) {
buf = G_find_key_value("a", old_proj_keys);
if ((buf != NULL) && (sscanf(buf, "%lf", &radius) == 1)) {
G_message(_("The radius is currently %f"), radius);
if (G_yes(_("Do you want to change the radius?"), 0))
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
}
}
else
radius =
prompt_num_double(_("Enter radius for the sphere in meters"),
RADIUS_DEF, 1);
} /* end ask radius */
}
}
/*** END get spheroid ***/
/* create the PROJ_INFO & PROJ_UNITS files, if required */
if (G_strcasecmp(proj_out, "LL") == 0) ;
else if (G_strcasecmp(proj_out, "STP") == 0)
get_stp_proj(buffb);
else if (sph_check != 2) {
G_strip(spheroid);
if (G_get_spheroid_by_name(spheroid, &aa, &e2, &f) == 0)
G_fatal_error(_("Invalid input ellipsoid"));
}
write_file:
/*
** NOTE the program will (hopefully) never exit abnormally
** after this point. Thus we know the file will be completely
** written out once it is opened for write
*/
if (exist) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
goto write_units;
/*
** Include MISC parameters for PROJ_INFO
*/
if (G_strcasecmp(proj_out, "STP") == 0) {
for (i = 0; i < strlen(buffb); i++)
if (buffb[i] == ' ')
buffb[i] = '\t';
sprintf(cmnd2, "%s\t\n", buffb);
for (i = 0; i < strlen(cmnd2); i++) {
j = k = 0;
if (cmnd2[i] == '+') {
while (cmnd2[++i] != '=')
buffa[j++] = cmnd2[i];
buffa[j] = 0;
while (cmnd2[++i] != '\t' && cmnd2[i] != '\n' &&
cmnd2[i] != 0)
buffb[k++] = cmnd2[i];
buffb[k] = 0;
G_set_key_value(buffa, buffb, out_proj_keys);
}
}
}
else if (G_strcasecmp(proj_out, "LL") == 0) {
G_set_key_value("proj", "ll", out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
}
else {
if (sph_check != 2) {
G_set_key_value("proj", proj_out, out_proj_keys);
G_set_key_value("ellps", spheroid, out_proj_keys);
sprintf(tmp_buff, "%.10f", aa);
G_set_key_value("a", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", e2);
G_set_key_value("es", tmp_buff, out_proj_keys);
sprintf(tmp_buff, "%.10f", f);
G_set_key_value("f", tmp_buff, out_proj_keys);
}
else {
G_set_key_value("proj", proj_out, out_proj_keys);
/* G_set_key_value ("ellps", "sphere", out_proj_keys); */
sprintf(tmp_buff, "%.10f", radius);
G_set_key_value("a", tmp_buff, out_proj_keys);
G_set_key_value("es", "0.0", out_proj_keys);
G_set_key_value("f", "0.0", out_proj_keys);
}
for (i = 0;; i++) {
struct proj_parm *parm = &proj_parms[i];
struct proj_desc *desc;
if (!parm->name)
break;
desc = get_proj_desc(parm->name);
if (!desc)
break;
if (parm->ask) {
if (G_strcasecmp(desc->type, "bool") == 0) {
if (G_yes((char *)desc->desc, 0)) {
G_set_key_value(desc->key, "defined", out_proj_keys);
if (G_strcasecmp(parm->name, "SOUTH") == 0)
cellhd.zone = -abs(cellhd.zone);
}
}
else if (G_strcasecmp(desc->type, "lat") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 1, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "lon") == 0) {
double val;
while (!get_LL_stuff(parm, desc, 0, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "float") == 0) {
double val;
while (!get_double(parm, desc, &val)) ;
sprintf(tmp_buff, "%.10f", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
int val;
while (!get_int(parm, desc, &val)) ;
sprintf(tmp_buff, "%d", val);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "zone") == 0) {
if ((Out_proj == PROJECTION_UTM) && (old_zone != 0)) {
G_message(_("The UTM zone is now set to %d"),
old_zone);
if (!G_yes
(_("Do you want to change the UTM zone?"), 0)) {
G_message(_("UTM zone information has not been updated"));
zone = old_zone;
break;
}
else {
G_message(_("But if you change zone, all the existing "
"data will be interpreted by projection software. "
"GRASS will not automatically re-project or even "
"change the headers for existing maps."));
if (!G_yes
(_("Would you still like to change the UTM zone?"),
0)) {
zone = old_zone;
break;
}
}
} /* UTM */
while (!get_zone()) ;
sprintf(tmp_buff, "%d", zone);
G_set_key_value("zone", tmp_buff, out_proj_keys);
cellhd.zone = zone;
}
}
else if (parm->def_exists) {
/* don't ask, use the default */
if (G_strcasecmp(desc->type, "float") == 0 ||
G_strcasecmp(desc->type, "lat") == 0 ||
G_strcasecmp(desc->type, "lon") == 0) {
sprintf(tmp_buff, "%.10f", parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
else if (G_strcasecmp(desc->type, "int") == 0) {
sprintf(tmp_buff, "%d", (int)parm->deflt);
G_set_key_value(desc->key, tmp_buff, out_proj_keys);
}
}
} /* for OPTIONS */
}
/* create the PROJ_INFO & PROJ_UNITS files, if required */
G_write_key_value_file(path, out_proj_keys, &out_stat);
if (out_stat != 0) {
G_fatal_error(_("Error writing PROJ_INFO file <%s>"), path);
}
G_free_key_value(out_proj_keys);
if (exist)
G_free_key_value(old_proj_keys);
write_units:
G_file_name(path, "", UNIT_FILE, set_name);
/* if we got this far, the user
** already affirmed to write over old info
** so if units file is here, remove it.
*/
if (access(path, 0) == 0) {
sprintf(buff, "%s~", path);
G_rename_file(path, buff);
}
if (Out_proj == 0)
leave(0);
{
in_unit_keys = G_create_key_value();
switch (Out_proj) {
case PROJECTION_UTM:
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
case PROJECTION_SP:
for (;;) {
do {
fprintf(stderr, "\nSpecify the correct units to use:\n");
fprintf(stderr, "Enter the corresponding number\n");
fprintf(stderr,
"1.\tUS Survey Foot (Default for State Plane 1927)\n");
fprintf(stderr, "2.\tInternational Foot\n");
fprintf(stderr, "3.\tMeter\n");
fprintf(stderr, ">");
} while (!G_gets(answer));
G_strip(answer);
if (strcmp(answer, "1") == 0) {
G_set_key_value("unit", "USfoot", in_unit_keys);
G_set_key_value("units", "USfeet", in_unit_keys);
G_set_key_value("meters", "0.30480060960121920243",
in_unit_keys);
break;
}
else if (strcmp(answer, "2") == 0) {
G_set_key_value("unit", "foot", in_unit_keys);
G_set_key_value("units", "feet", in_unit_keys);
G_set_key_value("meters", "0.3048", in_unit_keys);
break;
}
else if (strcmp(answer, "3") == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
}
else
fprintf(stderr, "\nInvalid Entry (number 1 - 3)\n");
}
break;
case PROJECTION_LL:
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
break;
default:
if (G_strcasecmp(proj_out, "LL") != 0) {
fprintf(stderr, _("Enter plural form of units [meters]: "));
G_gets(answer);
if (strlen(answer) == 0) {
G_set_key_value("unit", "meter", in_unit_keys);
G_set_key_value("units", "meters", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
else {
const struct proj_unit *unit;
G_strip(answer);
unit = get_proj_unit(answer);
if (unit) {
#ifdef FOO
if (G_strcasecmp(proj_out, "STP") == 0 &&
!strcmp(answer, "feet")) {
fprintf(stderr,
"%cPROJECTION 99 State Plane cannot be in FEET.\n",
7);
remove(path); /* remove file */
leave(SP_FATAL);
}
#endif
G_set_key_value("unit", unit->unit, in_unit_keys);
G_set_key_value("units", unit->units, in_unit_keys);
sprintf(buffb, "%.10f", unit->fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
else {
double unit_fact;
while (1) {
fprintf(stderr, _("Enter singular for unit: "));
G_gets(answer1);
G_strip(answer1);
if (strlen(answer1) > 0)
break;
}
while (1) {
fprintf(stderr,
_("Enter conversion factor from %s to meters: "),
answer);
G_gets(answer2);
G_strip(answer2);
if (!
(strlen(answer2) == 0 ||
(1 != sscanf(answer2, "%lf", &unit_fact))))
break;
}
G_set_key_value("unit", answer1, in_unit_keys);
G_set_key_value("units", answer, in_unit_keys);
sprintf(buffb, "%.10f", unit_fact);
G_set_key_value("meters", buffb, in_unit_keys);
}
}
}
else {
G_set_key_value("unit", "degree", in_unit_keys);
G_set_key_value("units", "degrees", in_unit_keys);
G_set_key_value("meters", "1.0", in_unit_keys);
}
} /* switch */
G_write_key_value_file(path, in_unit_keys, &out_stat);
if (out_stat != 0)
G_fatal_error(_("Error writing into UNITS output file <%s>"),
path);
G_free_key_value(in_unit_keys);
} /* if */
if (G__put_window(&cellhd, "", "DEFAULT_WIND") < 0)
G_fatal_error(_("Unable to write to DEFAULT_WIND region file"));
fprintf(stderr,
_("\nProjection information has been recorded for this location\n\n"));
if ((old_zone != zone) | (old_proj != cellhd.proj)) {
G_message(_("The geographic region information in WIND is now obsolete"));
G_message(_("Run g.region -d to update it"));
}
leave(0);
}
inline void wamp_hello_message::set_realm(const std::string& realm)
{
m_realm = msgpack::object(realm, get_zone());
}
inline void wamp_publish_message::set_topic(const std::string& topic)
{
m_topic = msgpack::object(topic, get_zone());
}
inline void wamp_abort_message::set_details(const msgpack::object& details)
{
assert(details.type == msgpack::type::MAP);
m_details = msgpack::object(details, get_zone());
}
inline void wamp_abort_message::set_reason(const std::string& reason)
{
m_reason = msgpack::object(reason, get_zone());
}
int main(int argc, char **argv){
int sockfd;
int len;
struct sockaddr_un address;
int ret;
const int LINE_LEN=512;
char line[LINE_LEN];
pthread_t lowthread;
const int outlen=200;
int olen;
int outarr[outlen];
char *lp;
if(argc<4)return EXIT_FAILURE;
sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
address.sun_family = AF_UNIX;
strcpy(address.sun_path, SERVER_SOCKET_NAME);
len = sizeof(address);
ret = connect(sockfd, (struct sockaddr *)&address, len);
if(ret == -1) {
perror("Unable to connect to server");
exit(1);
}
if(sqlite3_open_v2(argv[3],&cdb,SQLITE_OPEN_READWRITE,NULL)!=SQLITE_OK){
perror("Unable to open database");
return EXIT_FAILURE;
}
sprintf(line,"T%s\n%s",argv[1],argv[2]);
write(sockfd, line, strlen(line));
read(sockfd, &ret, sizeof(ret));
printf("result from server = %d\n", ret);
print_server_error(ret);
if(ret==SRV_OK){
pthread_create(&lowthread,NULL,run_low,argv);
while((len=read(0,line,LINE_LEN))>0 && strncmp("exit\n",line,len)!=0){
if(line[0]=='?'){
print_help(line+1);
continue;
}
switch(line[0]){
case '0':
olen=1+get_deck_array(outarr+1,strtol(line+1,NULL,10));
outarr[0]=-MTG_ACT_INIT_DECK;
break;
case 'p':
olen=1;
outarr[0]=-MTG_ACT_PASS;
break;
case 'd':
olen=1;
outarr[0]=-MTG_ACT_DONE;
break;
case 'D':
olen=2;
outarr[0]=-MTG_ACT_DRAW;
outarr[1]=line[1]!=0?strtol(line+1,NULL,10):1;
break;
case 'V':
olen=2;
outarr[0]=-MTG_ACT_VIS;
outarr[1]=line[1]!=0?strtol(line+1,NULL,10):1;
break;
case 'M':
olen=3;
outarr[0]=-MTG_ACT_MOVE;
outarr[1]=get_zone(line[1]);
outarr[2]=strtol(line+2,NULL,10);
break;
case 'T':
olen=2;
outarr[0]=-MTG_ACT_TAP;
outarr[1]=line[1]!=0?strtol(line+1,NULL,10):1;
break;
case 'c':
olen=3;
outarr[0]=-MTG_ACT_TRANS;
outarr[1]=strtol(line+1,&lp,10);
outarr[2]=strtol(lp+1,NULL,10);
break;
default:
olen=1;
outarr[0]=0;
break;
}
if(write(sockfd,outarr,sizeof(*outarr)*olen)<0)
break;
//while(fgets(line,LINE_LEN,stdin) && strcmp("exit\n",line)!=0){
//write(sockfd,line,strlen(line));
}
}
close(sockfd);
exit(0);
}
/*
* Start a note.
*/
void
snd_emux_note_on(void *p, int note, int vel, snd_midi_channel_t *chan)
{
snd_emux_t *emu;
int i, key, nvoices;
snd_emux_voice_t *vp;
snd_sf_zone_t *table[SNDRV_EMUX_MAX_MULTI_VOICES];
unsigned long flags;
snd_emux_port_t *port;
port = p;
snd_assert(port != NULL && chan != NULL, return);
emu = port->emu;
snd_assert(emu != NULL, return);
snd_assert(emu->ops.get_voice != NULL, return);
snd_assert(emu->ops.trigger != NULL, return);
key = note; /* remember the original note */
nvoices = get_zone(emu, port, ¬e, vel, chan, table);
if (! nvoices)
return;
/* exclusive note off */
for (i = 0; i < nvoices; i++) {
snd_sf_zone_t *zp = table[i];
if (zp && zp->v.exclusiveClass)
exclusive_note_off(emu, port, zp->v.exclusiveClass);
}
#if 0 // seems not necessary
/* Turn off the same note on the same channel. */
terminate_note1(emu, key, chan, 0);
#endif
spin_lock_irqsave(&emu->voice_lock, flags);
for (i = 0; i < nvoices; i++) {
/* set up each voice parameter */
/* at this stage, we don't trigger the voice yet. */
if (table[i] == NULL)
continue;
vp = emu->ops.get_voice(emu, port);
if (vp == NULL || vp->ch < 0)
continue;
if (STATE_IS_PLAYING(vp->state))
emu->ops.terminate(vp);
vp->time = emu->use_time++;
vp->chan = chan;
vp->port = port;
vp->key = key;
vp->note = note;
vp->velocity = vel;
vp->zone = table[i];
if (vp->zone->sample)
vp->block = vp->zone->sample->block;
else
vp->block = NULL;
setup_voice(vp);
vp->state = SNDRV_EMUX_ST_STANDBY;
if (emu->ops.prepare) {
vp->state = SNDRV_EMUX_ST_OFF;
if (emu->ops.prepare(vp) >= 0)
vp->state = SNDRV_EMUX_ST_STANDBY;
}
}
/* start envelope now */
for (i = 0; i < emu->max_voices; i++) {
vp = &emu->voices[i];
if (vp->state == SNDRV_EMUX_ST_STANDBY &&
vp->chan == chan) {
emu->ops.trigger(vp);
vp->state = SNDRV_EMUX_ST_ON;
vp->ontime = jiffies; /* remember the trigger timing */
}
}
spin_unlock_irqrestore(&emu->voice_lock, flags);
#ifdef SNDRV_EMUX_USE_RAW_EFFECT
if (port->port_mode == SNDRV_EMUX_PORT_MODE_OSS_SYNTH) {
/* clear voice position for the next note on this channel */
snd_emux_effect_table_t *fx = chan->private;
if (fx) {
fx->flag[EMUX_FX_SAMPLE_START] = 0;
fx->flag[EMUX_FX_COARSE_SAMPLE_START] = 0;
}
}
static int
canvas_handler(struct pgEvent *evt)
{
ENTER("canvas_handler(struct pgEvent *evt)");
static int draw = 0;
switch (evt->type) {
case PG_WE_PNTR_DOWN:
draw = 1;
DPRINTF("PG_WE_PNTR_DOWN\n");
break;
case PG_WE_PNTR_UP:
draw = 0;
DPRINTF("PG_WE_PNTR_UP\n");
break;
case PG_WE_PNTR_RELEASE:
draw = 0;
DPRINTF("PG_WE_PNTR_RELEASE\n");
break;
case PG_WE_PNTR_MOVE:
draw = 0;
DPRINTF("PG_WE_PNTR_MOVE\n");
break;
case PG_WE_BUILD:
DPRINTF("PG_WE_BUILD\n");
request_refresh(current_zone);
break;
case PG_WE_KBD_KEYUP:
DPRINTF("PG_WE_KBD_KEYUP\n");
LEAVE;
return 1;
case PG_WE_KBD_KEYDOWN:
DPRINTF("PG_WE_KBD_KEYDOWN\n");
LEAVE;
return 1;
default:
DPRINTF("??? unhandled type: 0x%x\n", evt->type);
break;
}
if(draw) {
int x = evt->e.pntr.x;
int y = evt->e.pntr.y;
int z = get_zone(x,y);
DPRINTF("(%d,%d)", x, y);
DPRINTF("=> z=%d\n", z);
if(z>=0 && z!=current_zone) {
current_zone = z;
request_refresh(z);
}
}
LEAVE;
return 1;
}
