bool FastXMLVisitor::VisitEnter (const XMLElement & element, const XMLAttribute* /* attr */)
{
const char* element_name = element.Name();
if (strcmp(element_name, "templates") == 0 ) {
instruction_context context;
context.ns_ = get_optional_attr(element, "templateNs", "");
context.dictionary_ = get_optional_attr(element, "dictionary", "");
context_stack_.push_back(context);
return VisitEnterTemplates(element);
}
std::string name_attr = get_optional_attr(element, "name", "");
if (strcmp(element_name, "templateRef") == 0) {
return VisitTemplateRef(element, name_attr, num_fields_.back());
}
bool result = true;
if (strcmp(element_name, "template") == 0 ) {
save_context(element);
result = VisitEnterTemplate(element, name_attr, num_fields_.back());
}
else if (strcmp(element_name, "group") == 0 ) {
save_context(element);
result = VisitEnterGroup(element, name_attr, num_fields_.back());
}
else if (strcmp(element_name, "sequence") == 0 ) {
save_context(element);
result = VisitEnterSequence(element, name_attr, num_fields_.back());
}
else if (strcmp(element_name, "define") == 0) {
return VisitEnterDefine(element, name_attr);
}
else {
int bits;
bool is_vector;
if ((strncmp(element_name, "int", 3) == 0 && parse_bits(element_name+3, bits, is_vector) ) ||
(strncmp(element_name, "uInt", 4) == 0 && parse_bits(element_name+4, bits, is_vector) ) ) {
// int8, int16 and uint8, uint16 are not standards, convert them to int32 and uint32 respectively
if (is_vector)
return VisitIntVector(element,bits, name_attr, num_fields_.back());
return VisitInteger(element,bits, name_attr, num_fields_.back());
}
else if (strcmp(element_name, "decimal") == 0 ) {
return VisitDecimal(element, name_attr, num_fields_.back());
}
else if (strcmp(element_name, "string") == 0 ) {
return VisitString(element, name_attr, num_fields_.back());
}
else if (strcmp(element_name, "byteVector") == 0 ) {
return VisitByteVector(element, name_attr, num_fields_.back());
}
return true;
}
num_fields_.push_back(0);
return result;
}
static CMPIStatus TCPCOMM_IndicationMI_deActivateFilter(provider_address * addr,
RemoteCMPIIndicationMI * cThis,
CMPIContext * context,
CMPIResult * result,
CMPIObjectPath * cop,
CMPISelectExp * filter,
const char *indType,
CMPIBoolean lastActivation)
#endif
{
int socket;
unsigned long int ctxid = save_context(context);
TRACE_NORMAL(("Executing remote MI call."));
CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
__FUNCTION__, context, cop);
if (socket < 0)
CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
(__sft)->serialize_CMPISelectExp(socket, filter);
(__sft)->serialize_string(socket, indType);
(__sft)->serialize_UINT8(socket, lastActivation);
{
CMPIStatus rc;
CMPIArray *r;
rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
close(socket);
remove_context(ctxid);
#ifndef CMPI_VER_100
socketcomm_array2result(r, result);
#endif
return rc;
};
};
static CMPIStatus TCPCOMM_InstanceMI_deleteInstance(provider_address * addr,
RemoteCMPIInstanceMI * cThis,
CONST CMPIContext * context,
CONST CMPIResult * result,
CONST CMPIObjectPath * cop)
{
int socket;
unsigned long int ctxid = save_context(context);
TRACE_NORMAL(("Executing remote MI call."));
CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
__FUNCTION__, context, cop);
if (socket < 0)
CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
{
CMPIStatus rc;
CMPIArray *r;
rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
close(socket);
remove_context(ctxid);
socketcomm_array2result(r, result);
return rc;
};
}
bool end_transaction () {
if (!in_transaction_)
return false;
in_transaction_ = false;
save_context();
return true;
}
/**********************************************************************
* ill_handler
*
* Handler for SIGILL.
*/
static void ill_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
{
EXCEPTION_RECORD rec;
CONTEXT context;
switch ( info->si_code )
{
default:
case ILL_ILLOPC:
case ILL_ILLOPN:
case ILL_ILLADR:
case ILL_ILLTRP:
rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
break;
case ILL_PRVOPC:
case ILL_PRVREG:
rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
break;
case ILL_BADSTK:
rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
break;
}
save_context( &context, ucontext );
rec.ExceptionRecord = NULL;
rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
rec.ExceptionAddress = (LPVOID)context.pc;
rec.NumberParameters = 0;
__regs_RtlRaiseException( &rec, &context );
restore_context( &context, ucontext );
}
static CMPIStatus TCPCOMM_AssociationMI_references(provider_address * addr,
RemoteCMPIAssociationMI * cThis,
CONST CMPIContext * context,
CONST CMPIResult * result,
CONST CMPIObjectPath * cop,
const char *assocclass,
const char *role,
CONST char **props)
{
int socket;
unsigned long int ctxid = save_context(context);
TRACE_NORMAL(("Executing remote MI call."));
CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
__FUNCTION__, context, cop);
if (socket < 0)
CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
(__sft)->serialize_string(socket, assocclass);
(__sft)->serialize_string(socket, role);
socketcomm_serialize_props(socket, (__sft), (char **)props);
{
CMPIStatus rc;
CMPIArray *r;
rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
close(socket);
remove_context(ctxid);
socketcomm_array2result(r, result);
return rc;
};
}
void PendSV_Handler( void )
{
static unsigned stackPointer = 0;
stackPointer = save_context();
stackPointer = cHwRTOS_MCU::schedule( stackPointer, false );
load_context( stackPointer );
}
__attribute__((naked))void PendSV_Handler(void)
{
save_context();
/* call scheduler update fk_thread variable with pdc of next thread */
asm("bl sched_run");
/* the thread that has higest priority and is in PENDING state */
restore_context();
}
void SVC_Handler(void)
{
save_context();
asm("bl sched_run");
/* call scheduler update sched_active_thread variable with pdc of next thread
* the thread that has higest priority and is in PENDING state */
restore_context();
}
/**********************************************************************
* usr1_handler
*
* Handler for SIGUSR1, used to signal a thread that it got suspended.
*/
static HANDLER_DEF(usr1_handler)
{
CONTEXT context;
save_context( &context, HANDLER_CONTEXT );
wait_suspend( &context );
restore_context( &context, HANDLER_CONTEXT );
}
void SysTick_Handler( void )
{
static unsigned stackPointer = 0;
stackPointer = save_context();
cHwRTOS_MCU::sysTic++;
stackPointer = cHwRTOS_MCU::schedule( stackPointer, true );
load_context( stackPointer );
}
void c_prepare_catch(error_context_t * econ) {
if (!save_context(econ))
error("Can't catch too deep recursion error.\n");
push_control_stack(FRAME_CATCH);
#if defined(DEBUG) || defined(TRACE_CODE)
csp->num_local_variables = (csp - 1)->num_local_variables; /* marion */
#endif
assign_svalue(&catch_value, &const1);
}
/* New version used when not in -o mode. The epilog() in master.c is
* supposed to return an array of files (castles in 2.4.5) to load. The array
* returned by apply() will be freed at next call of apply(), which means that
* the ref count has to be incremented to protect against deallocation.
*
* The master object is asked to do the actual loading.
*/
void preload_objects (int eflag)
{
VOLATILE array_t *prefiles;
svalue_t *ret;
VOLATILE int ix;
error_context_t econ;
save_context(&econ);
if (SETJMP(econ.context)) {
restore_context(&econ);
pop_context(&econ);
return;
}
push_number(eflag);
ret = apply_master_ob(APPLY_EPILOG, 1);
pop_context(&econ);
if ((ret == 0) || (ret == (svalue_t *)-1) || (ret->type != T_ARRAY))
return;
else
prefiles = ret->u.arr;
if ((prefiles == 0) || (prefiles->size < 1))
return;
debug_message("\nLoading preloaded files ...\n");
prefiles->ref++;
ix = 0;
/* in case of an error, effectively do a 'continue' */
save_context(&econ);
if (SETJMP(econ.context)) {
restore_context(&econ);
ix++;
}
for ( ; ix < prefiles->size; ix++) {
if (prefiles->item[ix].type != T_STRING)
continue;
set_eval(max_cost);
push_svalue(((array_t *)prefiles)->item + ix);
(void) apply_master_ob(APPLY_PRELOAD, 1);
}
free_array((array_t *)prefiles);
pop_context(&econ);
} /* preload_objects() */
bool persist_file_context::set_var(const std::string &global,const config &val, bool immediate)
{
// if (cfg_.empty()) {
// load_persist_data(namespace_,cfg_);
// }
config bak;
config bactive;
if (immediate) {
bak = cfg_;
bactive = active_->cfg_.child_or_add("variables");
load();
root_node_.init();
}
config &cfg = active_->cfg_.child_or_add("variables");
if (val.has_attribute(global)) {
if (val[global].empty()) {
clear_var(global,immediate);
} else {
cfg[global] = val[global];
if (immediate) bactive[global] = val[global];
}
} else {
cfg.clear_children(global);
cfg.append(val);
if (immediate) {
bactive.clear_children(global);
bactive.append(val);
}
}
// dirty_ = true;
if (!in_transaction_)
return save_context();
else if (immediate) {
bool ret = save_context();
cfg_ = bak;
root_node_.init();
active_->cfg_.clear_children("variables");
active_->cfg_.remove_attribute("variables");
active_->cfg_.add_child("variables",bactive);
return ret;
} else
return true;
}
static void TCPCOMM_prepareAttachThread(int socket, CONST CMPIBroker * broker,
CONST CMPIContext * context)
{
CMPIContext *ctx;
unsigned long int ctx_id;
ctx = CBPrepareAttachThread(broker, context);
ctx_id = save_context(ctx);
CMAddContextEntry(ctx, RCMPI_CTX_ID, &ctx_id, CMPI_uint32);
socketcomm_serialize_context(socket, (__sft), ctx);
}
/* we need to expose the update to be able to complete the reset at SoC level */
int lakemont_update_after_probemode_entry(struct target *t)
{
if (save_context(t) != ERROR_OK)
return ERROR_FAIL;
if (halt_prep(t) != ERROR_OK)
return ERROR_FAIL;
t->state = TARGET_HALTED;
return target_call_event_callbacks(t, TARGET_EVENT_HALTED);
}
static int find_column_number(
const Data& data,
const shared<meta_parameter>& param,
const polymorph_factory_context& context
)
{
return data.find_column(
save_context(context),
param->position()
);
}
/**********************************************************************
* abrt_handler
*
* Handler for SIGABRT.
*/
static HANDLER_DEF(abrt_handler)
{
EXCEPTION_RECORD rec;
CONTEXT context;
save_context( &context, HANDLER_CONTEXT );
rec.ExceptionCode = EXCEPTION_WINE_ASSERTION;
rec.ExceptionFlags = EH_NONCONTINUABLE;
rec.ExceptionRecord = NULL;
rec.ExceptionAddress = (LPVOID)context.pc;
rec.NumberParameters = 0;
__regs_RtlRaiseException( &rec, &context ); /* Should never return.. */
restore_context( &context, HANDLER_CONTEXT );
}
/**********************************************************************
* int_handler
*
* Handler for SIGINT.
*/
static void int_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
{
if (!dispatch_signal(SIGINT))
{
EXCEPTION_RECORD rec;
CONTEXT context;
save_context( &context, ucontext );
rec.ExceptionCode = CONTROL_C_EXIT;
rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
rec.ExceptionRecord = NULL;
rec.ExceptionAddress = (LPVOID)context.pc;
rec.NumberParameters = 0;
__regs_RtlRaiseException( &rec, &context );
restore_context( &context, ucontext );
}
}
//----------------------------------------------------------------------------------------------------//
// @func - suspend
//! @desc
//! Suspend a process inside the kernel. A rescheduling followed by the corresponding context
//! switch occurs within this routine.
//! @return
//! - Nothing
//! @note
//! - This routine is not expected to be invoked from within an ISR. i.e no suspension allowed in
//! an ISR.
//----------------------------------------------------------------------------------------------------//
void suspend ()
{
#ifdef CONFIG_STATS
current_process->active_ticks++;
budget_ticks++;
#endif
if (scheduler ()) {
DBG_PRINT ("XMK: Scheduling error. Cannot suspend current process.\r\n");
while (1)
;
}
if (ctx_save_process != NULL)
if (save_context (ctx_save_process)) // Save context returns 0 during save
return; // When saved context is restored, returns a 1
restore_context ();
}
void asmlinkage save_context_sysenter(struct context *context)
{
// Setup context
context->esp = context->ecx;
context->eip = context->edx;
context->ss = GDT_SELECTOR_DATA_U;
context->cs = GDT_SELECTOR_CODE_U;
context->eflags = 0x200202;
// Make sure we are in user mode
int user_mode = *get_per_cpu(int, cur_in_user_mode);
assert(user_mode);
// Call the regular context save function
save_context(context);
}
/**********************************************************************
* fpe_handler
*
* Handler for SIGFPE.
*/
static void fpe_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
{
EXCEPTION_RECORD rec;
CONTEXT context;
switch ( info->si_code )
{
case FPE_FLTSUB:
rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
break;
case FPE_INTDIV:
rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
break;
case FPE_INTOVF:
rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
break;
case FPE_FLTDIV:
rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
break;
case FPE_FLTOVF:
rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
break;
case FPE_FLTUND:
rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
break;
case FPE_FLTRES:
rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
break;
case FPE_FLTINV:
default:
rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
break;
}
save_context( &context, ucontext );
save_fpu( &context, ucontext );
rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
rec.ExceptionRecord = NULL;
rec.ExceptionAddress = (LPVOID)context.pc;
rec.NumberParameters = 0;
__regs_RtlRaiseException( &rec, &context );
restore_context( &context, ucontext );
restore_fpu( &context, ucontext );
}
/**********************************************************************
* bus_handler
*
* Handler for SIGBUS.
*/
static void bus_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
{
EXCEPTION_RECORD rec;
CONTEXT context;
save_context( &context, ucontext );
rec.ExceptionRecord = NULL;
rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
rec.ExceptionAddress = (LPVOID)context.pc;
rec.NumberParameters = 0;
if ( info->si_code == BUS_ADRALN )
rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
else
rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
__regs_RtlRaiseException( &rec, &context );
restore_context( &context, ucontext );
}
svalue_t *
safe_call_function_pointer (funptr_t * funp, int num_arg)
{
error_context_t econ;
svalue_t *ret;
if (!save_context(&econ))
return 0;
if (!SETJMP(econ.context)) {
ret = call_function_pointer(funp, num_arg);
} else {
restore_context(&econ);
/* condition was restored to where it was when we came in */
pop_n_elems(num_arg);
ret = 0;
}
pop_context(&econ);
return ret;
}
/**********************************************************************
* segv_handler
*
* Handler for SIGSEGV.
*/
static void segv_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
{
EXCEPTION_RECORD rec;
CONTEXT context;
/* we want the page-fault case to be fast */
if ( info->si_code == SEGV_ACCERR )
if (VIRTUAL_HandleFault( (LPVOID)info->si_addr )) return;
save_context( &context, ucontext );
rec.ExceptionCode = EXCEPTION_ACCESS_VIOLATION;
rec.ExceptionRecord = NULL;
rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
rec.ExceptionAddress = (LPVOID)context.pc;
rec.NumberParameters = 2;
rec.ExceptionInformation[0] = 0; /* FIXME: read/write access ? */
rec.ExceptionInformation[1] = (ULONG_PTR)info->si_addr;
__regs_RtlRaiseException( &rec, &context );
restore_context( &context, ucontext );
}
/**********************************************************************
* trap_handler
*
* Handler for SIGTRAP.
*/
static void trap_handler( int signal, siginfo_t *info, ucontext_t *ucontext )
{
EXCEPTION_RECORD rec;
CONTEXT context;
switch ( info->si_code )
{
case TRAP_TRACE:
rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
break;
case TRAP_BRKPT:
default:
rec.ExceptionCode = EXCEPTION_BREAKPOINT;
break;
}
save_context( &context, ucontext );
rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
rec.ExceptionRecord = NULL;
rec.ExceptionAddress = (LPVOID)context.pc;
rec.NumberParameters = 0;
__regs_RtlRaiseException( &rec, &context );
restore_context( &context, ucontext );
}
int main P2(int, argc, char **, argv)
{
time_t tm;
int i, new_mudlib = 0, got_defaults = 0;
int no_ip_demon = 0;
char *p;
char version_buf[80];
#if 0
int dtablesize;
#endif
error_context_t econ;
#if !defined(LATTICE) && !defined(OLD_ULTRIX) && !defined(sequent) && \
!defined(sgi)
void tzset();
#endif
struct lpc_predef_s predefs;
#if !defined(__SASC) && (defined(AMITCP) || defined(AS225))
amiga_sockinit();
atexit(amiga_sockexit);
#endif
#ifdef WRAPPEDMALLOC
wrappedmalloc_init();
#endif /* WRAPPEDMALLOC */
#ifdef DEBUGMALLOC
MDinit();
#endif
#if (defined(PROFILING) && !defined(PROFILE_ON) && defined(HAS_MONCONTROL))
moncontrol(0);
#endif
#if !defined(OLD_ULTRIX) && !defined(LATTICE) && !defined(sequent)
tzset();
#endif
boot_time = get_current_time();
const0.type = T_NUMBER;
const0.u.number = 0;
const1.type = T_NUMBER;
const1.u.number = 1;
/* const0u used by undefinedp() */
const0u.type = T_NUMBER;
const0u.subtype = T_UNDEFINED;
const0u.u.number = 0;
/* const0n used by nullp() */
const0n.type = T_NUMBER;
const0n.subtype = T_NULLVALUE;
const0n.u.number = 0;
fake_prog.program_size = 0;
/*
* Check that the definition of EXTRACT_UCHAR() is correct.
*/
p = (char *) &i;
*p = -10;
if (EXTRACT_UCHAR(p) != 0x100 - 10) {
fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in interpret.h.\n");
exit(-1);
}
/*
* An added test: can we do EXTRACT_UCHAR(x++)?
* (read_number, etc uses it)
*/
p = (char *) &i;
(void) EXTRACT_UCHAR(p++);
if ((p - (char *) &i) != 1) {
fprintf(stderr, "EXTRACT_UCHAR() in interpret.h evaluates its argument more than once.\n");
exit(-1);
}
/*
* Check the living hash table size
*/
if (CFG_LIVING_HASH_SIZE != 4 && CFG_LIVING_HASH_SIZE != 16 &&
CFG_LIVING_HASH_SIZE != 64 && CFG_LIVING_HASH_SIZE != 256 &&
CFG_LIVING_HASH_SIZE != 1024 && CFG_LIVING_HASH_SIZE != 4096) {
fprintf(stderr, "CFG_LIVING_HASH_SIZE in options.h must be one of 4, 16, 64, 256, 1024, 4096, ...\n");
exit(-1);
}
#ifdef RAND
srand(get_current_time());
#else
# ifdef DRAND48
srand48(get_current_time());
# else
# ifdef RANDOM
srandom(get_current_time());
# else
fprintf(stderr, "Warning: no random number generator specified!\n");
# endif
# endif
#endif
current_time = get_current_time();
/*
* Initialize the microsecond clock.
*/
init_usec_clock();
/* read in the configuration file */
got_defaults = 0;
for (i = 1; (i < argc) && !got_defaults; i++) {
if (argv[i][0] != '-') {
set_defaults(argv[i]);
got_defaults = 1;
}
}
if (!got_defaults) {
fprintf(stderr, "You must specify the configuration filename as an argument.\n");
exit(-1);
}
printf("Initializing internal tables....\n");
init_strings(); /* in stralloc.c */
init_otable(); /* in otable.c */
init_identifiers(); /* in lex.c */
init_locals(); /* in compiler.c */
/* disable this for now */
#if 0
/*
* We estimate that we will need MAX_USERS + MAX_EFUN_SOCKS + 10 file
* descriptors if the maximum number of users were to log in and all LPC
* sockets were in use. This is a pretty close estimate.
*/
#ifndef LATTICE
dtablesize = MAX_USERS + MAX_EFUN_SOCKS + 10;
#else
/*
* Amiga sockets separate from file descriptors
*/
dtablesize = MAX_USERS + MAX_EFUN_SOCKS;
#endif
/*
* If our estimate is larger than FD_SETSIZE, then we need more file
* descriptors than the operating system can handle. This is a problem
* that can be resolved by decreasing MAX_USERS, MAX_EFUN_SOCKS, or both.
*/
if (dtablesize > FD_SETSIZE) {
fprintf(stderr, "Warning: File descriptor requirements exceed system capacity!\n");
fprintf(stderr, " Configuration exceeds system capacity by %d descriptor(s).\n",
dtablesize - FD_SETSIZE);
}
#ifdef HAS_SETDTABLESIZE
/*
* If the operating system supports setdtablesize() then we can request
* the number of file descriptors we really need. First check to see if
* wee already have enough. If so dont bother the OS. If not, attempt to
* allocate the number we estimated above. There are system imposed
* limits on file descriptors, so we may not get as many as we asked for.
* Check to make sure we get enough.
*/
if (getdtablesize() < dtablesize)
if (setdtablesize(dtablesize) < dtablesize) {
fprintf(stderr, "Warning: Could not allocate enough file descriptors!\n");
fprintf(stderr, " setdtablesize() could not allocate %d descriptor(s).\n",
getdtablesize() - dtablesize);
}
/*
* Just be polite and tell the administrator how many he has.
*/
fprintf(stderr, "%d file descriptors were allocated, (%d were requested).\n",
getdtablesize(), dtablesize);
#endif
#endif
time_to_clean_up = TIME_TO_CLEAN_UP;
time_to_swap = TIME_TO_SWAP;
max_cost = MAX_COST;
reserved_size = RESERVED_SIZE;
max_array_size = MAX_ARRAY_SIZE;
max_buffer_size = MAX_BUFFER_SIZE;
max_string_length = MAX_STRING_LENGTH;
master_file_name = (char *) MASTER_FILE;
/* fix the filename */
while (*master_file_name == '/') master_file_name++;
p = master_file_name;
while (*p++);
if (p[-2]=='c' && p[-3]=='.')
p[-3]=0;
mud_lib = (char *) MUD_LIB;
set_inc_list(INCLUDE_DIRS);
if (reserved_size > 0)
reserved_area = (char *) DMALLOC(reserved_size, TAG_RESERVED, "main.c: reserved_area");
for (i = 0; i < sizeof consts / sizeof consts[0]; i++)
consts[i] = exp(-i / 900.0);
init_num_args();
reset_machine(1);
/*
* The flags are parsed twice ! The first time, we only search for the -m
* flag, which specifies another mudlib, and the D-flags, so that they
* will be available when compiling master.c.
*/
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-')
continue;
switch (argv[i][1]) {
case 'D':
if (argv[i][2]) { /* Amylaar : allow flags to be passed down to
* the LPC preprocessor */
struct lpc_predef_s *tmp;
tmp = &predefs;
tmp->flag = argv[i] + 2;
tmp->next = lpc_predefs;
lpc_predefs = tmp;
continue;
}
fprintf(stderr, "Illegal flag syntax: %s\n", argv[i]);
exit(-1);
case 'N':
no_ip_demon++;
continue;
#ifdef YYDEBUG
case 'y':
yydebug = 1;
continue;
#endif /* YYDEBUG */
case 'm':
mud_lib = alloc_cstring(argv[i] + 2, "mudlib dir");
if (chdir(mud_lib) == -1) {
fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib);
exit(-1);
}
new_mudlib = 1;
break;
}
}
if (!new_mudlib && chdir(mud_lib) == -1) {
fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib);
exit(-1);
}
get_version(version_buf);
time(&tm);
debug_message("----------------------------------------------------------------------------\n%s (%s) starting up on %s - %s\n\n", MUD_NAME, version_buf, ARCH, ctime(&tm));
#ifdef BINARIES
init_binaries(argc, argv);
#endif
#ifdef LPC_TO_C
init_lpc_to_c();
#endif
add_predefines();
#ifndef NO_IP_DEMON
if (!no_ip_demon && ADDR_SERVER_IP)
init_addr_server(ADDR_SERVER_IP, ADDR_SERVER_PORT);
#endif /* NO_IP_DEMON */
eval_cost = max_cost; /* needed for create() functions */
save_context(&econ);
if (SETJMP(econ.context)) {
debug_message("The simul_efun (%s) and master (%s) objects must be loadable.\n",
SIMUL_EFUN, MASTER_FILE);
exit(-1);
} else {
init_simul_efun(SIMUL_EFUN);
init_master(MASTER_FILE);
}
pop_context(&econ);
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
continue;
} else {
/*
* Look at flags. -m and -o has already been tested.
*/
switch (argv[i][1]) {
case 'D':
case 'N':
case 'm':
case 'y':
continue;
case 'f':
save_context(&econ);
if (SETJMP(econ.context)) {
debug_message("Error while calling master::flag(\"%s\"), aborting ...", argv[i] + 2);
exit(-1);
}
push_constant_string(argv[i] + 2);
(void) apply_master_ob(APPLY_FLAG, 1);
if (MudOS_is_being_shut_down) {
debug_message("Shutdown by master object.\n");
exit(0);
}
pop_context(&econ);
continue;
case 'e':
e_flag++;
continue;
case 'p':
external_port[0].port = atoi(argv[i] + 2);
continue;
case 'd':
#ifdef DEBUG
d_flag++;
#else
debug_message("Driver must be compiled with DEBUG on to use -d.\n");
#endif
case 'c':
comp_flag++;
continue;
case 't':
t_flag++;
continue;
default:
debug_message("Unknown flag: %s\n", argv[i]);
exit(-1);
}
}
}
if (MudOS_is_being_shut_down)
exit(1);
if (strlen(DEFAULT_FAIL_MESSAGE))
default_fail_message = DEFAULT_FAIL_MESSAGE;
else
default_fail_message = "What?";
#ifdef PACKAGE_MUDLIB_STATS
restore_stat_files();
#endif
#ifdef PACKAGE_SOCKETS
init_sockets(); /* initialize efun sockets */
#endif
preload_objects(e_flag);
#ifdef SIGFPE
signal(SIGFPE, sig_fpe);
#endif
#ifdef TRAP_CRASHES
#ifdef SIGUSR1
signal(SIGUSR1, sig_usr1);
#endif
signal(SIGTERM, sig_term);
signal(SIGINT, sig_int);
#ifndef DEBUG
#if defined(SIGABRT) && !defined(LATTICE)
signal(SIGABRT, sig_abrt);
#endif
#ifdef SIGIOT
signal(SIGIOT, sig_iot);
#endif
#ifdef SIGHUP
signal(SIGHUP, sig_hup);
#endif
#ifdef SIGBUS
signal(SIGBUS, sig_bus);
#endif
#ifndef LATTICE
signal(SIGSEGV, sig_segv);
signal(SIGILL, sig_ill);
#endif
#endif /* DEBUG */
#endif
backend();
return 0;
}
bool persist_file_context::clear_var(const std::string &global, bool immediate)
{
// if (cfg_.empty()) {
// load_persist_data(namespace_.root(),cfg_);
// }
config bak;
config bactive;
if (immediate) {
bak = cfg_;
bactive = active_->cfg_.child_or_add("variables");
load();
root_node_.init();
}
config &cfg = active_->cfg_.child_or_add("variables");
bool ret(cfg);
if (ret) {
bool exists = cfg.has_attribute(global);
if (!exists) {
if (cfg.child(global)) {
exists = true;
std::string::const_iterator index_start = std::find(global.begin(),global.end(),'[');
if (index_start != global.end())
{
const std::string::const_iterator index_end = std::find(global.begin(),global.end(),']');
const std::string index_str(index_start+1,index_end);
size_t index = static_cast<size_t>(lexical_cast_default<int>(index_str));
cfg.remove_child(global,index);
if (immediate) bactive.remove_child(global,index);
} else {
cfg.clear_children(global);
if (immediate) bactive.clear_children(global);
}
}
}
if (exists) {
cfg.remove_attribute(global);
if (immediate) bactive.remove_attribute(global);
if (cfg.empty()) {
active_->cfg_.clear_children("variables");
active_->cfg_.remove_attribute("variables");
while ((active_->cfg_.empty()) && (active_->parent_ != NULL)) {
active_ = active_->parent_;
active_->remove_child(namespace_.node_);
namespace_ = namespace_.prev();
}
}
// dirty_ = true;
if (!in_transaction_)
ret = save_context();
else if (immediate) {
ret = save_context();
cfg_ = bak;
root_node_.init();
active_->cfg_.clear_children("variables");
active_->cfg_.remove_attribute("variables");
active_->cfg_.add_child("variables",bactive);
config &cfg = active_->cfg_.child("variables");
if (cfg.empty()) {
active_->cfg_.clear_children("variables");
active_->cfg_.remove_attribute("variables");
while ((active_->cfg_.empty()) && (active_->parent_ != NULL)) {
active_ = active_->parent_;
active_->remove_child(namespace_.node_);
namespace_ = namespace_.prev();
}
}
} else
ret = true;
} else {
ret = exists;
}
}
return ret;
}
int main (int argc, char ** argv)
{
time_t tm;
int i, new_mudlib = 0, got_defaults = 0;
char *p;
char version_buf[80];
#if 0
int dtablesize;
#endif
error_context_t econ;
#ifdef PROTO_TZSET
void tzset();
#endif
#ifdef INCL_LOCALE_H
setlocale(LC_ALL, "C");
#endif
#if !defined(__SASC) && (defined(AMITCP) || defined(AS225))
amiga_sockinit();
atexit(amiga_sockexit);
#endif
#ifdef WRAPPEDMALLOC
wrappedmalloc_init();
#endif /* WRAPPEDMALLOC */
#ifdef DEBUGMALLOC
MDinit();
#endif
#if (defined(PROFILING) && !defined(PROFILE_ON) && defined(HAS_MONCONTROL))
moncontrol(0);
#endif
#ifdef USE_TZSET
tzset();
#endif
boot_time = get_current_time();
const0.type = T_NUMBER;
const0.u.number = 0;
const1.type = T_NUMBER;
const1.u.number = 1;
/* const0u used by undefinedp() */
const0u.type = T_NUMBER;
const0u.subtype = T_UNDEFINED;
const0u.u.number = 0;
//fake_prog.program_size = 0; //0 anyway
/*
* Check that the definition of EXTRACT_UCHAR() is correct.
*/
p = (char *) &i;
*p = -10;
if (EXTRACT_UCHAR(p) != 0x100 - 10) {
fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in interpret.h.\n");
exit(-1);
}
/*
* An added test: can we do EXTRACT_UCHAR(x++)?
* (read_number, etc uses it)
*/
p = (char *) &i;
(void) EXTRACT_UCHAR(p++);
if ((p - (char *) &i) != 1) {
fprintf(stderr, "EXTRACT_UCHAR() in interpret.h evaluates its argument more than once.\n");
exit(-1);
}
/*
* Check the living hash table size
*/
if (CFG_LIVING_HASH_SIZE != 4 && CFG_LIVING_HASH_SIZE != 16 &&
CFG_LIVING_HASH_SIZE != 64 && CFG_LIVING_HASH_SIZE != 256 &&
CFG_LIVING_HASH_SIZE != 1024 && CFG_LIVING_HASH_SIZE != 4096) {
fprintf(stderr, "CFG_LIVING_HASH_SIZE in options.h must be one of 4, 16, 64, 256, 1024, 4096, ...\n");
exit(-1);
}
#ifdef RAND
srand(get_current_time());
#else
# ifdef DRAND48
srand48(get_current_time());
# else
# ifdef RANDOM
srandom(get_current_time());
# else
fprintf(stderr, "Warning: no random number generator specified!\n");
# endif
# endif
#endif
current_time = get_current_time();
/*
* Initialize the microsecond clock.
*/
init_usec_clock();
/* read in the configuration file */
got_defaults = 0;
for (i = 1; (i < argc) && !got_defaults; i++) {
if (argv[i][0] != '-') {
set_defaults(argv[i]);
got_defaults = 1;
}
}
get_version(version_buf);
if (!got_defaults) {
fprintf(stderr, "%s for %s.\n", version_buf, ARCH);
fprintf(stderr, "You must specify the configuration filename as an argument.\n");
exit(-1);
}
printf("Initializing internal tables....\n");
init_strings(); /* in stralloc.c */
init_otable(); /* in otable.c */
init_identifiers(); /* in lex.c */
init_locals(); /* in compiler.c */
/*
* If our estimate is larger than FD_SETSIZE, then we need more file
* descriptors than the operating system can handle. This is a problem
* that can be resolved by decreasing MAX_USERS, MAX_EFUN_SOCKS, or both.
*
* Unfortunately, since neither MAX_USERS or MAX_EFUN_SOCKS exist any more,
* we have no clue how many we will need. This code really should be
* moved to places where ENFILE/EMFILE is returned.
*/
#if 0
if (dtablesize > FD_SETSIZE) {
fprintf(stderr, "Warning: File descriptor requirements exceed system capacity!\n");
fprintf(stderr, " Configuration exceeds system capacity by %d descriptor(s).\n",
dtablesize - FD_SETSIZE);
}
#ifdef HAS_SETDTABLESIZE
/*
* If the operating system supports setdtablesize() then we can request
* the number of file descriptors we really need. First check to see if
* wee already have enough. If so dont bother the OS. If not, attempt to
* allocate the number we estimated above. There are system imposed
* limits on file descriptors, so we may not get as many as we asked for.
* Check to make sure we get enough.
*/
if (getdtablesize() < dtablesize)
if (setdtablesize(dtablesize) < dtablesize) {
fprintf(stderr, "Warning: Could not allocate enough file descriptors!\n");
fprintf(stderr, " setdtablesize() could not allocate %d descriptor(s).\n",
getdtablesize() - dtablesize);
}
/*
* Just be polite and tell the administrator how many he has.
*/
fprintf(stderr, "%d file descriptors were allocated, (%d were requested).\n",
getdtablesize(), dtablesize);
#endif
#endif
time_to_clean_up = TIME_TO_CLEAN_UP;
max_cost = MAX_COST;
reserved_size = RESERVED_SIZE;
max_array_size = MAX_ARRAY_SIZE;
if(max_array_size > 65535){
fprintf(stderr, "Maximum array size can not exceed 65535");
max_array_size = 65535;
}
max_buffer_size = MAX_BUFFER_SIZE;
max_string_length = MAX_STRING_LENGTH;
mud_lib = (char *) MUD_LIB;
set_inc_list(INCLUDE_DIRS);
if (reserved_size > 0)
reserved_area = (char *) DMALLOC(reserved_size, TAG_RESERVED, "main.c: reserved_area");
for (i = 0; i < sizeof consts / sizeof consts[0]; i++)
consts[i] = exp(-i / 900.0);
reset_machine(1);
/*
* The flags are parsed twice ! The first time, we only search for the -m
* flag, which specifies another mudlib, and the D-flags, so that they
* will be available when compiling master.c.
*/
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-')
continue;
switch (argv[i][1]) {
case 'D':
if (argv[i][2]) {
lpc_predef_t *tmp = ALLOCATE(lpc_predef_t, TAG_PREDEFINES,
"predef");
tmp->flag = argv[i] + 2;
tmp->next = lpc_predefs;
lpc_predefs = tmp;
continue;
}
fprintf(stderr, "Illegal flag syntax: %s\n", argv[i]);
exit(-1);
case 'N':
no_ip_demon++;
continue;
#ifdef HAS_CONSOLE
case 'C':
has_console = 1;
continue;
#endif
#ifdef YYDEBUG
case 'y':
yydebug = 1;
continue;
#endif /* YYDEBUG */
case 'm':
mud_lib = alloc_cstring(argv[i] + 2, "mudlib dir");
if (chdir(mud_lib) == -1) {
fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib);
exit(-1);
}
new_mudlib = 1;
break;
}
}
if (!new_mudlib && chdir(mud_lib) == -1) {
fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib);
exit(-1);
}
time(&tm);
debug_message("----------------------------------------------------------------------------\n%s (%s) starting up on %s - %s\n\n", MUD_NAME, version_buf, ARCH, ctime(&tm));
add_predefines();
#ifdef WIN32
_tzset();
#endif
#ifndef NO_IP_DEMON
if (!no_ip_demon && ADDR_SERVER_IP)
init_addr_server(ADDR_SERVER_IP, ADDR_SERVER_PORT);
#endif /* NO_IP_DEMON */
set_eval(max_cost);
save_context(&econ);
if (SETJMP(econ.context)) {
debug_message("The simul_efun (%s) and master (%s) objects must be loadable.\n",
SIMUL_EFUN, MASTER_FILE);
exit(-1);
} else {
init_simul_efun(SIMUL_EFUN);
init_master();
}
pop_context(&econ);
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
continue;
} else {
/*
* Look at flags. -m and -o has already been tested.
*/
switch (argv[i][1]) {
case 'D':
case 'N':
case 'm':
case 'y':
case 'C':
continue;
case 'f':
save_context(&econ);
if (SETJMP(econ.context)) {
debug_message("Error while calling master::flag(\"%s\"), aborting ...\n", argv[i] + 2);
exit(-1);
}
push_constant_string(argv[i] + 2);
apply_master_ob(APPLY_FLAG, 1);
if (MudOS_is_being_shut_down) {
debug_message("Shutdown by master object.\n");
exit(0);
}
pop_context(&econ);
continue;
case 'e':
e_flag++;
continue;
case 'p':
external_port[0].port = atoi(argv[i] + 2);
continue;
case 'd':
#ifdef DEBUG_MACRO
if (argv[i][2])
debug_level_set(&argv[i][2]);
else
debug_level |= DBG_d_flag;
#else
debug_message("Driver must be compiled with DEBUG_MACRO on to use -d.\n");
#endif
break;
case 'c':
comp_flag++;
continue;
case 't':
t_flag++;
continue;
default:
debug_message("Unknown flag: %s\n", argv[i]);
exit(-1);
}
}
}
if (MudOS_is_being_shut_down)
exit(1);
if (*(DEFAULT_FAIL_MESSAGE)) {
char buf[8192];
strcpy(buf, DEFAULT_FAIL_MESSAGE);
strcat(buf, "\n");
default_fail_message = make_shared_string(buf);
} else
default_fail_message = "What?\n";
#ifdef PACKAGE_MUDLIB_STATS
restore_stat_files();
#endif
preload_objects(e_flag);
#ifdef SIGFPE
signal(SIGFPE, sig_fpe);
#endif
#ifdef TRAP_CRASHES
#ifdef SIGUSR1
signal(SIGUSR1, sig_usr1);
#endif
#ifdef SIGUSR2
signal(SIGUSR2, sig_usr2);
#endif
signal(SIGTERM, sig_term);
signal(SIGINT, sig_int);
#ifndef DEBUG
#if defined(SIGABRT)
signal(SIGABRT, sig_abrt);
#endif
#ifdef SIGIOT
signal(SIGIOT, sig_iot);
#endif
#ifdef SIGHUP
signal(SIGHUP, sig_hup);
#endif
#ifdef SIGBUS
signal(SIGBUS, sig_bus);
#endif
signal(SIGSEGV, sig_segv);
signal(SIGILL, sig_ill);
#endif /* DEBUG */
#endif
#ifndef WIN32
#ifdef USE_BSD_SIGNALS
signal(SIGCHLD, sig_cld);
#else
signal(SIGCLD, sig_cld);
#endif
#endif
#ifdef HAS_CONSOLE
if(has_console >= 0)
signal(SIGTTIN, sig_ttin);
signal(SIGTTOU, SIG_IGN);
#endif
backend();
return 0;
}
MainWindow::MainWindow()
{
//CREATION DU MENU
setWindowTitle("CalcUTC");
this->size_min();
QMenu *menuOption = menuBar()->addMenu("&Option");
QAction *actionQuitter = new QAction("&Quitter", this); //AJOUT DE QUITTER
menuOption->addAction(actionQuitter);
QAction *actionProgEdit = new QAction("Nouveau programme", this); // Ajout d'une action créer nouveau programme qui ouvre un QEDITTEXT
menuOption->addAction(actionProgEdit);
QMenu *menuAffichage = menuBar()->addMenu("&Affichage");
QAction *actionClavier = new QAction("&Clavier", this); //OPTION D'AFFICHAGE DU CLAVIER ET DES FONCTIONS SCIENTIFIQUES
menuAffichage->addAction(actionClavier);
QAction *actionScientifique = new QAction("&Mode scientifique", this);
menuAffichage->addAction(actionScientifique);
QAction *actionProg = new QAction("&Gestion Programme",this);
menuAffichage->addAction(actionProg);
QAction *actionRedo = new QAction("&Redo", this); // AJOUT DU "Redo"
menuOption->addAction(actionRedo);
actionRedo->setIcon(QIcon("\\Users\\Adrien\\Documents\\Adrien\\UTC\\GI 02\\LO21\\Projet\\version finale\\projet_1_0\\images/arrow_redo.png"));
actionRedo->setShortcut(QKeySequence(tr("Ctrl+y")));
QAction *actionUndo = new QAction("&Undo", this); // AJOUT DU "Undo"
menuOption->addAction(actionUndo);
actionUndo->setIcon(QIcon("\\Users\\Adrien\\Documents\\Adrien\\UTC\\GI 02\\LO21\\Projet\\version finale\\projet_1_0\\images/arrow_undo.png"));
actionUndo->setShortcut(QKeySequence(tr("Ctrl+z")));
QMenu *menuAide = menuBar()->addMenu("&Aide");
QAction *actionAPropos = new QAction("&A propos", this); // AJOUT DU "A PROPOS"
menuAide->addAction(actionAPropos);
// GESTION DES SIGNAUX ET SLOTS DU MENU
connect(actionQuitter, SIGNAL(triggered()), qApp, SLOT(quit()));
actionQuitter->setShortcut(QKeySequence("Escape"));
connect(actionScientifique, SIGNAL(triggered()), this, SLOT(afficher_scientique()));
connect(actionClavier, SIGNAL(triggered()), this, SLOT(afficher_clavier()));
actionClavier->setCheckable(true);
actionScientifique->setCheckable(true);
// CONNECT DU PROGEDIT
connect(actionProg,SIGNAL(triggered(bool)), this, SLOT(openProgWindow()));
connect(actionProgEdit,SIGNAL(triggered()), this, SLOT(openEditProg())); // OUVRE LE QEDITTEXT
connect(actionAPropos,SIGNAL(triggered(bool)), this, SLOT(afficher_APropos()));
//INITIALISATION DES OBJETS DU .h
mainArea = new QWidget;
mainSet = new QHBoxLayout;
scientificPad = new scientific_pad;
scientificPad->hide();
keyboard = new Keyboard();
keyboard->hide();
controlScreen = new QWidget();
controlScreen->setFixedSize(QSize(280, 300));
pile = new Pile ;
qDebug()<<pile;
controleur = Controleur::getInstance(LiteraleManager::getInstance() , *pile) ;
message = new QLineEdit() ;
commande = new QLineEdit() ;
vuePile = new QTableWidget (pile->getNbItemsToAffiche(),1) ;
pile_create();
topLayout = new QHBoxLayout();
middleLayout = new QHBoxLayout();
boutons_droits = new QVBoxLayout();
bottomLayout = new QHBoxLayout();
pile_plus = new QPushButton();
pile_moins = new QPushButton();
enter = new QPushButton();
leftLayout = new QVBoxLayout();
leftLayout->addWidget(vuePile);
vuePile->setStyleSheet("background : rgba(35,141,214,45)");
commande->setStyleSheet("background : rgba(35,141,214,45)");
//MIDDLELAYOUT SETTINGS
middleLayout->addLayout(leftLayout);
middleLayout->addLayout(boutons_droits);
boutons_droits->addWidget(pile_plus);
boutons_droits->addWidget(pile_moins);
//BOTTOM LAYOUT SETTINGS
bottomLayout->addWidget(commande);
bottomLayout->addWidget(enter);
enter->setIcon(QIcon("\\Users\\Adrien\\Documents\\Adrien\\UTC\\GI 02\\LO21\\Projet\\version finale\\projet_1_0\\images/enter-arrow.png"));
enter->setFlat(true);
enter->setFocusPolicy(Qt::NoFocus);
connect(enter,SIGNAL(clicked(bool)),this,SLOT(slot_getNextCommande()));
//BOUTON PILE SETTINGS + CONNECT
pile_plus->setIcon(QIcon("\\Users\\Adrien\\Documents\\Adrien\\UTC\\GI 02\\LO21\\Projet\\version finale\\projet_1_0\\images/add.png"));
pile_plus->setFlat(true);
pile_plus->setFocusPolicy(Qt::NoFocus);
pile_moins->setIcon(QIcon("\\Users\\Adrien\\Documents\\Adrien\\UTC\\GI 02\\LO21\\Projet\\version finale\\projet_1_0\\images/minus.png"));
pile_moins->setFlat(true);
pile_moins->setFocusPolicy(Qt::NoFocus);
connect(pile_plus,SIGNAL(clicked(bool)),pile,SLOT(aug_pile()));
connect(pile_plus,SIGNAL(clicked(bool)),this,SLOT(pile_create()));
connect(pile_moins,SIGNAL(clicked(bool)),pile,SLOT(dim_pile()));
connect(pile_moins,SIGNAL(clicked(bool)),this,SLOT(pile_create()));
// MESSAGE SETTINGS
message->setReadOnly(true); //empèche d'écrire dans la lineEdit
message->setStyleSheet("background: blue; color: yellow");
message->setAlignment(Qt::AlignHCenter);
message->setFixedHeight(45);
//VUE PLIE SETTINGS
vuePile->horizontalHeader()->setVisible(false); //enlève l'indice de col
vuePile->horizontalHeader()->setStretchLastSection(true); //ajuste la largeur à la fenetre
vuePile->setSelectionMode(QAbstractItemView::NoSelection);
vuePile->setEditTriggers(QAbstractItemView::NoEditTriggers) ; //empèche d'écrire dans les cellules
//SOUND_LOCK SETTINGS
sound_lock = new QPushButton();
sound_lock->setIcon(QIcon("\\Users\\Adrien\\Documents\\Adrien\\UTC\\GI 02\\LO21\\Projet\\version finale\\projet_1_0\\images/speaker.png"));
sound_lock->setFlat(true);
sound_lock->setFocusPolicy(Qt::NoFocus);
connect(sound_lock,SIGNAL(clicked(bool)),this,SLOT(sound_disable()));
//GESTION DES CONNECTS DU SCIENTIFIC_PAD
connect(scientificPad->cos, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->sin, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->tan, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->arccos, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->arcsin, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->arctan, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->sqrt, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->puis, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->exp, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->ln, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->div, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
connect(scientificPad->mod, SIGNAL(clicked(bool)), this, SLOT(keyboardButtonPressed()));
//GESTION DES CONNECTS DU CONTROLSCREEN
connect(commande, SIGNAL (returnPressed()) , this , SLOT(slot_getNextCommande())) ;
connect(pile , SIGNAL (modificationEtat()) , this, SLOT(refresh())) ;
//GESTION DES CONNECTS DU KEYBOARD
connect(keyboard->b1,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b2,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b3,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b4,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b5,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b6,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b7,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b8,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b9,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->b0,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->bplus,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->bmoins,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->bdiv,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->bmult,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->clear,SIGNAL(clicked(bool)),commande, SLOT(clear()));
connect(keyboard->space,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->bComp,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->bPo,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
connect(keyboard->bPf,SIGNAL(clicked(bool)),this, SLOT(keyboardButtonPressed()));
//CREATION DES LIENS ENTRE LES LAYOUTS
mainSet->addWidget(scientificPad);
scientificPad->setStyleSheet("background : rgba(35,141,214,45)");
mainSet->addWidget(controlScreen);
message->setStyleSheet("background : rgba(35,186,117,45)");
vuePile->setStyleSheet("background : rgba(35,141,214,25)");;
mainSet->addWidget(keyboard);
keyboard->setStyleSheet("background : rgba(35,141,214,45)");
topLayout->addWidget(message);
topLayout->addWidget(sound_lock);
LcontrolScreen = new QVBoxLayout;
controlScreen->setLayout(LcontrolScreen);
LcontrolScreen->addLayout(topLayout);
LcontrolScreen->addLayout(middleLayout);
LcontrolScreen->addLayout(bottomLayout);
mainArea->setLayout(mainSet);
setCentralWidget(mainArea);
//GESTION SAUVEGARDE CONTEXTE
connect(qApp,SIGNAL(aboutToQuit()),this,SLOT(save_context()));
open_context();
}