Example #1
0
END_TEST

START_TEST(test_parseModel_repressilator)
{
	doc = parseModel(EXAMPLES_FILENAME("repressilator.xml"), 0, 1);
	ck_assert(doc != NULL);
	model = SBMLDocument_getModel(doc);
	ck_assert(model != NULL);
	ck_assert(Model_getNumFunctionDefinitions(model) == 0);
	ck_assert(Model_getNumUnitDefinitions(model) == 0);
	ck_assert(Model_getNumCompartmentTypes(model) == 0);
	ck_assert(Model_getNumSpeciesTypes(model) == 0);
	ck_assert(Model_getNumCompartments(model) == 1);
	ck_assert(Model_getNumSpecies(model) == 6);
	ck_assert(Model_getNumSpeciesWithBoundaryCondition(model) == 0);
	ck_assert(Model_getNumParameters(model) == 3);
	ck_assert(Model_getNumInitialAssignments(model) == 0);
	ck_assert(Model_getNumRules(model) == 6);
	ck_assert(Model_getNumConstraints(model) == 0);
	ck_assert(Model_getNumReactions(model) == 0);
	ck_assert(Model_getNumEvents(model) == 0);
	CHECK_PARAMETER(model, 0, "alpha");
	CHECK_PARAMETER(model, 1, "beta");
	CHECK_PARAMETER(model, 2, "rho");
	CHECK_RULE(model, 0, "beta * (y1 - x1)");
	CHECK_RULE(model, 1, "beta * (y2 - x2)");
	CHECK_RULE(model, 2, "beta * (y3 - x3)");
	CHECK_RULE(model, 3, "alpha * x1 / (1 + x1 + rho * x3) - y1");
	CHECK_RULE(model, 4, "alpha * x2 / (1 + x2 + rho * x1) - y2");
	CHECK_RULE(model, 5, "alpha * x3 / (1 + x3 + rho * x2) - y3");
}
Example #2
0
donnee_t* creerDonnee(const char* type, const char* texte) {

	CHECK_PARAMETER(type, "Erreur : l'assertion n'a pas de type défini (type == NULL).");
	CHECK_PARAMETER(texte, "Erreur : l'assertion n'a pas de commentaire défini (texte == NULL).");

	donnee_t* d = ALLOC(1, donnee_t);
	d->texte = ALLOC(strlen(texte) + 1, char);
	d->type = ALLOC(strlen(type) + 1, char);

	strcpy(d->texte, texte);
	strcpy(d->type, type);

	return d;
}
Example #3
0
NTSTATUS
NTAPI
VTUTF8ChannelProcessAttributes(IN PSAC_CHANNEL Channel,
                               IN UCHAR Attribute)
{
    NTSTATUS Status;
    CHECK_PARAMETER(Channel);

    /* Set bold if needed */
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       Attribute & SAC_CELL_FLAG_BOLD ?
                                       SacAnsiSetBoldAttribute :
                                       SacAnsiClearBoldAttribute,
                                       NULL,
                                       0);
    if (!NT_SUCCESS(Status)) return Status;
    
    /* Set blink if needed */
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       Attribute & SAC_CELL_FLAG_BLINK ?
                                       SacAnsiSetBlinkAttribute :
                                       SacAnsiClearBlinkAttribute,
                                       NULL,
                                       0);
    if (!NT_SUCCESS(Status)) return Status;

    /* Set inverse if needed */
    return VTUTF8ChannelAnsiDispatch(Channel,
                                     Attribute & SAC_CELL_FLAG_INVERTED ?
                                     SacAnsiSetInverseAttribute :
                                     SacAnsiClearInverseAttribute,
                                     NULL,
                                     0);
}
Example #4
0
END_TEST

START_TEST(test_parseModel_basic)
{
	doc = parseModel(EXAMPLES_FILENAME("basic.xml"), 0, 1);
	ck_assert(doc != NULL);
	model = SBMLDocument_getModel(doc);
	ck_assert(model != NULL);
	ck_assert(Model_getNumFunctionDefinitions(model) == 0);
	ck_assert(Model_getNumUnitDefinitions(model) == 0);
	ck_assert(Model_getNumCompartmentTypes(model) == 0);
	ck_assert(Model_getNumSpeciesTypes(model) == 0);
	ck_assert(Model_getNumCompartments(model) == 1);
	ck_assert(Model_getNumSpecies(model) == 2);
	ck_assert(Model_getNumSpeciesWithBoundaryCondition(model) == 0);
	ck_assert(Model_getNumParameters(model) == 1);
	ck_assert(Model_getNumInitialAssignments(model) == 0);
	ck_assert(Model_getNumRules(model) == 0);
	ck_assert(Model_getNumConstraints(model) == 0);
	ck_assert(Model_getNumReactions(model) == 2);
	ck_assert(Model_getNumEvents(model) == 0);
	CHECK_PARAMETER(model, 0, "k_1");
	CHECK_REACTION(model, 0, "R1", "k_1 * S1");
	CHECK_REACTION(model, 1, "R2", "k_2 * S2");
}
Example #5
0
NTSTATUS
NTAPI
VTUTF8ChannelOInit(IN PSAC_CHANNEL Channel)
{
    PSAC_VTUTF8_SCREEN Screen;
    ULONG R, C;
    CHECK_PARAMETER(Channel);

    /* Set the current channel cell parameters */
    Channel->CellFlags = 0;
    Channel->CellBackColor = SetBackColorBlack;
    Channel->CellForeColor = SetColorWhite;

    /* Set the cell buffer position */
    Screen = (PSAC_VTUTF8_SCREEN)Channel->OBuffer;

    /* Loop the output buffer height by width */
    for (R = 0; R < SAC_VTUTF8_ROW_HEIGHT; R++)
    {
        for (C = 0; C < SAC_VTUTF8_COL_WIDTH; C++)
        {
            /* For every character, set the defaults */
            Screen->Cell[R][C].Char = L' ';
            Screen->Cell[R][C].CellBackColor = SetBackColorBlack;
            Screen->Cell[R][C].CellForeColor = SetColorWhite;
        }
    }

    /* All done */
    return STATUS_SUCCESS;
}
Example #6
0
void detruireDonnee(donnee_t* d) {

	CHECK_PARAMETER(d, "Destruction de donnée impossible : donnée nulle.");

	free(d->texte);
	free(d->type);
	free(d);
}
Example #7
0
NTSTATUS
NTAPI
ChannelDestroy(IN PSAC_CHANNEL Channel)
{
    CHECK_PARAMETER(Channel);

    /* Same thing as dereferencing all the handles */
    return ChannelDereferenceHandles(Channel);
}
void ControlMode::onInit()
{
  NODELET_INFO("ControlMode onInit() called");
  nh = getMTNodeHandle();
  nh_priv = getMTPrivateNodeHandle();

  // Diagnostics
  diag_updater.add(getName() + " status", this, &ControlMode::diagnostics);
  diag_updater.setHardwareID("none");
  diag_updater.force_update();

  // Parameters
  nh_priv.param("status_report_rate", status_report_rate, status_report_rate);
  nh_priv.param("control_output_rate", control_output_rate, control_output_rate);
  CHECK_PARAMETER((status_report_rate > 0), "parameter value out of range");
  CHECK_PARAMETER((control_output_rate > 0), "parameter value out of range");

  // Publishers
  control_mode_status_pub = nh_priv.advertise<control_mode_status> ("status", 1, true);
}
Example #9
0
NTSTATUS
NTAPI
VTUTF8ChannelDestroy(IN PSAC_CHANNEL Channel)
{
    CHECK_PARAMETER(Channel);

    /* Free the buffer and then destroy the channel */
    if (Channel->OBuffer) SacFreePool(Channel->OBuffer);
    if (Channel->IBuffer) SacFreePool(Channel->IBuffer);
    return ChannelDestroy(Channel);
}
Example #10
0
void detruireResultat(result_t* r) {

	CHECK_PARAMETER(r, "Tentative de destruction d'un resultat nulle.");

	int i;
	for (i = 0; i < r->size; i++) {
		detruireAssertion(r->asserts[i]);
	}
	free(r->asserts);
	free(r);
}
Example #11
0
void detruireAssertion(assert_t* a) {

	CHECK_PARAMETER(a, "Tentative de destruction d'une assertion nulle.");

	int i;
	for (i = 0; i < a->size; i++) {
		detruireDonnee(a->donnees[i]);
	}
	free(a->donnees);
	free(a->nom);
	free(a);
}
Example #12
0
assert_t* creerAssertion(int condition, const char* nom) {

	CHECK_PARAMETER(nom, "Erreur : l'assertion n'a pas de nom défini (nom == NULL).");

	assert_t* a = ALLOC(1, assert_t);
	a->nom = ALLOC(strlen(nom) + 1, char);
	strcpy(a->nom, nom);
	a->result = condition;
	a->donnees = ALLOC(DATA_LIST_MAX_SIZE, donnee_t*);
	a->size = 0;
	return a;
}
Example #13
0
NTSTATUS
NTAPI
ChannelClose(IN PSAC_CHANNEL Channel)
{
    NTSTATUS Status;
    CHECK_PARAMETER(Channel);

    /* Set the channel inactive */
    ChannelSetStatus(Channel, Inactive);

    /* Set the close event */
    if (Channel->Flags & SAC_CHANNEL_FLAG_CLOSE_EVENT)
    {
        ChannelSetEvent(Channel, CloseEvent);
    }

    /* Close all the handles */
    Status = ChannelDereferenceHandles(Channel);
    return Status;
}
Example #14
0
NTSTATUS
NTAPI
ChannelDereferenceHandles(IN PSAC_CHANNEL Channel)
{
    CHECK_PARAMETER(Channel);

    /* Clear the data event */
    if (Channel->HasNewDataEvent)
    {
        ChannelUninitializeEvent(Channel,
                                 HasNewDataEvent,
                                 SAC_CHANNEL_FLAG_HAS_NEW_DATA_EVENT);
    }

    /* Clear the close event */
    if (Channel->CloseEvent)
    {
        ChannelUninitializeEvent(Channel,
                                 CloseEvent,
                                 SAC_CHANNEL_FLAG_CLOSE_EVENT);
    }

    /* Clear the lock event */
    if (Channel->LockEvent)
    {
        ChannelUninitializeEvent(Channel,
                                 LockEvent,
                                 SAC_CHANNEL_FLAG_LOCK_EVENT);
    }

    /* Clear the redraw event */
    if (Channel->RedrawEvent)
    {
        ChannelUninitializeEvent(Channel,
                                 RedrawEvent,
                                 SAC_CHANNEL_FLAG_REDRAW_EVENT);
    }

    /* All done */
    return STATUS_SUCCESS;
}
Example #15
0
NTSTATUS
NTAPI
RawChannelCreate(IN PSAC_CHANNEL Channel)
{
    CHECK_PARAMETER(Channel);

    /* Allocate the output buffer */
    Channel->OBuffer = SacAllocatePool(SAC_RAW_OBUFFER_SIZE, GLOBAL_BLOCK_TAG);
    CHECK_ALLOCATION(Channel->OBuffer);

    /* Allocate the input buffer */
    Channel->IBuffer = SacAllocatePool(SAC_RAW_IBUFFER_SIZE, GLOBAL_BLOCK_TAG);
    CHECK_ALLOCATION(Channel->IBuffer);

    /* Reset all flags and return success */
    Channel->OBufferIndex = 0;
    Channel->OBufferFirstGoodIndex = 0;
    Channel->ChannelHasNewIBufferData = FALSE;
    Channel->ChannelHasNewOBufferData = FALSE;
    return STATUS_SUCCESS;
}
Example #16
0
NTSTATUS
NTAPI
VTUTF8ChannelCreate(IN PSAC_CHANNEL Channel)
{
    NTSTATUS Status;
    CHECK_PARAMETER(Channel);

    /* Allocate the output buffer */
    Channel->OBuffer = SacAllocatePool(SAC_VTUTF8_OBUFFER_SIZE, GLOBAL_BLOCK_TAG);
    CHECK_ALLOCATION(Channel->OBuffer);

    /* Allocate the input buffer */
    Channel->IBuffer = SacAllocatePool(SAC_VTUTF8_IBUFFER_SIZE, GLOBAL_BLOCK_TAG);
    CHECK_ALLOCATION(Channel->IBuffer);

    /* Initialize the output stream */
    Status = VTUTF8ChannelOInit(Channel);
    if (NT_SUCCESS(Status)) return Status;

    /* Reset all flags and return success */
    _InterlockedExchange(&Channel->ChannelHasNewOBufferData, 0);
    _InterlockedExchange(&Channel->ChannelHasNewIBufferData, 0);
    return STATUS_SUCCESS;
}
Example #17
0
NTSTATUS
NTAPI
VTUTF8ChannelOFlush(IN PSAC_CHANNEL Channel)
{
    NTSTATUS Status;
    PSAC_VTUTF8_SCREEN Screen;
    INT Color[2], Position[2];
    ULONG Utf8ProcessedCount, Utf8Count, R, C, ForeColor, BackColor, Attribute;
    PWCHAR TmpBuffer;
    BOOLEAN Overflow = FALSE;
    CHECK_PARAMETER(Channel);

    /* Set the cell buffer position */
    Screen = (PSAC_VTUTF8_SCREEN)Channel->OBuffer;

    /* Allocate a temporary buffer */
    TmpBuffer = SacAllocatePool(40, GLOBAL_BLOCK_TAG);
    if (!TmpBuffer)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }

    /* First, clear the screen */
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       SacAnsiClearScreen,
                                       NULL,
                                       0);
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* Next, reset the cursor position */
    Position[1] = 0;
    Position[0] = 0;
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       SacAnsiSetPosition,
                                       Position,
                                       sizeof(Position));
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* Finally, reset the attributes */
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       SacAnsiClearAttributes,
                                       NULL,
                                       0);
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* Now set the current cell attributes */
    Attribute = Channel->CellFlags;
    Status = VTUTF8ChannelProcessAttributes(Channel, Attribute);
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* And set the current cell colors */
    ForeColor = Channel->CellForeColor;
    BackColor = Channel->CellBackColor;
    Color[1] = BackColor;
    Color[0] = ForeColor;
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       SacAnsiSetColors,
                                       Color,
                                       sizeof(Color));
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* Now loop all the characters in the cell buffer */
    for (R = 0; R < SAC_VTUTF8_ROW_HEIGHT; R++)
    {
        /* Across every row */
        for (C = 0; C < SAC_VTUTF8_COL_WIDTH; C++)
        {
            /* Check if there's been a change in colors */
            if ((Screen->Cell[R][C].CellBackColor != BackColor) ||
                (Screen->Cell[R][C].CellForeColor != ForeColor))
            {
                /* New colors are being drawn -- are we also on a new row now? */
                if (Overflow)
                {
                    /* Reposition the cursor correctly */
                    Position[1] = R;
                    Position[0] = C;
                    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                                       SacAnsiSetPosition,
                                                       Position,
                                                       sizeof(Position));
                    if (!NT_SUCCESS(Status)) goto Quickie;
                    Overflow = FALSE;
                }

                /* Cache the new colors */
                ForeColor = Screen->Cell[R][C].CellForeColor;
                BackColor = Screen->Cell[R][C].CellBackColor;

                /* Set them on the screen */
                Color[1] = BackColor;
                Color[0] = ForeColor;
                Status = VTUTF8ChannelAnsiDispatch(Channel,
                                                   SacAnsiSetColors,
                                                   Color,
                                                   sizeof(Color));
                if (!NT_SUCCESS(Status)) goto Quickie;
            }

            /* Check if there's been a change in attributes */
            if (Screen->Cell[R][C].CellFlags != Attribute)
            {
                /* Yep! Are we also on a new row now? */
                if (Overflow)
                {
                    /* Reposition the cursor correctly */
                    Position[1] = R;
                    Position[0] = C;
                    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                                       SacAnsiSetPosition,
                                                       Position,
                                                       sizeof(Position));
                    if (!NT_SUCCESS(Status)) goto Quickie;
                    Overflow = FALSE;
                }

                /* Set the new attributes on screen */
                Attribute = Screen->Cell[R][C].CellFlags;
                Status = VTUTF8ChannelProcessAttributes(Channel, Attribute);
                if (!NT_SUCCESS(Status)) goto Quickie;
            }

            /* Time to write the character -- are we on a new row now? */
            if (Overflow)
            {
                /* Reposition the cursor correctly */
                Position[1] = R;
                Position[0] = C;
                Status = VTUTF8ChannelAnsiDispatch(Channel,
                                                   SacAnsiSetPosition,
                                                   Position,
                                                   sizeof(Position));
                if (!NT_SUCCESS(Status)) goto Quickie;
                Overflow = FALSE;
            }

            /* Write the character into our temporary buffer */
            *TmpBuffer = Screen->Cell[R][C].Char;
            TmpBuffer[1] = UNICODE_NULL;

            /* Convert it to UTF-8 */
            if (!SacTranslateUnicodeToUtf8(TmpBuffer,
                                           1,
                                           Utf8ConversionBuffer,
                                           Utf8ConversionBufferSize,
                                           &Utf8Count,
                                           &Utf8ProcessedCount))
            {
                /* Bail out if this failed */
                Status = STATUS_UNSUCCESSFUL;
                goto Quickie;
            }

            /* Make sure we have a remaining valid character */
            if (Utf8Count)
            {
                /* Write it out on the wire */
                Status = ConMgrWriteData(Channel, Utf8ConversionBuffer, Utf8Count);
                if (!NT_SUCCESS(Status)) goto Quickie;
            }
        }

        /* All the characters on the row are done, indicate we need a reset */
        Overflow = TRUE;
    }

    /* Everything is done, set the positition one last time */
    Position[1] = Channel->CursorRow;
    Position[0] = Channel->CursorCol;
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       SacAnsiSetPosition,
                                       Position,
                                       sizeof(Position));
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* Set the current attribute one last time */
    Status = VTUTF8ChannelProcessAttributes(Channel, Channel->CellFlags);
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* Set the current colors one last time */
    Color[1] = Channel->CellBackColor;
    Color[0] = Channel->CellForeColor;
    Status = VTUTF8ChannelAnsiDispatch(Channel,
                                       SacAnsiSetColors,
                                       Color,
                                       sizeof(Color));
    if (!NT_SUCCESS(Status)) goto Quickie;

    /* Flush all the data out on the wire */
    Status = ConMgrFlushData(Channel);

Quickie:
    /* We're done, free the temporary buffer */
    if (TmpBuffer) SacFreePool(TmpBuffer);

    /* Indicate that all new data has been flushed now */
    if (NT_SUCCESS(Status))
    {
        _InterlockedExchange(&Channel->ChannelHasNewOBufferData, 0);
    }

    /* Return the result */
    return Status;
}
Example #18
0
NTSTATUS
NTAPI
ChannelCreate(IN PSAC_CHANNEL Channel,
              IN PSAC_CHANNEL_ATTRIBUTES Attributes,
              IN SAC_CHANNEL_ID ChannelId)
{
    NTSTATUS Status;
    CHECK_PARAMETER1(Channel);
    CHECK_PARAMETER2(Attributes);

    /* If a close event is being passed in, it must exist, and vice-versa */
    if (Attributes->Flag & SAC_CHANNEL_FLAG_CLOSE_EVENT)
    {
        CHECK_PARAMETER(Attributes->CloseEvent != NULL);
    }
    else
    {
        CHECK_PARAMETER(Attributes->CloseEvent == NULL);
    }

    /* If a new data event is being passed in, it must exist, and vice-versa */
    if (Attributes->Flag & SAC_CHANNEL_FLAG_HAS_NEW_DATA_EVENT)
    {
        CHECK_PARAMETER(Attributes->HasNewDataEvent != NULL);
    }
    else
    {
        CHECK_PARAMETER(Attributes->HasNewDataEvent == NULL);
    }

    /* If a lock event is being passed in, it must exist, and vice-versa */
    if (Attributes->Flag & SAC_CHANNEL_FLAG_LOCK_EVENT)
    {
        CHECK_PARAMETER(Attributes->LockEvent != NULL);
    }
    else
    {
        CHECK_PARAMETER(Attributes->LockEvent == NULL);
    }

    /* If a redraw event is being passed in, it must exist, and vice-versa */
    if (Attributes->Flag & SAC_CHANNEL_FLAG_REDRAW_EVENT)
    {
        CHECK_PARAMETER(Attributes->RedrawEvent != NULL);
    }
    else
    {
        CHECK_PARAMETER(Attributes->RedrawEvent == NULL);
    }

    /* Initialize the channel structure */
    RtlZeroMemory(Channel, sizeof(SAC_CHANNEL));
    Channel->ChannelId = ChannelId;
    Channel->ChannelType = Attributes->ChannelType;
    Channel->Flags = Attributes->Flag;
    if (Attributes->Flag & SAC_CHANNEL_FLAG_APPLICATION)
    {
        Channel->ApplicationType = Attributes->ChannelId;
    }

    /* Initialize all the locks and events */
    SacInitializeLock(&Channel->ChannelAttributeLock);
    SacInitializeLock(&Channel->ChannelOBufferLock);
    SacInitializeLock(&Channel->ChannelIBufferLock);
    ChannelInitializeEvent(Channel, Attributes, CloseEvent);
    ChannelInitializeEvent(Channel, Attributes, HasNewDataEvent);
    ChannelInitializeEvent(Channel, Attributes, LockEvent);
    ChannelInitializeEvent(Channel, Attributes, RedrawEvent);

    /* Set the name and description */
    ChannelSetName(Channel, Attributes->NameBuffer);
    ChannelSetDescription(Channel, Attributes->DescriptionBuffer);

    /* Initialize the function table for the type of channel this is */
    Status = ChannelInitializeVTable(Channel);
    if (!NT_SUCCESS(Status))
    {
        /* This is critical */
        SAC_DBG(SAC_DBG_INIT, "SAC Create Channel :: Failed to initialize vtable\n");
        goto FailChannel;
    }

    /* Now call the channel specific type constructor */
    Status = Channel->ChannelCreate(Channel);
    if (!NT_SUCCESS(Status))
    {
        /* This is critical */
        SAC_DBG(SAC_DBG_INIT, "SAC Create Channel :: Failed channel specific initialization\n");
        goto FailChannel;
    }

    /* Finally, mark the channel as active */
    ChannelSetStatus(Channel, Active);
    return STATUS_SUCCESS;

FailChannel:
    /* Destroy the channel and return the failure code */
    Channel->ChannelDestroy(Channel);
    return Status;
}
Example #19
0
H_U32 _StorageUpdata(device_storage_gather_t *device_info)
{
	H_U32 retcode;
	WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"in __storage_device_updata");
	CHECK_PARAMETER(device_info, H_NULL, H_FAULTER);
	//H_U8 * buffer = H_NULL;
	//buffer = (H_U8 *)wy_malloc(STORAGE_BLOCK_LEN);
	//if( buffer == H_NULL)
	//{
	//	WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"malloc fail");
	//	return H_FAULTER;
	//}
	static H_U8 storage_buffer[STORAGE_BLOCK_LEN] = {0};
	H_U32 offset = 0;
	H_U32 magic_data = 0;

	wy_memset(storage_buffer,0xFF,STORAGE_BLOCK_LEN);
	//WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"reading entire block...");
	if(_StorageRead(device_info->handler, STORAGE_BLOCK_LEN,0,storage_buffer,device_info->user_block_size) != H_SUCCESS)
	{
		WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"read fail");
		//wy_free(buffer);
		//buffer = H_NULL;
		return H_FAULTER;
	}
	//WYPrintf_array(storage_buffer, STORAGE_BLOCK_LEN);
	wy_tools_op()->_delay_ms(10);
	offset = device_info->id * device_info->user_block_size ;
	WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"offset will be:%d",offset);
	magic_data = decode32(storage_buffer, offset);
	if(magic_data == device_info->magic_data || magic_data == 0) // check whether this block has been written before and is written by correct module
	{                                                          //workaround
		WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"magic1");
		if(device_info->magic_clear)//delete a record
		{
			WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"magic2");
			wy_memset(&(storage_buffer[offset]), 0xff, device_info->hand_len);
		}
		wy_memcpy(&(storage_buffer[offset + device_info->hand_len]), device_info->data, device_info->data_len);
	}
	else  //this block has not been written before 
	{
		if(!device_info->magic_clear)//add a record 
		{
			encode32(device_info->magic_data, storage_buffer, offset);
			wy_memcpy(&(storage_buffer[offset + device_info->hand_len]), device_info->data, device_info->data_len);
			
			WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"magic3:%x ",device_info->magic_data);
			
		}
	}
	retcode = _StorageErase(device_info->handler,STORAGE_BLOCK_LEN);
	WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"erasing module:%d block :%d",device_info->handler->module_id,device_info->handler->block_id);
	WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"ret of erase:%d",retcode);
	if(retcode  != H_SUCCESS)
		
	{
		WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"erase fail");
		//wy_free(buffer);
		//buffer = H_NULL;
		return H_FAULTER;
	}
	//wy_tools_op()->_delay_ms(100);
	//WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"before write1 for module:%d",device_info->handler->module_id);
	retcode = _StorageWrite(device_info->handler,storage_buffer,STORAGE_BLOCK_LEN, 0,device_info->user_block_size);
	WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"ret of write:%d  block size:%d",retcode,device_info->user_block_size);
	if(retcode != H_SUCCESS)
	{
		WYPrintf(MODULE_DEBUG_STORAGE,LEVEL_DEBUG,"rewrite fail");
		//wy_free(buffer);
		//buffer = H_NULL;
		return H_FAULTER;
	}
	wy_tools_op()->_delay_ms(100);
	//wy_free(buffer);
	//buffer = H_NULL;
	return H_SUCCESS;
}