void RFM70::setModeRX(void) {
	uint8_t val;

	// Flush RX FIFO
	spiSend(0, (uint8_t *) RFM70_cmd_flush_rx, NELEMS(RFM70_cmd_flush_rx));
	// Read Status
	val = readRegVal(RFM70_REG_STATUS);
	// Reset IRQ bits
	uint8_t data[] = {RFM70_CMD_WRITE_REG | RFM70_REG_STATUS, val};
	spiSend(0, data, 2);
	// RFM chip disable
	digitalWrite(_ce, LOW);
	// set PRIM_RX bit to 1
	val = readRegVal(RFM70_REG_CONFIG);
	val |= RFM70_PIN_PRIM_RX;
	data[0] = RFM70_CMD_WRITE_REG | RFM70_REG_CONFIG;
	data[1] = val;
	spiSend(0, data, 2);
	// RFM chip enable
	digitalWrite(_ce, HIGH);
}

static void
recv_stop(Event_Type et, Object *obj, Any_Type reg_arg, Any_Type call_arg) {
    Call *c = (Call *) obj;
    int index;

    assert(et == EV_CALL_RECV_STOP && object_is_call(c));
    assert(c->basic.time_recv_start > 0);

    basic.call_xfer_sum += timer_now() - c->basic.time_recv_start;

    basic.hdr_bytes_received += c->reply.header_bytes;
    basic.reply_bytes_received += c->reply.content_bytes;
    basic.footer_bytes_received += c->reply.footer_bytes;

    index = (c->reply.status / 100);
    assert((unsigned) index < NELEMS(basic.num_replies));
    ++basic.num_replies[index];
    ++num_replies;

    ++c->conn->basic.num_calls_completed;
}

void Atom_free(const char *str)
{
	unsigned long h;
	unsigned long hash_number;
	struct atom *p;
	struct atom *c;
	int Len;

	assert(str);

	Len = strlen(str);

	//Cercare atomo con la stringa
	hash_number = Atom_CalculateHash(str, Len);
	h = hash_number % NELEMS(buckets);
#ifdef DEBUG
	fprintf(stderr, "Hash number for string %s => %ld\n", str, hash_number);
	fprintf(stderr, "Hash value for string %s => %ld\n", str, h);
#endif

	c = buckets[h];
	p = NULL;
	/* Se due stringhe hanno un hash_number uguale, significa che corrispondono
	 * */
	while( c && (hash_number != c->hash_number) )
	{
		p = c;
		c = c->link;
	}

	if( p == NULL )
	{
		buckets[h] = c->link;
	}
	else
	{
		p->link = c->link;
	}
    FREE(c);
}

static void
set_debug_level(void)
{
    char *ccspDbg;
    int i;
    struct {
        char *name;
        int level;
    } levelTab[] = {
        {"debug",       CCSP_TRACE_LEVEL_DEBUG, },
        {"info",        CCSP_TRACE_LEVEL_INFO, },
        {"notice",      CCSP_TRACE_LEVEL_NOTICE, },
        {"warning",     CCSP_TRACE_LEVEL_WARNING, },
        {"error",       CCSP_TRACE_LEVEL_ERROR, },
        {"critical",    CCSP_TRACE_LEVEL_CRITICAL, },
        {"alert",       CCSP_TRACE_LEVEL_ALERT, },
        {"emergency",   CCSP_TRACE_LEVEL_EMERGENCY, },
    };

            pComponentName = "CCSP_SNMNP_Plugin";

    ccspDbg = getenv("CCSPDBG");
    if (!ccspDbg)
        return;

    for (i = 0; i < NELEMS(levelTab); i++)
    {
        if (AnscEqualString(ccspDbg, levelTab[i].name, TRUE))
        {
            AnscSetTraceLevel(levelTab[i].level);
            //pComponentName = "CCSP_SNMNP_Plugin";

            AnscTraceWarning(("setting debug level to \"%s\"\n", levelTab[i].name));
            break;
        }
    }

    return;
}

	LONG WINAPI OnUnhandledException(PEXCEPTION_POINTERS pExceptionInfo)
	{
		if (!bPassOn) // exception occurred while closing, force kill the server
			ExitProcess(1);

		bPassOn = false;

		MINIDUMP_EXCEPTION_INFORMATION ei;
		ei.ExceptionPointers = pExceptionInfo;
		ei.ThreadId = GetCurrentThreadId();
		ei.ClientPointers = FALSE;

		DWORD dwProcessId = GetCurrentProcessId();
		SYSTEMTIME stLocalTime;
		GetLocalTime(&stLocalTime);
		wchar_t CrashDumpW[1024];
		swprintf_s(CrashDumpW, NELEMS(CrashDumpW), 
				L"%s\\%s-%s-%s-%04X-%04d%02d%02d-%02d%02d%02d-%ld-%ld.dmp", 
				g_CrashDirectory.c_str(), L"Phasor", PHASOR_HALO_BUILD,
				PHASOR_MAJOR_VERSION_STR, 
				PHASOR_INTERNAL_VERSION, stLocalTime.wYear, stLocalTime.wMonth,
				stLocalTime.wDay, stLocalTime.wHour, stLocalTime.wMinute, 
				stLocalTime.wSecond, dwProcessId, ei.ThreadId);

		HANDLE hFile = CreateFileW(CrashDumpW, GENERIC_READ | GENERIC_WRITE,
			NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

#ifdef BUILD_DEBUG
		MINIDUMP_TYPE dwDumpType = MiniDumpWithFullMemory;
#else
		MINIDUMP_TYPE dwDumpType = MiniDumpScanMemory;
#endif

		MiniDumpWriteDump(GetCurrentProcess(), dwProcessId, hFile, 
			dwDumpType, &ei, NULL, NULL);
		CloseHandle(hFile);

		return EXCEPTION_EXECUTE_HANDLER;
	}

void AllocateLightingPreviewtextures(void)
{
	static bool bHaveAllocated=false;
	if (! bHaveAllocated )
	{
		bHaveAllocated = true;
		MaterialSystemInterface()->BeginRenderTargetAllocation();
		for(int idx=0;idx<NELEMS(sg_ExtraFP16Targets);idx++)
			sg_ExtraFP16Targets[idx].Init(
				materials->CreateNamedRenderTargetTextureEx2(
					s_rt_names[idx],
					512, 512, RT_SIZE_DEFAULT, s_rt_formats[idx],
					MATERIAL_RT_DEPTH_SHARED, 
					TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
					CREATERENDERTARGETFLAGS_HDR )
				);
		
		// End block in which all render targets should be allocated (kicking off an Alt-Tab type
		// behavior)
		MaterialSystemInterface()->EndRenderTargetAllocation();
	}
}

void CASW_Briefing::AutoSelectFullSquadForSingleplayer( int nFirstSelectedProfileIndex )
{
	if ( !MarineProfileList() )
		return;

	CASW_Marine_Profile* pFirstSelectedProfile = MarineProfileList()->GetProfile( nFirstSelectedProfileIndex );
	if ( !pFirstSelectedProfile )
		return;

	ASW_Marine_Class nMarineClasses[]=
	{
		MARINE_CLASS_NCO, 
		MARINE_CLASS_SPECIAL_WEAPONS,
		MARINE_CLASS_MEDIC,
		MARINE_CLASS_TECH
	};

	// select one of each class
	for ( int i = 0; i < NELEMS( nMarineClasses ); i++ )
	{
		if ( nMarineClasses[ i ] == pFirstSelectedProfile->GetMarineClass() )
			continue;

		CASW_Marine_Profile* pProfile = NULL;
		for ( int p = 0; p < MarineProfileList()->m_NumProfiles; p++ )
		{
			pProfile = MarineProfileList()->GetProfile( p );
			if ( pProfile && pProfile->GetMarineClass() == nMarineClasses[i] )
			{
				break;
			}
		}

		if ( !pProfile )
			continue;

		SelectMarine( 0, pProfile->m_ProfileIndex, -1 );
	}
}

static unsigned int
elf_x86_x86_map_reloc_info_to_type(elf_reloc_entry *reloc,
                                   yasm_symrec **ssyms)
{
    if (reloc->wrt) {
        size_t i;
        for (i=0; i<NELEMS(elf_x86_x86_ssyms); i++) {
            if (reloc->wrt == ssyms[i] &&
                reloc->valsize == elf_x86_x86_ssyms[i].size) {
                /* Force TLS type; this is required by the linker. */
                if (elf_x86_x86_ssyms[i].sym_rel & ELF_SSYM_THREAD_LOCAL) {
                    elf_symtab_entry *esym;

                    esym = yasm_symrec_get_data(reloc->reloc.sym,
                                                &elf_symrec_data);
                    if (esym)
                        esym->type = STT_TLS;
                }
                return (unsigned char) elf_x86_x86_ssyms[i].reloc;
            }
        }
        yasm_internal_error(N_("Unsupported WRT"));
    } else if (reloc->rtype_rel) {
        switch (reloc->valsize) {
            case 8: return (unsigned char) R_386_PC8;
            case 16: return (unsigned char) R_386_PC16;
            case 32: return (unsigned char) R_386_PC32;
            default: yasm_internal_error(N_("Unsupported relocation size"));
        }
    } else {
        switch (reloc->valsize) {
            case 8: return (unsigned char) R_386_8;
            case 16: return (unsigned char) R_386_16;
            case 32: return (unsigned char) R_386_32;
            default: yasm_internal_error(N_("Unsupported relocation size"));
        }
    }
    return 0;
}

static error test_rename(atom_set_t *d)
{
  error err;
  int   i;

  printf("test: rename\n");

  for (i = 0; i < NELEMS(newnames); i++)
  {
    atom_t idx;

    printf("adding '%s'... ", data[i]);

    err = atom_new(d, (const unsigned char *) data[i],
                   strlen(data[i]) + 1, &idx);
    if (err && err != error_ATOM_NAME_EXISTS)
      return err;

    if (err == error_ATOM_NAME_EXISTS)
      printf("already exists ");

    printf("as %d\n", idx);

    printf("renaming index %d to '%s'... ", idx, newnames[i]);

    err = atom_set(d, idx, (const unsigned char *) newnames[i],
                   strlen(newnames[i]) + 1);
    if (err == error_ATOM_NAME_EXISTS)
      printf("already exists!");
    else if (err)
      return err;
    else
      printf("ok");

    printf("\n");
  }

  return error_OK;
}

int uninstall_cfw(void)
{
	int ret;

	sceIoRemove("flash1:/config.se");

	int i; for(i=0; i<NELEMS(g_file_lists); ++i) {
		printf("Removing %s...", g_file_lists[i].dst);
		ret = sceIoRemove(g_file_lists[i].dst);

		if(ret == 0 || ret == 0x80010002) {
			printf("OK\n");
		} else {
			printf("failed(0x%08X)\n", ret);
		}
	}

	// per model uninstall goes here:
	switch(psp_model) {
		case PSP_GO:
			break;
		case PSP_4000:
			break;
		case PSP_3000:
			break;
		case PSP_2000:
			break;
		case PSP_1000:
			break;
	}

	if(is_permanent_patch_installed()) {
		printf("Uninstalling permanent patch...");
		uninstall_permanent_patch();
		printf("OK\n");
	}

	return 0;
}

static error test_add_tags(State *state)
{
  error err;
  int   i;

  for (i = 0; i < NELEMS(tagnames); i++)
  {
    printf("adding '%s'...", tagnames[i]);
    err = tagdb_add(state->db, tagnames[i], &state->tags[i]);
    if (err)
      goto Failure;

    printf("is tag %d\n", state->tags[i]);
  }

  return error_OK;


Failure:

  return err;
}

int simulate_files(int creat)
{
	size_t i;
	char *files[] =
	    { "config0.cfg", "config1.cfg", "config2.cfg", "config3.cfg",
		"rr109.img", "rx100.img", "rx107.img", "rm957.img", "messages"
	};

	for (i = 0; i < NELEMS(files); i++) {
		if (creat)
			touch(files[i]);
		else
			erase(files[i]);
	}

	if (creat)
		symlink("config2.cfg", STARTUP_CONFIG);
	else
		erase(STARTUP_CONFIG);

	return 0;
}

static void
mrb_wslay_event_on_msg_recv_callback(wslay_event_context_ptr ctx,
  const struct wslay_event_on_msg_recv_arg *arg, void *user_data)
{
  mrb_wslay_user_data *data = (mrb_wslay_user_data *) user_data;
  mrb_state *mrb = data->mrb;

  int ai = mrb_gc_arena_save(mrb);
  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
  struct mrb_jmpbuf c_jmp;

  MRB_TRY(&c_jmp) {
    mrb->jmp = &c_jmp;

    mrb_value argv[4];
    argv[0] = mrb_fixnum_value(arg->rsv);
    argv[1] = MRB_GET_OPCODE(mrb_fixnum_value(arg->opcode));
    argv[2] = mrb_str_new(mrb, (const char *) arg->msg, arg->msg_length);
    argv[3] = MRB_GET_STATUSCODE(mrb_fixnum_value(arg->status_code));

    mrb_value on_msg_recv_arg = mrb_obj_new(mrb,
      mrb_class_get_under(mrb,
        mrb_module_get_under(mrb,
          mrb_module_get(mrb, "Wslay"), "Event"), "OnMsgRecvArg"), NELEMS(argv), argv);

    mrb_assert(mrb_type(data->on_msg_recv_callback) == MRB_TT_PROC);
    mrb_yield(mrb, data->on_msg_recv_callback, on_msg_recv_arg);

    mrb_gc_arena_restore(mrb, ai);

    mrb->jmp = prev_jmp;
  } MRB_CATCH(&c_jmp) {
    mrb->jmp = prev_jmp;
    wslay_event_set_error(ctx, WSLAY_ERR_CALLBACK_FAILURE);
    mrb_gc_arena_restore(mrb, ai);
    MRB_THROW(mrb->jmp);
  } MRB_END_EXC(&c_jmp);
}

String Accelerometer::processor() {
  String output;
  for (int axis=0; axis<3; axis++) {
    average_delta_a[axis]  = 0;
  }
  
  for (int i=0; i<iterations; i++) {
    readAccelerometer();
    for (int axis=0; axis<3; axis++) {
      //delta_a[axis][i]=current_acceleration[axis] - previous_acceleration[axis];
      //average_delta_a[axis] += delta_a[axis][i];
      average_delta_a[axis] += current_acceleration[axis] - previous_acceleration[axis];
    }
    delay(delta);
  }

  for (int axis=0; axis<3; axis++) {
    average_delta_a[axis] = average_delta_a[axis] / iterations;
    
    if (abs(average_delta_a[axis]) > mThreshold
      && (millis() - previous_event_time[axis]) > mEventThreshold) {
      if (previous_event[axis] > 0 && average_delta_a[axis] < 0) { // turning point
        output = axes[axis][0];
      } else if (previous_event[axis] < 0 && average_delta_a[axis] > 0) { // turning point 
        output = axes[axis][1];
      }
      previous_event_time[axis] = millis(); // update last event
      previous_event[axis] = average_delta_a[axis]; // store this last acceleration value
    }
    
  }
  
  // store previous acceleration
  for (int i=0; i<NELEMS(current_acceleration); i++) {
    previous_acceleration[i] = current_acceleration[i];
  }
  return output;
}

static error test_enumerate_ids_by_tags(State *state)
{
  error err;
  int   cont;
  char  buf[256];

  {
    static const tagdb_tag want[] = { 0, 1 };

    printf("ids tagged with '%s' and '%s'...\n",
           tagnames[want[0]], tagnames[want[1]]);

    cont = 0;
    do
    {
      err = tagdb_enumerate_ids_by_tags(state->db, want, NELEMS(want),
                                              &cont, buf, sizeof(buf));
      if (err)
        goto Failure;

      if (cont)
      {
        printf("- ");
        printdigest(buf);
        printf("\n");
      }
    }
    while (cont);
  }

  return error_OK;


Failure:

  return err;
}

void preferences_save_media(int fd)
{
 Wire w;
 int i, n;
 char *medium_defs="MEDIUM_DEFINITIONS";

  DBG(DBG_proc, "preferences_save_media\n");

  w.io.fd = fd;
  w.io.read = read;
  w.io.write = write;
  xsane_rc_io_w_init(&w);
  xsane_rc_io_w_set_dir(&w, WIRE_ENCODE);

  xsane_rc_io_w_string(&w, &medium_defs);
  xsane_rc_io_w_word(&w, &preferences.medium_definitions);

  /* save media */

  n=0;

  DBG(DBG_info, "saving %d medium definitions\n", preferences.medium_definitions);

  while (n < preferences.medium_definitions)
  {
    DBG(DBG_info2, "=> saving medium definition %s\n", preferences.medium[n]->name);
    for (i = 0; i < NELEMS(desc_medium); ++i)
    {
      xsane_rc_io_w_string(&w, &desc_medium[i].name);
      (*desc_medium[i].codec) (&w, preferences.medium[n], desc_medium[i].offset);
    }
    n++;
  }

  xsane_rc_io_w_set_dir(&w, WIRE_DECODE);	/* flush it out */
  xsane_rc_io_w_exit(&w);
}

static unsigned emitasm(Node p, int nt) {
	int rulenum;
	short *nts;
	char *fmt;
	Node kids[10];

	p = reuse(p, nt);
	rulenum = getrule(p, nt);
	nts = IR->x._nts[rulenum];
	fmt = IR->x._templates[rulenum];
	assert(fmt);
	if (IR->x._isinstruction[rulenum] && p->x.emitted)
		print("%s", p->syms[RX]->x.name);
	else if (*fmt == '#')
		(*IR->x.emit2)(p);
	else {
		if (*fmt == '?') {
			fmt++;
			assert(p->kids[0]);
			if (p->syms[RX] == p->x.kids[0]->syms[RX])
				while (*fmt++ != '\n')
					;
		}
		for ((*IR->x._kids)(p, rulenum, kids); *fmt; fmt++)
			if (*fmt != '%')
				(void)putchar(*fmt);
			else if (*++fmt == 'F')
				print("%d", framesize);
			else if (*fmt >= '0' && *fmt <= '9')
				emitasm(kids[*fmt - '0'], nts[*fmt - '0']);
			else if (*fmt >= 'a' && *fmt < 'a' + NELEMS(p->syms))
				fputs(p->syms[*fmt - 'a']->x.name, stdout);
			else
				(void)putchar(*fmt);
	}
	return 0;
}

static void *
extract_db_exec_stat (FILE * fp, const char *dbname, T_CM_ERROR * err_buf)
{
  unsigned int nitem = 0;
  char linebuf[LINE_MAX];
  char prop_name[100];
  T_CM_DB_EXEC_STAT *stat;
  stat = (T_CM_DB_EXEC_STAT *) calloc (1, sizeof (*stat));
  if (stat == NULL)
    {
      cm_set_error (err_buf, CM_OUT_OF_MEMORY);
      return NULL;
    }
  while (fgets (linebuf, sizeof (linebuf), fp))
    {
      unsigned int *member_ptr;
      unsigned int prop_val;
      memset (prop_name, 0, sizeof (prop_name));
      sscanf (linebuf, "%99s%*s%u", prop_name, &prop_val);
      member_ptr = get_statdump_member_ptr (stat, prop_name);
      if (!member_ptr)
	continue;
      *member_ptr = prop_val;
      nitem++;
    }
  if (nitem < NELEMS (statdump_offset))
    {
      err_buf->err_code = CM_READ_STATDUMP_INFO_ERROR;
      snprintf (err_buf->err_msg, sizeof (err_buf->err_msg) - 1,
		ER (err_buf->err_code), dbname);
      FREE_MEM (stat);
      return NULL;
    }

  return stat;

}

// monitor output from our process to determine which part of the build we're in
void CASW_Map_Builder::UpdateProgress()
{
	// copy the new chars into our buffer
	int newcharslen = Q_strlen(m_szProcessBuffer);
	for (int i=0;i<newcharslen;i++)
	{
		m_szOutputBuffer[m_iOutputBufferPos++] = m_szProcessBuffer[i];
		// if we go over the end of our output buffer, then shift everything back by half the buffer and continue
		if (m_iOutputBufferPos >= MAP_BUILD_OUTPUT_BUFFER_SIZE)
		{
			for (int k=0;k<MAP_BUILD_OUTPUT_BUFFER_HALF_SIZE;k++)
			{
				m_szOutputBuffer[k] = m_szOutputBuffer[k + MAP_BUILD_OUTPUT_BUFFER_HALF_SIZE];
			}
			m_iOutputBufferPos = MAP_BUILD_OUTPUT_BUFFER_HALF_SIZE;
		}
	}

	// now scan our buffer for progress messages in reverse order
	int iNumSearch = NELEMS(s_szProgressTerms);
	for (int iSearch=iNumSearch-1;iSearch>m_iCurrentBuildSearch;iSearch--)
	{
		char *pos = Q_strstr(m_szOutputBuffer, s_szProgressTerms[iSearch]);
		if ( pos )
		{
			//Msg("Output (%s) matched (%s) result %s at %d\n", m_szOutputBuffer, s_szProgressTerms[iSearch], pos, pos - m_szOutputBuffer);
			m_iCurrentBuildSearch = iSearch;
			m_flProgress = float(iSearch) / float (iNumSearch);
			if (Q_strlen(s_szStatusLabels[iSearch]) > 0)
			{
				Q_snprintf( m_szStatusMessage, sizeof(m_szStatusMessage), "%s", s_szStatusLabels[iSearch] );

			}
			break;
		}
	}
}

char *stringn(char *str, int len)
{
    int i;
    unsigned int h;
    char *end;
    struct string *p;

    /* hash function */
    for (h = 0, i = len, end = str; i > 0; i--)
	h = (h<<1) + scatter[*(unsigned char *)end++];
    h &= NELEMS(buckets) - 1;

    for (p = buckets[h]; p; p = p->link)
	if (len == p->len) {
	    char *s1 = str, *s2 = p->str;
	    do {
		if (s1 == end)
		    return p->str;
	    } while (*s1++ == *s2++);
	}
    {
	static char *next, *strlimit;
	if (next + len + 1 >= strlimit) {
	    int n = len + 4*1024;
	    next = allocate(n, PERM);
	    strlimit = next + n;
	}
	NEW(p, PERM);
	p->len = len;
	for (p->str = next; str < end; )
	    *next++ = *str++;
	*next++ = 0;
	p->link = buckets[h];
	buckets[h] = p;
	return p->str;
    }
}