/** Check if a sequence of three accounts violates the no ripple constrains
[first] -> [second] -> [third]
Disallowed if 'second' set no ripple on [first]->[second] and [second]->[third]
*/
void PathState::checkNoRipple (
uint160 const& firstAccount,
uint160 const& secondAccount, // This is the account whose constraints we are checking
uint160 const& thirdAccount,
uint160 const& currency)
{
// fetch the ripple lines into and out of this node
SLE::pointer sleIn = lesEntries.entryCache (ltRIPPLE_STATE,
Ledger::getRippleStateIndex (firstAccount, secondAccount, currency));
SLE::pointer sleOut = lesEntries.entryCache (ltRIPPLE_STATE,
Ledger::getRippleStateIndex (secondAccount, thirdAccount, currency));
if (!sleIn || !sleOut)
{
terStatus = terNO_LINE;
}
else if (
is_bit_set (sleIn->getFieldU32 (sfFlags),
(secondAccount > firstAccount) ? lsfHighNoRipple : lsfLowNoRipple) &&
is_bit_set (sleOut->getFieldU32 (sfFlags),
(secondAccount > thirdAccount) ? lsfHighNoRipple : lsfLowNoRipple))
{
WriteLog (lsINFO, RippleCalc) << "Path violates noRipple constraint between " <<
RippleAddress::createHumanAccountID (firstAccount) << ", " <<
RippleAddress::createHumanAccountID (secondAccount) << " and " <<
RippleAddress::createHumanAccountID (thirdAccount);
terStatus = terNO_RIPPLE;
}
}
static int serial_device_init(unsigned int ttys, long baud)
{
unsigned long serialaddr;
unsigned long devid;
serial_fifo_t *serf;
/* hardware serial device number */
if( ttys >= 16 ) {
return -ENODEV;
}
if( baud < 0)
return -EINVAL;
devid = XM_2_DEV(Console_MINOR, Console_MAJOR);
suspend_domain(devid, XMDEV_IO_OPEN);
serialaddr = event_handling->serialaddr;
serf = (serial_fifo_t *)serialaddr;
/* register serial device */
if( !is_bit_set(serf->flag, RT_SERIAL_dev_INIT) )
return -EPIPE;
if( is_bit_set(serf->flag, RT_SERIAL_dom_USED) )
return -EBUSY;
set_bit(serf->flag, RT_SERIAL_dom_USED);
/* register serial device */
rt_serial.in.serf = (serial_fifo_t *)serialaddr;
rt_serial.in.addr = (char *)(serialaddr + sizeof(serial_fifo_t));
serialaddr += PAGE_SIZE;
rt_serial.out.serf = (serial_fifo_t *)serialaddr;
rt_serial.out.addr = (char *)(serialaddr + sizeof(serial_fifo_t));
serf->baud = baud;
serf->prio = Console_MINOR;
serf->flag |= (ttys << 24) & RT_SERIAL_dom_DEST_MASK; /* Destination Console Device */
serf = rt_serial.out.serf;
set_bit(serf->flag, RT_SERIAL_dom_USED);
serf->baud = baud;
serf->prio = Console_MINOR;
serf->flag |= (ttys << 24) & RT_SERIAL_dom_DEST_MASK; /* Destination Console Device */
return 0;
}
int oxygen_pci_resume(struct pci_dev *pci)
{
struct snd_card *card = pci_get_drvdata(pci);
struct oxygen *chip = card->private_data;
unsigned int i;
pci_set_power_state(pci, PCI_D0);
pci_restore_state(pci);
if (pci_enable_device(pci) < 0) {
snd_printk(KERN_ERR "cannot reenable device");
snd_card_disconnect(card);
return -EIO;
}
pci_set_master(pci);
oxygen_write16(chip, OXYGEN_DMA_STATUS, 0);
oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, 0);
for (i = 0; i < OXYGEN_IO_SIZE; ++i)
if (is_bit_set(registers_to_restore, i))
oxygen_write8(chip, i, chip->saved_registers._8[i]);
if (chip->has_ac97_0)
oxygen_restore_ac97(chip, 0);
if (chip->has_ac97_1)
oxygen_restore_ac97(chip, 1);
if (chip->model.resume)
chip->model.resume(chip);
oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, chip->interrupt_mask);
snd_power_change_state(card, SNDRV_CTL_POWER_D0);
return 0;
}
// check stuff before you bother to lock the ledger
TER Transactor::preCheck ()
{
mTxnAccountID = mTxn.getSourceAccount ().getAccountID ();
if (!mTxnAccountID)
{
m_journal.warning << "apply: bad transaction source id";
return temBAD_SRC_ACCOUNT;
}
// Extract signing key
// Transactions contain a signing key. This allows us to trivially verify a transaction has at least been properly signed
// without going to disk. Each transaction also notes a source account id. This is used to verify that the signing key is
// associated with the account.
// XXX This could be a lot cleaner to prevent unnecessary copying.
mSigningPubKey = RippleAddress::createAccountPublic (mTxn.getSigningPubKey ());
// Consistency: really signed.
if (!mTxn.isKnownGood ())
{
if (mTxn.isKnownBad () || (!is_bit_set (mParams, tapNO_CHECK_SIGN) && !mTxn.checkSign (mSigningPubKey)))
{
mTxn.setBad ();
m_journal.warning << "apply: Invalid transaction (bad signature)";
return temINVALID;
}
mTxn.setGood ();
}
return tesSUCCESS;
}
static int linux_uart_write(struct file *fp,
const char __user *buff, size_t size, loff_t *off)
{
int wsize;
if(buff == NULL) return 0;
if(fp->private_data == NULL) return -EPERM;
if( !is_bit_set(serial.out.serf->flag, RT_SERIAL_dom_WRITE)) {
return -EPERM;
}
down_interruptible(&wsem);
wsize = rt_serial_user_write(&serial.out, buff, size);
up(&wsem);
if(wsize > 0) {
outb(0xB, UART_IER(uart));
outb(0x9, UART_MCR(uart));
}
return wsize;
}
void Effect::updateFreeflyCamera(double time, double delta) {
if (!_useFreeflyCamera)
return;
double orgDelta = delta;
if (is_bit_set(GetAsyncKeyState(VK_SHIFT), 15))
delta /= 10;
if (_keystate['W'])
_freefly_camera.move(FreeflyCamera::kForward, (float)(100 * delta));
if (_keystate['S'])
_freefly_camera.move(FreeflyCamera::kForward, (float)(-100 * delta));
if (_keystate['A'])
_freefly_camera.move(FreeflyCamera::kRight, (float)(-100 * delta));
if (_keystate['D'])
_freefly_camera.move(FreeflyCamera::kRight, (float)(100 * delta));
if (_keystate['Q'])
_freefly_camera.move(FreeflyCamera::kUp, (float)(100 * delta));
if (_keystate['E'])
_freefly_camera.move(FreeflyCamera::kUp, (float)(-100 * delta));
if (_mouse_lbutton) {
float dx = (float)(100 * orgDelta) * _mouse_horiz / 200.0f;
float dy = (float)(100 * orgDelta) * _mouse_vert / 200.0f;
_freefly_camera.rotate(FreeflyCamera::kXAxis, dx);
_freefly_camera.rotate(FreeflyCamera::kYAxis, dy);
}
}
void
pair_ports(void)
{
uint8_t i, j;
/* Pair ports with their "closest neighbour" in the portmask */
for (i = 0; i < RTE_MAX_ETHPORTS; i++)
if (is_bit_set(i, portmask))
for (j = (uint8_t) (i + 1); j < RTE_MAX_ETHPORTS; j++)
if (is_bit_set(j, portmask)) {
port_pairs[i] = j;
port_pairs[j] = i;
i = j;
break;
}
}
int next_piece(int previous_piece, struct peer_state *peer) {
/*
for(int i=0;i<get_total_pieces_available();i++){
if(piece_occurence_value[i] >0 && piece_status[i] == PIECE_EMPTY &&
is_bit_set(peer->bitfield,i)){
if(next_piece != -2 && piece_occurence_value[i] <= piece_occurence_value[next_piece])
next_piece = i;
}
}
*/
//printf("Insice next piece\n");
fflush(stdout);
if(previous_piece!=-1){
piece_status[previous_piece]=PIECE_FINISHED;
}
draw_state();
int next_piece=-2;
//using the bitfield count and checking next rare piece
for(int i=0;i<get_total_pieces_available();i++){
if(piece_occurence_value[i] >0 && piece_status[i] == PIECE_EMPTY &&
is_bit_set(peer->bitfield,i)){
if(next_piece == -2)
next_piece = i;
if(next_piece != -2 && piece_occurence_value[i] <= piece_occurence_value[next_piece])
next_piece = i;
}
}
piece_status[next_piece]=PIECE_PENDING;
return next_piece;
}
int dom_serial_fifo_write(dom_fifo_t *df, const char *src, int size)
{
serial_fifo_t *ff;
long top, offset;
int wsize;
if (df == NULL || src == NULL || size < 0)
return -EINVAL;
ff = df->serf;
if (!is_bit_set(ff->flag, RT_SERIAL_dom_WRITE))
return -EPERM;
wsize = (ff->bom + ff->size - ff->top - 1) % ff->size;
if (wsize < size) return -ENOMEM;
wsize = size;
top = ff->top;
if ( (ff->bom <= top) && (ff->size - top < wsize)) {
offset = ff->size - top;
memcpy(df->addr + top, src, offset);
memcpy(df->addr, src+offset, wsize-offset);
} else {
memcpy(df->addr + top, src, wsize);
}
ff->top = (ff->top + wsize) % ff->size;
return wsize;
}
static void rt_isr_event_entry(void* parameter)
{
rt_err_t err;
rt_uint32_t e;
printf_syn("rt_isr_event_entry()\n");
say_thread_start();
while (1) {
err = rt_event_recv(&isr_event_set
, EVENT_BIT_NEED_RUN_TIM2_IRQ | EVENT_BIT_NEED_RUN_TIM4_IRQ | EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ
, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &e);
if (RT_EOK != err) {
printf_syn("recv isr event error(%d)", err);
} else {
#if RT_USING_SI4432_MAC
if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ)) {
clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ);
si4432_mac_exti_isr();
}
#endif
#if RT_USING_ADE7880
if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM4_IRQ)) {
clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM4_IRQ);
#if 0 == ADE7880_USE_I2C_HSDC
tim4_isr();
#endif
}
#endif
#if RT_USING_SI4432_MAC
if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ)) {
clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ);
si4432_mac_exti_isr();
}
if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM2_IRQ)) {
clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM2_IRQ);
tim2_isr();
}
#endif
}
}
return;
}
void append_to_buffer(byte_buffer *b, code *c) {
int i, byte, pos;
for (i = 0; i < c->num_bits; ++i) {
byte = i / 8;
pos = i % 8;
append_bit_to_buffer(b, is_bit_set(c->memory[byte], pos));
}
}
// software reset for mmci
void mmci_software_reset (void) {
// perform a Software reset for mmci_cmd line.
address sd_system_control = (address) MMCHS_SYSCTL_MMCHS1;
set_bit(sd_system_control, 25);
while (!is_bit_set(sd_system_control, 25))
;
}
int view_spatial_filter(const sized_buf *k, const sized_buf *v,
const bitmap_t *bm)
{
uint16_t partition = 0;
(void) k;
partition = decode_raw16(*((raw_16 *) v->buf));
return is_bit_set(bm, partition);
}
void main ()
{
int a = 2;
int b = 2;
if (is_bit_set (a, b)) {
printf ("\n: bit is set = ");
} else {
printf ("\n: bit is not set = ");
}
}
static void oxygen_restore_ac97(struct oxygen *chip, unsigned int codec)
{
unsigned int i;
oxygen_write_ac97(chip, codec, AC97_RESET, 0);
msleep(1);
for (i = 1; i < 0x40; ++i)
if (is_bit_set(ac97_registers_to_restore[codec], i))
oxygen_write_ac97(chip, codec, i * 2,
chip->saved_ac97_registers[codec][i]);
}
void print_buffer(byte_buffer *b) {
int i, k;
for (i = 0; i <= b->current_byte; ++i) {
if (i == b->current_byte) {
for (k = 0; k < b->current_bit; ++k) {
printf("%d", is_bit_set(b->buffer[i], k));
}
} else {
for (k = 0; k < 8; ++k) {
printf("%d", is_bit_set(b->buffer[i], k));
}
if ((i+1)%4 == 0) {
printf("\n");
} else {
printf(" ");
}
}
}
printf("\n");
}
SDCARD_RC SDCARD_inserted (void) {
address sd_status = (address) MMCHS_STAT_MMCHS1;
// Reset the MMC card
sendCMD0 ();
// check if we have a SDIO card
int counter = 0;
sendCMD5 ();
if (is_bit_set (sd_status, 0))
return SDCARD_SDIO;
while ((is_bit_set (sd_status, 16) == FALSE) & (counter < 5)) {
if (is_bit_set (sd_status, 0))
return SDCARD_SDIO;
counter++;
}
// card is version 2.0
mmci_software_reset ();
sendCMD8 ();
if (is_bit_set (sd_status, 0))
return SDCARD_VERSION2;
counter = 0;
while ((is_bit_set (sd_status, 16) == FALSE) & (counter < 5)) {
if (is_bit_set (sd_status, 0))
return SDCARD_VERSION2;
counter ++;
}
mmci_software_reset ();
// check if we have a 1 card
sendCMD55 ();
sendACMD41 ();
if (is_bit_set (sd_status, 0))
return SDCARD_VERSION1;
counter = 0;
while ((is_bit_set (sd_status, 16) == FALSE) & (counter < 5)) {
if (is_bit_set (sd_status, 0))
return SDCARD_VERSION1;
counter ++;
}
// we do not care for other cards so just send an error
return SDCARD_UNKNOWN;
}
enum Signal Gpio_get_signal(struct Gpio * self)
{
enum Signal signal = Signal_Undefined;
if(Direction_Input == self->direction) {
if(is_bit_set(self->input, self->pin)) {
signal = Signal_High;
} else {
signal = Signal_Low;
}
}
return signal;
}
void write_length(byte_buffer *b, int length, ushort bits) {
// Check endianess -- might need to reverse direction
int i, k, num_bytes = (int)ceil((double)bits/8.0);
uchar *bytes = (uchar *)(&length);
for (i = 0; i < num_bytes; ++i) {
for (k = 0; k < 8 && bits > 0; ++k) {
append_bit_to_buffer(b, is_bit_set(bytes[i], k));
bits--;
}
}
}
uchar get_next_bit(byte_buffer *b) {
if (b->current_byte > b->capacity) return -1;
uchar bit = is_bit_set(b->buffer[b->current_byte], b->current_bit);
b->current_bit++;
if (b->current_bit > 7) {
b->current_byte++;
b->current_bit = 0;
}
return bit;
}
static int view_purgekv_action(bitmap_t *bm, uint16_t part_id,
uint64_t valcount,
view_purger_ctx_t *ctx)
{
int action = PURGE_KEEP;
if (is_bit_set(bm, part_id)) {
ctx->count += valcount;
action = PURGE_ITEM;
}
return action;
}
BOOLEAN module_initialation (void) {
// Step 2: controller software reset
address SD_controller_config = (address) MMCHS_SYSCONFIG_MMCHS1;
set_bit (SD_controller_config, 1); // reset module
// controller initialisation. ARM TRM Page 3143 / 3147
// Step 1: nfigure interface and functional clock
address interface_clock = (address) CM_ICLKEN1_CORE;
set_bit(interface_clock, 24); // MMC SCIO 1 interface clock is enabled
set_bit(interface_clock, 25); // MMC SCIO 2 interface clock is enabled
address functional_clock = (address) CM_FCLKEN1_CORE;
set_bit (functional_clock, 24);
set_bit (functional_clock, 25);
// now check if the reset is finished
int counter = 0;
address SD_controller_reset = (address) MMCHS_SYSSTATUS_MMCHS1;
while ((!is_bit_set(SD_controller_reset, 0)) & (counter < 5))
counter++; // wait
// configure controller
address SD_host_controller_power;
SD_host_controller_power = (address) MMCHS_HCTL_MMCHS1;
set_bit (SD_controller_config, 2); // Wake-up capability is enabled. TRM 3173
set_bit (SD_host_controller_power, 24); // Wake-up event enable on SD card interrupt. TRM 3193
// module init
address configuration = (address) MMCHS_CON_MMCHS1;
set_bit(configuration, 1); // Send initialization stream (All cards). TRM 3182
address command = (address) MMCHS_CMD_MMCHS1;
*command = 0x0;
// now wait 1 ms???? TRM 3147 TODO:
volatile int i;
for (i = 0; i <= 100000; i++)
;
address command_complete = (address) MMCHS_STAT_MMCHS1; // Command complete.
set_bit (command_complete, 0); // Send initialization stream (All cards). TRM 3182
clear_bit (configuration, 1); // End initialization stream (All cards). TRM 3147
*command_complete = 0xFFFFFFFF; // clear register
// change frequecy to fit protocoll
return TRUE;
}
void init_mm (u32_t magic, u32_t addr)
{
multiboot_info_t *mbi = (multiboot_info_t *) addr;
u32_t up_mem_kb = 0;
if ( is_bit_set (mbi->flags, 0) ) up_mem_kb = mbi->mem_upper;
init_paging (up_mem_kb, phys_addr ( (u32_t) __kernel_img_end) );
_mbi = mbi;
init_page_alloc (up_mem_kb, phys_addr ( (u32_t) __kernel_img_end));
}
byte_buffer *rl_compress(char *data, long size) {
byte_buffer *buff = new_buffer((3 * size)/4);
long i;
int k;
// 1. Determine the longest sequence of 1s or 0s.
int longest_seq = 1, current_seq = 0;
uchar current = is_bit_set(data[0], 0);
for (i = 0; i < size; i++) {
for (k = 0; k < 8; ++k) {
if (is_bit_set(data[i], k) == current) {
current_seq++;
} else {
if (current_seq > longest_seq)
longest_seq = current_seq;
current_seq = 1;
current = (current == 0)? 1 : 0;
}
}
}
// 2. Determine number of bits required to represent that sequence.
const ushort NUM_BITS = (const ushort)ceil(log((double)longest_seq)/log(2.0));
// 3. First 16 bits used to store length of the run lengths in bits.
uchar *byte_representation = (uchar *)(&NUM_BITS);
for (i = 0; i < sizeof(NUM_BITS); ++i) {
append_byte_to_buffer(buff, byte_representation[i]);
}
// 4. Start with 0s, write length, then write 1s length, etc.
if (is_bit_set(data[0], 0)) {
write_length(buff, 0, NUM_BITS);
}
current_seq = 0;
current = is_bit_set(data[0], 0);
for (i = 0; i < size; i++) {
for (k = 0; k < 8; ++k) {
if (is_bit_set(data[i], k) == current) {
current_seq++;
} else {
write_length(buff, current_seq, NUM_BITS);
current_seq = 1;
current = is_bit_set(data[i], k);
}
}
}
if (current_seq > 0) {
write_length(buff, current_seq, NUM_BITS);
}
return buff;
}
static int linux_uart_read(struct file *fp,
char __user *buff, size_t size, loff_t *off)
{
int rsize;
if(buff == NULL) return 0;
if(fp->private_data == NULL) return -EPERM;
if( !is_bit_set(serial.out.serf->flag, RT_SERIAL_dom_READ)) {
return -EPERM;
}
rsize = rt_serial_user_read(&serial.in, buff, size);
return rsize;
}
static int linux_uart_open(struct inode *np, struct file *fp)
{
int min = MINOR(np->i_rdev);
if (min != 0 || serial.in.addr == NULL) {
return -ENODEV;
}
if( !is_bit_set(serial.in.serf->flag, RT_SERIAL_dev_INIT) )
return -EPIPE;
if(fp->private_data == &serial) return 0;
clients ++;
fp->private_data = &serial;
return 0;
}
void broadcast_have_msg(int piece)
{
//printf("Inside broadcase msg function\n");
fflush(stdout);
char *havemsg = malloc(9);
memset(havemsg,0,9);
havemsg[3] =5;
havemsg[4]=4;
*(int*)(havemsg+5) = htonl(piece);
struct peer_state *peer = peers;
while(peer){
if(peer->connected && !is_bit_set(peer->bitfield, piece) && !peer->not_interested){
push_into_msg_outgoing_buf(peer, havemsg, 9);
}
peer = peer->next;
}
//printf("Exit broadcast msg function\n");
}
int view_btree_filter(const sized_buf *k, const sized_buf *v,
const bitmap_t *bm)
{
int ret = 0;
couchstore_error_t errcode = COUCHSTORE_SUCCESS;
view_btree_value_t *val = NULL;
(void) k;
errcode = decode_view_btree_value(v->buf, v->size, &val);
if (errcode != COUCHSTORE_SUCCESS) {
ret = (int) errcode;
goto cleanup;
}
ret = is_bit_set(bm, val->partition);
cleanup:
free_view_btree_value(val);
return ret;
}
// This is for debugging not end users. Output names can be changed without warning.
Json::Value PathState::Node::getJson () const
{
Json::Value jvNode (Json::objectValue);
Json::Value jvFlags (Json::arrayValue);
jvNode["type"] = uFlags;
if (is_bit_set (uFlags, STPathElement::typeAccount) || !!uAccountID)
jvFlags.append (!!is_bit_set (uFlags, STPathElement::typeAccount) == !!uAccountID ? "account" : "-account");
if (is_bit_set (uFlags, STPathElement::typeCurrency) || !!uCurrencyID)
jvFlags.append (!!is_bit_set (uFlags, STPathElement::typeCurrency) == !!uCurrencyID ? "currency" : "-currency");
if (is_bit_set (uFlags, STPathElement::typeIssuer) || !!uIssuerID)
jvFlags.append (!!is_bit_set (uFlags, STPathElement::typeIssuer) == !!uIssuerID ? "issuer" : "-issuer");
jvNode["flags"] = jvFlags;
if (!!uAccountID)
jvNode["account"] = RippleAddress::createHumanAccountID (uAccountID);
if (!!uCurrencyID)
jvNode["currency"] = STAmount::createHumanCurrency (uCurrencyID);
if (!!uIssuerID)
jvNode["issuer"] = RippleAddress::createHumanAccountID (uIssuerID);
if (saRevRedeem)
jvNode["rev_redeem"] = saRevRedeem.getFullText ();
if (saRevIssue)
jvNode["rev_issue"] = saRevIssue.getFullText ();
if (saRevDeliver)
jvNode["rev_deliver"] = saRevDeliver.getFullText ();
if (saFwdRedeem)
jvNode["fwd_redeem"] = saFwdRedeem.getFullText ();
if (saFwdIssue)
jvNode["fwd_issue"] = saFwdIssue.getFullText ();
if (saFwdDeliver)
jvNode["fwd_deliver"] = saFwdDeliver.getFullText ();
return jvNode;
}
TER Transactor::payFee ()
{
STAmount saPaid = mTxn.getTransactionFee ();
if (!saPaid.isLegalNet ())
return temBAD_AMOUNT;
// Only check fee is sufficient when the ledger is open.
if (is_bit_set(mParams, tapOPEN_LEDGER) &&
saPaid < mFeeDue)
{
m_journal.trace << "Insufficient fee paid: " <<
saPaid.getText () << "/" << mFeeDue.getText ();
return telINSUF_FEE_P;
}
if (saPaid < zero || !saPaid.isNative ())
return temBAD_FEE;
if (!saPaid) return tesSUCCESS;
// Deduct the fee, so it's not available during the transaction.
// Will only write the account back, if the transaction succeeds.
if (mSourceBalance < saPaid)
{
m_journal.trace << "Insufficient balance:" <<
" balance=" << mSourceBalance.getText () <<
" paid=" << saPaid.getText ();
return terINSUF_FEE_B;
}
mSourceBalance -= saPaid;
mTxnAccount->setFieldAmount (sfBalance, mSourceBalance);
return tesSUCCESS;
}
